Merge branch 'js/bisect-helper-check-get-oid-return-value'
[git] / sequencer.c
1 #include "cache.h"
2 #include "config.h"
3 #include "lockfile.h"
4 #include "dir.h"
5 #include "object-store.h"
6 #include "object.h"
7 #include "commit.h"
8 #include "sequencer.h"
9 #include "tag.h"
10 #include "run-command.h"
11 #include "exec-cmd.h"
12 #include "utf8.h"
13 #include "cache-tree.h"
14 #include "diff.h"
15 #include "revision.h"
16 #include "rerere.h"
17 #include "merge-recursive.h"
18 #include "refs.h"
19 #include "argv-array.h"
20 #include "quote.h"
21 #include "trailer.h"
22 #include "log-tree.h"
23 #include "wt-status.h"
24 #include "hashmap.h"
25 #include "notes-utils.h"
26 #include "sigchain.h"
27 #include "unpack-trees.h"
28 #include "worktree.h"
29 #include "oidmap.h"
30 #include "oidset.h"
31 #include "commit-slab.h"
32 #include "alias.h"
33 #include "commit-reach.h"
34 #include "rebase-interactive.h"
35
36 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
37
38 static const char sign_off_header[] = "Signed-off-by: ";
39 static const char cherry_picked_prefix[] = "(cherry picked from commit ";
40
41 GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
42
43 GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
44
45 static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
46 static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
47 static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
48 static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
49
50 static GIT_PATH_FUNC(rebase_path, "rebase-merge")
51 /*
52  * The file containing rebase commands, comments, and empty lines.
53  * This file is created by "git rebase -i" then edited by the user. As
54  * the lines are processed, they are removed from the front of this
55  * file and written to the tail of 'done'.
56  */
57 GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
58 GIT_PATH_FUNC(rebase_path_todo_backup, "rebase-merge/git-rebase-todo.backup")
59
60 /*
61  * The rebase command lines that have already been processed. A line
62  * is moved here when it is first handled, before any associated user
63  * actions.
64  */
65 static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
66 /*
67  * The file to keep track of how many commands were already processed (e.g.
68  * for the prompt).
69  */
70 static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum")
71 /*
72  * The file to keep track of how many commands are to be processed in total
73  * (e.g. for the prompt).
74  */
75 static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end")
76 /*
77  * The commit message that is planned to be used for any changes that
78  * need to be committed following a user interaction.
79  */
80 static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
81 /*
82  * The file into which is accumulated the suggested commit message for
83  * squash/fixup commands. When the first of a series of squash/fixups
84  * is seen, the file is created and the commit message from the
85  * previous commit and from the first squash/fixup commit are written
86  * to it. The commit message for each subsequent squash/fixup commit
87  * is appended to the file as it is processed.
88  */
89 static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
90 /*
91  * If the current series of squash/fixups has not yet included a squash
92  * command, then this file exists and holds the commit message of the
93  * original "pick" commit.  (If the series ends without a "squash"
94  * command, then this can be used as the commit message of the combined
95  * commit without opening the editor.)
96  */
97 static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
98 /*
99  * This file contains the list fixup/squash commands that have been
100  * accumulated into message-fixup or message-squash so far.
101  */
102 static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")
103 /*
104  * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
105  * GIT_AUTHOR_DATE that will be used for the commit that is currently
106  * being rebased.
107  */
108 static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
109 /*
110  * When an "edit" rebase command is being processed, the SHA1 of the
111  * commit to be edited is recorded in this file.  When "git rebase
112  * --continue" is executed, if there are any staged changes then they
113  * will be amended to the HEAD commit, but only provided the HEAD
114  * commit is still the commit to be edited.  When any other rebase
115  * command is processed, this file is deleted.
116  */
117 static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
118 /*
119  * When we stop at a given patch via the "edit" command, this file contains
120  * the abbreviated commit name of the corresponding patch.
121  */
122 static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
123 /*
124  * For the post-rewrite hook, we make a list of rewritten commits and
125  * their new sha1s.  The rewritten-pending list keeps the sha1s of
126  * commits that have been processed, but not committed yet,
127  * e.g. because they are waiting for a 'squash' command.
128  */
129 static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
130 static GIT_PATH_FUNC(rebase_path_rewritten_pending,
131         "rebase-merge/rewritten-pending")
132
133 /*
134  * The path of the file containig the OID of the "squash onto" commit, i.e.
135  * the dummy commit used for `reset [new root]`.
136  */
137 static GIT_PATH_FUNC(rebase_path_squash_onto, "rebase-merge/squash-onto")
138
139 /*
140  * The path of the file listing refs that need to be deleted after the rebase
141  * finishes. This is used by the `label` command to record the need for cleanup.
142  */
143 static GIT_PATH_FUNC(rebase_path_refs_to_delete, "rebase-merge/refs-to-delete")
144
145 /*
146  * The following files are written by git-rebase just after parsing the
147  * command-line.
148  */
149 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
150 static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
151 static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
152 static GIT_PATH_FUNC(rebase_path_quiet, "rebase-merge/quiet")
153 static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")
154 static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
155 static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
156 static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
157 static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
158 static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
159 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
160 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec, "rebase-merge/reschedule-failed-exec")
161
162 static int git_sequencer_config(const char *k, const char *v, void *cb)
163 {
164         struct replay_opts *opts = cb;
165         int status;
166
167         if (!strcmp(k, "commit.cleanup")) {
168                 const char *s;
169
170                 status = git_config_string(&s, k, v);
171                 if (status)
172                         return status;
173
174                 if (!strcmp(s, "verbatim")) {
175                         opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
176                         opts->explicit_cleanup = 1;
177                 } else if (!strcmp(s, "whitespace")) {
178                         opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
179                         opts->explicit_cleanup = 1;
180                 } else if (!strcmp(s, "strip")) {
181                         opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
182                         opts->explicit_cleanup = 1;
183                 } else if (!strcmp(s, "scissors")) {
184                         opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SCISSORS;
185                         opts->explicit_cleanup = 1;
186                 } else {
187                         warning(_("invalid commit message cleanup mode '%s'"),
188                                   s);
189                 }
190
191                 free((char *)s);
192                 return status;
193         }
194
195         if (!strcmp(k, "commit.gpgsign")) {
196                 opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
197                 return 0;
198         }
199
200         status = git_gpg_config(k, v, NULL);
201         if (status)
202                 return status;
203
204         return git_diff_basic_config(k, v, NULL);
205 }
206
207 void sequencer_init_config(struct replay_opts *opts)
208 {
209         opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
210         git_config(git_sequencer_config, opts);
211 }
212
213 static inline int is_rebase_i(const struct replay_opts *opts)
214 {
215         return opts->action == REPLAY_INTERACTIVE_REBASE;
216 }
217
218 static const char *get_dir(const struct replay_opts *opts)
219 {
220         if (is_rebase_i(opts))
221                 return rebase_path();
222         return git_path_seq_dir();
223 }
224
225 static const char *get_todo_path(const struct replay_opts *opts)
226 {
227         if (is_rebase_i(opts))
228                 return rebase_path_todo();
229         return git_path_todo_file();
230 }
231
232 /*
233  * Returns 0 for non-conforming footer
234  * Returns 1 for conforming footer
235  * Returns 2 when sob exists within conforming footer
236  * Returns 3 when sob exists within conforming footer as last entry
237  */
238 static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
239         size_t ignore_footer)
240 {
241         struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
242         struct trailer_info info;
243         size_t i;
244         int found_sob = 0, found_sob_last = 0;
245
246         opts.no_divider = 1;
247
248         trailer_info_get(&info, sb->buf, &opts);
249
250         if (info.trailer_start == info.trailer_end)
251                 return 0;
252
253         for (i = 0; i < info.trailer_nr; i++)
254                 if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
255                         found_sob = 1;
256                         if (i == info.trailer_nr - 1)
257                                 found_sob_last = 1;
258                 }
259
260         trailer_info_release(&info);
261
262         if (found_sob_last)
263                 return 3;
264         if (found_sob)
265                 return 2;
266         return 1;
267 }
268
269 static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
270 {
271         static struct strbuf buf = STRBUF_INIT;
272
273         strbuf_reset(&buf);
274         if (opts->gpg_sign)
275                 sq_quotef(&buf, "-S%s", opts->gpg_sign);
276         return buf.buf;
277 }
278
279 int sequencer_remove_state(struct replay_opts *opts)
280 {
281         struct strbuf buf = STRBUF_INIT;
282         int i;
283
284         if (is_rebase_i(opts) &&
285             strbuf_read_file(&buf, rebase_path_refs_to_delete(), 0) > 0) {
286                 char *p = buf.buf;
287                 while (*p) {
288                         char *eol = strchr(p, '\n');
289                         if (eol)
290                                 *eol = '\0';
291                         if (delete_ref("(rebase -i) cleanup", p, NULL, 0) < 0)
292                                 warning(_("could not delete '%s'"), p);
293                         if (!eol)
294                                 break;
295                         p = eol + 1;
296                 }
297         }
298
299         free(opts->gpg_sign);
300         free(opts->strategy);
301         for (i = 0; i < opts->xopts_nr; i++)
302                 free(opts->xopts[i]);
303         free(opts->xopts);
304         strbuf_release(&opts->current_fixups);
305
306         strbuf_reset(&buf);
307         strbuf_addstr(&buf, get_dir(opts));
308         remove_dir_recursively(&buf, 0);
309         strbuf_release(&buf);
310
311         return 0;
312 }
313
314 static const char *action_name(const struct replay_opts *opts)
315 {
316         switch (opts->action) {
317         case REPLAY_REVERT:
318                 return N_("revert");
319         case REPLAY_PICK:
320                 return N_("cherry-pick");
321         case REPLAY_INTERACTIVE_REBASE:
322                 return N_("rebase -i");
323         }
324         die(_("unknown action: %d"), opts->action);
325 }
326
327 struct commit_message {
328         char *parent_label;
329         char *label;
330         char *subject;
331         const char *message;
332 };
333
334 static const char *short_commit_name(struct commit *commit)
335 {
336         return find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV);
337 }
338
339 static int get_message(struct commit *commit, struct commit_message *out)
340 {
341         const char *abbrev, *subject;
342         int subject_len;
343
344         out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
345         abbrev = short_commit_name(commit);
346
347         subject_len = find_commit_subject(out->message, &subject);
348
349         out->subject = xmemdupz(subject, subject_len);
350         out->label = xstrfmt("%s... %s", abbrev, out->subject);
351         out->parent_label = xstrfmt("parent of %s", out->label);
352
353         return 0;
354 }
355
356 static void free_message(struct commit *commit, struct commit_message *msg)
357 {
358         free(msg->parent_label);
359         free(msg->label);
360         free(msg->subject);
361         unuse_commit_buffer(commit, msg->message);
362 }
363
364 static void print_advice(struct repository *r, int show_hint,
365                          struct replay_opts *opts)
366 {
367         char *msg = getenv("GIT_CHERRY_PICK_HELP");
368
369         if (msg) {
370                 fprintf(stderr, "%s\n", msg);
371                 /*
372                  * A conflict has occurred but the porcelain
373                  * (typically rebase --interactive) wants to take care
374                  * of the commit itself so remove CHERRY_PICK_HEAD
375                  */
376                 unlink(git_path_cherry_pick_head(r));
377                 return;
378         }
379
380         if (show_hint) {
381                 if (opts->no_commit)
382                         advise(_("after resolving the conflicts, mark the corrected paths\n"
383                                  "with 'git add <paths>' or 'git rm <paths>'"));
384                 else
385                         advise(_("after resolving the conflicts, mark the corrected paths\n"
386                                  "with 'git add <paths>' or 'git rm <paths>'\n"
387                                  "and commit the result with 'git commit'"));
388         }
389 }
390
391 static int write_message(const void *buf, size_t len, const char *filename,
392                          int append_eol)
393 {
394         struct lock_file msg_file = LOCK_INIT;
395
396         int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
397         if (msg_fd < 0)
398                 return error_errno(_("could not lock '%s'"), filename);
399         if (write_in_full(msg_fd, buf, len) < 0) {
400                 error_errno(_("could not write to '%s'"), filename);
401                 rollback_lock_file(&msg_file);
402                 return -1;
403         }
404         if (append_eol && write(msg_fd, "\n", 1) < 0) {
405                 error_errno(_("could not write eol to '%s'"), filename);
406                 rollback_lock_file(&msg_file);
407                 return -1;
408         }
409         if (commit_lock_file(&msg_file) < 0)
410                 return error(_("failed to finalize '%s'"), filename);
411
412         return 0;
413 }
414
415 /*
416  * Reads a file that was presumably written by a shell script, i.e. with an
417  * end-of-line marker that needs to be stripped.
418  *
419  * Note that only the last end-of-line marker is stripped, consistent with the
420  * behavior of "$(cat path)" in a shell script.
421  *
422  * Returns 1 if the file was read, 0 if it could not be read or does not exist.
423  */
424 static int read_oneliner(struct strbuf *buf,
425         const char *path, int skip_if_empty)
426 {
427         int orig_len = buf->len;
428
429         if (!file_exists(path))
430                 return 0;
431
432         if (strbuf_read_file(buf, path, 0) < 0) {
433                 warning_errno(_("could not read '%s'"), path);
434                 return 0;
435         }
436
437         if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
438                 if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
439                         --buf->len;
440                 buf->buf[buf->len] = '\0';
441         }
442
443         if (skip_if_empty && buf->len == orig_len)
444                 return 0;
445
446         return 1;
447 }
448
449 static struct tree *empty_tree(struct repository *r)
450 {
451         return lookup_tree(r, the_hash_algo->empty_tree);
452 }
453
454 static int error_dirty_index(struct repository *repo, struct replay_opts *opts)
455 {
456         if (repo_read_index_unmerged(repo))
457                 return error_resolve_conflict(_(action_name(opts)));
458
459         error(_("your local changes would be overwritten by %s."),
460                 _(action_name(opts)));
461
462         if (advice_commit_before_merge)
463                 advise(_("commit your changes or stash them to proceed."));
464         return -1;
465 }
466
467 static void update_abort_safety_file(void)
468 {
469         struct object_id head;
470
471         /* Do nothing on a single-pick */
472         if (!file_exists(git_path_seq_dir()))
473                 return;
474
475         if (!get_oid("HEAD", &head))
476                 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
477         else
478                 write_file(git_path_abort_safety_file(), "%s", "");
479 }
480
481 static int fast_forward_to(struct repository *r,
482                            const struct object_id *to,
483                            const struct object_id *from,
484                            int unborn,
485                            struct replay_opts *opts)
486 {
487         struct ref_transaction *transaction;
488         struct strbuf sb = STRBUF_INIT;
489         struct strbuf err = STRBUF_INIT;
490
491         repo_read_index(r);
492         if (checkout_fast_forward(r, from, to, 1))
493                 return -1; /* the callee should have complained already */
494
495         strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
496
497         transaction = ref_transaction_begin(&err);
498         if (!transaction ||
499             ref_transaction_update(transaction, "HEAD",
500                                    to, unborn && !is_rebase_i(opts) ?
501                                    &null_oid : from,
502                                    0, sb.buf, &err) ||
503             ref_transaction_commit(transaction, &err)) {
504                 ref_transaction_free(transaction);
505                 error("%s", err.buf);
506                 strbuf_release(&sb);
507                 strbuf_release(&err);
508                 return -1;
509         }
510
511         strbuf_release(&sb);
512         strbuf_release(&err);
513         ref_transaction_free(transaction);
514         update_abort_safety_file();
515         return 0;
516 }
517
518 enum commit_msg_cleanup_mode get_cleanup_mode(const char *cleanup_arg,
519         int use_editor)
520 {
521         if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
522                 return use_editor ? COMMIT_MSG_CLEANUP_ALL :
523                                     COMMIT_MSG_CLEANUP_SPACE;
524         else if (!strcmp(cleanup_arg, "verbatim"))
525                 return COMMIT_MSG_CLEANUP_NONE;
526         else if (!strcmp(cleanup_arg, "whitespace"))
527                 return COMMIT_MSG_CLEANUP_SPACE;
528         else if (!strcmp(cleanup_arg, "strip"))
529                 return COMMIT_MSG_CLEANUP_ALL;
530         else if (!strcmp(cleanup_arg, "scissors"))
531                 return use_editor ? COMMIT_MSG_CLEANUP_SCISSORS :
532                                     COMMIT_MSG_CLEANUP_SPACE;
533         else
534                 die(_("Invalid cleanup mode %s"), cleanup_arg);
535 }
536
537 /*
538  * NB using int rather than enum cleanup_mode to stop clang's
539  * -Wtautological-constant-out-of-range-compare complaining that the comparison
540  * is always true.
541  */
542 static const char *describe_cleanup_mode(int cleanup_mode)
543 {
544         static const char *modes[] = { "whitespace",
545                                        "verbatim",
546                                        "scissors",
547                                        "strip" };
548
549         if (cleanup_mode < ARRAY_SIZE(modes))
550                 return modes[cleanup_mode];
551
552         BUG("invalid cleanup_mode provided (%d)", cleanup_mode);
553 }
554
555 void append_conflicts_hint(struct index_state *istate,
556         struct strbuf *msgbuf, enum commit_msg_cleanup_mode cleanup_mode)
557 {
558         int i;
559
560         if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS) {
561                 strbuf_addch(msgbuf, '\n');
562                 wt_status_append_cut_line(msgbuf);
563                 strbuf_addch(msgbuf, comment_line_char);
564         }
565
566         strbuf_addch(msgbuf, '\n');
567         strbuf_commented_addf(msgbuf, "Conflicts:\n");
568         for (i = 0; i < istate->cache_nr;) {
569                 const struct cache_entry *ce = istate->cache[i++];
570                 if (ce_stage(ce)) {
571                         strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
572                         while (i < istate->cache_nr &&
573                                !strcmp(ce->name, istate->cache[i]->name))
574                                 i++;
575                 }
576         }
577 }
578
579 static int do_recursive_merge(struct repository *r,
580                               struct commit *base, struct commit *next,
581                               const char *base_label, const char *next_label,
582                               struct object_id *head, struct strbuf *msgbuf,
583                               struct replay_opts *opts)
584 {
585         struct merge_options o;
586         struct tree *result, *next_tree, *base_tree, *head_tree;
587         int clean;
588         char **xopt;
589         struct lock_file index_lock = LOCK_INIT;
590
591         if (repo_hold_locked_index(r, &index_lock, LOCK_REPORT_ON_ERROR) < 0)
592                 return -1;
593
594         repo_read_index(r);
595
596         init_merge_options(&o, r);
597         o.ancestor = base ? base_label : "(empty tree)";
598         o.branch1 = "HEAD";
599         o.branch2 = next ? next_label : "(empty tree)";
600         if (is_rebase_i(opts))
601                 o.buffer_output = 2;
602         o.show_rename_progress = 1;
603
604         head_tree = parse_tree_indirect(head);
605         next_tree = next ? get_commit_tree(next) : empty_tree(r);
606         base_tree = base ? get_commit_tree(base) : empty_tree(r);
607
608         for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)
609                 parse_merge_opt(&o, *xopt);
610
611         clean = merge_trees(&o,
612                             head_tree,
613                             next_tree, base_tree, &result);
614         if (is_rebase_i(opts) && clean <= 0)
615                 fputs(o.obuf.buf, stdout);
616         strbuf_release(&o.obuf);
617         diff_warn_rename_limit("merge.renamelimit", o.needed_rename_limit, 0);
618         if (clean < 0) {
619                 rollback_lock_file(&index_lock);
620                 return clean;
621         }
622
623         if (write_locked_index(r->index, &index_lock,
624                                COMMIT_LOCK | SKIP_IF_UNCHANGED))
625                 /*
626                  * TRANSLATORS: %s will be "revert", "cherry-pick" or
627                  * "rebase -i".
628                  */
629                 return error(_("%s: Unable to write new index file"),
630                         _(action_name(opts)));
631
632         if (!clean)
633                 append_conflicts_hint(r->index, msgbuf,
634                                       opts->default_msg_cleanup);
635
636         return !clean;
637 }
638
639 static struct object_id *get_cache_tree_oid(struct index_state *istate)
640 {
641         if (!istate->cache_tree)
642                 istate->cache_tree = cache_tree();
643
644         if (!cache_tree_fully_valid(istate->cache_tree))
645                 if (cache_tree_update(istate, 0)) {
646                         error(_("unable to update cache tree"));
647                         return NULL;
648                 }
649
650         return &istate->cache_tree->oid;
651 }
652
653 static int is_index_unchanged(struct repository *r)
654 {
655         struct object_id head_oid, *cache_tree_oid;
656         struct commit *head_commit;
657         struct index_state *istate = r->index;
658
659         if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
660                 return error(_("could not resolve HEAD commit"));
661
662         head_commit = lookup_commit(r, &head_oid);
663
664         /*
665          * If head_commit is NULL, check_commit, called from
666          * lookup_commit, would have indicated that head_commit is not
667          * a commit object already.  parse_commit() will return failure
668          * without further complaints in such a case.  Otherwise, if
669          * the commit is invalid, parse_commit() will complain.  So
670          * there is nothing for us to say here.  Just return failure.
671          */
672         if (parse_commit(head_commit))
673                 return -1;
674
675         if (!(cache_tree_oid = get_cache_tree_oid(istate)))
676                 return -1;
677
678         return oideq(cache_tree_oid, get_commit_tree_oid(head_commit));
679 }
680
681 static int write_author_script(const char *message)
682 {
683         struct strbuf buf = STRBUF_INIT;
684         const char *eol;
685         int res;
686
687         for (;;)
688                 if (!*message || starts_with(message, "\n")) {
689 missing_author:
690                         /* Missing 'author' line? */
691                         unlink(rebase_path_author_script());
692                         return 0;
693                 } else if (skip_prefix(message, "author ", &message))
694                         break;
695                 else if ((eol = strchr(message, '\n')))
696                         message = eol + 1;
697                 else
698                         goto missing_author;
699
700         strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
701         while (*message && *message != '\n' && *message != '\r')
702                 if (skip_prefix(message, " <", &message))
703                         break;
704                 else if (*message != '\'')
705                         strbuf_addch(&buf, *(message++));
706                 else
707                         strbuf_addf(&buf, "'\\%c'", *(message++));
708         strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
709         while (*message && *message != '\n' && *message != '\r')
710                 if (skip_prefix(message, "> ", &message))
711                         break;
712                 else if (*message != '\'')
713                         strbuf_addch(&buf, *(message++));
714                 else
715                         strbuf_addf(&buf, "'\\%c'", *(message++));
716         strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
717         while (*message && *message != '\n' && *message != '\r')
718                 if (*message != '\'')
719                         strbuf_addch(&buf, *(message++));
720                 else
721                         strbuf_addf(&buf, "'\\%c'", *(message++));
722         strbuf_addch(&buf, '\'');
723         res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
724         strbuf_release(&buf);
725         return res;
726 }
727
728 /**
729  * Take a series of KEY='VALUE' lines where VALUE part is
730  * sq-quoted, and append <KEY, VALUE> at the end of the string list
731  */
732 static int parse_key_value_squoted(char *buf, struct string_list *list)
733 {
734         while (*buf) {
735                 struct string_list_item *item;
736                 char *np;
737                 char *cp = strchr(buf, '=');
738                 if (!cp) {
739                         np = strchrnul(buf, '\n');
740                         return error(_("no key present in '%.*s'"),
741                                      (int) (np - buf), buf);
742                 }
743                 np = strchrnul(cp, '\n');
744                 *cp++ = '\0';
745                 item = string_list_append(list, buf);
746
747                 buf = np + (*np == '\n');
748                 *np = '\0';
749                 cp = sq_dequote(cp);
750                 if (!cp)
751                         return error(_("unable to dequote value of '%s'"),
752                                      item->string);
753                 item->util = xstrdup(cp);
754         }
755         return 0;
756 }
757
758 /**
759  * Reads and parses the state directory's "author-script" file, and sets name,
760  * email and date accordingly.
761  * Returns 0 on success, -1 if the file could not be parsed.
762  *
763  * The author script is of the format:
764  *
765  *      GIT_AUTHOR_NAME='$author_name'
766  *      GIT_AUTHOR_EMAIL='$author_email'
767  *      GIT_AUTHOR_DATE='$author_date'
768  *
769  * where $author_name, $author_email and $author_date are quoted. We are strict
770  * with our parsing, as the file was meant to be eval'd in the now-removed
771  * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
772  * from what this function expects, it is better to bail out than to do
773  * something that the user does not expect.
774  */
775 int read_author_script(const char *path, char **name, char **email, char **date,
776                        int allow_missing)
777 {
778         struct strbuf buf = STRBUF_INIT;
779         struct string_list kv = STRING_LIST_INIT_DUP;
780         int retval = -1; /* assume failure */
781         int i, name_i = -2, email_i = -2, date_i = -2, err = 0;
782
783         if (strbuf_read_file(&buf, path, 256) <= 0) {
784                 strbuf_release(&buf);
785                 if (errno == ENOENT && allow_missing)
786                         return 0;
787                 else
788                         return error_errno(_("could not open '%s' for reading"),
789                                            path);
790         }
791
792         if (parse_key_value_squoted(buf.buf, &kv))
793                 goto finish;
794
795         for (i = 0; i < kv.nr; i++) {
796                 if (!strcmp(kv.items[i].string, "GIT_AUTHOR_NAME")) {
797                         if (name_i != -2)
798                                 name_i = error(_("'GIT_AUTHOR_NAME' already given"));
799                         else
800                                 name_i = i;
801                 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_EMAIL")) {
802                         if (email_i != -2)
803                                 email_i = error(_("'GIT_AUTHOR_EMAIL' already given"));
804                         else
805                                 email_i = i;
806                 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_DATE")) {
807                         if (date_i != -2)
808                                 date_i = error(_("'GIT_AUTHOR_DATE' already given"));
809                         else
810                                 date_i = i;
811                 } else {
812                         err = error(_("unknown variable '%s'"),
813                                     kv.items[i].string);
814                 }
815         }
816         if (name_i == -2)
817                 error(_("missing 'GIT_AUTHOR_NAME'"));
818         if (email_i == -2)
819                 error(_("missing 'GIT_AUTHOR_EMAIL'"));
820         if (date_i == -2)
821                 error(_("missing 'GIT_AUTHOR_DATE'"));
822         if (date_i < 0 || email_i < 0 || date_i < 0 || err)
823                 goto finish;
824         *name = kv.items[name_i].util;
825         *email = kv.items[email_i].util;
826         *date = kv.items[date_i].util;
827         retval = 0;
828 finish:
829         string_list_clear(&kv, !!retval);
830         strbuf_release(&buf);
831         return retval;
832 }
833
834 /*
835  * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
836  * file with shell quoting into struct argv_array. Returns -1 on
837  * error, 0 otherwise.
838  */
839 static int read_env_script(struct argv_array *env)
840 {
841         char *name, *email, *date;
842
843         if (read_author_script(rebase_path_author_script(),
844                                &name, &email, &date, 0))
845                 return -1;
846
847         argv_array_pushf(env, "GIT_AUTHOR_NAME=%s", name);
848         argv_array_pushf(env, "GIT_AUTHOR_EMAIL=%s", email);
849         argv_array_pushf(env, "GIT_AUTHOR_DATE=%s", date);
850         free(name);
851         free(email);
852         free(date);
853
854         return 0;
855 }
856
857 static char *get_author(const char *message)
858 {
859         size_t len;
860         const char *a;
861
862         a = find_commit_header(message, "author", &len);
863         if (a)
864                 return xmemdupz(a, len);
865
866         return NULL;
867 }
868
869 /* Read author-script and return an ident line (author <email> timestamp) */
870 static const char *read_author_ident(struct strbuf *buf)
871 {
872         struct strbuf out = STRBUF_INIT;
873         char *name, *email, *date;
874
875         if (read_author_script(rebase_path_author_script(),
876                                &name, &email, &date, 0))
877                 return NULL;
878
879         /* validate date since fmt_ident() will die() on bad value */
880         if (parse_date(date, &out)){
881                 warning(_("invalid date format '%s' in '%s'"),
882                         date, rebase_path_author_script());
883                 strbuf_release(&out);
884                 return NULL;
885         }
886
887         strbuf_reset(&out);
888         strbuf_addstr(&out, fmt_ident(name, email, WANT_AUTHOR_IDENT, date, 0));
889         strbuf_swap(buf, &out);
890         strbuf_release(&out);
891         free(name);
892         free(email);
893         free(date);
894         return buf->buf;
895 }
896
897 static const char staged_changes_advice[] =
898 N_("you have staged changes in your working tree\n"
899 "If these changes are meant to be squashed into the previous commit, run:\n"
900 "\n"
901 "  git commit --amend %s\n"
902 "\n"
903 "If they are meant to go into a new commit, run:\n"
904 "\n"
905 "  git commit %s\n"
906 "\n"
907 "In both cases, once you're done, continue with:\n"
908 "\n"
909 "  git rebase --continue\n");
910
911 #define ALLOW_EMPTY (1<<0)
912 #define EDIT_MSG    (1<<1)
913 #define AMEND_MSG   (1<<2)
914 #define CLEANUP_MSG (1<<3)
915 #define VERIFY_MSG  (1<<4)
916 #define CREATE_ROOT_COMMIT (1<<5)
917
918 static int run_command_silent_on_success(struct child_process *cmd)
919 {
920         struct strbuf buf = STRBUF_INIT;
921         int rc;
922
923         cmd->stdout_to_stderr = 1;
924         rc = pipe_command(cmd,
925                           NULL, 0,
926                           NULL, 0,
927                           &buf, 0);
928
929         if (rc)
930                 fputs(buf.buf, stderr);
931         strbuf_release(&buf);
932         return rc;
933 }
934
935 /*
936  * If we are cherry-pick, and if the merge did not result in
937  * hand-editing, we will hit this commit and inherit the original
938  * author date and name.
939  *
940  * If we are revert, or if our cherry-pick results in a hand merge,
941  * we had better say that the current user is responsible for that.
942  *
943  * An exception is when run_git_commit() is called during an
944  * interactive rebase: in that case, we will want to retain the
945  * author metadata.
946  */
947 static int run_git_commit(struct repository *r,
948                           const char *defmsg,
949                           struct replay_opts *opts,
950                           unsigned int flags)
951 {
952         struct child_process cmd = CHILD_PROCESS_INIT;
953
954         if ((flags & CREATE_ROOT_COMMIT) && !(flags & AMEND_MSG)) {
955                 struct strbuf msg = STRBUF_INIT, script = STRBUF_INIT;
956                 const char *author = NULL;
957                 struct object_id root_commit, *cache_tree_oid;
958                 int res = 0;
959
960                 if (is_rebase_i(opts)) {
961                         author = read_author_ident(&script);
962                         if (!author) {
963                                 strbuf_release(&script);
964                                 return -1;
965                         }
966                 }
967
968                 if (!defmsg)
969                         BUG("root commit without message");
970
971                 if (!(cache_tree_oid = get_cache_tree_oid(r->index)))
972                         res = -1;
973
974                 if (!res)
975                         res = strbuf_read_file(&msg, defmsg, 0);
976
977                 if (res <= 0)
978                         res = error_errno(_("could not read '%s'"), defmsg);
979                 else
980                         res = commit_tree(msg.buf, msg.len, cache_tree_oid,
981                                           NULL, &root_commit, author,
982                                           opts->gpg_sign);
983
984                 strbuf_release(&msg);
985                 strbuf_release(&script);
986                 if (!res) {
987                         update_ref(NULL, "CHERRY_PICK_HEAD", &root_commit, NULL,
988                                    REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR);
989                         res = update_ref(NULL, "HEAD", &root_commit, NULL, 0,
990                                          UPDATE_REFS_MSG_ON_ERR);
991                 }
992                 return res < 0 ? error(_("writing root commit")) : 0;
993         }
994
995         cmd.git_cmd = 1;
996
997         if (is_rebase_i(opts) && read_env_script(&cmd.env_array)) {
998                 const char *gpg_opt = gpg_sign_opt_quoted(opts);
999
1000                 return error(_(staged_changes_advice),
1001                              gpg_opt, gpg_opt);
1002         }
1003
1004         argv_array_push(&cmd.args, "commit");
1005
1006         if (!(flags & VERIFY_MSG))
1007                 argv_array_push(&cmd.args, "-n");
1008         if ((flags & AMEND_MSG))
1009                 argv_array_push(&cmd.args, "--amend");
1010         if (opts->gpg_sign)
1011                 argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
1012         if (defmsg)
1013                 argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
1014         else if (!(flags & EDIT_MSG))
1015                 argv_array_pushl(&cmd.args, "-C", "HEAD", NULL);
1016         if ((flags & CLEANUP_MSG))
1017                 argv_array_push(&cmd.args, "--cleanup=strip");
1018         if ((flags & EDIT_MSG))
1019                 argv_array_push(&cmd.args, "-e");
1020         else if (!(flags & CLEANUP_MSG) &&
1021                  !opts->signoff && !opts->record_origin &&
1022                  !opts->explicit_cleanup)
1023                 argv_array_push(&cmd.args, "--cleanup=verbatim");
1024
1025         if ((flags & ALLOW_EMPTY))
1026                 argv_array_push(&cmd.args, "--allow-empty");
1027
1028         if (!(flags & EDIT_MSG))
1029                 argv_array_push(&cmd.args, "--allow-empty-message");
1030
1031         if (is_rebase_i(opts) && !(flags & EDIT_MSG))
1032                 return run_command_silent_on_success(&cmd);
1033         else
1034                 return run_command(&cmd);
1035 }
1036
1037 static int rest_is_empty(const struct strbuf *sb, int start)
1038 {
1039         int i, eol;
1040         const char *nl;
1041
1042         /* Check if the rest is just whitespace and Signed-off-by's. */
1043         for (i = start; i < sb->len; i++) {
1044                 nl = memchr(sb->buf + i, '\n', sb->len - i);
1045                 if (nl)
1046                         eol = nl - sb->buf;
1047                 else
1048                         eol = sb->len;
1049
1050                 if (strlen(sign_off_header) <= eol - i &&
1051                     starts_with(sb->buf + i, sign_off_header)) {
1052                         i = eol;
1053                         continue;
1054                 }
1055                 while (i < eol)
1056                         if (!isspace(sb->buf[i++]))
1057                                 return 0;
1058         }
1059
1060         return 1;
1061 }
1062
1063 void cleanup_message(struct strbuf *msgbuf,
1064         enum commit_msg_cleanup_mode cleanup_mode, int verbose)
1065 {
1066         if (verbose || /* Truncate the message just before the diff, if any. */
1067             cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS)
1068                 strbuf_setlen(msgbuf, wt_status_locate_end(msgbuf->buf, msgbuf->len));
1069         if (cleanup_mode != COMMIT_MSG_CLEANUP_NONE)
1070                 strbuf_stripspace(msgbuf, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1071 }
1072
1073 /*
1074  * Find out if the message in the strbuf contains only whitespace and
1075  * Signed-off-by lines.
1076  */
1077 int message_is_empty(const struct strbuf *sb,
1078                      enum commit_msg_cleanup_mode cleanup_mode)
1079 {
1080         if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1081                 return 0;
1082         return rest_is_empty(sb, 0);
1083 }
1084
1085 /*
1086  * See if the user edited the message in the editor or left what
1087  * was in the template intact
1088  */
1089 int template_untouched(const struct strbuf *sb, const char *template_file,
1090                        enum commit_msg_cleanup_mode cleanup_mode)
1091 {
1092         struct strbuf tmpl = STRBUF_INIT;
1093         const char *start;
1094
1095         if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1096                 return 0;
1097
1098         if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1099                 return 0;
1100
1101         strbuf_stripspace(&tmpl, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1102         if (!skip_prefix(sb->buf, tmpl.buf, &start))
1103                 start = sb->buf;
1104         strbuf_release(&tmpl);
1105         return rest_is_empty(sb, start - sb->buf);
1106 }
1107
1108 int update_head_with_reflog(const struct commit *old_head,
1109                             const struct object_id *new_head,
1110                             const char *action, const struct strbuf *msg,
1111                             struct strbuf *err)
1112 {
1113         struct ref_transaction *transaction;
1114         struct strbuf sb = STRBUF_INIT;
1115         const char *nl;
1116         int ret = 0;
1117
1118         if (action) {
1119                 strbuf_addstr(&sb, action);
1120                 strbuf_addstr(&sb, ": ");
1121         }
1122
1123         nl = strchr(msg->buf, '\n');
1124         if (nl) {
1125                 strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
1126         } else {
1127                 strbuf_addbuf(&sb, msg);
1128                 strbuf_addch(&sb, '\n');
1129         }
1130
1131         transaction = ref_transaction_begin(err);
1132         if (!transaction ||
1133             ref_transaction_update(transaction, "HEAD", new_head,
1134                                    old_head ? &old_head->object.oid : &null_oid,
1135                                    0, sb.buf, err) ||
1136             ref_transaction_commit(transaction, err)) {
1137                 ret = -1;
1138         }
1139         ref_transaction_free(transaction);
1140         strbuf_release(&sb);
1141
1142         return ret;
1143 }
1144
1145 static int run_rewrite_hook(const struct object_id *oldoid,
1146                             const struct object_id *newoid)
1147 {
1148         struct child_process proc = CHILD_PROCESS_INIT;
1149         const char *argv[3];
1150         int code;
1151         struct strbuf sb = STRBUF_INIT;
1152
1153         argv[0] = find_hook("post-rewrite");
1154         if (!argv[0])
1155                 return 0;
1156
1157         argv[1] = "amend";
1158         argv[2] = NULL;
1159
1160         proc.argv = argv;
1161         proc.in = -1;
1162         proc.stdout_to_stderr = 1;
1163         proc.trace2_hook_name = "post-rewrite";
1164
1165         code = start_command(&proc);
1166         if (code)
1167                 return code;
1168         strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1169         sigchain_push(SIGPIPE, SIG_IGN);
1170         write_in_full(proc.in, sb.buf, sb.len);
1171         close(proc.in);
1172         strbuf_release(&sb);
1173         sigchain_pop(SIGPIPE);
1174         return finish_command(&proc);
1175 }
1176
1177 void commit_post_rewrite(struct repository *r,
1178                          const struct commit *old_head,
1179                          const struct object_id *new_head)
1180 {
1181         struct notes_rewrite_cfg *cfg;
1182
1183         cfg = init_copy_notes_for_rewrite("amend");
1184         if (cfg) {
1185                 /* we are amending, so old_head is not NULL */
1186                 copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
1187                 finish_copy_notes_for_rewrite(r, cfg, "Notes added by 'git commit --amend'");
1188         }
1189         run_rewrite_hook(&old_head->object.oid, new_head);
1190 }
1191
1192 static int run_prepare_commit_msg_hook(struct repository *r,
1193                                        struct strbuf *msg,
1194                                        const char *commit)
1195 {
1196         struct argv_array hook_env = ARGV_ARRAY_INIT;
1197         int ret;
1198         const char *name;
1199
1200         name = git_path_commit_editmsg();
1201         if (write_message(msg->buf, msg->len, name, 0))
1202                 return -1;
1203
1204         argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", r->index_file);
1205         argv_array_push(&hook_env, "GIT_EDITOR=:");
1206         if (commit)
1207                 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1208                                   "commit", commit, NULL);
1209         else
1210                 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1211                                   "message", NULL);
1212         if (ret)
1213                 ret = error(_("'prepare-commit-msg' hook failed"));
1214         argv_array_clear(&hook_env);
1215
1216         return ret;
1217 }
1218
1219 static const char implicit_ident_advice_noconfig[] =
1220 N_("Your name and email address were configured automatically based\n"
1221 "on your username and hostname. Please check that they are accurate.\n"
1222 "You can suppress this message by setting them explicitly. Run the\n"
1223 "following command and follow the instructions in your editor to edit\n"
1224 "your configuration file:\n"
1225 "\n"
1226 "    git config --global --edit\n"
1227 "\n"
1228 "After doing this, you may fix the identity used for this commit with:\n"
1229 "\n"
1230 "    git commit --amend --reset-author\n");
1231
1232 static const char implicit_ident_advice_config[] =
1233 N_("Your name and email address were configured automatically based\n"
1234 "on your username and hostname. Please check that they are accurate.\n"
1235 "You can suppress this message by setting them explicitly:\n"
1236 "\n"
1237 "    git config --global user.name \"Your Name\"\n"
1238 "    git config --global user.email you@example.com\n"
1239 "\n"
1240 "After doing this, you may fix the identity used for this commit with:\n"
1241 "\n"
1242 "    git commit --amend --reset-author\n");
1243
1244 static const char *implicit_ident_advice(void)
1245 {
1246         char *user_config = expand_user_path("~/.gitconfig", 0);
1247         char *xdg_config = xdg_config_home("config");
1248         int config_exists = file_exists(user_config) || file_exists(xdg_config);
1249
1250         free(user_config);
1251         free(xdg_config);
1252
1253         if (config_exists)
1254                 return _(implicit_ident_advice_config);
1255         else
1256                 return _(implicit_ident_advice_noconfig);
1257
1258 }
1259
1260 void print_commit_summary(struct repository *r,
1261                           const char *prefix,
1262                           const struct object_id *oid,
1263                           unsigned int flags)
1264 {
1265         struct rev_info rev;
1266         struct commit *commit;
1267         struct strbuf format = STRBUF_INIT;
1268         const char *head;
1269         struct pretty_print_context pctx = {0};
1270         struct strbuf author_ident = STRBUF_INIT;
1271         struct strbuf committer_ident = STRBUF_INIT;
1272
1273         commit = lookup_commit(r, oid);
1274         if (!commit)
1275                 die(_("couldn't look up newly created commit"));
1276         if (parse_commit(commit))
1277                 die(_("could not parse newly created commit"));
1278
1279         strbuf_addstr(&format, "format:%h] %s");
1280
1281         format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1282         format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1283         if (strbuf_cmp(&author_ident, &committer_ident)) {
1284                 strbuf_addstr(&format, "\n Author: ");
1285                 strbuf_addbuf_percentquote(&format, &author_ident);
1286         }
1287         if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
1288                 struct strbuf date = STRBUF_INIT;
1289
1290                 format_commit_message(commit, "%ad", &date, &pctx);
1291                 strbuf_addstr(&format, "\n Date: ");
1292                 strbuf_addbuf_percentquote(&format, &date);
1293                 strbuf_release(&date);
1294         }
1295         if (!committer_ident_sufficiently_given()) {
1296                 strbuf_addstr(&format, "\n Committer: ");
1297                 strbuf_addbuf_percentquote(&format, &committer_ident);
1298                 if (advice_implicit_identity) {
1299                         strbuf_addch(&format, '\n');
1300                         strbuf_addstr(&format, implicit_ident_advice());
1301                 }
1302         }
1303         strbuf_release(&author_ident);
1304         strbuf_release(&committer_ident);
1305
1306         repo_init_revisions(r, &rev, prefix);
1307         setup_revisions(0, NULL, &rev, NULL);
1308
1309         rev.diff = 1;
1310         rev.diffopt.output_format =
1311                 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1312
1313         rev.verbose_header = 1;
1314         rev.show_root_diff = 1;
1315         get_commit_format(format.buf, &rev);
1316         rev.always_show_header = 0;
1317         rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1318         rev.diffopt.break_opt = 0;
1319         diff_setup_done(&rev.diffopt);
1320
1321         head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1322         if (!head)
1323                 die_errno(_("unable to resolve HEAD after creating commit"));
1324         if (!strcmp(head, "HEAD"))
1325                 head = _("detached HEAD");
1326         else
1327                 skip_prefix(head, "refs/heads/", &head);
1328         printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1329                                                 _(" (root-commit)") : "");
1330
1331         if (!log_tree_commit(&rev, commit)) {
1332                 rev.always_show_header = 1;
1333                 rev.use_terminator = 1;
1334                 log_tree_commit(&rev, commit);
1335         }
1336
1337         strbuf_release(&format);
1338 }
1339
1340 static int parse_head(struct repository *r, struct commit **head)
1341 {
1342         struct commit *current_head;
1343         struct object_id oid;
1344
1345         if (get_oid("HEAD", &oid)) {
1346                 current_head = NULL;
1347         } else {
1348                 current_head = lookup_commit_reference(r, &oid);
1349                 if (!current_head)
1350                         return error(_("could not parse HEAD"));
1351                 if (!oideq(&oid, &current_head->object.oid)) {
1352                         warning(_("HEAD %s is not a commit!"),
1353                                 oid_to_hex(&oid));
1354                 }
1355                 if (parse_commit(current_head))
1356                         return error(_("could not parse HEAD commit"));
1357         }
1358         *head = current_head;
1359
1360         return 0;
1361 }
1362
1363 /*
1364  * Try to commit without forking 'git commit'. In some cases we need
1365  * to run 'git commit' to display an error message
1366  *
1367  * Returns:
1368  *  -1 - error unable to commit
1369  *   0 - success
1370  *   1 - run 'git commit'
1371  */
1372 static int try_to_commit(struct repository *r,
1373                          struct strbuf *msg, const char *author,
1374                          struct replay_opts *opts, unsigned int flags,
1375                          struct object_id *oid)
1376 {
1377         struct object_id tree;
1378         struct commit *current_head;
1379         struct commit_list *parents = NULL;
1380         struct commit_extra_header *extra = NULL;
1381         struct strbuf err = STRBUF_INIT;
1382         struct strbuf commit_msg = STRBUF_INIT;
1383         char *amend_author = NULL;
1384         const char *hook_commit = NULL;
1385         enum commit_msg_cleanup_mode cleanup;
1386         int res = 0;
1387
1388         if (parse_head(r, &current_head))
1389                 return -1;
1390
1391         if (flags & AMEND_MSG) {
1392                 const char *exclude_gpgsig[] = { "gpgsig", NULL };
1393                 const char *out_enc = get_commit_output_encoding();
1394                 const char *message = logmsg_reencode(current_head, NULL,
1395                                                       out_enc);
1396
1397                 if (!msg) {
1398                         const char *orig_message = NULL;
1399
1400                         find_commit_subject(message, &orig_message);
1401                         msg = &commit_msg;
1402                         strbuf_addstr(msg, orig_message);
1403                         hook_commit = "HEAD";
1404                 }
1405                 author = amend_author = get_author(message);
1406                 unuse_commit_buffer(current_head, message);
1407                 if (!author) {
1408                         res = error(_("unable to parse commit author"));
1409                         goto out;
1410                 }
1411                 parents = copy_commit_list(current_head->parents);
1412                 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1413         } else if (current_head) {
1414                 commit_list_insert(current_head, &parents);
1415         }
1416
1417         if (write_index_as_tree(&tree, r->index, r->index_file, 0, NULL)) {
1418                 res = error(_("git write-tree failed to write a tree"));
1419                 goto out;
1420         }
1421
1422         if (!(flags & ALLOW_EMPTY) && oideq(current_head ?
1423                                             get_commit_tree_oid(current_head) :
1424                                             the_hash_algo->empty_tree, &tree)) {
1425                 res = 1; /* run 'git commit' to display error message */
1426                 goto out;
1427         }
1428
1429         if (find_hook("prepare-commit-msg")) {
1430                 res = run_prepare_commit_msg_hook(r, msg, hook_commit);
1431                 if (res)
1432                         goto out;
1433                 if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1434                                      2048) < 0) {
1435                         res = error_errno(_("unable to read commit message "
1436                                               "from '%s'"),
1437                                             git_path_commit_editmsg());
1438                         goto out;
1439                 }
1440                 msg = &commit_msg;
1441         }
1442
1443         if (flags & CLEANUP_MSG)
1444                 cleanup = COMMIT_MSG_CLEANUP_ALL;
1445         else if ((opts->signoff || opts->record_origin) &&
1446                  !opts->explicit_cleanup)
1447                 cleanup = COMMIT_MSG_CLEANUP_SPACE;
1448         else
1449                 cleanup = opts->default_msg_cleanup;
1450
1451         if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1452                 strbuf_stripspace(msg, cleanup == COMMIT_MSG_CLEANUP_ALL);
1453         if ((flags & EDIT_MSG) && message_is_empty(msg, cleanup)) {
1454                 res = 1; /* run 'git commit' to display error message */
1455                 goto out;
1456         }
1457
1458         reset_ident_date();
1459
1460         if (commit_tree_extended(msg->buf, msg->len, &tree, parents,
1461                                  oid, author, opts->gpg_sign, extra)) {
1462                 res = error(_("failed to write commit object"));
1463                 goto out;
1464         }
1465
1466         if (update_head_with_reflog(current_head, oid,
1467                                     getenv("GIT_REFLOG_ACTION"), msg, &err)) {
1468                 res = error("%s", err.buf);
1469                 goto out;
1470         }
1471
1472         if (flags & AMEND_MSG)
1473                 commit_post_rewrite(r, current_head, oid);
1474
1475 out:
1476         free_commit_extra_headers(extra);
1477         strbuf_release(&err);
1478         strbuf_release(&commit_msg);
1479         free(amend_author);
1480
1481         return res;
1482 }
1483
1484 static int do_commit(struct repository *r,
1485                      const char *msg_file, const char *author,
1486                      struct replay_opts *opts, unsigned int flags)
1487 {
1488         int res = 1;
1489
1490         if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG) &&
1491             !(flags & CREATE_ROOT_COMMIT)) {
1492                 struct object_id oid;
1493                 struct strbuf sb = STRBUF_INIT;
1494
1495                 if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1496                         return error_errno(_("unable to read commit message "
1497                                              "from '%s'"),
1498                                            msg_file);
1499
1500                 res = try_to_commit(r, msg_file ? &sb : NULL,
1501                                     author, opts, flags, &oid);
1502                 strbuf_release(&sb);
1503                 if (!res) {
1504                         unlink(git_path_cherry_pick_head(r));
1505                         unlink(git_path_merge_msg(r));
1506                         if (!is_rebase_i(opts))
1507                                 print_commit_summary(r, NULL, &oid,
1508                                                 SUMMARY_SHOW_AUTHOR_DATE);
1509                         return res;
1510                 }
1511         }
1512         if (res == 1)
1513                 return run_git_commit(r, msg_file, opts, flags);
1514
1515         return res;
1516 }
1517
1518 static int is_original_commit_empty(struct commit *commit)
1519 {
1520         const struct object_id *ptree_oid;
1521
1522         if (parse_commit(commit))
1523                 return error(_("could not parse commit %s"),
1524                              oid_to_hex(&commit->object.oid));
1525         if (commit->parents) {
1526                 struct commit *parent = commit->parents->item;
1527                 if (parse_commit(parent))
1528                         return error(_("could not parse parent commit %s"),
1529                                 oid_to_hex(&parent->object.oid));
1530                 ptree_oid = get_commit_tree_oid(parent);
1531         } else {
1532                 ptree_oid = the_hash_algo->empty_tree; /* commit is root */
1533         }
1534
1535         return oideq(ptree_oid, get_commit_tree_oid(commit));
1536 }
1537
1538 /*
1539  * Do we run "git commit" with "--allow-empty"?
1540  */
1541 static int allow_empty(struct repository *r,
1542                        struct replay_opts *opts,
1543                        struct commit *commit)
1544 {
1545         int index_unchanged, empty_commit;
1546
1547         /*
1548          * Three cases:
1549          *
1550          * (1) we do not allow empty at all and error out.
1551          *
1552          * (2) we allow ones that were initially empty, but
1553          * forbid the ones that become empty;
1554          *
1555          * (3) we allow both.
1556          */
1557         if (!opts->allow_empty)
1558                 return 0; /* let "git commit" barf as necessary */
1559
1560         index_unchanged = is_index_unchanged(r);
1561         if (index_unchanged < 0)
1562                 return index_unchanged;
1563         if (!index_unchanged)
1564                 return 0; /* we do not have to say --allow-empty */
1565
1566         if (opts->keep_redundant_commits)
1567                 return 1;
1568
1569         empty_commit = is_original_commit_empty(commit);
1570         if (empty_commit < 0)
1571                 return empty_commit;
1572         if (!empty_commit)
1573                 return 0;
1574         else
1575                 return 1;
1576 }
1577
1578 static struct {
1579         char c;
1580         const char *str;
1581 } todo_command_info[] = {
1582         { 'p', "pick" },
1583         { 0,   "revert" },
1584         { 'e', "edit" },
1585         { 'r', "reword" },
1586         { 'f', "fixup" },
1587         { 's', "squash" },
1588         { 'x', "exec" },
1589         { 'b', "break" },
1590         { 'l', "label" },
1591         { 't', "reset" },
1592         { 'm', "merge" },
1593         { 0,   "noop" },
1594         { 'd', "drop" },
1595         { 0,   NULL }
1596 };
1597
1598 static const char *command_to_string(const enum todo_command command)
1599 {
1600         if (command < TODO_COMMENT)
1601                 return todo_command_info[command].str;
1602         die(_("unknown command: %d"), command);
1603 }
1604
1605 static char command_to_char(const enum todo_command command)
1606 {
1607         if (command < TODO_COMMENT && todo_command_info[command].c)
1608                 return todo_command_info[command].c;
1609         return comment_line_char;
1610 }
1611
1612 static int is_noop(const enum todo_command command)
1613 {
1614         return TODO_NOOP <= command;
1615 }
1616
1617 static int is_fixup(enum todo_command command)
1618 {
1619         return command == TODO_FIXUP || command == TODO_SQUASH;
1620 }
1621
1622 /* Does this command create a (non-merge) commit? */
1623 static int is_pick_or_similar(enum todo_command command)
1624 {
1625         switch (command) {
1626         case TODO_PICK:
1627         case TODO_REVERT:
1628         case TODO_EDIT:
1629         case TODO_REWORD:
1630         case TODO_FIXUP:
1631         case TODO_SQUASH:
1632                 return 1;
1633         default:
1634                 return 0;
1635         }
1636 }
1637
1638 static int update_squash_messages(struct repository *r,
1639                                   enum todo_command command,
1640                                   struct commit *commit,
1641                                   struct replay_opts *opts)
1642 {
1643         struct strbuf buf = STRBUF_INIT;
1644         int res;
1645         const char *message, *body;
1646
1647         if (opts->current_fixup_count > 0) {
1648                 struct strbuf header = STRBUF_INIT;
1649                 char *eol;
1650
1651                 if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
1652                         return error(_("could not read '%s'"),
1653                                 rebase_path_squash_msg());
1654
1655                 eol = buf.buf[0] != comment_line_char ?
1656                         buf.buf : strchrnul(buf.buf, '\n');
1657
1658                 strbuf_addf(&header, "%c ", comment_line_char);
1659                 strbuf_addf(&header, _("This is a combination of %d commits."),
1660                             opts->current_fixup_count + 2);
1661                 strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
1662                 strbuf_release(&header);
1663         } else {
1664                 struct object_id head;
1665                 struct commit *head_commit;
1666                 const char *head_message, *body;
1667
1668                 if (get_oid("HEAD", &head))
1669                         return error(_("need a HEAD to fixup"));
1670                 if (!(head_commit = lookup_commit_reference(r, &head)))
1671                         return error(_("could not read HEAD"));
1672                 if (!(head_message = get_commit_buffer(head_commit, NULL)))
1673                         return error(_("could not read HEAD's commit message"));
1674
1675                 find_commit_subject(head_message, &body);
1676                 if (write_message(body, strlen(body),
1677                                   rebase_path_fixup_msg(), 0)) {
1678                         unuse_commit_buffer(head_commit, head_message);
1679                         return error(_("cannot write '%s'"),
1680                                      rebase_path_fixup_msg());
1681                 }
1682
1683                 strbuf_addf(&buf, "%c ", comment_line_char);
1684                 strbuf_addf(&buf, _("This is a combination of %d commits."), 2);
1685                 strbuf_addf(&buf, "\n%c ", comment_line_char);
1686                 strbuf_addstr(&buf, _("This is the 1st commit message:"));
1687                 strbuf_addstr(&buf, "\n\n");
1688                 strbuf_addstr(&buf, body);
1689
1690                 unuse_commit_buffer(head_commit, head_message);
1691         }
1692
1693         if (!(message = get_commit_buffer(commit, NULL)))
1694                 return error(_("could not read commit message of %s"),
1695                              oid_to_hex(&commit->object.oid));
1696         find_commit_subject(message, &body);
1697
1698         if (command == TODO_SQUASH) {
1699                 unlink(rebase_path_fixup_msg());
1700                 strbuf_addf(&buf, "\n%c ", comment_line_char);
1701                 strbuf_addf(&buf, _("This is the commit message #%d:"),
1702                             ++opts->current_fixup_count + 1);
1703                 strbuf_addstr(&buf, "\n\n");
1704                 strbuf_addstr(&buf, body);
1705         } else if (command == TODO_FIXUP) {
1706                 strbuf_addf(&buf, "\n%c ", comment_line_char);
1707                 strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
1708                             ++opts->current_fixup_count + 1);
1709                 strbuf_addstr(&buf, "\n\n");
1710                 strbuf_add_commented_lines(&buf, body, strlen(body));
1711         } else
1712                 return error(_("unknown command: %d"), command);
1713         unuse_commit_buffer(commit, message);
1714
1715         res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
1716         strbuf_release(&buf);
1717
1718         if (!res) {
1719                 strbuf_addf(&opts->current_fixups, "%s%s %s",
1720                             opts->current_fixups.len ? "\n" : "",
1721                             command_to_string(command),
1722                             oid_to_hex(&commit->object.oid));
1723                 res = write_message(opts->current_fixups.buf,
1724                                     opts->current_fixups.len,
1725                                     rebase_path_current_fixups(), 0);
1726         }
1727
1728         return res;
1729 }
1730
1731 static void flush_rewritten_pending(void)
1732 {
1733         struct strbuf buf = STRBUF_INIT;
1734         struct object_id newoid;
1735         FILE *out;
1736
1737         if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
1738             !get_oid("HEAD", &newoid) &&
1739             (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1740                 char *bol = buf.buf, *eol;
1741
1742                 while (*bol) {
1743                         eol = strchrnul(bol, '\n');
1744                         fprintf(out, "%.*s %s\n", (int)(eol - bol),
1745                                         bol, oid_to_hex(&newoid));
1746                         if (!*eol)
1747                                 break;
1748                         bol = eol + 1;
1749                 }
1750                 fclose(out);
1751                 unlink(rebase_path_rewritten_pending());
1752         }
1753         strbuf_release(&buf);
1754 }
1755
1756 static void record_in_rewritten(struct object_id *oid,
1757                 enum todo_command next_command)
1758 {
1759         FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
1760
1761         if (!out)
1762                 return;
1763
1764         fprintf(out, "%s\n", oid_to_hex(oid));
1765         fclose(out);
1766
1767         if (!is_fixup(next_command))
1768                 flush_rewritten_pending();
1769 }
1770
1771 static int do_pick_commit(struct repository *r,
1772                           enum todo_command command,
1773                           struct commit *commit,
1774                           struct replay_opts *opts,
1775                           int final_fixup)
1776 {
1777         unsigned int flags = opts->edit ? EDIT_MSG : 0;
1778         const char *msg_file = opts->edit ? NULL : git_path_merge_msg(r);
1779         struct object_id head;
1780         struct commit *base, *next, *parent;
1781         const char *base_label, *next_label;
1782         char *author = NULL;
1783         struct commit_message msg = { NULL, NULL, NULL, NULL };
1784         struct strbuf msgbuf = STRBUF_INIT;
1785         int res, unborn = 0, allow;
1786
1787         if (opts->no_commit) {
1788                 /*
1789                  * We do not intend to commit immediately.  We just want to
1790                  * merge the differences in, so let's compute the tree
1791                  * that represents the "current" state for merge-recursive
1792                  * to work on.
1793                  */
1794                 if (write_index_as_tree(&head, r->index, r->index_file, 0, NULL))
1795                         return error(_("your index file is unmerged."));
1796         } else {
1797                 unborn = get_oid("HEAD", &head);
1798                 /* Do we want to generate a root commit? */
1799                 if (is_pick_or_similar(command) && opts->have_squash_onto &&
1800                     oideq(&head, &opts->squash_onto)) {
1801                         if (is_fixup(command))
1802                                 return error(_("cannot fixup root commit"));
1803                         flags |= CREATE_ROOT_COMMIT;
1804                         unborn = 1;
1805                 } else if (unborn)
1806                         oidcpy(&head, the_hash_algo->empty_tree);
1807                 if (index_differs_from(r, unborn ? empty_tree_oid_hex() : "HEAD",
1808                                        NULL, 0))
1809                         return error_dirty_index(r, opts);
1810         }
1811         discard_index(r->index);
1812
1813         if (!commit->parents)
1814                 parent = NULL;
1815         else if (commit->parents->next) {
1816                 /* Reverting or cherry-picking a merge commit */
1817                 int cnt;
1818                 struct commit_list *p;
1819
1820                 if (!opts->mainline)
1821                         return error(_("commit %s is a merge but no -m option was given."),
1822                                 oid_to_hex(&commit->object.oid));
1823
1824                 for (cnt = 1, p = commit->parents;
1825                      cnt != opts->mainline && p;
1826                      cnt++)
1827                         p = p->next;
1828                 if (cnt != opts->mainline || !p)
1829                         return error(_("commit %s does not have parent %d"),
1830                                 oid_to_hex(&commit->object.oid), opts->mainline);
1831                 parent = p->item;
1832         } else if (1 < opts->mainline)
1833                 /*
1834                  *  Non-first parent explicitly specified as mainline for
1835                  *  non-merge commit
1836                  */
1837                 return error(_("commit %s does not have parent %d"),
1838                              oid_to_hex(&commit->object.oid), opts->mainline);
1839         else
1840                 parent = commit->parents->item;
1841
1842         if (get_message(commit, &msg) != 0)
1843                 return error(_("cannot get commit message for %s"),
1844                         oid_to_hex(&commit->object.oid));
1845
1846         if (opts->allow_ff && !is_fixup(command) &&
1847             ((parent && oideq(&parent->object.oid, &head)) ||
1848              (!parent && unborn))) {
1849                 if (is_rebase_i(opts))
1850                         write_author_script(msg.message);
1851                 res = fast_forward_to(r, &commit->object.oid, &head, unborn,
1852                         opts);
1853                 if (res || command != TODO_REWORD)
1854                         goto leave;
1855                 flags |= EDIT_MSG | AMEND_MSG | VERIFY_MSG;
1856                 msg_file = NULL;
1857                 goto fast_forward_edit;
1858         }
1859         if (parent && parse_commit(parent) < 0)
1860                 /* TRANSLATORS: The first %s will be a "todo" command like
1861                    "revert" or "pick", the second %s a SHA1. */
1862                 return error(_("%s: cannot parse parent commit %s"),
1863                         command_to_string(command),
1864                         oid_to_hex(&parent->object.oid));
1865
1866         /*
1867          * "commit" is an existing commit.  We would want to apply
1868          * the difference it introduces since its first parent "prev"
1869          * on top of the current HEAD if we are cherry-pick.  Or the
1870          * reverse of it if we are revert.
1871          */
1872
1873         if (command == TODO_REVERT) {
1874                 base = commit;
1875                 base_label = msg.label;
1876                 next = parent;
1877                 next_label = msg.parent_label;
1878                 strbuf_addstr(&msgbuf, "Revert \"");
1879                 strbuf_addstr(&msgbuf, msg.subject);
1880                 strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
1881                 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1882
1883                 if (commit->parents && commit->parents->next) {
1884                         strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
1885                         strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
1886                 }
1887                 strbuf_addstr(&msgbuf, ".\n");
1888         } else {
1889                 const char *p;
1890
1891                 base = parent;
1892                 base_label = msg.parent_label;
1893                 next = commit;
1894                 next_label = msg.label;
1895
1896                 /* Append the commit log message to msgbuf. */
1897                 if (find_commit_subject(msg.message, &p))
1898                         strbuf_addstr(&msgbuf, p);
1899
1900                 if (opts->record_origin) {
1901                         strbuf_complete_line(&msgbuf);
1902                         if (!has_conforming_footer(&msgbuf, NULL, 0))
1903                                 strbuf_addch(&msgbuf, '\n');
1904                         strbuf_addstr(&msgbuf, cherry_picked_prefix);
1905                         strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1906                         strbuf_addstr(&msgbuf, ")\n");
1907                 }
1908                 if (!is_fixup(command))
1909                         author = get_author(msg.message);
1910         }
1911
1912         if (command == TODO_REWORD)
1913                 flags |= EDIT_MSG | VERIFY_MSG;
1914         else if (is_fixup(command)) {
1915                 if (update_squash_messages(r, command, commit, opts))
1916                         return -1;
1917                 flags |= AMEND_MSG;
1918                 if (!final_fixup)
1919                         msg_file = rebase_path_squash_msg();
1920                 else if (file_exists(rebase_path_fixup_msg())) {
1921                         flags |= CLEANUP_MSG;
1922                         msg_file = rebase_path_fixup_msg();
1923                 } else {
1924                         const char *dest = git_path_squash_msg(r);
1925                         unlink(dest);
1926                         if (copy_file(dest, rebase_path_squash_msg(), 0666))
1927                                 return error(_("could not rename '%s' to '%s'"),
1928                                              rebase_path_squash_msg(), dest);
1929                         unlink(git_path_merge_msg(r));
1930                         msg_file = dest;
1931                         flags |= EDIT_MSG;
1932                 }
1933         }
1934
1935         if (opts->signoff && !is_fixup(command))
1936                 append_signoff(&msgbuf, 0, 0);
1937
1938         if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1939                 res = -1;
1940         else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
1941                 res = do_recursive_merge(r, base, next, base_label, next_label,
1942                                          &head, &msgbuf, opts);
1943                 if (res < 0)
1944                         goto leave;
1945
1946                 res |= write_message(msgbuf.buf, msgbuf.len,
1947                                      git_path_merge_msg(r), 0);
1948         } else {
1949                 struct commit_list *common = NULL;
1950                 struct commit_list *remotes = NULL;
1951
1952                 res = write_message(msgbuf.buf, msgbuf.len,
1953                                     git_path_merge_msg(r), 0);
1954
1955                 commit_list_insert(base, &common);
1956                 commit_list_insert(next, &remotes);
1957                 res |= try_merge_command(r, opts->strategy,
1958                                          opts->xopts_nr, (const char **)opts->xopts,
1959                                         common, oid_to_hex(&head), remotes);
1960                 free_commit_list(common);
1961                 free_commit_list(remotes);
1962         }
1963         strbuf_release(&msgbuf);
1964
1965         /*
1966          * If the merge was clean or if it failed due to conflict, we write
1967          * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1968          * However, if the merge did not even start, then we don't want to
1969          * write it at all.
1970          */
1971         if (command == TODO_PICK && !opts->no_commit && (res == 0 || res == 1) &&
1972             update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
1973                        REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1974                 res = -1;
1975         if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
1976             update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
1977                        REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1978                 res = -1;
1979
1980         if (res) {
1981                 error(command == TODO_REVERT
1982                       ? _("could not revert %s... %s")
1983                       : _("could not apply %s... %s"),
1984                       short_commit_name(commit), msg.subject);
1985                 print_advice(r, res == 1, opts);
1986                 repo_rerere(r, opts->allow_rerere_auto);
1987                 goto leave;
1988         }
1989
1990         allow = allow_empty(r, opts, commit);
1991         if (allow < 0) {
1992                 res = allow;
1993                 goto leave;
1994         } else if (allow)
1995                 flags |= ALLOW_EMPTY;
1996         if (!opts->no_commit) {
1997 fast_forward_edit:
1998                 if (author || command == TODO_REVERT || (flags & AMEND_MSG))
1999                         res = do_commit(r, msg_file, author, opts, flags);
2000                 else
2001                         res = error(_("unable to parse commit author"));
2002         }
2003
2004         if (!res && final_fixup) {
2005                 unlink(rebase_path_fixup_msg());
2006                 unlink(rebase_path_squash_msg());
2007                 unlink(rebase_path_current_fixups());
2008                 strbuf_reset(&opts->current_fixups);
2009                 opts->current_fixup_count = 0;
2010         }
2011
2012 leave:
2013         free_message(commit, &msg);
2014         free(author);
2015         update_abort_safety_file();
2016
2017         return res;
2018 }
2019
2020 static int prepare_revs(struct replay_opts *opts)
2021 {
2022         /*
2023          * picking (but not reverting) ranges (but not individual revisions)
2024          * should be done in reverse
2025          */
2026         if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
2027                 opts->revs->reverse ^= 1;
2028
2029         if (prepare_revision_walk(opts->revs))
2030                 return error(_("revision walk setup failed"));
2031
2032         return 0;
2033 }
2034
2035 static int read_and_refresh_cache(struct repository *r,
2036                                   struct replay_opts *opts)
2037 {
2038         struct lock_file index_lock = LOCK_INIT;
2039         int index_fd = repo_hold_locked_index(r, &index_lock, 0);
2040         if (repo_read_index(r) < 0) {
2041                 rollback_lock_file(&index_lock);
2042                 return error(_("git %s: failed to read the index"),
2043                         _(action_name(opts)));
2044         }
2045         refresh_index(r->index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
2046         if (index_fd >= 0) {
2047                 if (write_locked_index(r->index, &index_lock,
2048                                        COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
2049                         return error(_("git %s: failed to refresh the index"),
2050                                 _(action_name(opts)));
2051                 }
2052         }
2053         return 0;
2054 }
2055
2056 enum todo_item_flags {
2057         TODO_EDIT_MERGE_MSG = 1
2058 };
2059
2060 void todo_list_release(struct todo_list *todo_list)
2061 {
2062         strbuf_release(&todo_list->buf);
2063         FREE_AND_NULL(todo_list->items);
2064         todo_list->nr = todo_list->alloc = 0;
2065 }
2066
2067 static struct todo_item *append_new_todo(struct todo_list *todo_list)
2068 {
2069         ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
2070         return todo_list->items + todo_list->nr++;
2071 }
2072
2073 const char *todo_item_get_arg(struct todo_list *todo_list,
2074                               struct todo_item *item)
2075 {
2076         return todo_list->buf.buf + item->arg_offset;
2077 }
2078
2079 static int parse_insn_line(struct repository *r, struct todo_item *item,
2080                            const char *buf, const char *bol, char *eol)
2081 {
2082         struct object_id commit_oid;
2083         char *end_of_object_name;
2084         int i, saved, status, padding;
2085
2086         item->flags = 0;
2087
2088         /* left-trim */
2089         bol += strspn(bol, " \t");
2090
2091         if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
2092                 item->command = TODO_COMMENT;
2093                 item->commit = NULL;
2094                 item->arg_offset = bol - buf;
2095                 item->arg_len = eol - bol;
2096                 return 0;
2097         }
2098
2099         for (i = 0; i < TODO_COMMENT; i++)
2100                 if (skip_prefix(bol, todo_command_info[i].str, &bol)) {
2101                         item->command = i;
2102                         break;
2103                 } else if ((bol + 1 == eol || bol[1] == ' ') &&
2104                            *bol == todo_command_info[i].c) {
2105                         bol++;
2106                         item->command = i;
2107                         break;
2108                 }
2109         if (i >= TODO_COMMENT)
2110                 return -1;
2111
2112         /* Eat up extra spaces/ tabs before object name */
2113         padding = strspn(bol, " \t");
2114         bol += padding;
2115
2116         if (item->command == TODO_NOOP || item->command == TODO_BREAK) {
2117                 if (bol != eol)
2118                         return error(_("%s does not accept arguments: '%s'"),
2119                                      command_to_string(item->command), bol);
2120                 item->commit = NULL;
2121                 item->arg_offset = bol - buf;
2122                 item->arg_len = eol - bol;
2123                 return 0;
2124         }
2125
2126         if (!padding)
2127                 return error(_("missing arguments for %s"),
2128                              command_to_string(item->command));
2129
2130         if (item->command == TODO_EXEC || item->command == TODO_LABEL ||
2131             item->command == TODO_RESET) {
2132                 item->commit = NULL;
2133                 item->arg_offset = bol - buf;
2134                 item->arg_len = (int)(eol - bol);
2135                 return 0;
2136         }
2137
2138         if (item->command == TODO_MERGE) {
2139                 if (skip_prefix(bol, "-C", &bol))
2140                         bol += strspn(bol, " \t");
2141                 else if (skip_prefix(bol, "-c", &bol)) {
2142                         bol += strspn(bol, " \t");
2143                         item->flags |= TODO_EDIT_MERGE_MSG;
2144                 } else {
2145                         item->flags |= TODO_EDIT_MERGE_MSG;
2146                         item->commit = NULL;
2147                         item->arg_offset = bol - buf;
2148                         item->arg_len = (int)(eol - bol);
2149                         return 0;
2150                 }
2151         }
2152
2153         end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
2154         saved = *end_of_object_name;
2155         *end_of_object_name = '\0';
2156         status = get_oid(bol, &commit_oid);
2157         *end_of_object_name = saved;
2158
2159         bol = end_of_object_name + strspn(end_of_object_name, " \t");
2160         item->arg_offset = bol - buf;
2161         item->arg_len = (int)(eol - bol);
2162
2163         if (status < 0)
2164                 return error(_("could not parse '%.*s'"),
2165                              (int)(end_of_object_name - bol), bol);
2166
2167         item->commit = lookup_commit_reference(r, &commit_oid);
2168         return !item->commit;
2169 }
2170
2171 int sequencer_get_last_command(struct repository *r, enum replay_action *action)
2172 {
2173         struct todo_item item;
2174         char *eol;
2175         const char *todo_file;
2176         struct strbuf buf = STRBUF_INIT;
2177         int ret = -1;
2178
2179         todo_file = git_path_todo_file();
2180         if (strbuf_read_file(&buf, todo_file, 0) < 0) {
2181                 if (errno == ENOENT)
2182                         return -1;
2183                 else
2184                         return error_errno("unable to open '%s'", todo_file);
2185         }
2186         eol = strchrnul(buf.buf, '\n');
2187         if (buf.buf != eol && eol[-1] == '\r')
2188                 eol--; /* strip Carriage Return */
2189         if (parse_insn_line(r, &item, buf.buf, buf.buf, eol))
2190                 goto fail;
2191         if (item.command == TODO_PICK)
2192                 *action = REPLAY_PICK;
2193         else if (item.command == TODO_REVERT)
2194                 *action = REPLAY_REVERT;
2195         else
2196                 goto fail;
2197
2198         ret = 0;
2199
2200  fail:
2201         strbuf_release(&buf);
2202
2203         return ret;
2204 }
2205
2206 int todo_list_parse_insn_buffer(struct repository *r, char *buf,
2207                                 struct todo_list *todo_list)
2208 {
2209         struct todo_item *item;
2210         char *p = buf, *next_p;
2211         int i, res = 0, fixup_okay = file_exists(rebase_path_done());
2212
2213         todo_list->current = todo_list->nr = 0;
2214
2215         for (i = 1; *p; i++, p = next_p) {
2216                 char *eol = strchrnul(p, '\n');
2217
2218                 next_p = *eol ? eol + 1 /* skip LF */ : eol;
2219
2220                 if (p != eol && eol[-1] == '\r')
2221                         eol--; /* strip Carriage Return */
2222
2223                 item = append_new_todo(todo_list);
2224                 item->offset_in_buf = p - todo_list->buf.buf;
2225                 if (parse_insn_line(r, item, buf, p, eol)) {
2226                         res = error(_("invalid line %d: %.*s"),
2227                                 i, (int)(eol - p), p);
2228                         item->command = TODO_COMMENT + 1;
2229                         item->arg_offset = p - buf;
2230                         item->arg_len = (int)(eol - p);
2231                         item->commit = NULL;
2232                 }
2233
2234                 if (fixup_okay)
2235                         ; /* do nothing */
2236                 else if (is_fixup(item->command))
2237                         return error(_("cannot '%s' without a previous commit"),
2238                                 command_to_string(item->command));
2239                 else if (!is_noop(item->command))
2240                         fixup_okay = 1;
2241         }
2242
2243         return res;
2244 }
2245
2246 static int count_commands(struct todo_list *todo_list)
2247 {
2248         int count = 0, i;
2249
2250         for (i = 0; i < todo_list->nr; i++)
2251                 if (todo_list->items[i].command != TODO_COMMENT)
2252                         count++;
2253
2254         return count;
2255 }
2256
2257 static int get_item_line_offset(struct todo_list *todo_list, int index)
2258 {
2259         return index < todo_list->nr ?
2260                 todo_list->items[index].offset_in_buf : todo_list->buf.len;
2261 }
2262
2263 static const char *get_item_line(struct todo_list *todo_list, int index)
2264 {
2265         return todo_list->buf.buf + get_item_line_offset(todo_list, index);
2266 }
2267
2268 static int get_item_line_length(struct todo_list *todo_list, int index)
2269 {
2270         return get_item_line_offset(todo_list, index + 1)
2271                 -  get_item_line_offset(todo_list, index);
2272 }
2273
2274 static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
2275 {
2276         int fd;
2277         ssize_t len;
2278
2279         fd = open(path, O_RDONLY);
2280         if (fd < 0)
2281                 return error_errno(_("could not open '%s'"), path);
2282         len = strbuf_read(sb, fd, 0);
2283         close(fd);
2284         if (len < 0)
2285                 return error(_("could not read '%s'."), path);
2286         return len;
2287 }
2288
2289 static int have_finished_the_last_pick(void)
2290 {
2291         struct strbuf buf = STRBUF_INIT;
2292         const char *eol;
2293         const char *todo_path = git_path_todo_file();
2294         int ret = 0;
2295
2296         if (strbuf_read_file(&buf, todo_path, 0) < 0) {
2297                 if (errno == ENOENT) {
2298                         return 0;
2299                 } else {
2300                         error_errno("unable to open '%s'", todo_path);
2301                         return 0;
2302                 }
2303         }
2304         /* If there is only one line then we are done */
2305         eol = strchr(buf.buf, '\n');
2306         if (!eol || !eol[1])
2307                 ret = 1;
2308
2309         strbuf_release(&buf);
2310
2311         return ret;
2312 }
2313
2314 void sequencer_post_commit_cleanup(struct repository *r)
2315 {
2316         struct replay_opts opts = REPLAY_OPTS_INIT;
2317         int need_cleanup = 0;
2318
2319         if (file_exists(git_path_cherry_pick_head(r))) {
2320                 unlink(git_path_cherry_pick_head(r));
2321                 opts.action = REPLAY_PICK;
2322                 need_cleanup = 1;
2323         }
2324
2325         if (file_exists(git_path_revert_head(r))) {
2326                 unlink(git_path_revert_head(r));
2327                 opts.action = REPLAY_REVERT;
2328                 need_cleanup = 1;
2329         }
2330
2331         if (!need_cleanup)
2332                 return;
2333
2334         if (!have_finished_the_last_pick())
2335                 return;
2336
2337         sequencer_remove_state(&opts);
2338 }
2339
2340 static int read_populate_todo(struct repository *r,
2341                               struct todo_list *todo_list,
2342                               struct replay_opts *opts)
2343 {
2344         struct stat st;
2345         const char *todo_file = get_todo_path(opts);
2346         int res;
2347
2348         strbuf_reset(&todo_list->buf);
2349         if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
2350                 return -1;
2351
2352         res = stat(todo_file, &st);
2353         if (res)
2354                 return error(_("could not stat '%s'"), todo_file);
2355         fill_stat_data(&todo_list->stat, &st);
2356
2357         res = todo_list_parse_insn_buffer(r, todo_list->buf.buf, todo_list);
2358         if (res) {
2359                 if (is_rebase_i(opts))
2360                         return error(_("please fix this using "
2361                                        "'git rebase --edit-todo'."));
2362                 return error(_("unusable instruction sheet: '%s'"), todo_file);
2363         }
2364
2365         if (!todo_list->nr &&
2366             (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
2367                 return error(_("no commits parsed."));
2368
2369         if (!is_rebase_i(opts)) {
2370                 enum todo_command valid =
2371                         opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
2372                 int i;
2373
2374                 for (i = 0; i < todo_list->nr; i++)
2375                         if (valid == todo_list->items[i].command)
2376                                 continue;
2377                         else if (valid == TODO_PICK)
2378                                 return error(_("cannot cherry-pick during a revert."));
2379                         else
2380                                 return error(_("cannot revert during a cherry-pick."));
2381         }
2382
2383         if (is_rebase_i(opts)) {
2384                 struct todo_list done = TODO_LIST_INIT;
2385                 FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
2386
2387                 if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
2388                     !todo_list_parse_insn_buffer(r, done.buf.buf, &done))
2389                         todo_list->done_nr = count_commands(&done);
2390                 else
2391                         todo_list->done_nr = 0;
2392
2393                 todo_list->total_nr = todo_list->done_nr
2394                         + count_commands(todo_list);
2395                 todo_list_release(&done);
2396
2397                 if (f) {
2398                         fprintf(f, "%d\n", todo_list->total_nr);
2399                         fclose(f);
2400                 }
2401         }
2402
2403         return 0;
2404 }
2405
2406 static int git_config_string_dup(char **dest,
2407                                  const char *var, const char *value)
2408 {
2409         if (!value)
2410                 return config_error_nonbool(var);
2411         free(*dest);
2412         *dest = xstrdup(value);
2413         return 0;
2414 }
2415
2416 static int populate_opts_cb(const char *key, const char *value, void *data)
2417 {
2418         struct replay_opts *opts = data;
2419         int error_flag = 1;
2420
2421         if (!value)
2422                 error_flag = 0;
2423         else if (!strcmp(key, "options.no-commit"))
2424                 opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
2425         else if (!strcmp(key, "options.edit"))
2426                 opts->edit = git_config_bool_or_int(key, value, &error_flag);
2427         else if (!strcmp(key, "options.allow-empty"))
2428                 opts->allow_empty =
2429                         git_config_bool_or_int(key, value, &error_flag);
2430         else if (!strcmp(key, "options.allow-empty-message"))
2431                 opts->allow_empty_message =
2432                         git_config_bool_or_int(key, value, &error_flag);
2433         else if (!strcmp(key, "options.keep-redundant-commits"))
2434                 opts->keep_redundant_commits =
2435                         git_config_bool_or_int(key, value, &error_flag);
2436         else if (!strcmp(key, "options.signoff"))
2437                 opts->signoff = git_config_bool_or_int(key, value, &error_flag);
2438         else if (!strcmp(key, "options.record-origin"))
2439                 opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
2440         else if (!strcmp(key, "options.allow-ff"))
2441                 opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
2442         else if (!strcmp(key, "options.mainline"))
2443                 opts->mainline = git_config_int(key, value);
2444         else if (!strcmp(key, "options.strategy"))
2445                 git_config_string_dup(&opts->strategy, key, value);
2446         else if (!strcmp(key, "options.gpg-sign"))
2447                 git_config_string_dup(&opts->gpg_sign, key, value);
2448         else if (!strcmp(key, "options.strategy-option")) {
2449                 ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
2450                 opts->xopts[opts->xopts_nr++] = xstrdup(value);
2451         } else if (!strcmp(key, "options.allow-rerere-auto"))
2452                 opts->allow_rerere_auto =
2453                         git_config_bool_or_int(key, value, &error_flag) ?
2454                                 RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
2455         else if (!strcmp(key, "options.default-msg-cleanup")) {
2456                 opts->explicit_cleanup = 1;
2457                 opts->default_msg_cleanup = get_cleanup_mode(value, 1);
2458         } else
2459                 return error(_("invalid key: %s"), key);
2460
2461         if (!error_flag)
2462                 return error(_("invalid value for %s: %s"), key, value);
2463
2464         return 0;
2465 }
2466
2467 void parse_strategy_opts(struct replay_opts *opts, char *raw_opts)
2468 {
2469         int i;
2470         char *strategy_opts_string = raw_opts;
2471
2472         if (*strategy_opts_string == ' ')
2473                 strategy_opts_string++;
2474
2475         opts->xopts_nr = split_cmdline(strategy_opts_string,
2476                                        (const char ***)&opts->xopts);
2477         for (i = 0; i < opts->xopts_nr; i++) {
2478                 const char *arg = opts->xopts[i];
2479
2480                 skip_prefix(arg, "--", &arg);
2481                 opts->xopts[i] = xstrdup(arg);
2482         }
2483 }
2484
2485 static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
2486 {
2487         strbuf_reset(buf);
2488         if (!read_oneliner(buf, rebase_path_strategy(), 0))
2489                 return;
2490         opts->strategy = strbuf_detach(buf, NULL);
2491         if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2492                 return;
2493
2494         parse_strategy_opts(opts, buf->buf);
2495 }
2496
2497 static int read_populate_opts(struct replay_opts *opts)
2498 {
2499         if (is_rebase_i(opts)) {
2500                 struct strbuf buf = STRBUF_INIT;
2501
2502                 if (read_oneliner(&buf, rebase_path_gpg_sign_opt(), 1)) {
2503                         if (!starts_with(buf.buf, "-S"))
2504                                 strbuf_reset(&buf);
2505                         else {
2506                                 free(opts->gpg_sign);
2507                                 opts->gpg_sign = xstrdup(buf.buf + 2);
2508                         }
2509                         strbuf_reset(&buf);
2510                 }
2511
2512                 if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(), 1)) {
2513                         if (!strcmp(buf.buf, "--rerere-autoupdate"))
2514                                 opts->allow_rerere_auto = RERERE_AUTOUPDATE;
2515                         else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
2516                                 opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
2517                         strbuf_reset(&buf);
2518                 }
2519
2520                 if (file_exists(rebase_path_verbose()))
2521                         opts->verbose = 1;
2522
2523                 if (file_exists(rebase_path_quiet()))
2524                         opts->quiet = 1;
2525
2526                 if (file_exists(rebase_path_signoff())) {
2527                         opts->allow_ff = 0;
2528                         opts->signoff = 1;
2529                 }
2530
2531                 if (file_exists(rebase_path_reschedule_failed_exec()))
2532                         opts->reschedule_failed_exec = 1;
2533
2534                 read_strategy_opts(opts, &buf);
2535                 strbuf_release(&buf);
2536
2537                 if (read_oneliner(&opts->current_fixups,
2538                                   rebase_path_current_fixups(), 1)) {
2539                         const char *p = opts->current_fixups.buf;
2540                         opts->current_fixup_count = 1;
2541                         while ((p = strchr(p, '\n'))) {
2542                                 opts->current_fixup_count++;
2543                                 p++;
2544                         }
2545                 }
2546
2547                 if (read_oneliner(&buf, rebase_path_squash_onto(), 0)) {
2548                         if (get_oid_hex(buf.buf, &opts->squash_onto) < 0)
2549                                 return error(_("unusable squash-onto"));
2550                         opts->have_squash_onto = 1;
2551                 }
2552
2553                 return 0;
2554         }
2555
2556         if (!file_exists(git_path_opts_file()))
2557                 return 0;
2558         /*
2559          * The function git_parse_source(), called from git_config_from_file(),
2560          * may die() in case of a syntactically incorrect file. We do not care
2561          * about this case, though, because we wrote that file ourselves, so we
2562          * are pretty certain that it is syntactically correct.
2563          */
2564         if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
2565                 return error(_("malformed options sheet: '%s'"),
2566                         git_path_opts_file());
2567         return 0;
2568 }
2569
2570 static void write_strategy_opts(struct replay_opts *opts)
2571 {
2572         int i;
2573         struct strbuf buf = STRBUF_INIT;
2574
2575         for (i = 0; i < opts->xopts_nr; ++i)
2576                 strbuf_addf(&buf, " --%s", opts->xopts[i]);
2577
2578         write_file(rebase_path_strategy_opts(), "%s\n", buf.buf);
2579         strbuf_release(&buf);
2580 }
2581
2582 int write_basic_state(struct replay_opts *opts, const char *head_name,
2583                       struct commit *onto, const char *orig_head)
2584 {
2585         const char *quiet = getenv("GIT_QUIET");
2586
2587         if (head_name)
2588                 write_file(rebase_path_head_name(), "%s\n", head_name);
2589         if (onto)
2590                 write_file(rebase_path_onto(), "%s\n",
2591                            oid_to_hex(&onto->object.oid));
2592         if (orig_head)
2593                 write_file(rebase_path_orig_head(), "%s\n", orig_head);
2594
2595         if (quiet)
2596                 write_file(rebase_path_quiet(), "%s\n", quiet);
2597         if (opts->verbose)
2598                 write_file(rebase_path_verbose(), "%s", "");
2599         if (opts->strategy)
2600                 write_file(rebase_path_strategy(), "%s\n", opts->strategy);
2601         if (opts->xopts_nr > 0)
2602                 write_strategy_opts(opts);
2603
2604         if (opts->allow_rerere_auto == RERERE_AUTOUPDATE)
2605                 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2606         else if (opts->allow_rerere_auto == RERERE_NOAUTOUPDATE)
2607                 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2608
2609         if (opts->gpg_sign)
2610                 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts->gpg_sign);
2611         if (opts->signoff)
2612                 write_file(rebase_path_signoff(), "--signoff\n");
2613         if (opts->reschedule_failed_exec)
2614                 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
2615
2616         return 0;
2617 }
2618
2619 static int walk_revs_populate_todo(struct todo_list *todo_list,
2620                                 struct replay_opts *opts)
2621 {
2622         enum todo_command command = opts->action == REPLAY_PICK ?
2623                 TODO_PICK : TODO_REVERT;
2624         const char *command_string = todo_command_info[command].str;
2625         struct commit *commit;
2626
2627         if (prepare_revs(opts))
2628                 return -1;
2629
2630         while ((commit = get_revision(opts->revs))) {
2631                 struct todo_item *item = append_new_todo(todo_list);
2632                 const char *commit_buffer = get_commit_buffer(commit, NULL);
2633                 const char *subject;
2634                 int subject_len;
2635
2636                 item->command = command;
2637                 item->commit = commit;
2638                 item->arg_offset = 0;
2639                 item->arg_len = 0;
2640                 item->offset_in_buf = todo_list->buf.len;
2641                 subject_len = find_commit_subject(commit_buffer, &subject);
2642                 strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
2643                         short_commit_name(commit), subject_len, subject);
2644                 unuse_commit_buffer(commit, commit_buffer);
2645         }
2646
2647         if (!todo_list->nr)
2648                 return error(_("empty commit set passed"));
2649
2650         return 0;
2651 }
2652
2653 static int create_seq_dir(void)
2654 {
2655         if (file_exists(git_path_seq_dir())) {
2656                 error(_("a cherry-pick or revert is already in progress"));
2657                 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
2658                 return -1;
2659         } else if (mkdir(git_path_seq_dir(), 0777) < 0)
2660                 return error_errno(_("could not create sequencer directory '%s'"),
2661                                    git_path_seq_dir());
2662         return 0;
2663 }
2664
2665 static int save_head(const char *head)
2666 {
2667         struct lock_file head_lock = LOCK_INIT;
2668         struct strbuf buf = STRBUF_INIT;
2669         int fd;
2670         ssize_t written;
2671
2672         fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
2673         if (fd < 0)
2674                 return error_errno(_("could not lock HEAD"));
2675         strbuf_addf(&buf, "%s\n", head);
2676         written = write_in_full(fd, buf.buf, buf.len);
2677         strbuf_release(&buf);
2678         if (written < 0) {
2679                 error_errno(_("could not write to '%s'"), git_path_head_file());
2680                 rollback_lock_file(&head_lock);
2681                 return -1;
2682         }
2683         if (commit_lock_file(&head_lock) < 0)
2684                 return error(_("failed to finalize '%s'"), git_path_head_file());
2685         return 0;
2686 }
2687
2688 static int rollback_is_safe(void)
2689 {
2690         struct strbuf sb = STRBUF_INIT;
2691         struct object_id expected_head, actual_head;
2692
2693         if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2694                 strbuf_trim(&sb);
2695                 if (get_oid_hex(sb.buf, &expected_head)) {
2696                         strbuf_release(&sb);
2697                         die(_("could not parse %s"), git_path_abort_safety_file());
2698                 }
2699                 strbuf_release(&sb);
2700         }
2701         else if (errno == ENOENT)
2702                 oidclr(&expected_head);
2703         else
2704                 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2705
2706         if (get_oid("HEAD", &actual_head))
2707                 oidclr(&actual_head);
2708
2709         return oideq(&actual_head, &expected_head);
2710 }
2711
2712 static int reset_for_rollback(const struct object_id *oid)
2713 {
2714         const char *argv[4];    /* reset --merge <arg> + NULL */
2715
2716         argv[0] = "reset";
2717         argv[1] = "--merge";
2718         argv[2] = oid_to_hex(oid);
2719         argv[3] = NULL;
2720         return run_command_v_opt(argv, RUN_GIT_CMD);
2721 }
2722
2723 static int rollback_single_pick(struct repository *r)
2724 {
2725         struct object_id head_oid;
2726
2727         if (!file_exists(git_path_cherry_pick_head(r)) &&
2728             !file_exists(git_path_revert_head(r)))
2729                 return error(_("no cherry-pick or revert in progress"));
2730         if (read_ref_full("HEAD", 0, &head_oid, NULL))
2731                 return error(_("cannot resolve HEAD"));
2732         if (is_null_oid(&head_oid))
2733                 return error(_("cannot abort from a branch yet to be born"));
2734         return reset_for_rollback(&head_oid);
2735 }
2736
2737 int sequencer_rollback(struct repository *r, struct replay_opts *opts)
2738 {
2739         FILE *f;
2740         struct object_id oid;
2741         struct strbuf buf = STRBUF_INIT;
2742         const char *p;
2743
2744         f = fopen(git_path_head_file(), "r");
2745         if (!f && errno == ENOENT) {
2746                 /*
2747                  * There is no multiple-cherry-pick in progress.
2748                  * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2749                  * a single-cherry-pick in progress, abort that.
2750                  */
2751                 return rollback_single_pick(r);
2752         }
2753         if (!f)
2754                 return error_errno(_("cannot open '%s'"), git_path_head_file());
2755         if (strbuf_getline_lf(&buf, f)) {
2756                 error(_("cannot read '%s': %s"), git_path_head_file(),
2757                       ferror(f) ?  strerror(errno) : _("unexpected end of file"));
2758                 fclose(f);
2759                 goto fail;
2760         }
2761         fclose(f);
2762         if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
2763                 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2764                         git_path_head_file());
2765                 goto fail;
2766         }
2767         if (is_null_oid(&oid)) {
2768                 error(_("cannot abort from a branch yet to be born"));
2769                 goto fail;
2770         }
2771
2772         if (!rollback_is_safe()) {
2773                 /* Do not error, just do not rollback */
2774                 warning(_("You seem to have moved HEAD. "
2775                           "Not rewinding, check your HEAD!"));
2776         } else
2777         if (reset_for_rollback(&oid))
2778                 goto fail;
2779         strbuf_release(&buf);
2780         return sequencer_remove_state(opts);
2781 fail:
2782         strbuf_release(&buf);
2783         return -1;
2784 }
2785
2786 static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
2787 {
2788         struct lock_file todo_lock = LOCK_INIT;
2789         const char *todo_path = get_todo_path(opts);
2790         int next = todo_list->current, offset, fd;
2791
2792         /*
2793          * rebase -i writes "git-rebase-todo" without the currently executing
2794          * command, appending it to "done" instead.
2795          */
2796         if (is_rebase_i(opts))
2797                 next++;
2798
2799         fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
2800         if (fd < 0)
2801                 return error_errno(_("could not lock '%s'"), todo_path);
2802         offset = get_item_line_offset(todo_list, next);
2803         if (write_in_full(fd, todo_list->buf.buf + offset,
2804                         todo_list->buf.len - offset) < 0)
2805                 return error_errno(_("could not write to '%s'"), todo_path);
2806         if (commit_lock_file(&todo_lock) < 0)
2807                 return error(_("failed to finalize '%s'"), todo_path);
2808
2809         if (is_rebase_i(opts) && next > 0) {
2810                 const char *done = rebase_path_done();
2811                 int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
2812                 int ret = 0;
2813
2814                 if (fd < 0)
2815                         return 0;
2816                 if (write_in_full(fd, get_item_line(todo_list, next - 1),
2817                                   get_item_line_length(todo_list, next - 1))
2818                     < 0)
2819                         ret = error_errno(_("could not write to '%s'"), done);
2820                 if (close(fd) < 0)
2821                         ret = error_errno(_("failed to finalize '%s'"), done);
2822                 return ret;
2823         }
2824         return 0;
2825 }
2826
2827 static int save_opts(struct replay_opts *opts)
2828 {
2829         const char *opts_file = git_path_opts_file();
2830         int res = 0;
2831
2832         if (opts->no_commit)
2833                 res |= git_config_set_in_file_gently(opts_file,
2834                                         "options.no-commit", "true");
2835         if (opts->edit)
2836                 res |= git_config_set_in_file_gently(opts_file,
2837                                         "options.edit", "true");
2838         if (opts->allow_empty)
2839                 res |= git_config_set_in_file_gently(opts_file,
2840                                         "options.allow-empty", "true");
2841         if (opts->allow_empty_message)
2842                 res |= git_config_set_in_file_gently(opts_file,
2843                                 "options.allow-empty-message", "true");
2844         if (opts->keep_redundant_commits)
2845                 res |= git_config_set_in_file_gently(opts_file,
2846                                 "options.keep-redundant-commits", "true");
2847         if (opts->signoff)
2848                 res |= git_config_set_in_file_gently(opts_file,
2849                                         "options.signoff", "true");
2850         if (opts->record_origin)
2851                 res |= git_config_set_in_file_gently(opts_file,
2852                                         "options.record-origin", "true");
2853         if (opts->allow_ff)
2854                 res |= git_config_set_in_file_gently(opts_file,
2855                                         "options.allow-ff", "true");
2856         if (opts->mainline) {
2857                 struct strbuf buf = STRBUF_INIT;
2858                 strbuf_addf(&buf, "%d", opts->mainline);
2859                 res |= git_config_set_in_file_gently(opts_file,
2860                                         "options.mainline", buf.buf);
2861                 strbuf_release(&buf);
2862         }
2863         if (opts->strategy)
2864                 res |= git_config_set_in_file_gently(opts_file,
2865                                         "options.strategy", opts->strategy);
2866         if (opts->gpg_sign)
2867                 res |= git_config_set_in_file_gently(opts_file,
2868                                         "options.gpg-sign", opts->gpg_sign);
2869         if (opts->xopts) {
2870                 int i;
2871                 for (i = 0; i < opts->xopts_nr; i++)
2872                         res |= git_config_set_multivar_in_file_gently(opts_file,
2873                                         "options.strategy-option",
2874                                         opts->xopts[i], "^$", 0);
2875         }
2876         if (opts->allow_rerere_auto)
2877                 res |= git_config_set_in_file_gently(opts_file,
2878                                 "options.allow-rerere-auto",
2879                                 opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
2880                                 "true" : "false");
2881
2882         if (opts->explicit_cleanup)
2883                 res |= git_config_set_in_file_gently(opts_file,
2884                                 "options.default-msg-cleanup",
2885                                 describe_cleanup_mode(opts->default_msg_cleanup));
2886         return res;
2887 }
2888
2889 static int make_patch(struct repository *r,
2890                       struct commit *commit,
2891                       struct replay_opts *opts)
2892 {
2893         struct strbuf buf = STRBUF_INIT;
2894         struct rev_info log_tree_opt;
2895         const char *subject, *p;
2896         int res = 0;
2897
2898         p = short_commit_name(commit);
2899         if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
2900                 return -1;
2901         if (update_ref("rebase", "REBASE_HEAD", &commit->object.oid,
2902                        NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2903                 res |= error(_("could not update %s"), "REBASE_HEAD");
2904
2905         strbuf_addf(&buf, "%s/patch", get_dir(opts));
2906         memset(&log_tree_opt, 0, sizeof(log_tree_opt));
2907         repo_init_revisions(r, &log_tree_opt, NULL);
2908         log_tree_opt.abbrev = 0;
2909         log_tree_opt.diff = 1;
2910         log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
2911         log_tree_opt.disable_stdin = 1;
2912         log_tree_opt.no_commit_id = 1;
2913         log_tree_opt.diffopt.file = fopen(buf.buf, "w");
2914         log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
2915         if (!log_tree_opt.diffopt.file)
2916                 res |= error_errno(_("could not open '%s'"), buf.buf);
2917         else {
2918                 res |= log_tree_commit(&log_tree_opt, commit);
2919                 fclose(log_tree_opt.diffopt.file);
2920         }
2921         strbuf_reset(&buf);
2922
2923         strbuf_addf(&buf, "%s/message", get_dir(opts));
2924         if (!file_exists(buf.buf)) {
2925                 const char *commit_buffer = get_commit_buffer(commit, NULL);
2926                 find_commit_subject(commit_buffer, &subject);
2927                 res |= write_message(subject, strlen(subject), buf.buf, 1);
2928                 unuse_commit_buffer(commit, commit_buffer);
2929         }
2930         strbuf_release(&buf);
2931
2932         return res;
2933 }
2934
2935 static int intend_to_amend(void)
2936 {
2937         struct object_id head;
2938         char *p;
2939
2940         if (get_oid("HEAD", &head))
2941                 return error(_("cannot read HEAD"));
2942
2943         p = oid_to_hex(&head);
2944         return write_message(p, strlen(p), rebase_path_amend(), 1);
2945 }
2946
2947 static int error_with_patch(struct repository *r,
2948                             struct commit *commit,
2949                             const char *subject, int subject_len,
2950                             struct replay_opts *opts,
2951                             int exit_code, int to_amend)
2952 {
2953         if (commit) {
2954                 if (make_patch(r, commit, opts))
2955                         return -1;
2956         } else if (copy_file(rebase_path_message(),
2957                              git_path_merge_msg(r), 0666))
2958                 return error(_("unable to copy '%s' to '%s'"),
2959                              git_path_merge_msg(r), rebase_path_message());
2960
2961         if (to_amend) {
2962                 if (intend_to_amend())
2963                         return -1;
2964
2965                 fprintf(stderr,
2966                         _("You can amend the commit now, with\n"
2967                           "\n"
2968                           "  git commit --amend %s\n"
2969                           "\n"
2970                           "Once you are satisfied with your changes, run\n"
2971                           "\n"
2972                           "  git rebase --continue\n"),
2973                         gpg_sign_opt_quoted(opts));
2974         } else if (exit_code) {
2975                 if (commit)
2976                         fprintf_ln(stderr, _("Could not apply %s... %.*s"),
2977                                    short_commit_name(commit), subject_len, subject);
2978                 else
2979                         /*
2980                          * We don't have the hash of the parent so
2981                          * just print the line from the todo file.
2982                          */
2983                         fprintf_ln(stderr, _("Could not merge %.*s"),
2984                                    subject_len, subject);
2985         }
2986
2987         return exit_code;
2988 }
2989
2990 static int error_failed_squash(struct repository *r,
2991                                struct commit *commit,
2992                                struct replay_opts *opts,
2993                                int subject_len,
2994                                const char *subject)
2995 {
2996         if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
2997                 return error(_("could not copy '%s' to '%s'"),
2998                         rebase_path_squash_msg(), rebase_path_message());
2999         unlink(git_path_merge_msg(r));
3000         if (copy_file(git_path_merge_msg(r), rebase_path_message(), 0666))
3001                 return error(_("could not copy '%s' to '%s'"),
3002                              rebase_path_message(),
3003                              git_path_merge_msg(r));
3004         return error_with_patch(r, commit, subject, subject_len, opts, 1, 0);
3005 }
3006
3007 static int do_exec(struct repository *r, const char *command_line)
3008 {
3009         struct argv_array child_env = ARGV_ARRAY_INIT;
3010         const char *child_argv[] = { NULL, NULL };
3011         int dirty, status;
3012
3013         fprintf(stderr, "Executing: %s\n", command_line);
3014         child_argv[0] = command_line;
3015         argv_array_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
3016         argv_array_pushf(&child_env, "GIT_WORK_TREE=%s",
3017                          absolute_path(get_git_work_tree()));
3018         status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
3019                                           child_env.argv);
3020
3021         /* force re-reading of the cache */
3022         if (discard_index(r->index) < 0 || repo_read_index(r) < 0)
3023                 return error(_("could not read index"));
3024
3025         dirty = require_clean_work_tree(r, "rebase", NULL, 1, 1);
3026
3027         if (status) {
3028                 warning(_("execution failed: %s\n%s"
3029                           "You can fix the problem, and then run\n"
3030                           "\n"
3031                           "  git rebase --continue\n"
3032                           "\n"),
3033                         command_line,
3034                         dirty ? N_("and made changes to the index and/or the "
3035                                 "working tree\n") : "");
3036                 if (status == 127)
3037                         /* command not found */
3038                         status = 1;
3039         } else if (dirty) {
3040                 warning(_("execution succeeded: %s\nbut "
3041                           "left changes to the index and/or the working tree\n"
3042                           "Commit or stash your changes, and then run\n"
3043                           "\n"
3044                           "  git rebase --continue\n"
3045                           "\n"), command_line);
3046                 status = 1;
3047         }
3048
3049         argv_array_clear(&child_env);
3050
3051         return status;
3052 }
3053
3054 static int safe_append(const char *filename, const char *fmt, ...)
3055 {
3056         va_list ap;
3057         struct lock_file lock = LOCK_INIT;
3058         int fd = hold_lock_file_for_update(&lock, filename,
3059                                            LOCK_REPORT_ON_ERROR);
3060         struct strbuf buf = STRBUF_INIT;
3061
3062         if (fd < 0)
3063                 return -1;
3064
3065         if (strbuf_read_file(&buf, filename, 0) < 0 && errno != ENOENT) {
3066                 error_errno(_("could not read '%s'"), filename);
3067                 rollback_lock_file(&lock);
3068                 return -1;
3069         }
3070         strbuf_complete(&buf, '\n');
3071         va_start(ap, fmt);
3072         strbuf_vaddf(&buf, fmt, ap);
3073         va_end(ap);
3074
3075         if (write_in_full(fd, buf.buf, buf.len) < 0) {
3076                 error_errno(_("could not write to '%s'"), filename);
3077                 strbuf_release(&buf);
3078                 rollback_lock_file(&lock);
3079                 return -1;
3080         }
3081         if (commit_lock_file(&lock) < 0) {
3082                 strbuf_release(&buf);
3083                 rollback_lock_file(&lock);
3084                 return error(_("failed to finalize '%s'"), filename);
3085         }
3086
3087         strbuf_release(&buf);
3088         return 0;
3089 }
3090
3091 static int do_label(struct repository *r, const char *name, int len)
3092 {
3093         struct ref_store *refs = get_main_ref_store(r);
3094         struct ref_transaction *transaction;
3095         struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
3096         struct strbuf msg = STRBUF_INIT;
3097         int ret = 0;
3098         struct object_id head_oid;
3099
3100         if (len == 1 && *name == '#')
3101                 return error(_("illegal label name: '%.*s'"), len, name);
3102
3103         strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3104         strbuf_addf(&msg, "rebase -i (label) '%.*s'", len, name);
3105
3106         transaction = ref_store_transaction_begin(refs, &err);
3107         if (!transaction) {
3108                 error("%s", err.buf);
3109                 ret = -1;
3110         } else if (get_oid("HEAD", &head_oid)) {
3111                 error(_("could not read HEAD"));
3112                 ret = -1;
3113         } else if (ref_transaction_update(transaction, ref_name.buf, &head_oid,
3114                                           NULL, 0, msg.buf, &err) < 0 ||
3115                    ref_transaction_commit(transaction, &err)) {
3116                 error("%s", err.buf);
3117                 ret = -1;
3118         }
3119         ref_transaction_free(transaction);
3120         strbuf_release(&err);
3121         strbuf_release(&msg);
3122
3123         if (!ret)
3124                 ret = safe_append(rebase_path_refs_to_delete(),
3125                                   "%s\n", ref_name.buf);
3126         strbuf_release(&ref_name);
3127
3128         return ret;
3129 }
3130
3131 static const char *reflog_message(struct replay_opts *opts,
3132         const char *sub_action, const char *fmt, ...);
3133
3134 static int do_reset(struct repository *r,
3135                     const char *name, int len,
3136                     struct replay_opts *opts)
3137 {
3138         struct strbuf ref_name = STRBUF_INIT;
3139         struct object_id oid;
3140         struct lock_file lock = LOCK_INIT;
3141         struct tree_desc desc;
3142         struct tree *tree;
3143         struct unpack_trees_options unpack_tree_opts;
3144         int ret = 0;
3145
3146         if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0)
3147                 return -1;
3148
3149         if (len == 10 && !strncmp("[new root]", name, len)) {
3150                 if (!opts->have_squash_onto) {
3151                         const char *hex;
3152                         if (commit_tree("", 0, the_hash_algo->empty_tree,
3153                                         NULL, &opts->squash_onto,
3154                                         NULL, NULL))
3155                                 return error(_("writing fake root commit"));
3156                         opts->have_squash_onto = 1;
3157                         hex = oid_to_hex(&opts->squash_onto);
3158                         if (write_message(hex, strlen(hex),
3159                                           rebase_path_squash_onto(), 0))
3160                                 return error(_("writing squash-onto"));
3161                 }
3162                 oidcpy(&oid, &opts->squash_onto);
3163         } else {
3164                 int i;
3165
3166                 /* Determine the length of the label */
3167                 for (i = 0; i < len; i++)
3168                         if (isspace(name[i]))
3169                                 break;
3170                 len = i;
3171
3172                 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3173                 if (get_oid(ref_name.buf, &oid) &&
3174                     get_oid(ref_name.buf + strlen("refs/rewritten/"), &oid)) {
3175                         error(_("could not read '%s'"), ref_name.buf);
3176                         rollback_lock_file(&lock);
3177                         strbuf_release(&ref_name);
3178                         return -1;
3179                 }
3180         }
3181
3182         memset(&unpack_tree_opts, 0, sizeof(unpack_tree_opts));
3183         setup_unpack_trees_porcelain(&unpack_tree_opts, "reset");
3184         unpack_tree_opts.head_idx = 1;
3185         unpack_tree_opts.src_index = r->index;
3186         unpack_tree_opts.dst_index = r->index;
3187         unpack_tree_opts.fn = oneway_merge;
3188         unpack_tree_opts.merge = 1;
3189         unpack_tree_opts.update = 1;
3190
3191         if (repo_read_index_unmerged(r)) {
3192                 rollback_lock_file(&lock);
3193                 strbuf_release(&ref_name);
3194                 return error_resolve_conflict(_(action_name(opts)));
3195         }
3196
3197         if (!fill_tree_descriptor(&desc, &oid)) {
3198                 error(_("failed to find tree of %s"), oid_to_hex(&oid));
3199                 rollback_lock_file(&lock);
3200                 free((void *)desc.buffer);
3201                 strbuf_release(&ref_name);
3202                 return -1;
3203         }
3204
3205         if (unpack_trees(1, &desc, &unpack_tree_opts)) {
3206                 rollback_lock_file(&lock);
3207                 free((void *)desc.buffer);
3208                 strbuf_release(&ref_name);
3209                 return -1;
3210         }
3211
3212         tree = parse_tree_indirect(&oid);
3213         prime_cache_tree(r, r->index, tree);
3214
3215         if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
3216                 ret = error(_("could not write index"));
3217         free((void *)desc.buffer);
3218
3219         if (!ret)
3220                 ret = update_ref(reflog_message(opts, "reset", "'%.*s'",
3221                                                 len, name), "HEAD", &oid,
3222                                  NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3223
3224         strbuf_release(&ref_name);
3225         return ret;
3226 }
3227
3228 static struct commit *lookup_label(const char *label, int len,
3229                                    struct strbuf *buf)
3230 {
3231         struct commit *commit;
3232
3233         strbuf_reset(buf);
3234         strbuf_addf(buf, "refs/rewritten/%.*s", len, label);
3235         commit = lookup_commit_reference_by_name(buf->buf);
3236         if (!commit) {
3237                 /* fall back to non-rewritten ref or commit */
3238                 strbuf_splice(buf, 0, strlen("refs/rewritten/"), "", 0);
3239                 commit = lookup_commit_reference_by_name(buf->buf);
3240         }
3241
3242         if (!commit)
3243                 error(_("could not resolve '%s'"), buf->buf);
3244
3245         return commit;
3246 }
3247
3248 static int do_merge(struct repository *r,
3249                     struct commit *commit,
3250                     const char *arg, int arg_len,
3251                     int flags, struct replay_opts *opts)
3252 {
3253         int run_commit_flags = (flags & TODO_EDIT_MERGE_MSG) ?
3254                 EDIT_MSG | VERIFY_MSG : 0;
3255         struct strbuf ref_name = STRBUF_INIT;
3256         struct commit *head_commit, *merge_commit, *i;
3257         struct commit_list *bases, *j, *reversed = NULL;
3258         struct commit_list *to_merge = NULL, **tail = &to_merge;
3259         struct merge_options o;
3260         int merge_arg_len, oneline_offset, can_fast_forward, ret, k;
3261         static struct lock_file lock;
3262         const char *p;
3263
3264         if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0) {
3265                 ret = -1;
3266                 goto leave_merge;
3267         }
3268
3269         head_commit = lookup_commit_reference_by_name("HEAD");
3270         if (!head_commit) {
3271                 ret = error(_("cannot merge without a current revision"));
3272                 goto leave_merge;
3273         }
3274
3275         /*
3276          * For octopus merges, the arg starts with the list of revisions to be
3277          * merged. The list is optionally followed by '#' and the oneline.
3278          */
3279         merge_arg_len = oneline_offset = arg_len;
3280         for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {
3281                 if (!*p)
3282                         break;
3283                 if (*p == '#' && (!p[1] || isspace(p[1]))) {
3284                         p += 1 + strspn(p + 1, " \t\n");
3285                         oneline_offset = p - arg;
3286                         break;
3287                 }
3288                 k = strcspn(p, " \t\n");
3289                 if (!k)
3290                         continue;
3291                 merge_commit = lookup_label(p, k, &ref_name);
3292                 if (!merge_commit) {
3293                         ret = error(_("unable to parse '%.*s'"), k, p);
3294                         goto leave_merge;
3295                 }
3296                 tail = &commit_list_insert(merge_commit, tail)->next;
3297                 p += k;
3298                 merge_arg_len = p - arg;
3299         }
3300
3301         if (!to_merge) {
3302                 ret = error(_("nothing to merge: '%.*s'"), arg_len, arg);
3303                 goto leave_merge;
3304         }
3305
3306         if (opts->have_squash_onto &&
3307             oideq(&head_commit->object.oid, &opts->squash_onto)) {
3308                 /*
3309                  * When the user tells us to "merge" something into a
3310                  * "[new root]", let's simply fast-forward to the merge head.
3311                  */
3312                 rollback_lock_file(&lock);
3313                 if (to_merge->next)
3314                         ret = error(_("octopus merge cannot be executed on "
3315                                       "top of a [new root]"));
3316                 else
3317                         ret = fast_forward_to(r, &to_merge->item->object.oid,
3318                                               &head_commit->object.oid, 0,
3319                                               opts);
3320                 goto leave_merge;
3321         }
3322
3323         if (commit) {
3324                 const char *message = get_commit_buffer(commit, NULL);
3325                 const char *body;
3326                 int len;
3327
3328                 if (!message) {
3329                         ret = error(_("could not get commit message of '%s'"),
3330                                     oid_to_hex(&commit->object.oid));
3331                         goto leave_merge;
3332                 }
3333                 write_author_script(message);
3334                 find_commit_subject(message, &body);
3335                 len = strlen(body);
3336                 ret = write_message(body, len, git_path_merge_msg(r), 0);
3337                 unuse_commit_buffer(commit, message);
3338                 if (ret) {
3339                         error_errno(_("could not write '%s'"),
3340                                     git_path_merge_msg(r));
3341                         goto leave_merge;
3342                 }
3343         } else {
3344                 struct strbuf buf = STRBUF_INIT;
3345                 int len;
3346
3347                 strbuf_addf(&buf, "author %s", git_author_info(0));
3348                 write_author_script(buf.buf);
3349                 strbuf_reset(&buf);
3350
3351                 if (oneline_offset < arg_len) {
3352                         p = arg + oneline_offset;
3353                         len = arg_len - oneline_offset;
3354                 } else {
3355                         strbuf_addf(&buf, "Merge %s '%.*s'",
3356                                     to_merge->next ? "branches" : "branch",
3357                                     merge_arg_len, arg);
3358                         p = buf.buf;
3359                         len = buf.len;
3360                 }
3361
3362                 ret = write_message(p, len, git_path_merge_msg(r), 0);
3363                 strbuf_release(&buf);
3364                 if (ret) {
3365                         error_errno(_("could not write '%s'"),
3366                                     git_path_merge_msg(r));
3367                         goto leave_merge;
3368                 }
3369         }
3370
3371         /*
3372          * If HEAD is not identical to the first parent of the original merge
3373          * commit, we cannot fast-forward.
3374          */
3375         can_fast_forward = opts->allow_ff && commit && commit->parents &&
3376                 oideq(&commit->parents->item->object.oid,
3377                       &head_commit->object.oid);
3378
3379         /*
3380          * If any merge head is different from the original one, we cannot
3381          * fast-forward.
3382          */
3383         if (can_fast_forward) {
3384                 struct commit_list *p = commit->parents->next;
3385
3386                 for (j = to_merge; j && p; j = j->next, p = p->next)
3387                         if (!oideq(&j->item->object.oid,
3388                                    &p->item->object.oid)) {
3389                                 can_fast_forward = 0;
3390                                 break;
3391                         }
3392                 /*
3393                  * If the number of merge heads differs from the original merge
3394                  * commit, we cannot fast-forward.
3395                  */
3396                 if (j || p)
3397                         can_fast_forward = 0;
3398         }
3399
3400         if (can_fast_forward) {
3401                 rollback_lock_file(&lock);
3402                 ret = fast_forward_to(r, &commit->object.oid,
3403                                       &head_commit->object.oid, 0, opts);
3404                 if (flags & TODO_EDIT_MERGE_MSG) {
3405                         run_commit_flags |= AMEND_MSG;
3406                         goto fast_forward_edit;
3407                 }
3408                 goto leave_merge;
3409         }
3410
3411         if (to_merge->next) {
3412                 /* Octopus merge */
3413                 struct child_process cmd = CHILD_PROCESS_INIT;
3414
3415                 if (read_env_script(&cmd.env_array)) {
3416                         const char *gpg_opt = gpg_sign_opt_quoted(opts);
3417
3418                         ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
3419                         goto leave_merge;
3420                 }
3421
3422                 cmd.git_cmd = 1;
3423                 argv_array_push(&cmd.args, "merge");
3424                 argv_array_push(&cmd.args, "-s");
3425                 argv_array_push(&cmd.args, "octopus");
3426                 argv_array_push(&cmd.args, "--no-edit");
3427                 argv_array_push(&cmd.args, "--no-ff");
3428                 argv_array_push(&cmd.args, "--no-log");
3429                 argv_array_push(&cmd.args, "--no-stat");
3430                 argv_array_push(&cmd.args, "-F");
3431                 argv_array_push(&cmd.args, git_path_merge_msg(r));
3432                 if (opts->gpg_sign)
3433                         argv_array_push(&cmd.args, opts->gpg_sign);
3434
3435                 /* Add the tips to be merged */
3436                 for (j = to_merge; j; j = j->next)
3437                         argv_array_push(&cmd.args,
3438                                         oid_to_hex(&j->item->object.oid));
3439
3440                 strbuf_release(&ref_name);
3441                 unlink(git_path_cherry_pick_head(r));
3442                 rollback_lock_file(&lock);
3443
3444                 rollback_lock_file(&lock);
3445                 ret = run_command(&cmd);
3446
3447                 /* force re-reading of the cache */
3448                 if (!ret && (discard_index(r->index) < 0 ||
3449                              repo_read_index(r) < 0))
3450                         ret = error(_("could not read index"));
3451                 goto leave_merge;
3452         }
3453
3454         merge_commit = to_merge->item;
3455         bases = get_merge_bases(head_commit, merge_commit);
3456         if (bases && oideq(&merge_commit->object.oid,
3457                            &bases->item->object.oid)) {
3458                 ret = 0;
3459                 /* skip merging an ancestor of HEAD */
3460                 goto leave_merge;
3461         }
3462
3463         write_message(oid_to_hex(&merge_commit->object.oid), GIT_SHA1_HEXSZ,
3464                       git_path_merge_head(r), 0);
3465         write_message("no-ff", 5, git_path_merge_mode(r), 0);
3466
3467         for (j = bases; j; j = j->next)
3468                 commit_list_insert(j->item, &reversed);
3469         free_commit_list(bases);
3470
3471         repo_read_index(r);
3472         init_merge_options(&o, r);
3473         o.branch1 = "HEAD";
3474         o.branch2 = ref_name.buf;
3475         o.buffer_output = 2;
3476
3477         ret = merge_recursive(&o, head_commit, merge_commit, reversed, &i);
3478         if (ret <= 0)
3479                 fputs(o.obuf.buf, stdout);
3480         strbuf_release(&o.obuf);
3481         if (ret < 0) {
3482                 error(_("could not even attempt to merge '%.*s'"),
3483                       merge_arg_len, arg);
3484                 goto leave_merge;
3485         }
3486         /*
3487          * The return value of merge_recursive() is 1 on clean, and 0 on
3488          * unclean merge.
3489          *
3490          * Let's reverse that, so that do_merge() returns 0 upon success and
3491          * 1 upon failed merge (keeping the return value -1 for the cases where
3492          * we will want to reschedule the `merge` command).
3493          */
3494         ret = !ret;
3495
3496         if (r->index->cache_changed &&
3497             write_locked_index(r->index, &lock, COMMIT_LOCK)) {
3498                 ret = error(_("merge: Unable to write new index file"));
3499                 goto leave_merge;
3500         }
3501
3502         rollback_lock_file(&lock);
3503         if (ret)
3504                 repo_rerere(r, opts->allow_rerere_auto);
3505         else
3506                 /*
3507                  * In case of problems, we now want to return a positive
3508                  * value (a negative one would indicate that the `merge`
3509                  * command needs to be rescheduled).
3510                  */
3511         fast_forward_edit:
3512                 ret = !!run_git_commit(r, git_path_merge_msg(r), opts,
3513                                        run_commit_flags);
3514
3515 leave_merge:
3516         strbuf_release(&ref_name);
3517         rollback_lock_file(&lock);
3518         free_commit_list(to_merge);
3519         return ret;
3520 }
3521
3522 static int is_final_fixup(struct todo_list *todo_list)
3523 {
3524         int i = todo_list->current;
3525
3526         if (!is_fixup(todo_list->items[i].command))
3527                 return 0;
3528
3529         while (++i < todo_list->nr)
3530                 if (is_fixup(todo_list->items[i].command))
3531                         return 0;
3532                 else if (!is_noop(todo_list->items[i].command))
3533                         break;
3534         return 1;
3535 }
3536
3537 static enum todo_command peek_command(struct todo_list *todo_list, int offset)
3538 {
3539         int i;
3540
3541         for (i = todo_list->current + offset; i < todo_list->nr; i++)
3542                 if (!is_noop(todo_list->items[i].command))
3543                         return todo_list->items[i].command;
3544
3545         return -1;
3546 }
3547
3548 static int apply_autostash(struct replay_opts *opts)
3549 {
3550         struct strbuf stash_sha1 = STRBUF_INIT;
3551         struct child_process child = CHILD_PROCESS_INIT;
3552         int ret = 0;
3553
3554         if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
3555                 strbuf_release(&stash_sha1);
3556                 return 0;
3557         }
3558         strbuf_trim(&stash_sha1);
3559
3560         child.git_cmd = 1;
3561         child.no_stdout = 1;
3562         child.no_stderr = 1;
3563         argv_array_push(&child.args, "stash");
3564         argv_array_push(&child.args, "apply");
3565         argv_array_push(&child.args, stash_sha1.buf);
3566         if (!run_command(&child))
3567                 fprintf(stderr, _("Applied autostash.\n"));
3568         else {
3569                 struct child_process store = CHILD_PROCESS_INIT;
3570
3571                 store.git_cmd = 1;
3572                 argv_array_push(&store.args, "stash");
3573                 argv_array_push(&store.args, "store");
3574                 argv_array_push(&store.args, "-m");
3575                 argv_array_push(&store.args, "autostash");
3576                 argv_array_push(&store.args, "-q");
3577                 argv_array_push(&store.args, stash_sha1.buf);
3578                 if (run_command(&store))
3579                         ret = error(_("cannot store %s"), stash_sha1.buf);
3580                 else
3581                         fprintf(stderr,
3582                                 _("Applying autostash resulted in conflicts.\n"
3583                                   "Your changes are safe in the stash.\n"
3584                                   "You can run \"git stash pop\" or"
3585                                   " \"git stash drop\" at any time.\n"));
3586         }
3587
3588         strbuf_release(&stash_sha1);
3589         return ret;
3590 }
3591
3592 static const char *reflog_message(struct replay_opts *opts,
3593         const char *sub_action, const char *fmt, ...)
3594 {
3595         va_list ap;
3596         static struct strbuf buf = STRBUF_INIT;
3597
3598         va_start(ap, fmt);
3599         strbuf_reset(&buf);
3600         strbuf_addstr(&buf, action_name(opts));
3601         if (sub_action)
3602                 strbuf_addf(&buf, " (%s)", sub_action);
3603         if (fmt) {
3604                 strbuf_addstr(&buf, ": ");
3605                 strbuf_vaddf(&buf, fmt, ap);
3606         }
3607         va_end(ap);
3608
3609         return buf.buf;
3610 }
3611
3612 static int run_git_checkout(struct repository *r, struct replay_opts *opts,
3613                             const char *commit, const char *action)
3614 {
3615         struct child_process cmd = CHILD_PROCESS_INIT;
3616         int ret;
3617
3618         cmd.git_cmd = 1;
3619
3620         argv_array_push(&cmd.args, "checkout");
3621         argv_array_push(&cmd.args, commit);
3622         argv_array_pushf(&cmd.env_array, GIT_REFLOG_ACTION "=%s", action);
3623
3624         if (opts->verbose)
3625                 ret = run_command(&cmd);
3626         else
3627                 ret = run_command_silent_on_success(&cmd);
3628
3629         if (!ret)
3630                 discard_index(r->index);
3631
3632         return ret;
3633 }
3634
3635 int prepare_branch_to_be_rebased(struct repository *r, struct replay_opts *opts,
3636                                  const char *commit)
3637 {
3638         const char *action;
3639
3640         if (commit && *commit) {
3641                 action = reflog_message(opts, "start", "checkout %s", commit);
3642                 if (run_git_checkout(r, opts, commit, action))
3643                         return error(_("could not checkout %s"), commit);
3644         }
3645
3646         return 0;
3647 }
3648
3649 static int checkout_onto(struct repository *r, struct replay_opts *opts,
3650                          const char *onto_name, const struct object_id *onto,
3651                          const char *orig_head)
3652 {
3653         struct object_id oid;
3654         const char *action = reflog_message(opts, "start", "checkout %s", onto_name);
3655
3656         if (get_oid(orig_head, &oid))
3657                 return error(_("%s: not a valid OID"), orig_head);
3658
3659         if (run_git_checkout(r, opts, oid_to_hex(onto), action)) {
3660                 apply_autostash(opts);
3661                 sequencer_remove_state(opts);
3662                 return error(_("could not detach HEAD"));
3663         }
3664
3665         return update_ref(NULL, "ORIG_HEAD", &oid, NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3666 }
3667
3668 static int stopped_at_head(struct repository *r)
3669 {
3670         struct object_id head;
3671         struct commit *commit;
3672         struct commit_message message;
3673
3674         if (get_oid("HEAD", &head) ||
3675             !(commit = lookup_commit(r, &head)) ||
3676             parse_commit(commit) || get_message(commit, &message))
3677                 fprintf(stderr, _("Stopped at HEAD\n"));
3678         else {
3679                 fprintf(stderr, _("Stopped at %s\n"), message.label);
3680                 free_message(commit, &message);
3681         }
3682         return 0;
3683
3684 }
3685
3686 static const char rescheduled_advice[] =
3687 N_("Could not execute the todo command\n"
3688 "\n"
3689 "    %.*s"
3690 "\n"
3691 "It has been rescheduled; To edit the command before continuing, please\n"
3692 "edit the todo list first:\n"
3693 "\n"
3694 "    git rebase --edit-todo\n"
3695 "    git rebase --continue\n");
3696
3697 static int pick_commits(struct repository *r,
3698                         struct todo_list *todo_list,
3699                         struct replay_opts *opts)
3700 {
3701         int res = 0, reschedule = 0;
3702
3703         setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
3704         if (opts->allow_ff)
3705                 assert(!(opts->signoff || opts->no_commit ||
3706                                 opts->record_origin || opts->edit));
3707         if (read_and_refresh_cache(r, opts))
3708                 return -1;
3709
3710         while (todo_list->current < todo_list->nr) {
3711                 struct todo_item *item = todo_list->items + todo_list->current;
3712                 const char *arg = todo_item_get_arg(todo_list, item);
3713
3714                 if (save_todo(todo_list, opts))
3715                         return -1;
3716                 if (is_rebase_i(opts)) {
3717                         if (item->command != TODO_COMMENT) {
3718                                 FILE *f = fopen(rebase_path_msgnum(), "w");
3719
3720                                 todo_list->done_nr++;
3721
3722                                 if (f) {
3723                                         fprintf(f, "%d\n", todo_list->done_nr);
3724                                         fclose(f);
3725                                 }
3726                                 if (!opts->quiet)
3727                                         fprintf(stderr, "Rebasing (%d/%d)%s",
3728                                                 todo_list->done_nr,
3729                                                 todo_list->total_nr,
3730                                                 opts->verbose ? "\n" : "\r");
3731                         }
3732                         unlink(rebase_path_message());
3733                         unlink(rebase_path_author_script());
3734                         unlink(rebase_path_stopped_sha());
3735                         unlink(rebase_path_amend());
3736                         unlink(git_path_merge_head(the_repository));
3737                         delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
3738
3739                         if (item->command == TODO_BREAK)
3740                                 return stopped_at_head(r);
3741                 }
3742                 if (item->command <= TODO_SQUASH) {
3743                         if (is_rebase_i(opts))
3744                                 setenv("GIT_REFLOG_ACTION", reflog_message(opts,
3745                                         command_to_string(item->command), NULL),
3746                                         1);
3747                         res = do_pick_commit(r, item->command, item->commit,
3748                                         opts, is_final_fixup(todo_list));
3749                         if (is_rebase_i(opts) && res < 0) {
3750                                 /* Reschedule */
3751                                 advise(_(rescheduled_advice),
3752                                        get_item_line_length(todo_list,
3753                                                             todo_list->current),
3754                                        get_item_line(todo_list,
3755                                                      todo_list->current));
3756                                 todo_list->current--;
3757                                 if (save_todo(todo_list, opts))
3758                                         return -1;
3759                         }
3760                         if (item->command == TODO_EDIT) {
3761                                 struct commit *commit = item->commit;
3762                                 if (!res)
3763                                         fprintf(stderr,
3764                                                 _("Stopped at %s...  %.*s\n"),
3765                                                 short_commit_name(commit),
3766                                                 item->arg_len, arg);
3767                                 return error_with_patch(r, commit,
3768                                         arg, item->arg_len, opts, res, !res);
3769                         }
3770                         if (is_rebase_i(opts) && !res)
3771                                 record_in_rewritten(&item->commit->object.oid,
3772                                         peek_command(todo_list, 1));
3773                         if (res && is_fixup(item->command)) {
3774                                 if (res == 1)
3775                                         intend_to_amend();
3776                                 return error_failed_squash(r, item->commit, opts,
3777                                         item->arg_len, arg);
3778                         } else if (res && is_rebase_i(opts) && item->commit) {
3779                                 int to_amend = 0;
3780                                 struct object_id oid;
3781
3782                                 /*
3783                                  * If we are rewording and have either
3784                                  * fast-forwarded already, or are about to
3785                                  * create a new root commit, we want to amend,
3786                                  * otherwise we do not.
3787                                  */
3788                                 if (item->command == TODO_REWORD &&
3789                                     !get_oid("HEAD", &oid) &&
3790                                     (oideq(&item->commit->object.oid, &oid) ||
3791                                      (opts->have_squash_onto &&
3792                                       oideq(&opts->squash_onto, &oid))))
3793                                         to_amend = 1;
3794
3795                                 return res | error_with_patch(r, item->commit,
3796                                                 arg, item->arg_len, opts,
3797                                                 res, to_amend);
3798                         }
3799                 } else if (item->command == TODO_EXEC) {
3800                         char *end_of_arg = (char *)(arg + item->arg_len);
3801                         int saved = *end_of_arg;
3802                         struct stat st;
3803
3804                         *end_of_arg = '\0';
3805                         res = do_exec(r, arg);
3806                         *end_of_arg = saved;
3807
3808                         if (res) {
3809                                 if (opts->reschedule_failed_exec)
3810                                         reschedule = 1;
3811                         } else if (stat(get_todo_path(opts), &st))
3812                                 res = error_errno(_("could not stat '%s'"),
3813                                                   get_todo_path(opts));
3814                         else if (match_stat_data(&todo_list->stat, &st)) {
3815                                 /* Reread the todo file if it has changed. */
3816                                 todo_list_release(todo_list);
3817                                 if (read_populate_todo(r, todo_list, opts))
3818                                         res = -1; /* message was printed */
3819                                 /* `current` will be incremented below */
3820                                 todo_list->current = -1;
3821                         }
3822                 } else if (item->command == TODO_LABEL) {
3823                         if ((res = do_label(r, arg, item->arg_len)))
3824                                 reschedule = 1;
3825                 } else if (item->command == TODO_RESET) {
3826                         if ((res = do_reset(r, arg, item->arg_len, opts)))
3827                                 reschedule = 1;
3828                 } else if (item->command == TODO_MERGE) {
3829                         if ((res = do_merge(r, item->commit,
3830                                             arg, item->arg_len,
3831                                             item->flags, opts)) < 0)
3832                                 reschedule = 1;
3833                         else if (item->commit)
3834                                 record_in_rewritten(&item->commit->object.oid,
3835                                                     peek_command(todo_list, 1));
3836                         if (res > 0)
3837                                 /* failed with merge conflicts */
3838                                 return error_with_patch(r, item->commit,
3839                                                         arg, item->arg_len,
3840                                                         opts, res, 0);
3841                 } else if (!is_noop(item->command))
3842                         return error(_("unknown command %d"), item->command);
3843
3844                 if (reschedule) {
3845                         advise(_(rescheduled_advice),
3846                                get_item_line_length(todo_list,
3847                                                     todo_list->current),
3848                                get_item_line(todo_list, todo_list->current));
3849                         todo_list->current--;
3850                         if (save_todo(todo_list, opts))
3851                                 return -1;
3852                         if (item->commit)
3853                                 return error_with_patch(r,
3854                                                         item->commit,
3855                                                         arg, item->arg_len,
3856                                                         opts, res, 0);
3857                 }
3858
3859                 todo_list->current++;
3860                 if (res)
3861                         return res;
3862         }
3863
3864         if (is_rebase_i(opts)) {
3865                 struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
3866                 struct stat st;
3867
3868                 /* Stopped in the middle, as planned? */
3869                 if (todo_list->current < todo_list->nr)
3870                         return 0;
3871
3872                 if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
3873                                 starts_with(head_ref.buf, "refs/")) {
3874                         const char *msg;
3875                         struct object_id head, orig;
3876                         int res;
3877
3878                         if (get_oid("HEAD", &head)) {
3879                                 res = error(_("cannot read HEAD"));
3880 cleanup_head_ref:
3881                                 strbuf_release(&head_ref);
3882                                 strbuf_release(&buf);
3883                                 return res;
3884                         }
3885                         if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
3886                                         get_oid_hex(buf.buf, &orig)) {
3887                                 res = error(_("could not read orig-head"));
3888                                 goto cleanup_head_ref;
3889                         }
3890                         strbuf_reset(&buf);
3891                         if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
3892                                 res = error(_("could not read 'onto'"));
3893                                 goto cleanup_head_ref;
3894                         }
3895                         msg = reflog_message(opts, "finish", "%s onto %s",
3896                                 head_ref.buf, buf.buf);
3897                         if (update_ref(msg, head_ref.buf, &head, &orig,
3898                                        REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
3899                                 res = error(_("could not update %s"),
3900                                         head_ref.buf);
3901                                 goto cleanup_head_ref;
3902                         }
3903                         msg = reflog_message(opts, "finish", "returning to %s",
3904                                 head_ref.buf);
3905                         if (create_symref("HEAD", head_ref.buf, msg)) {
3906                                 res = error(_("could not update HEAD to %s"),
3907                                         head_ref.buf);
3908                                 goto cleanup_head_ref;
3909                         }
3910                         strbuf_reset(&buf);
3911                 }
3912
3913                 if (opts->verbose) {
3914                         struct rev_info log_tree_opt;
3915                         struct object_id orig, head;
3916
3917                         memset(&log_tree_opt, 0, sizeof(log_tree_opt));
3918                         repo_init_revisions(r, &log_tree_opt, NULL);
3919                         log_tree_opt.diff = 1;
3920                         log_tree_opt.diffopt.output_format =
3921                                 DIFF_FORMAT_DIFFSTAT;
3922                         log_tree_opt.disable_stdin = 1;
3923
3924                         if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
3925                             !get_oid(buf.buf, &orig) &&
3926                             !get_oid("HEAD", &head)) {
3927                                 diff_tree_oid(&orig, &head, "",
3928                                               &log_tree_opt.diffopt);
3929                                 log_tree_diff_flush(&log_tree_opt);
3930                         }
3931                 }
3932                 flush_rewritten_pending();
3933                 if (!stat(rebase_path_rewritten_list(), &st) &&
3934                                 st.st_size > 0) {
3935                         struct child_process child = CHILD_PROCESS_INIT;
3936                         const char *post_rewrite_hook =
3937                                 find_hook("post-rewrite");
3938
3939                         child.in = open(rebase_path_rewritten_list(), O_RDONLY);
3940                         child.git_cmd = 1;
3941                         argv_array_push(&child.args, "notes");
3942                         argv_array_push(&child.args, "copy");
3943                         argv_array_push(&child.args, "--for-rewrite=rebase");
3944                         /* we don't care if this copying failed */
3945                         run_command(&child);
3946
3947                         if (post_rewrite_hook) {
3948                                 struct child_process hook = CHILD_PROCESS_INIT;
3949
3950                                 hook.in = open(rebase_path_rewritten_list(),
3951                                         O_RDONLY);
3952                                 hook.stdout_to_stderr = 1;
3953                                 hook.trace2_hook_name = "post-rewrite";
3954                                 argv_array_push(&hook.args, post_rewrite_hook);
3955                                 argv_array_push(&hook.args, "rebase");
3956                                 /* we don't care if this hook failed */
3957                                 run_command(&hook);
3958                         }
3959                 }
3960                 apply_autostash(opts);
3961
3962                 if (!opts->quiet)
3963                         fprintf(stderr,
3964                                 "Successfully rebased and updated %s.\n",
3965                                 head_ref.buf);
3966
3967                 strbuf_release(&buf);
3968                 strbuf_release(&head_ref);
3969         }
3970
3971         /*
3972          * Sequence of picks finished successfully; cleanup by
3973          * removing the .git/sequencer directory
3974          */
3975         return sequencer_remove_state(opts);
3976 }
3977
3978 static int continue_single_pick(struct repository *r)
3979 {
3980         const char *argv[] = { "commit", NULL };
3981
3982         if (!file_exists(git_path_cherry_pick_head(r)) &&
3983             !file_exists(git_path_revert_head(r)))
3984                 return error(_("no cherry-pick or revert in progress"));
3985         return run_command_v_opt(argv, RUN_GIT_CMD);
3986 }
3987
3988 static int commit_staged_changes(struct repository *r,
3989                                  struct replay_opts *opts,
3990                                  struct todo_list *todo_list)
3991 {
3992         unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
3993         unsigned int final_fixup = 0, is_clean;
3994
3995         if (has_unstaged_changes(r, 1))
3996                 return error(_("cannot rebase: You have unstaged changes."));
3997
3998         is_clean = !has_uncommitted_changes(r, 0);
3999
4000         if (file_exists(rebase_path_amend())) {
4001                 struct strbuf rev = STRBUF_INIT;
4002                 struct object_id head, to_amend;
4003
4004                 if (get_oid("HEAD", &head))
4005                         return error(_("cannot amend non-existing commit"));
4006                 if (!read_oneliner(&rev, rebase_path_amend(), 0))
4007                         return error(_("invalid file: '%s'"), rebase_path_amend());
4008                 if (get_oid_hex(rev.buf, &to_amend))
4009                         return error(_("invalid contents: '%s'"),
4010                                 rebase_path_amend());
4011                 if (!is_clean && !oideq(&head, &to_amend))
4012                         return error(_("\nYou have uncommitted changes in your "
4013                                        "working tree. Please, commit them\n"
4014                                        "first and then run 'git rebase "
4015                                        "--continue' again."));
4016                 /*
4017                  * When skipping a failed fixup/squash, we need to edit the
4018                  * commit message, the current fixup list and count, and if it
4019                  * was the last fixup/squash in the chain, we need to clean up
4020                  * the commit message and if there was a squash, let the user
4021                  * edit it.
4022                  */
4023                 if (!is_clean || !opts->current_fixup_count)
4024                         ; /* this is not the final fixup */
4025                 else if (!oideq(&head, &to_amend) ||
4026                          !file_exists(rebase_path_stopped_sha())) {
4027                         /* was a final fixup or squash done manually? */
4028                         if (!is_fixup(peek_command(todo_list, 0))) {
4029                                 unlink(rebase_path_fixup_msg());
4030                                 unlink(rebase_path_squash_msg());
4031                                 unlink(rebase_path_current_fixups());
4032                                 strbuf_reset(&opts->current_fixups);
4033                                 opts->current_fixup_count = 0;
4034                         }
4035                 } else {
4036                         /* we are in a fixup/squash chain */
4037                         const char *p = opts->current_fixups.buf;
4038                         int len = opts->current_fixups.len;
4039
4040                         opts->current_fixup_count--;
4041                         if (!len)
4042                                 BUG("Incorrect current_fixups:\n%s", p);
4043                         while (len && p[len - 1] != '\n')
4044                                 len--;
4045                         strbuf_setlen(&opts->current_fixups, len);
4046                         if (write_message(p, len, rebase_path_current_fixups(),
4047                                           0) < 0)
4048                                 return error(_("could not write file: '%s'"),
4049                                              rebase_path_current_fixups());
4050
4051                         /*
4052                          * If a fixup/squash in a fixup/squash chain failed, the
4053                          * commit message is already correct, no need to commit
4054                          * it again.
4055                          *
4056                          * Only if it is the final command in the fixup/squash
4057                          * chain, and only if the chain is longer than a single
4058                          * fixup/squash command (which was just skipped), do we
4059                          * actually need to re-commit with a cleaned up commit
4060                          * message.
4061                          */
4062                         if (opts->current_fixup_count > 0 &&
4063                             !is_fixup(peek_command(todo_list, 0))) {
4064                                 final_fixup = 1;
4065                                 /*
4066                                  * If there was not a single "squash" in the
4067                                  * chain, we only need to clean up the commit
4068                                  * message, no need to bother the user with
4069                                  * opening the commit message in the editor.
4070                                  */
4071                                 if (!starts_with(p, "squash ") &&
4072                                     !strstr(p, "\nsquash "))
4073                                         flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;
4074                         } else if (is_fixup(peek_command(todo_list, 0))) {
4075                                 /*
4076                                  * We need to update the squash message to skip
4077                                  * the latest commit message.
4078                                  */
4079                                 struct commit *commit;
4080                                 const char *path = rebase_path_squash_msg();
4081
4082                                 if (parse_head(r, &commit) ||
4083                                     !(p = get_commit_buffer(commit, NULL)) ||
4084                                     write_message(p, strlen(p), path, 0)) {
4085                                         unuse_commit_buffer(commit, p);
4086                                         return error(_("could not write file: "
4087                                                        "'%s'"), path);
4088                                 }
4089                                 unuse_commit_buffer(commit, p);
4090                         }
4091                 }
4092
4093                 strbuf_release(&rev);
4094                 flags |= AMEND_MSG;
4095         }
4096
4097         if (is_clean) {
4098                 const char *cherry_pick_head = git_path_cherry_pick_head(r);
4099
4100                 if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
4101                         return error(_("could not remove CHERRY_PICK_HEAD"));
4102                 if (!final_fixup)
4103                         return 0;
4104         }
4105
4106         if (run_git_commit(r, final_fixup ? NULL : rebase_path_message(),
4107                            opts, flags))
4108                 return error(_("could not commit staged changes."));
4109         unlink(rebase_path_amend());
4110         unlink(git_path_merge_head(the_repository));
4111         if (final_fixup) {
4112                 unlink(rebase_path_fixup_msg());
4113                 unlink(rebase_path_squash_msg());
4114         }
4115         if (opts->current_fixup_count > 0) {
4116                 /*
4117                  * Whether final fixup or not, we just cleaned up the commit
4118                  * message...
4119                  */
4120                 unlink(rebase_path_current_fixups());
4121                 strbuf_reset(&opts->current_fixups);
4122                 opts->current_fixup_count = 0;
4123         }
4124         return 0;
4125 }
4126
4127 int sequencer_continue(struct repository *r, struct replay_opts *opts)
4128 {
4129         struct todo_list todo_list = TODO_LIST_INIT;
4130         int res;
4131
4132         if (read_and_refresh_cache(r, opts))
4133                 return -1;
4134
4135         if (read_populate_opts(opts))
4136                 return -1;
4137         if (is_rebase_i(opts)) {
4138                 if ((res = read_populate_todo(r, &todo_list, opts)))
4139                         goto release_todo_list;
4140                 if (commit_staged_changes(r, opts, &todo_list))
4141                         return -1;
4142         } else if (!file_exists(get_todo_path(opts)))
4143                 return continue_single_pick(r);
4144         else if ((res = read_populate_todo(r, &todo_list, opts)))
4145                 goto release_todo_list;
4146
4147         if (!is_rebase_i(opts)) {
4148                 /* Verify that the conflict has been resolved */
4149                 if (file_exists(git_path_cherry_pick_head(r)) ||
4150                     file_exists(git_path_revert_head(r))) {
4151                         res = continue_single_pick(r);
4152                         if (res)
4153                                 goto release_todo_list;
4154                 }
4155                 if (index_differs_from(r, "HEAD", NULL, 0)) {
4156                         res = error_dirty_index(r, opts);
4157                         goto release_todo_list;
4158                 }
4159                 todo_list.current++;
4160         } else if (file_exists(rebase_path_stopped_sha())) {
4161                 struct strbuf buf = STRBUF_INIT;
4162                 struct object_id oid;
4163
4164                 if (read_oneliner(&buf, rebase_path_stopped_sha(), 1) &&
4165                     !get_oid_committish(buf.buf, &oid))
4166                         record_in_rewritten(&oid, peek_command(&todo_list, 0));
4167                 strbuf_release(&buf);
4168         }
4169
4170         res = pick_commits(r, &todo_list, opts);
4171 release_todo_list:
4172         todo_list_release(&todo_list);
4173         return res;
4174 }
4175
4176 static int single_pick(struct repository *r,
4177                        struct commit *cmit,
4178                        struct replay_opts *opts)
4179 {
4180         setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
4181         return do_pick_commit(r, opts->action == REPLAY_PICK ?
4182                 TODO_PICK : TODO_REVERT, cmit, opts, 0);
4183 }
4184
4185 int sequencer_pick_revisions(struct repository *r,
4186                              struct replay_opts *opts)
4187 {
4188         struct todo_list todo_list = TODO_LIST_INIT;
4189         struct object_id oid;
4190         int i, res;
4191
4192         assert(opts->revs);
4193         if (read_and_refresh_cache(r, opts))
4194                 return -1;
4195
4196         for (i = 0; i < opts->revs->pending.nr; i++) {
4197                 struct object_id oid;
4198                 const char *name = opts->revs->pending.objects[i].name;
4199
4200                 /* This happens when using --stdin. */
4201                 if (!strlen(name))
4202                         continue;
4203
4204                 if (!get_oid(name, &oid)) {
4205                         if (!lookup_commit_reference_gently(r, &oid, 1)) {
4206                                 enum object_type type = oid_object_info(r,
4207                                                                         &oid,
4208                                                                         NULL);
4209                                 return error(_("%s: can't cherry-pick a %s"),
4210                                         name, type_name(type));
4211                         }
4212                 } else
4213                         return error(_("%s: bad revision"), name);
4214         }
4215
4216         /*
4217          * If we were called as "git cherry-pick <commit>", just
4218          * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4219          * REVERT_HEAD, and don't touch the sequencer state.
4220          * This means it is possible to cherry-pick in the middle
4221          * of a cherry-pick sequence.
4222          */
4223         if (opts->revs->cmdline.nr == 1 &&
4224             opts->revs->cmdline.rev->whence == REV_CMD_REV &&
4225             opts->revs->no_walk &&
4226             !opts->revs->cmdline.rev->flags) {
4227                 struct commit *cmit;
4228                 if (prepare_revision_walk(opts->revs))
4229                         return error(_("revision walk setup failed"));
4230                 cmit = get_revision(opts->revs);
4231                 if (!cmit)
4232                         return error(_("empty commit set passed"));
4233                 if (get_revision(opts->revs))
4234                         BUG("unexpected extra commit from walk");
4235                 return single_pick(r, cmit, opts);
4236         }
4237
4238         /*
4239          * Start a new cherry-pick/ revert sequence; but
4240          * first, make sure that an existing one isn't in
4241          * progress
4242          */
4243
4244         if (walk_revs_populate_todo(&todo_list, opts) ||
4245                         create_seq_dir() < 0)
4246                 return -1;
4247         if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
4248                 return error(_("can't revert as initial commit"));
4249         if (save_head(oid_to_hex(&oid)))
4250                 return -1;
4251         if (save_opts(opts))
4252                 return -1;
4253         update_abort_safety_file();
4254         res = pick_commits(r, &todo_list, opts);
4255         todo_list_release(&todo_list);
4256         return res;
4257 }
4258
4259 void append_signoff(struct strbuf *msgbuf, size_t ignore_footer, unsigned flag)
4260 {
4261         unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
4262         struct strbuf sob = STRBUF_INIT;
4263         int has_footer;
4264
4265         strbuf_addstr(&sob, sign_off_header);
4266         strbuf_addstr(&sob, fmt_name(WANT_COMMITTER_IDENT));
4267         strbuf_addch(&sob, '\n');
4268
4269         if (!ignore_footer)
4270                 strbuf_complete_line(msgbuf);
4271
4272         /*
4273          * If the whole message buffer is equal to the sob, pretend that we
4274          * found a conforming footer with a matching sob
4275          */
4276         if (msgbuf->len - ignore_footer == sob.len &&
4277             !strncmp(msgbuf->buf, sob.buf, sob.len))
4278                 has_footer = 3;
4279         else
4280                 has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
4281
4282         if (!has_footer) {
4283                 const char *append_newlines = NULL;
4284                 size_t len = msgbuf->len - ignore_footer;
4285
4286                 if (!len) {
4287                         /*
4288                          * The buffer is completely empty.  Leave foom for
4289                          * the title and body to be filled in by the user.
4290                          */
4291                         append_newlines = "\n\n";
4292                 } else if (len == 1) {
4293                         /*
4294                          * Buffer contains a single newline.  Add another
4295                          * so that we leave room for the title and body.
4296                          */
4297                         append_newlines = "\n";
4298                 } else if (msgbuf->buf[len - 2] != '\n') {
4299                         /*
4300                          * Buffer ends with a single newline.  Add another
4301                          * so that there is an empty line between the message
4302                          * body and the sob.
4303                          */
4304                         append_newlines = "\n";
4305                 } /* else, the buffer already ends with two newlines. */
4306
4307                 if (append_newlines)
4308                         strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4309                                 append_newlines, strlen(append_newlines));
4310         }
4311
4312         if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
4313                 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4314                                 sob.buf, sob.len);
4315
4316         strbuf_release(&sob);
4317 }
4318
4319 struct labels_entry {
4320         struct hashmap_entry entry;
4321         char label[FLEX_ARRAY];
4322 };
4323
4324 static int labels_cmp(const void *fndata, const struct labels_entry *a,
4325                       const struct labels_entry *b, const void *key)
4326 {
4327         return key ? strcmp(a->label, key) : strcmp(a->label, b->label);
4328 }
4329
4330 struct string_entry {
4331         struct oidmap_entry entry;
4332         char string[FLEX_ARRAY];
4333 };
4334
4335 struct label_state {
4336         struct oidmap commit2label;
4337         struct hashmap labels;
4338         struct strbuf buf;
4339 };
4340
4341 static const char *label_oid(struct object_id *oid, const char *label,
4342                              struct label_state *state)
4343 {
4344         struct labels_entry *labels_entry;
4345         struct string_entry *string_entry;
4346         struct object_id dummy;
4347         size_t len;
4348         int i;
4349
4350         string_entry = oidmap_get(&state->commit2label, oid);
4351         if (string_entry)
4352                 return string_entry->string;
4353
4354         /*
4355          * For "uninteresting" commits, i.e. commits that are not to be
4356          * rebased, and which can therefore not be labeled, we use a unique
4357          * abbreviation of the commit name. This is slightly more complicated
4358          * than calling find_unique_abbrev() because we also need to make
4359          * sure that the abbreviation does not conflict with any other
4360          * label.
4361          *
4362          * We disallow "interesting" commits to be labeled by a string that
4363          * is a valid full-length hash, to ensure that we always can find an
4364          * abbreviation for any uninteresting commit's names that does not
4365          * clash with any other label.
4366          */
4367         if (!label) {
4368                 char *p;
4369
4370                 strbuf_reset(&state->buf);
4371                 strbuf_grow(&state->buf, GIT_SHA1_HEXSZ);
4372                 label = p = state->buf.buf;
4373
4374                 find_unique_abbrev_r(p, oid, default_abbrev);
4375
4376                 /*
4377                  * We may need to extend the abbreviated hash so that there is
4378                  * no conflicting label.
4379                  */
4380                 if (hashmap_get_from_hash(&state->labels, strihash(p), p)) {
4381                         size_t i = strlen(p) + 1;
4382
4383                         oid_to_hex_r(p, oid);
4384                         for (; i < GIT_SHA1_HEXSZ; i++) {
4385                                 char save = p[i];
4386                                 p[i] = '\0';
4387                                 if (!hashmap_get_from_hash(&state->labels,
4388                                                            strihash(p), p))
4389                                         break;
4390                                 p[i] = save;
4391                         }
4392                 }
4393         } else if (((len = strlen(label)) == the_hash_algo->hexsz &&
4394                     !get_oid_hex(label, &dummy)) ||
4395                    (len == 1 && *label == '#') ||
4396                    hashmap_get_from_hash(&state->labels,
4397                                          strihash(label), label)) {
4398                 /*
4399                  * If the label already exists, or if the label is a valid full
4400                  * OID, or the label is a '#' (which we use as a separator
4401                  * between merge heads and oneline), we append a dash and a
4402                  * number to make it unique.
4403                  */
4404                 struct strbuf *buf = &state->buf;
4405
4406                 strbuf_reset(buf);
4407                 strbuf_add(buf, label, len);
4408
4409                 for (i = 2; ; i++) {
4410                         strbuf_setlen(buf, len);
4411                         strbuf_addf(buf, "-%d", i);
4412                         if (!hashmap_get_from_hash(&state->labels,
4413                                                    strihash(buf->buf),
4414                                                    buf->buf))
4415                                 break;
4416                 }
4417
4418                 label = buf->buf;
4419         }
4420
4421         FLEX_ALLOC_STR(labels_entry, label, label);
4422         hashmap_entry_init(labels_entry, strihash(label));
4423         hashmap_add(&state->labels, labels_entry);
4424
4425         FLEX_ALLOC_STR(string_entry, string, label);
4426         oidcpy(&string_entry->entry.oid, oid);
4427         oidmap_put(&state->commit2label, string_entry);
4428
4429         return string_entry->string;
4430 }
4431
4432 static int make_script_with_merges(struct pretty_print_context *pp,
4433                                    struct rev_info *revs, struct strbuf *out,
4434                                    unsigned flags)
4435 {
4436         int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4437         int rebase_cousins = flags & TODO_LIST_REBASE_COUSINS;
4438         struct strbuf buf = STRBUF_INIT, oneline = STRBUF_INIT;
4439         struct strbuf label = STRBUF_INIT;
4440         struct commit_list *commits = NULL, **tail = &commits, *iter;
4441         struct commit_list *tips = NULL, **tips_tail = &tips;
4442         struct commit *commit;
4443         struct oidmap commit2todo = OIDMAP_INIT;
4444         struct string_entry *entry;
4445         struct oidset interesting = OIDSET_INIT, child_seen = OIDSET_INIT,
4446                 shown = OIDSET_INIT;
4447         struct label_state state = { OIDMAP_INIT, { NULL }, STRBUF_INIT };
4448
4449         int abbr = flags & TODO_LIST_ABBREVIATE_CMDS;
4450         const char *cmd_pick = abbr ? "p" : "pick",
4451                 *cmd_label = abbr ? "l" : "label",
4452                 *cmd_reset = abbr ? "t" : "reset",
4453                 *cmd_merge = abbr ? "m" : "merge";
4454
4455         oidmap_init(&commit2todo, 0);
4456         oidmap_init(&state.commit2label, 0);
4457         hashmap_init(&state.labels, (hashmap_cmp_fn) labels_cmp, NULL, 0);
4458         strbuf_init(&state.buf, 32);
4459
4460         if (revs->cmdline.nr && (revs->cmdline.rev[0].flags & BOTTOM)) {
4461                 struct object_id *oid = &revs->cmdline.rev[0].item->oid;
4462                 FLEX_ALLOC_STR(entry, string, "onto");
4463                 oidcpy(&entry->entry.oid, oid);
4464                 oidmap_put(&state.commit2label, entry);
4465         }
4466
4467         /*
4468          * First phase:
4469          * - get onelines for all commits
4470          * - gather all branch tips (i.e. 2nd or later parents of merges)
4471          * - label all branch tips
4472          */
4473         while ((commit = get_revision(revs))) {
4474                 struct commit_list *to_merge;
4475                 const char *p1, *p2;
4476                 struct object_id *oid;
4477                 int is_empty;
4478
4479                 tail = &commit_list_insert(commit, tail)->next;
4480                 oidset_insert(&interesting, &commit->object.oid);
4481
4482                 is_empty = is_original_commit_empty(commit);
4483                 if (!is_empty && (commit->object.flags & PATCHSAME))
4484                         continue;
4485
4486                 strbuf_reset(&oneline);
4487                 pretty_print_commit(pp, commit, &oneline);
4488
4489                 to_merge = commit->parents ? commit->parents->next : NULL;
4490                 if (!to_merge) {
4491                         /* non-merge commit: easy case */
4492                         strbuf_reset(&buf);
4493                         if (!keep_empty && is_empty)
4494                                 strbuf_addf(&buf, "%c ", comment_line_char);
4495                         strbuf_addf(&buf, "%s %s %s", cmd_pick,
4496                                     oid_to_hex(&commit->object.oid),
4497                                     oneline.buf);
4498
4499                         FLEX_ALLOC_STR(entry, string, buf.buf);
4500                         oidcpy(&entry->entry.oid, &commit->object.oid);
4501                         oidmap_put(&commit2todo, entry);
4502
4503                         continue;
4504                 }
4505
4506                 /* Create a label */
4507                 strbuf_reset(&label);
4508                 if (skip_prefix(oneline.buf, "Merge ", &p1) &&
4509                     (p1 = strchr(p1, '\'')) &&
4510                     (p2 = strchr(++p1, '\'')))
4511                         strbuf_add(&label, p1, p2 - p1);
4512                 else if (skip_prefix(oneline.buf, "Merge pull request ",
4513                                      &p1) &&
4514                          (p1 = strstr(p1, " from ")))
4515                         strbuf_addstr(&label, p1 + strlen(" from "));
4516                 else
4517                         strbuf_addbuf(&label, &oneline);
4518
4519                 for (p1 = label.buf; *p1; p1++)
4520                         if (isspace(*p1))
4521                                 *(char *)p1 = '-';
4522
4523                 strbuf_reset(&buf);
4524                 strbuf_addf(&buf, "%s -C %s",
4525                             cmd_merge, oid_to_hex(&commit->object.oid));
4526
4527                 /* label the tips of merged branches */
4528                 for (; to_merge; to_merge = to_merge->next) {
4529                         oid = &to_merge->item->object.oid;
4530                         strbuf_addch(&buf, ' ');
4531
4532                         if (!oidset_contains(&interesting, oid)) {
4533                                 strbuf_addstr(&buf, label_oid(oid, NULL,
4534                                                               &state));
4535                                 continue;
4536                         }
4537
4538                         tips_tail = &commit_list_insert(to_merge->item,
4539                                                         tips_tail)->next;
4540
4541                         strbuf_addstr(&buf, label_oid(oid, label.buf, &state));
4542                 }
4543                 strbuf_addf(&buf, " # %s", oneline.buf);
4544
4545                 FLEX_ALLOC_STR(entry, string, buf.buf);
4546                 oidcpy(&entry->entry.oid, &commit->object.oid);
4547                 oidmap_put(&commit2todo, entry);
4548         }
4549
4550         /*
4551          * Second phase:
4552          * - label branch points
4553          * - add HEAD to the branch tips
4554          */
4555         for (iter = commits; iter; iter = iter->next) {
4556                 struct commit_list *parent = iter->item->parents;
4557                 for (; parent; parent = parent->next) {
4558                         struct object_id *oid = &parent->item->object.oid;
4559                         if (!oidset_contains(&interesting, oid))
4560                                 continue;
4561                         if (oidset_insert(&child_seen, oid))
4562                                 label_oid(oid, "branch-point", &state);
4563                 }
4564
4565                 /* Add HEAD as implict "tip of branch" */
4566                 if (!iter->next)
4567                         tips_tail = &commit_list_insert(iter->item,
4568                                                         tips_tail)->next;
4569         }
4570
4571         /*
4572          * Third phase: output the todo list. This is a bit tricky, as we
4573          * want to avoid jumping back and forth between revisions. To
4574          * accomplish that goal, we walk backwards from the branch tips,
4575          * gathering commits not yet shown, reversing the list on the fly,
4576          * then outputting that list (labeling revisions as needed).
4577          */
4578         strbuf_addf(out, "%s onto\n", cmd_label);
4579         for (iter = tips; iter; iter = iter->next) {
4580                 struct commit_list *list = NULL, *iter2;
4581
4582                 commit = iter->item;
4583                 if (oidset_contains(&shown, &commit->object.oid))
4584                         continue;
4585                 entry = oidmap_get(&state.commit2label, &commit->object.oid);
4586
4587                 if (entry)
4588                         strbuf_addf(out, "\n%c Branch %s\n", comment_line_char, entry->string);
4589                 else
4590                         strbuf_addch(out, '\n');
4591
4592                 while (oidset_contains(&interesting, &commit->object.oid) &&
4593                        !oidset_contains(&shown, &commit->object.oid)) {
4594                         commit_list_insert(commit, &list);
4595                         if (!commit->parents) {
4596                                 commit = NULL;
4597                                 break;
4598                         }
4599                         commit = commit->parents->item;
4600                 }
4601
4602                 if (!commit)
4603                         strbuf_addf(out, "%s %s\n", cmd_reset,
4604                                     rebase_cousins ? "onto" : "[new root]");
4605                 else {
4606                         const char *to = NULL;
4607
4608                         entry = oidmap_get(&state.commit2label,
4609                                            &commit->object.oid);
4610                         if (entry)
4611                                 to = entry->string;
4612                         else if (!rebase_cousins)
4613                                 to = label_oid(&commit->object.oid, NULL,
4614                                                &state);
4615
4616                         if (!to || !strcmp(to, "onto"))
4617                                 strbuf_addf(out, "%s onto\n", cmd_reset);
4618                         else {
4619                                 strbuf_reset(&oneline);
4620                                 pretty_print_commit(pp, commit, &oneline);
4621                                 strbuf_addf(out, "%s %s # %s\n",
4622                                             cmd_reset, to, oneline.buf);
4623                         }
4624                 }
4625
4626                 for (iter2 = list; iter2; iter2 = iter2->next) {
4627                         struct object_id *oid = &iter2->item->object.oid;
4628                         entry = oidmap_get(&commit2todo, oid);
4629                         /* only show if not already upstream */
4630                         if (entry)
4631                                 strbuf_addf(out, "%s\n", entry->string);
4632                         entry = oidmap_get(&state.commit2label, oid);
4633                         if (entry)
4634                                 strbuf_addf(out, "%s %s\n",
4635                                             cmd_label, entry->string);
4636                         oidset_insert(&shown, oid);
4637                 }
4638
4639                 free_commit_list(list);
4640         }
4641
4642         free_commit_list(commits);
4643         free_commit_list(tips);
4644
4645         strbuf_release(&label);
4646         strbuf_release(&oneline);
4647         strbuf_release(&buf);
4648
4649         oidmap_free(&commit2todo, 1);
4650         oidmap_free(&state.commit2label, 1);
4651         hashmap_free(&state.labels, 1);
4652         strbuf_release(&state.buf);
4653
4654         return 0;
4655 }
4656
4657 int sequencer_make_script(struct repository *r, struct strbuf *out, int argc,
4658                           const char **argv, unsigned flags)
4659 {
4660         char *format = NULL;
4661         struct pretty_print_context pp = {0};
4662         struct rev_info revs;
4663         struct commit *commit;
4664         int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4665         const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";
4666         int rebase_merges = flags & TODO_LIST_REBASE_MERGES;
4667
4668         repo_init_revisions(r, &revs, NULL);
4669         revs.verbose_header = 1;
4670         if (!rebase_merges)
4671                 revs.max_parents = 1;
4672         revs.cherry_mark = 1;
4673         revs.limited = 1;
4674         revs.reverse = 1;
4675         revs.right_only = 1;
4676         revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
4677         revs.topo_order = 1;
4678
4679         revs.pretty_given = 1;
4680         git_config_get_string("rebase.instructionFormat", &format);
4681         if (!format || !*format) {
4682                 free(format);
4683                 format = xstrdup("%s");
4684         }
4685         get_commit_format(format, &revs);
4686         free(format);
4687         pp.fmt = revs.commit_format;
4688         pp.output_encoding = get_log_output_encoding();
4689
4690         if (setup_revisions(argc, argv, &revs, NULL) > 1)
4691                 return error(_("make_script: unhandled options"));
4692
4693         if (prepare_revision_walk(&revs) < 0)
4694                 return error(_("make_script: error preparing revisions"));
4695
4696         if (rebase_merges)
4697                 return make_script_with_merges(&pp, &revs, out, flags);
4698
4699         while ((commit = get_revision(&revs))) {
4700                 int is_empty  = is_original_commit_empty(commit);
4701
4702                 if (!is_empty && (commit->object.flags & PATCHSAME))
4703                         continue;
4704                 if (!keep_empty && is_empty)
4705                         strbuf_addf(out, "%c ", comment_line_char);
4706                 strbuf_addf(out, "%s %s ", insn,
4707                             oid_to_hex(&commit->object.oid));
4708                 pretty_print_commit(&pp, commit, out);
4709                 strbuf_addch(out, '\n');
4710         }
4711         return 0;
4712 }
4713
4714 /*
4715  * Add commands after pick and (series of) squash/fixup commands
4716  * in the todo list.
4717  */
4718 void todo_list_add_exec_commands(struct todo_list *todo_list,
4719                                  struct string_list *commands)
4720 {
4721         struct strbuf *buf = &todo_list->buf;
4722         size_t base_offset = buf->len;
4723         int i, insert, nr = 0, alloc = 0;
4724         struct todo_item *items = NULL, *base_items = NULL;
4725
4726         base_items = xcalloc(commands->nr, sizeof(struct todo_item));
4727         for (i = 0; i < commands->nr; i++) {
4728                 size_t command_len = strlen(commands->items[i].string);
4729
4730                 strbuf_addstr(buf, commands->items[i].string);
4731                 strbuf_addch(buf, '\n');
4732
4733                 base_items[i].command = TODO_EXEC;
4734                 base_items[i].offset_in_buf = base_offset;
4735                 base_items[i].arg_offset = base_offset + strlen("exec ");
4736                 base_items[i].arg_len = command_len - strlen("exec ");
4737
4738                 base_offset += command_len + 1;
4739         }
4740
4741         /*
4742          * Insert <commands> after every pick. Here, fixup/squash chains
4743          * are considered part of the pick, so we insert the commands *after*
4744          * those chains if there are any.
4745          *
4746          * As we insert the exec commands immediatly after rearranging
4747          * any fixups and before the user edits the list, a fixup chain
4748          * can never contain comments (any comments are empty picks that
4749          * have been commented out because the user did not specify
4750          * --keep-empty).  So, it is safe to insert an exec command
4751          * without looking at the command following a comment.
4752          */
4753         insert = 0;
4754         for (i = 0; i < todo_list->nr; i++) {
4755                 enum todo_command command = todo_list->items[i].command;
4756                 if (insert && !is_fixup(command)) {
4757                         ALLOC_GROW(items, nr + commands->nr, alloc);
4758                         COPY_ARRAY(items + nr, base_items, commands->nr);
4759                         nr += commands->nr;
4760
4761                         insert = 0;
4762                 }
4763
4764                 ALLOC_GROW(items, nr + 1, alloc);
4765                 items[nr++] = todo_list->items[i];
4766
4767                 if (command == TODO_PICK || command == TODO_MERGE)
4768                         insert = 1;
4769         }
4770
4771         /* insert or append final <commands> */
4772         if (insert || nr == todo_list->nr) {
4773                 ALLOC_GROW(items, nr + commands->nr, alloc);
4774                 COPY_ARRAY(items + nr, base_items, commands->nr);
4775                 nr += commands->nr;
4776         }
4777
4778         free(base_items);
4779         FREE_AND_NULL(todo_list->items);
4780         todo_list->items = items;
4781         todo_list->nr = nr;
4782         todo_list->alloc = alloc;
4783 }
4784
4785 static void todo_list_to_strbuf(struct repository *r, struct todo_list *todo_list,
4786                                 struct strbuf *buf, int num, unsigned flags)
4787 {
4788         struct todo_item *item;
4789         int i, max = todo_list->nr;
4790
4791         if (num > 0 && num < max)
4792                 max = num;
4793
4794         for (item = todo_list->items, i = 0; i < max; i++, item++) {
4795                 /* if the item is not a command write it and continue */
4796                 if (item->command >= TODO_COMMENT) {
4797                         strbuf_addf(buf, "%.*s\n", item->arg_len,
4798                                     todo_item_get_arg(todo_list, item));
4799                         continue;
4800                 }
4801
4802                 /* add command to the buffer */
4803                 if (flags & TODO_LIST_ABBREVIATE_CMDS)
4804                         strbuf_addch(buf, command_to_char(item->command));
4805                 else
4806                         strbuf_addstr(buf, command_to_string(item->command));
4807
4808                 /* add commit id */
4809                 if (item->commit) {
4810                         const char *oid = flags & TODO_LIST_SHORTEN_IDS ?
4811                                           short_commit_name(item->commit) :
4812                                           oid_to_hex(&item->commit->object.oid);
4813
4814                         if (item->command == TODO_MERGE) {
4815                                 if (item->flags & TODO_EDIT_MERGE_MSG)
4816                                         strbuf_addstr(buf, " -c");
4817                                 else
4818                                         strbuf_addstr(buf, " -C");
4819                         }
4820
4821                         strbuf_addf(buf, " %s", oid);
4822                 }
4823
4824                 /* add all the rest */
4825                 if (!item->arg_len)
4826                         strbuf_addch(buf, '\n');
4827                 else
4828                         strbuf_addf(buf, " %.*s\n", item->arg_len,
4829                                     todo_item_get_arg(todo_list, item));
4830         }
4831 }
4832
4833 int todo_list_write_to_file(struct repository *r, struct todo_list *todo_list,
4834                             const char *file, const char *shortrevisions,
4835                             const char *shortonto, int num, unsigned flags)
4836 {
4837         int res;
4838         struct strbuf buf = STRBUF_INIT;
4839
4840         todo_list_to_strbuf(r, todo_list, &buf, num, flags);
4841         if (flags & TODO_LIST_APPEND_TODO_HELP)
4842                 append_todo_help(flags & TODO_LIST_KEEP_EMPTY, count_commands(todo_list),
4843                                  shortrevisions, shortonto, &buf);
4844
4845         res = write_message(buf.buf, buf.len, file, 0);
4846         strbuf_release(&buf);
4847
4848         return res;
4849 }
4850
4851 static const char edit_todo_list_advice[] =
4852 N_("You can fix this with 'git rebase --edit-todo' "
4853 "and then run 'git rebase --continue'.\n"
4854 "Or you can abort the rebase with 'git rebase"
4855 " --abort'.\n");
4856
4857 int check_todo_list_from_file(struct repository *r)
4858 {
4859         struct todo_list old_todo = TODO_LIST_INIT, new_todo = TODO_LIST_INIT;
4860         int res = 0;
4861
4862         if (strbuf_read_file_or_whine(&new_todo.buf, rebase_path_todo()) < 0) {
4863                 res = -1;
4864                 goto out;
4865         }
4866
4867         if (strbuf_read_file_or_whine(&old_todo.buf, rebase_path_todo_backup()) < 0) {
4868                 res = -1;
4869                 goto out;
4870         }
4871
4872         res = todo_list_parse_insn_buffer(r, old_todo.buf.buf, &old_todo);
4873         if (!res)
4874                 res = todo_list_parse_insn_buffer(r, new_todo.buf.buf, &new_todo);
4875         if (!res)
4876                 res = todo_list_check(&old_todo, &new_todo);
4877         if (res)
4878                 fprintf(stderr, _(edit_todo_list_advice));
4879 out:
4880         todo_list_release(&old_todo);
4881         todo_list_release(&new_todo);
4882
4883         return res;
4884 }
4885
4886 /* skip picking commits whose parents are unchanged */
4887 static int skip_unnecessary_picks(struct repository *r,
4888                                   struct todo_list *todo_list,
4889                                   struct object_id *base_oid)
4890 {
4891         struct object_id *parent_oid;
4892         int i;
4893
4894         for (i = 0; i < todo_list->nr; i++) {
4895                 struct todo_item *item = todo_list->items + i;
4896
4897                 if (item->command >= TODO_NOOP)
4898                         continue;
4899                 if (item->command != TODO_PICK)
4900                         break;
4901                 if (parse_commit(item->commit)) {
4902                         return error(_("could not parse commit '%s'"),
4903                                 oid_to_hex(&item->commit->object.oid));
4904                 }
4905                 if (!item->commit->parents)
4906                         break; /* root commit */
4907                 if (item->commit->parents->next)
4908                         break; /* merge commit */
4909                 parent_oid = &item->commit->parents->item->object.oid;
4910                 if (!oideq(parent_oid, base_oid))
4911                         break;
4912                 oidcpy(base_oid, &item->commit->object.oid);
4913         }
4914         if (i > 0) {
4915                 const char *done_path = rebase_path_done();
4916
4917                 if (todo_list_write_to_file(r, todo_list, done_path, NULL, NULL, i, 0)) {
4918                         error_errno(_("could not write to '%s'"), done_path);
4919                         return -1;
4920                 }
4921
4922                 MOVE_ARRAY(todo_list->items, todo_list->items + i, todo_list->nr - i);
4923                 todo_list->nr -= i;
4924                 todo_list->current = 0;
4925
4926                 if (is_fixup(peek_command(todo_list, 0)))
4927                         record_in_rewritten(base_oid, peek_command(todo_list, 0));
4928         }
4929
4930         return 0;
4931 }
4932
4933 int complete_action(struct repository *r, struct replay_opts *opts, unsigned flags,
4934                     const char *shortrevisions, const char *onto_name,
4935                     struct commit *onto, const char *orig_head,
4936                     struct string_list *commands, unsigned autosquash,
4937                     struct todo_list *todo_list)
4938 {
4939         const char *shortonto, *todo_file = rebase_path_todo();
4940         struct todo_list new_todo = TODO_LIST_INIT;
4941         struct strbuf *buf = &todo_list->buf;
4942         struct object_id oid = onto->object.oid;
4943         int res;
4944
4945         shortonto = find_unique_abbrev(&oid, DEFAULT_ABBREV);
4946
4947         if (buf->len == 0) {
4948                 struct todo_item *item = append_new_todo(todo_list);
4949                 item->command = TODO_NOOP;
4950                 item->commit = NULL;
4951                 item->arg_len = item->arg_offset = item->flags = item->offset_in_buf = 0;
4952         }
4953
4954         if (autosquash && todo_list_rearrange_squash(todo_list))
4955                 return -1;
4956
4957         if (commands->nr)
4958                 todo_list_add_exec_commands(todo_list, commands);
4959
4960         if (count_commands(todo_list) == 0) {
4961                 apply_autostash(opts);
4962                 sequencer_remove_state(opts);
4963
4964                 return error(_("nothing to do"));
4965         }
4966
4967         res = edit_todo_list(r, todo_list, &new_todo, shortrevisions,
4968                              shortonto, flags);
4969         if (res == -1)
4970                 return -1;
4971         else if (res == -2) {
4972                 apply_autostash(opts);
4973                 sequencer_remove_state(opts);
4974
4975                 return -1;
4976         } else if (res == -3) {
4977                 apply_autostash(opts);
4978                 sequencer_remove_state(opts);
4979                 todo_list_release(&new_todo);
4980
4981                 return error(_("nothing to do"));
4982         }
4983
4984         if (todo_list_parse_insn_buffer(r, new_todo.buf.buf, &new_todo) ||
4985             todo_list_check(todo_list, &new_todo)) {
4986                 fprintf(stderr, _(edit_todo_list_advice));
4987                 checkout_onto(r, opts, onto_name, &onto->object.oid, orig_head);
4988                 todo_list_release(&new_todo);
4989
4990                 return -1;
4991         }
4992
4993         if (opts->allow_ff && skip_unnecessary_picks(r, &new_todo, &oid)) {
4994                 todo_list_release(&new_todo);
4995                 return error(_("could not skip unnecessary pick commands"));
4996         }
4997
4998         if (todo_list_write_to_file(r, &new_todo, todo_file, NULL, NULL, -1,
4999                                     flags & ~(TODO_LIST_SHORTEN_IDS))) {
5000                 todo_list_release(&new_todo);
5001                 return error_errno(_("could not write '%s'"), todo_file);
5002         }
5003
5004         todo_list_release(&new_todo);
5005
5006         if (checkout_onto(r, opts, onto_name, &oid, orig_head))
5007                 return -1;
5008
5009         if (require_clean_work_tree(r, "rebase", "", 1, 1))
5010                 return -1;
5011
5012         return sequencer_continue(r, opts);
5013 }
5014
5015 struct subject2item_entry {
5016         struct hashmap_entry entry;
5017         int i;
5018         char subject[FLEX_ARRAY];
5019 };
5020
5021 static int subject2item_cmp(const void *fndata,
5022                             const struct subject2item_entry *a,
5023                             const struct subject2item_entry *b, const void *key)
5024 {
5025         return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
5026 }
5027
5028 define_commit_slab(commit_todo_item, struct todo_item *);
5029
5030 /*
5031  * Rearrange the todo list that has both "pick commit-id msg" and "pick
5032  * commit-id fixup!/squash! msg" in it so that the latter is put immediately
5033  * after the former, and change "pick" to "fixup"/"squash".
5034  *
5035  * Note that if the config has specified a custom instruction format, each log
5036  * message will have to be retrieved from the commit (as the oneline in the
5037  * script cannot be trusted) in order to normalize the autosquash arrangement.
5038  */
5039 int todo_list_rearrange_squash(struct todo_list *todo_list)
5040 {
5041         struct hashmap subject2item;
5042         int rearranged = 0, *next, *tail, i, nr = 0, alloc = 0;
5043         char **subjects;
5044         struct commit_todo_item commit_todo;
5045         struct todo_item *items = NULL;
5046
5047         init_commit_todo_item(&commit_todo);
5048         /*
5049          * The hashmap maps onelines to the respective todo list index.
5050          *
5051          * If any items need to be rearranged, the next[i] value will indicate
5052          * which item was moved directly after the i'th.
5053          *
5054          * In that case, last[i] will indicate the index of the latest item to
5055          * be moved to appear after the i'th.
5056          */
5057         hashmap_init(&subject2item, (hashmap_cmp_fn) subject2item_cmp,
5058                      NULL, todo_list->nr);
5059         ALLOC_ARRAY(next, todo_list->nr);
5060         ALLOC_ARRAY(tail, todo_list->nr);
5061         ALLOC_ARRAY(subjects, todo_list->nr);
5062         for (i = 0; i < todo_list->nr; i++) {
5063                 struct strbuf buf = STRBUF_INIT;
5064                 struct todo_item *item = todo_list->items + i;
5065                 const char *commit_buffer, *subject, *p;
5066                 size_t subject_len;
5067                 int i2 = -1;
5068                 struct subject2item_entry *entry;
5069
5070                 next[i] = tail[i] = -1;
5071                 if (!item->commit || item->command == TODO_DROP) {
5072                         subjects[i] = NULL;
5073                         continue;
5074                 }
5075
5076                 if (is_fixup(item->command)) {
5077                         clear_commit_todo_item(&commit_todo);
5078                         return error(_("the script was already rearranged."));
5079                 }
5080
5081                 *commit_todo_item_at(&commit_todo, item->commit) = item;
5082
5083                 parse_commit(item->commit);
5084                 commit_buffer = get_commit_buffer(item->commit, NULL);
5085                 find_commit_subject(commit_buffer, &subject);
5086                 format_subject(&buf, subject, " ");
5087                 subject = subjects[i] = strbuf_detach(&buf, &subject_len);
5088                 unuse_commit_buffer(item->commit, commit_buffer);
5089                 if ((skip_prefix(subject, "fixup! ", &p) ||
5090                      skip_prefix(subject, "squash! ", &p))) {
5091                         struct commit *commit2;
5092
5093                         for (;;) {
5094                                 while (isspace(*p))
5095                                         p++;
5096                                 if (!skip_prefix(p, "fixup! ", &p) &&
5097                                     !skip_prefix(p, "squash! ", &p))
5098                                         break;
5099                         }
5100
5101                         if ((entry = hashmap_get_from_hash(&subject2item,
5102                                                            strhash(p), p)))
5103                                 /* found by title */
5104                                 i2 = entry->i;
5105                         else if (!strchr(p, ' ') &&
5106                                  (commit2 =
5107                                   lookup_commit_reference_by_name(p)) &&
5108                                  *commit_todo_item_at(&commit_todo, commit2))
5109                                 /* found by commit name */
5110                                 i2 = *commit_todo_item_at(&commit_todo, commit2)
5111                                         - todo_list->items;
5112                         else {
5113                                 /* copy can be a prefix of the commit subject */
5114                                 for (i2 = 0; i2 < i; i2++)
5115                                         if (subjects[i2] &&
5116                                             starts_with(subjects[i2], p))
5117                                                 break;
5118                                 if (i2 == i)
5119                                         i2 = -1;
5120                         }
5121                 }
5122                 if (i2 >= 0) {
5123                         rearranged = 1;
5124                         todo_list->items[i].command =
5125                                 starts_with(subject, "fixup!") ?
5126                                 TODO_FIXUP : TODO_SQUASH;
5127                         if (next[i2] < 0)
5128                                 next[i2] = i;
5129                         else
5130                                 next[tail[i2]] = i;
5131                         tail[i2] = i;
5132                 } else if (!hashmap_get_from_hash(&subject2item,
5133                                                 strhash(subject), subject)) {
5134                         FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
5135                         entry->i = i;
5136                         hashmap_entry_init(entry, strhash(entry->subject));
5137                         hashmap_put(&subject2item, entry);
5138                 }
5139         }
5140
5141         if (rearranged) {
5142                 for (i = 0; i < todo_list->nr; i++) {
5143                         enum todo_command command = todo_list->items[i].command;
5144                         int cur = i;
5145
5146                         /*
5147                          * Initially, all commands are 'pick's. If it is a
5148                          * fixup or a squash now, we have rearranged it.
5149                          */
5150                         if (is_fixup(command))
5151                                 continue;
5152
5153                         while (cur >= 0) {
5154                                 ALLOC_GROW(items, nr + 1, alloc);
5155                                 items[nr++] = todo_list->items[cur];
5156                                 cur = next[cur];
5157                         }
5158                 }
5159
5160                 FREE_AND_NULL(todo_list->items);
5161                 todo_list->items = items;
5162                 todo_list->nr = nr;
5163                 todo_list->alloc = alloc;
5164         }
5165
5166         free(next);
5167         free(tail);
5168         for (i = 0; i < todo_list->nr; i++)
5169                 free(subjects[i]);
5170         free(subjects);
5171         hashmap_free(&subject2item, 1);
5172
5173         clear_commit_todo_item(&commit_todo);
5174
5175         return 0;
5176 }