sequencer: the `am` and `rebase--interactive` scripts are gone
[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                 goto leave_merge;
3405         }
3406
3407         if (to_merge->next) {
3408                 /* Octopus merge */
3409                 struct child_process cmd = CHILD_PROCESS_INIT;
3410
3411                 if (read_env_script(&cmd.env_array)) {
3412                         const char *gpg_opt = gpg_sign_opt_quoted(opts);
3413
3414                         ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
3415                         goto leave_merge;
3416                 }
3417
3418                 cmd.git_cmd = 1;
3419                 argv_array_push(&cmd.args, "merge");
3420                 argv_array_push(&cmd.args, "-s");
3421                 argv_array_push(&cmd.args, "octopus");
3422                 argv_array_push(&cmd.args, "--no-edit");
3423                 argv_array_push(&cmd.args, "--no-ff");
3424                 argv_array_push(&cmd.args, "--no-log");
3425                 argv_array_push(&cmd.args, "--no-stat");
3426                 argv_array_push(&cmd.args, "-F");
3427                 argv_array_push(&cmd.args, git_path_merge_msg(r));
3428                 if (opts->gpg_sign)
3429                         argv_array_push(&cmd.args, opts->gpg_sign);
3430
3431                 /* Add the tips to be merged */
3432                 for (j = to_merge; j; j = j->next)
3433                         argv_array_push(&cmd.args,
3434                                         oid_to_hex(&j->item->object.oid));
3435
3436                 strbuf_release(&ref_name);
3437                 unlink(git_path_cherry_pick_head(r));
3438                 rollback_lock_file(&lock);
3439
3440                 rollback_lock_file(&lock);
3441                 ret = run_command(&cmd);
3442
3443                 /* force re-reading of the cache */
3444                 if (!ret && (discard_index(r->index) < 0 ||
3445                              repo_read_index(r) < 0))
3446                         ret = error(_("could not read index"));
3447                 goto leave_merge;
3448         }
3449
3450         merge_commit = to_merge->item;
3451         bases = get_merge_bases(head_commit, merge_commit);
3452         if (bases && oideq(&merge_commit->object.oid,
3453                            &bases->item->object.oid)) {
3454                 ret = 0;
3455                 /* skip merging an ancestor of HEAD */
3456                 goto leave_merge;
3457         }
3458
3459         write_message(oid_to_hex(&merge_commit->object.oid), GIT_SHA1_HEXSZ,
3460                       git_path_merge_head(r), 0);
3461         write_message("no-ff", 5, git_path_merge_mode(r), 0);
3462
3463         for (j = bases; j; j = j->next)
3464                 commit_list_insert(j->item, &reversed);
3465         free_commit_list(bases);
3466
3467         repo_read_index(r);
3468         init_merge_options(&o, r);
3469         o.branch1 = "HEAD";
3470         o.branch2 = ref_name.buf;
3471         o.buffer_output = 2;
3472
3473         ret = merge_recursive(&o, head_commit, merge_commit, reversed, &i);
3474         if (ret <= 0)
3475                 fputs(o.obuf.buf, stdout);
3476         strbuf_release(&o.obuf);
3477         if (ret < 0) {
3478                 error(_("could not even attempt to merge '%.*s'"),
3479                       merge_arg_len, arg);
3480                 goto leave_merge;
3481         }
3482         /*
3483          * The return value of merge_recursive() is 1 on clean, and 0 on
3484          * unclean merge.
3485          *
3486          * Let's reverse that, so that do_merge() returns 0 upon success and
3487          * 1 upon failed merge (keeping the return value -1 for the cases where
3488          * we will want to reschedule the `merge` command).
3489          */
3490         ret = !ret;
3491
3492         if (r->index->cache_changed &&
3493             write_locked_index(r->index, &lock, COMMIT_LOCK)) {
3494                 ret = error(_("merge: Unable to write new index file"));
3495                 goto leave_merge;
3496         }
3497
3498         rollback_lock_file(&lock);
3499         if (ret)
3500                 repo_rerere(r, opts->allow_rerere_auto);
3501         else
3502                 /*
3503                  * In case of problems, we now want to return a positive
3504                  * value (a negative one would indicate that the `merge`
3505                  * command needs to be rescheduled).
3506                  */
3507                 ret = !!run_git_commit(r, git_path_merge_msg(r), opts,
3508                                        run_commit_flags);
3509
3510 leave_merge:
3511         strbuf_release(&ref_name);
3512         rollback_lock_file(&lock);
3513         free_commit_list(to_merge);
3514         return ret;
3515 }
3516
3517 static int is_final_fixup(struct todo_list *todo_list)
3518 {
3519         int i = todo_list->current;
3520
3521         if (!is_fixup(todo_list->items[i].command))
3522                 return 0;
3523
3524         while (++i < todo_list->nr)
3525                 if (is_fixup(todo_list->items[i].command))
3526                         return 0;
3527                 else if (!is_noop(todo_list->items[i].command))
3528                         break;
3529         return 1;
3530 }
3531
3532 static enum todo_command peek_command(struct todo_list *todo_list, int offset)
3533 {
3534         int i;
3535
3536         for (i = todo_list->current + offset; i < todo_list->nr; i++)
3537                 if (!is_noop(todo_list->items[i].command))
3538                         return todo_list->items[i].command;
3539
3540         return -1;
3541 }
3542
3543 static int apply_autostash(struct replay_opts *opts)
3544 {
3545         struct strbuf stash_sha1 = STRBUF_INIT;
3546         struct child_process child = CHILD_PROCESS_INIT;
3547         int ret = 0;
3548
3549         if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
3550                 strbuf_release(&stash_sha1);
3551                 return 0;
3552         }
3553         strbuf_trim(&stash_sha1);
3554
3555         child.git_cmd = 1;
3556         child.no_stdout = 1;
3557         child.no_stderr = 1;
3558         argv_array_push(&child.args, "stash");
3559         argv_array_push(&child.args, "apply");
3560         argv_array_push(&child.args, stash_sha1.buf);
3561         if (!run_command(&child))
3562                 fprintf(stderr, _("Applied autostash.\n"));
3563         else {
3564                 struct child_process store = CHILD_PROCESS_INIT;
3565
3566                 store.git_cmd = 1;
3567                 argv_array_push(&store.args, "stash");
3568                 argv_array_push(&store.args, "store");
3569                 argv_array_push(&store.args, "-m");
3570                 argv_array_push(&store.args, "autostash");
3571                 argv_array_push(&store.args, "-q");
3572                 argv_array_push(&store.args, stash_sha1.buf);
3573                 if (run_command(&store))
3574                         ret = error(_("cannot store %s"), stash_sha1.buf);
3575                 else
3576                         fprintf(stderr,
3577                                 _("Applying autostash resulted in conflicts.\n"
3578                                   "Your changes are safe in the stash.\n"
3579                                   "You can run \"git stash pop\" or"
3580                                   " \"git stash drop\" at any time.\n"));
3581         }
3582
3583         strbuf_release(&stash_sha1);
3584         return ret;
3585 }
3586
3587 static const char *reflog_message(struct replay_opts *opts,
3588         const char *sub_action, const char *fmt, ...)
3589 {
3590         va_list ap;
3591         static struct strbuf buf = STRBUF_INIT;
3592
3593         va_start(ap, fmt);
3594         strbuf_reset(&buf);
3595         strbuf_addstr(&buf, action_name(opts));
3596         if (sub_action)
3597                 strbuf_addf(&buf, " (%s)", sub_action);
3598         if (fmt) {
3599                 strbuf_addstr(&buf, ": ");
3600                 strbuf_vaddf(&buf, fmt, ap);
3601         }
3602         va_end(ap);
3603
3604         return buf.buf;
3605 }
3606
3607 static int run_git_checkout(struct repository *r, struct replay_opts *opts,
3608                             const char *commit, const char *action)
3609 {
3610         struct child_process cmd = CHILD_PROCESS_INIT;
3611         int ret;
3612
3613         cmd.git_cmd = 1;
3614
3615         argv_array_push(&cmd.args, "checkout");
3616         argv_array_push(&cmd.args, commit);
3617         argv_array_pushf(&cmd.env_array, GIT_REFLOG_ACTION "=%s", action);
3618
3619         if (opts->verbose)
3620                 ret = run_command(&cmd);
3621         else
3622                 ret = run_command_silent_on_success(&cmd);
3623
3624         if (!ret)
3625                 discard_index(r->index);
3626
3627         return ret;
3628 }
3629
3630 int prepare_branch_to_be_rebased(struct repository *r, struct replay_opts *opts,
3631                                  const char *commit)
3632 {
3633         const char *action;
3634
3635         if (commit && *commit) {
3636                 action = reflog_message(opts, "start", "checkout %s", commit);
3637                 if (run_git_checkout(r, opts, commit, action))
3638                         return error(_("could not checkout %s"), commit);
3639         }
3640
3641         return 0;
3642 }
3643
3644 static int checkout_onto(struct repository *r, struct replay_opts *opts,
3645                          const char *onto_name, const struct object_id *onto,
3646                          const char *orig_head)
3647 {
3648         struct object_id oid;
3649         const char *action = reflog_message(opts, "start", "checkout %s", onto_name);
3650
3651         if (get_oid(orig_head, &oid))
3652                 return error(_("%s: not a valid OID"), orig_head);
3653
3654         if (run_git_checkout(r, opts, oid_to_hex(onto), action)) {
3655                 apply_autostash(opts);
3656                 sequencer_remove_state(opts);
3657                 return error(_("could not detach HEAD"));
3658         }
3659
3660         return update_ref(NULL, "ORIG_HEAD", &oid, NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3661 }
3662
3663 static int stopped_at_head(struct repository *r)
3664 {
3665         struct object_id head;
3666         struct commit *commit;
3667         struct commit_message message;
3668
3669         if (get_oid("HEAD", &head) ||
3670             !(commit = lookup_commit(r, &head)) ||
3671             parse_commit(commit) || get_message(commit, &message))
3672                 fprintf(stderr, _("Stopped at HEAD\n"));
3673         else {
3674                 fprintf(stderr, _("Stopped at %s\n"), message.label);
3675                 free_message(commit, &message);
3676         }
3677         return 0;
3678
3679 }
3680
3681 static const char rescheduled_advice[] =
3682 N_("Could not execute the todo command\n"
3683 "\n"
3684 "    %.*s"
3685 "\n"
3686 "It has been rescheduled; To edit the command before continuing, please\n"
3687 "edit the todo list first:\n"
3688 "\n"
3689 "    git rebase --edit-todo\n"
3690 "    git rebase --continue\n");
3691
3692 static int pick_commits(struct repository *r,
3693                         struct todo_list *todo_list,
3694                         struct replay_opts *opts)
3695 {
3696         int res = 0, reschedule = 0;
3697
3698         setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
3699         if (opts->allow_ff)
3700                 assert(!(opts->signoff || opts->no_commit ||
3701                                 opts->record_origin || opts->edit));
3702         if (read_and_refresh_cache(r, opts))
3703                 return -1;
3704
3705         while (todo_list->current < todo_list->nr) {
3706                 struct todo_item *item = todo_list->items + todo_list->current;
3707                 const char *arg = todo_item_get_arg(todo_list, item);
3708
3709                 if (save_todo(todo_list, opts))
3710                         return -1;
3711                 if (is_rebase_i(opts)) {
3712                         if (item->command != TODO_COMMENT) {
3713                                 FILE *f = fopen(rebase_path_msgnum(), "w");
3714
3715                                 todo_list->done_nr++;
3716
3717                                 if (f) {
3718                                         fprintf(f, "%d\n", todo_list->done_nr);
3719                                         fclose(f);
3720                                 }
3721                                 if (!opts->quiet)
3722                                         fprintf(stderr, "Rebasing (%d/%d)%s",
3723                                                 todo_list->done_nr,
3724                                                 todo_list->total_nr,
3725                                                 opts->verbose ? "\n" : "\r");
3726                         }
3727                         unlink(rebase_path_message());
3728                         unlink(rebase_path_author_script());
3729                         unlink(rebase_path_stopped_sha());
3730                         unlink(rebase_path_amend());
3731                         unlink(git_path_merge_head(the_repository));
3732                         delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
3733
3734                         if (item->command == TODO_BREAK)
3735                                 return stopped_at_head(r);
3736                 }
3737                 if (item->command <= TODO_SQUASH) {
3738                         if (is_rebase_i(opts))
3739                                 setenv("GIT_REFLOG_ACTION", reflog_message(opts,
3740                                         command_to_string(item->command), NULL),
3741                                         1);
3742                         res = do_pick_commit(r, item->command, item->commit,
3743                                         opts, is_final_fixup(todo_list));
3744                         if (is_rebase_i(opts) && res < 0) {
3745                                 /* Reschedule */
3746                                 advise(_(rescheduled_advice),
3747                                        get_item_line_length(todo_list,
3748                                                             todo_list->current),
3749                                        get_item_line(todo_list,
3750                                                      todo_list->current));
3751                                 todo_list->current--;
3752                                 if (save_todo(todo_list, opts))
3753                                         return -1;
3754                         }
3755                         if (item->command == TODO_EDIT) {
3756                                 struct commit *commit = item->commit;
3757                                 if (!res)
3758                                         fprintf(stderr,
3759                                                 _("Stopped at %s...  %.*s\n"),
3760                                                 short_commit_name(commit),
3761                                                 item->arg_len, arg);
3762                                 return error_with_patch(r, commit,
3763                                         arg, item->arg_len, opts, res, !res);
3764                         }
3765                         if (is_rebase_i(opts) && !res)
3766                                 record_in_rewritten(&item->commit->object.oid,
3767                                         peek_command(todo_list, 1));
3768                         if (res && is_fixup(item->command)) {
3769                                 if (res == 1)
3770                                         intend_to_amend();
3771                                 return error_failed_squash(r, item->commit, opts,
3772                                         item->arg_len, arg);
3773                         } else if (res && is_rebase_i(opts) && item->commit) {
3774                                 int to_amend = 0;
3775                                 struct object_id oid;
3776
3777                                 /*
3778                                  * If we are rewording and have either
3779                                  * fast-forwarded already, or are about to
3780                                  * create a new root commit, we want to amend,
3781                                  * otherwise we do not.
3782                                  */
3783                                 if (item->command == TODO_REWORD &&
3784                                     !get_oid("HEAD", &oid) &&
3785                                     (oideq(&item->commit->object.oid, &oid) ||
3786                                      (opts->have_squash_onto &&
3787                                       oideq(&opts->squash_onto, &oid))))
3788                                         to_amend = 1;
3789
3790                                 return res | error_with_patch(r, item->commit,
3791                                                 arg, item->arg_len, opts,
3792                                                 res, to_amend);
3793                         }
3794                 } else if (item->command == TODO_EXEC) {
3795                         char *end_of_arg = (char *)(arg + item->arg_len);
3796                         int saved = *end_of_arg;
3797                         struct stat st;
3798
3799                         *end_of_arg = '\0';
3800                         res = do_exec(r, arg);
3801                         *end_of_arg = saved;
3802
3803                         if (res) {
3804                                 if (opts->reschedule_failed_exec)
3805                                         reschedule = 1;
3806                         } else if (stat(get_todo_path(opts), &st))
3807                                 res = error_errno(_("could not stat '%s'"),
3808                                                   get_todo_path(opts));
3809                         else if (match_stat_data(&todo_list->stat, &st)) {
3810                                 /* Reread the todo file if it has changed. */
3811                                 todo_list_release(todo_list);
3812                                 if (read_populate_todo(r, todo_list, opts))
3813                                         res = -1; /* message was printed */
3814                                 /* `current` will be incremented below */
3815                                 todo_list->current = -1;
3816                         }
3817                 } else if (item->command == TODO_LABEL) {
3818                         if ((res = do_label(r, arg, item->arg_len)))
3819                                 reschedule = 1;
3820                 } else if (item->command == TODO_RESET) {
3821                         if ((res = do_reset(r, arg, item->arg_len, opts)))
3822                                 reschedule = 1;
3823                 } else if (item->command == TODO_MERGE) {
3824                         if ((res = do_merge(r, item->commit,
3825                                             arg, item->arg_len,
3826                                             item->flags, opts)) < 0)
3827                                 reschedule = 1;
3828                         else if (item->commit)
3829                                 record_in_rewritten(&item->commit->object.oid,
3830                                                     peek_command(todo_list, 1));
3831                         if (res > 0)
3832                                 /* failed with merge conflicts */
3833                                 return error_with_patch(r, item->commit,
3834                                                         arg, item->arg_len,
3835                                                         opts, res, 0);
3836                 } else if (!is_noop(item->command))
3837                         return error(_("unknown command %d"), item->command);
3838
3839                 if (reschedule) {
3840                         advise(_(rescheduled_advice),
3841                                get_item_line_length(todo_list,
3842                                                     todo_list->current),
3843                                get_item_line(todo_list, todo_list->current));
3844                         todo_list->current--;
3845                         if (save_todo(todo_list, opts))
3846                                 return -1;
3847                         if (item->commit)
3848                                 return error_with_patch(r,
3849                                                         item->commit,
3850                                                         arg, item->arg_len,
3851                                                         opts, res, 0);
3852                 }
3853
3854                 todo_list->current++;
3855                 if (res)
3856                         return res;
3857         }
3858
3859         if (is_rebase_i(opts)) {
3860                 struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
3861                 struct stat st;
3862
3863                 /* Stopped in the middle, as planned? */
3864                 if (todo_list->current < todo_list->nr)
3865                         return 0;
3866
3867                 if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
3868                                 starts_with(head_ref.buf, "refs/")) {
3869                         const char *msg;
3870                         struct object_id head, orig;
3871                         int res;
3872
3873                         if (get_oid("HEAD", &head)) {
3874                                 res = error(_("cannot read HEAD"));
3875 cleanup_head_ref:
3876                                 strbuf_release(&head_ref);
3877                                 strbuf_release(&buf);
3878                                 return res;
3879                         }
3880                         if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
3881                                         get_oid_hex(buf.buf, &orig)) {
3882                                 res = error(_("could not read orig-head"));
3883                                 goto cleanup_head_ref;
3884                         }
3885                         strbuf_reset(&buf);
3886                         if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
3887                                 res = error(_("could not read 'onto'"));
3888                                 goto cleanup_head_ref;
3889                         }
3890                         msg = reflog_message(opts, "finish", "%s onto %s",
3891                                 head_ref.buf, buf.buf);
3892                         if (update_ref(msg, head_ref.buf, &head, &orig,
3893                                        REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
3894                                 res = error(_("could not update %s"),
3895                                         head_ref.buf);
3896                                 goto cleanup_head_ref;
3897                         }
3898                         msg = reflog_message(opts, "finish", "returning to %s",
3899                                 head_ref.buf);
3900                         if (create_symref("HEAD", head_ref.buf, msg)) {
3901                                 res = error(_("could not update HEAD to %s"),
3902                                         head_ref.buf);
3903                                 goto cleanup_head_ref;
3904                         }
3905                         strbuf_reset(&buf);
3906                 }
3907
3908                 if (opts->verbose) {
3909                         struct rev_info log_tree_opt;
3910                         struct object_id orig, head;
3911
3912                         memset(&log_tree_opt, 0, sizeof(log_tree_opt));
3913                         repo_init_revisions(r, &log_tree_opt, NULL);
3914                         log_tree_opt.diff = 1;
3915                         log_tree_opt.diffopt.output_format =
3916                                 DIFF_FORMAT_DIFFSTAT;
3917                         log_tree_opt.disable_stdin = 1;
3918
3919                         if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
3920                             !get_oid(buf.buf, &orig) &&
3921                             !get_oid("HEAD", &head)) {
3922                                 diff_tree_oid(&orig, &head, "",
3923                                               &log_tree_opt.diffopt);
3924                                 log_tree_diff_flush(&log_tree_opt);
3925                         }
3926                 }
3927                 flush_rewritten_pending();
3928                 if (!stat(rebase_path_rewritten_list(), &st) &&
3929                                 st.st_size > 0) {
3930                         struct child_process child = CHILD_PROCESS_INIT;
3931                         const char *post_rewrite_hook =
3932                                 find_hook("post-rewrite");
3933
3934                         child.in = open(rebase_path_rewritten_list(), O_RDONLY);
3935                         child.git_cmd = 1;
3936                         argv_array_push(&child.args, "notes");
3937                         argv_array_push(&child.args, "copy");
3938                         argv_array_push(&child.args, "--for-rewrite=rebase");
3939                         /* we don't care if this copying failed */
3940                         run_command(&child);
3941
3942                         if (post_rewrite_hook) {
3943                                 struct child_process hook = CHILD_PROCESS_INIT;
3944
3945                                 hook.in = open(rebase_path_rewritten_list(),
3946                                         O_RDONLY);
3947                                 hook.stdout_to_stderr = 1;
3948                                 hook.trace2_hook_name = "post-rewrite";
3949                                 argv_array_push(&hook.args, post_rewrite_hook);
3950                                 argv_array_push(&hook.args, "rebase");
3951                                 /* we don't care if this hook failed */
3952                                 run_command(&hook);
3953                         }
3954                 }
3955                 apply_autostash(opts);
3956
3957                 if (!opts->quiet)
3958                         fprintf(stderr,
3959                                 "Successfully rebased and updated %s.\n",
3960                                 head_ref.buf);
3961
3962                 strbuf_release(&buf);
3963                 strbuf_release(&head_ref);
3964         }
3965
3966         /*
3967          * Sequence of picks finished successfully; cleanup by
3968          * removing the .git/sequencer directory
3969          */
3970         return sequencer_remove_state(opts);
3971 }
3972
3973 static int continue_single_pick(struct repository *r)
3974 {
3975         const char *argv[] = { "commit", NULL };
3976
3977         if (!file_exists(git_path_cherry_pick_head(r)) &&
3978             !file_exists(git_path_revert_head(r)))
3979                 return error(_("no cherry-pick or revert in progress"));
3980         return run_command_v_opt(argv, RUN_GIT_CMD);
3981 }
3982
3983 static int commit_staged_changes(struct repository *r,
3984                                  struct replay_opts *opts,
3985                                  struct todo_list *todo_list)
3986 {
3987         unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
3988         unsigned int final_fixup = 0, is_clean;
3989
3990         if (has_unstaged_changes(r, 1))
3991                 return error(_("cannot rebase: You have unstaged changes."));
3992
3993         is_clean = !has_uncommitted_changes(r, 0);
3994
3995         if (file_exists(rebase_path_amend())) {
3996                 struct strbuf rev = STRBUF_INIT;
3997                 struct object_id head, to_amend;
3998
3999                 if (get_oid("HEAD", &head))
4000                         return error(_("cannot amend non-existing commit"));
4001                 if (!read_oneliner(&rev, rebase_path_amend(), 0))
4002                         return error(_("invalid file: '%s'"), rebase_path_amend());
4003                 if (get_oid_hex(rev.buf, &to_amend))
4004                         return error(_("invalid contents: '%s'"),
4005                                 rebase_path_amend());
4006                 if (!is_clean && !oideq(&head, &to_amend))
4007                         return error(_("\nYou have uncommitted changes in your "
4008                                        "working tree. Please, commit them\n"
4009                                        "first and then run 'git rebase "
4010                                        "--continue' again."));
4011                 /*
4012                  * When skipping a failed fixup/squash, we need to edit the
4013                  * commit message, the current fixup list and count, and if it
4014                  * was the last fixup/squash in the chain, we need to clean up
4015                  * the commit message and if there was a squash, let the user
4016                  * edit it.
4017                  */
4018                 if (!is_clean || !opts->current_fixup_count)
4019                         ; /* this is not the final fixup */
4020                 else if (!oideq(&head, &to_amend) ||
4021                          !file_exists(rebase_path_stopped_sha())) {
4022                         /* was a final fixup or squash done manually? */
4023                         if (!is_fixup(peek_command(todo_list, 0))) {
4024                                 unlink(rebase_path_fixup_msg());
4025                                 unlink(rebase_path_squash_msg());
4026                                 unlink(rebase_path_current_fixups());
4027                                 strbuf_reset(&opts->current_fixups);
4028                                 opts->current_fixup_count = 0;
4029                         }
4030                 } else {
4031                         /* we are in a fixup/squash chain */
4032                         const char *p = opts->current_fixups.buf;
4033                         int len = opts->current_fixups.len;
4034
4035                         opts->current_fixup_count--;
4036                         if (!len)
4037                                 BUG("Incorrect current_fixups:\n%s", p);
4038                         while (len && p[len - 1] != '\n')
4039                                 len--;
4040                         strbuf_setlen(&opts->current_fixups, len);
4041                         if (write_message(p, len, rebase_path_current_fixups(),
4042                                           0) < 0)
4043                                 return error(_("could not write file: '%s'"),
4044                                              rebase_path_current_fixups());
4045
4046                         /*
4047                          * If a fixup/squash in a fixup/squash chain failed, the
4048                          * commit message is already correct, no need to commit
4049                          * it again.
4050                          *
4051                          * Only if it is the final command in the fixup/squash
4052                          * chain, and only if the chain is longer than a single
4053                          * fixup/squash command (which was just skipped), do we
4054                          * actually need to re-commit with a cleaned up commit
4055                          * message.
4056                          */
4057                         if (opts->current_fixup_count > 0 &&
4058                             !is_fixup(peek_command(todo_list, 0))) {
4059                                 final_fixup = 1;
4060                                 /*
4061                                  * If there was not a single "squash" in the
4062                                  * chain, we only need to clean up the commit
4063                                  * message, no need to bother the user with
4064                                  * opening the commit message in the editor.
4065                                  */
4066                                 if (!starts_with(p, "squash ") &&
4067                                     !strstr(p, "\nsquash "))
4068                                         flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;
4069                         } else if (is_fixup(peek_command(todo_list, 0))) {
4070                                 /*
4071                                  * We need to update the squash message to skip
4072                                  * the latest commit message.
4073                                  */
4074                                 struct commit *commit;
4075                                 const char *path = rebase_path_squash_msg();
4076
4077                                 if (parse_head(r, &commit) ||
4078                                     !(p = get_commit_buffer(commit, NULL)) ||
4079                                     write_message(p, strlen(p), path, 0)) {
4080                                         unuse_commit_buffer(commit, p);
4081                                         return error(_("could not write file: "
4082                                                        "'%s'"), path);
4083                                 }
4084                                 unuse_commit_buffer(commit, p);
4085                         }
4086                 }
4087
4088                 strbuf_release(&rev);
4089                 flags |= AMEND_MSG;
4090         }
4091
4092         if (is_clean) {
4093                 const char *cherry_pick_head = git_path_cherry_pick_head(r);
4094
4095                 if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
4096                         return error(_("could not remove CHERRY_PICK_HEAD"));
4097                 if (!final_fixup)
4098                         return 0;
4099         }
4100
4101         if (run_git_commit(r, final_fixup ? NULL : rebase_path_message(),
4102                            opts, flags))
4103                 return error(_("could not commit staged changes."));
4104         unlink(rebase_path_amend());
4105         unlink(git_path_merge_head(the_repository));
4106         if (final_fixup) {
4107                 unlink(rebase_path_fixup_msg());
4108                 unlink(rebase_path_squash_msg());
4109         }
4110         if (opts->current_fixup_count > 0) {
4111                 /*
4112                  * Whether final fixup or not, we just cleaned up the commit
4113                  * message...
4114                  */
4115                 unlink(rebase_path_current_fixups());
4116                 strbuf_reset(&opts->current_fixups);
4117                 opts->current_fixup_count = 0;
4118         }
4119         return 0;
4120 }
4121
4122 int sequencer_continue(struct repository *r, struct replay_opts *opts)
4123 {
4124         struct todo_list todo_list = TODO_LIST_INIT;
4125         int res;
4126
4127         if (read_and_refresh_cache(r, opts))
4128                 return -1;
4129
4130         if (read_populate_opts(opts))
4131                 return -1;
4132         if (is_rebase_i(opts)) {
4133                 if ((res = read_populate_todo(r, &todo_list, opts)))
4134                         goto release_todo_list;
4135                 if (commit_staged_changes(r, opts, &todo_list))
4136                         return -1;
4137         } else if (!file_exists(get_todo_path(opts)))
4138                 return continue_single_pick(r);
4139         else if ((res = read_populate_todo(r, &todo_list, opts)))
4140                 goto release_todo_list;
4141
4142         if (!is_rebase_i(opts)) {
4143                 /* Verify that the conflict has been resolved */
4144                 if (file_exists(git_path_cherry_pick_head(r)) ||
4145                     file_exists(git_path_revert_head(r))) {
4146                         res = continue_single_pick(r);
4147                         if (res)
4148                                 goto release_todo_list;
4149                 }
4150                 if (index_differs_from(r, "HEAD", NULL, 0)) {
4151                         res = error_dirty_index(r, opts);
4152                         goto release_todo_list;
4153                 }
4154                 todo_list.current++;
4155         } else if (file_exists(rebase_path_stopped_sha())) {
4156                 struct strbuf buf = STRBUF_INIT;
4157                 struct object_id oid;
4158
4159                 if (read_oneliner(&buf, rebase_path_stopped_sha(), 1) &&
4160                     !get_oid_committish(buf.buf, &oid))
4161                         record_in_rewritten(&oid, peek_command(&todo_list, 0));
4162                 strbuf_release(&buf);
4163         }
4164
4165         res = pick_commits(r, &todo_list, opts);
4166 release_todo_list:
4167         todo_list_release(&todo_list);
4168         return res;
4169 }
4170
4171 static int single_pick(struct repository *r,
4172                        struct commit *cmit,
4173                        struct replay_opts *opts)
4174 {
4175         setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
4176         return do_pick_commit(r, opts->action == REPLAY_PICK ?
4177                 TODO_PICK : TODO_REVERT, cmit, opts, 0);
4178 }
4179
4180 int sequencer_pick_revisions(struct repository *r,
4181                              struct replay_opts *opts)
4182 {
4183         struct todo_list todo_list = TODO_LIST_INIT;
4184         struct object_id oid;
4185         int i, res;
4186
4187         assert(opts->revs);
4188         if (read_and_refresh_cache(r, opts))
4189                 return -1;
4190
4191         for (i = 0; i < opts->revs->pending.nr; i++) {
4192                 struct object_id oid;
4193                 const char *name = opts->revs->pending.objects[i].name;
4194
4195                 /* This happens when using --stdin. */
4196                 if (!strlen(name))
4197                         continue;
4198
4199                 if (!get_oid(name, &oid)) {
4200                         if (!lookup_commit_reference_gently(r, &oid, 1)) {
4201                                 enum object_type type = oid_object_info(r,
4202                                                                         &oid,
4203                                                                         NULL);
4204                                 return error(_("%s: can't cherry-pick a %s"),
4205                                         name, type_name(type));
4206                         }
4207                 } else
4208                         return error(_("%s: bad revision"), name);
4209         }
4210
4211         /*
4212          * If we were called as "git cherry-pick <commit>", just
4213          * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4214          * REVERT_HEAD, and don't touch the sequencer state.
4215          * This means it is possible to cherry-pick in the middle
4216          * of a cherry-pick sequence.
4217          */
4218         if (opts->revs->cmdline.nr == 1 &&
4219             opts->revs->cmdline.rev->whence == REV_CMD_REV &&
4220             opts->revs->no_walk &&
4221             !opts->revs->cmdline.rev->flags) {
4222                 struct commit *cmit;
4223                 if (prepare_revision_walk(opts->revs))
4224                         return error(_("revision walk setup failed"));
4225                 cmit = get_revision(opts->revs);
4226                 if (!cmit)
4227                         return error(_("empty commit set passed"));
4228                 if (get_revision(opts->revs))
4229                         BUG("unexpected extra commit from walk");
4230                 return single_pick(r, cmit, opts);
4231         }
4232
4233         /*
4234          * Start a new cherry-pick/ revert sequence; but
4235          * first, make sure that an existing one isn't in
4236          * progress
4237          */
4238
4239         if (walk_revs_populate_todo(&todo_list, opts) ||
4240                         create_seq_dir() < 0)
4241                 return -1;
4242         if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
4243                 return error(_("can't revert as initial commit"));
4244         if (save_head(oid_to_hex(&oid)))
4245                 return -1;
4246         if (save_opts(opts))
4247                 return -1;
4248         update_abort_safety_file();
4249         res = pick_commits(r, &todo_list, opts);
4250         todo_list_release(&todo_list);
4251         return res;
4252 }
4253
4254 void append_signoff(struct strbuf *msgbuf, size_t ignore_footer, unsigned flag)
4255 {
4256         unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
4257         struct strbuf sob = STRBUF_INIT;
4258         int has_footer;
4259
4260         strbuf_addstr(&sob, sign_off_header);
4261         strbuf_addstr(&sob, fmt_name(WANT_COMMITTER_IDENT));
4262         strbuf_addch(&sob, '\n');
4263
4264         if (!ignore_footer)
4265                 strbuf_complete_line(msgbuf);
4266
4267         /*
4268          * If the whole message buffer is equal to the sob, pretend that we
4269          * found a conforming footer with a matching sob
4270          */
4271         if (msgbuf->len - ignore_footer == sob.len &&
4272             !strncmp(msgbuf->buf, sob.buf, sob.len))
4273                 has_footer = 3;
4274         else
4275                 has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
4276
4277         if (!has_footer) {
4278                 const char *append_newlines = NULL;
4279                 size_t len = msgbuf->len - ignore_footer;
4280
4281                 if (!len) {
4282                         /*
4283                          * The buffer is completely empty.  Leave foom for
4284                          * the title and body to be filled in by the user.
4285                          */
4286                         append_newlines = "\n\n";
4287                 } else if (len == 1) {
4288                         /*
4289                          * Buffer contains a single newline.  Add another
4290                          * so that we leave room for the title and body.
4291                          */
4292                         append_newlines = "\n";
4293                 } else if (msgbuf->buf[len - 2] != '\n') {
4294                         /*
4295                          * Buffer ends with a single newline.  Add another
4296                          * so that there is an empty line between the message
4297                          * body and the sob.
4298                          */
4299                         append_newlines = "\n";
4300                 } /* else, the buffer already ends with two newlines. */
4301
4302                 if (append_newlines)
4303                         strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4304                                 append_newlines, strlen(append_newlines));
4305         }
4306
4307         if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
4308                 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4309                                 sob.buf, sob.len);
4310
4311         strbuf_release(&sob);
4312 }
4313
4314 struct labels_entry {
4315         struct hashmap_entry entry;
4316         char label[FLEX_ARRAY];
4317 };
4318
4319 static int labels_cmp(const void *fndata, const struct labels_entry *a,
4320                       const struct labels_entry *b, const void *key)
4321 {
4322         return key ? strcmp(a->label, key) : strcmp(a->label, b->label);
4323 }
4324
4325 struct string_entry {
4326         struct oidmap_entry entry;
4327         char string[FLEX_ARRAY];
4328 };
4329
4330 struct label_state {
4331         struct oidmap commit2label;
4332         struct hashmap labels;
4333         struct strbuf buf;
4334 };
4335
4336 static const char *label_oid(struct object_id *oid, const char *label,
4337                              struct label_state *state)
4338 {
4339         struct labels_entry *labels_entry;
4340         struct string_entry *string_entry;
4341         struct object_id dummy;
4342         size_t len;
4343         int i;
4344
4345         string_entry = oidmap_get(&state->commit2label, oid);
4346         if (string_entry)
4347                 return string_entry->string;
4348
4349         /*
4350          * For "uninteresting" commits, i.e. commits that are not to be
4351          * rebased, and which can therefore not be labeled, we use a unique
4352          * abbreviation of the commit name. This is slightly more complicated
4353          * than calling find_unique_abbrev() because we also need to make
4354          * sure that the abbreviation does not conflict with any other
4355          * label.
4356          *
4357          * We disallow "interesting" commits to be labeled by a string that
4358          * is a valid full-length hash, to ensure that we always can find an
4359          * abbreviation for any uninteresting commit's names that does not
4360          * clash with any other label.
4361          */
4362         if (!label) {
4363                 char *p;
4364
4365                 strbuf_reset(&state->buf);
4366                 strbuf_grow(&state->buf, GIT_SHA1_HEXSZ);
4367                 label = p = state->buf.buf;
4368
4369                 find_unique_abbrev_r(p, oid, default_abbrev);
4370
4371                 /*
4372                  * We may need to extend the abbreviated hash so that there is
4373                  * no conflicting label.
4374                  */
4375                 if (hashmap_get_from_hash(&state->labels, strihash(p), p)) {
4376                         size_t i = strlen(p) + 1;
4377
4378                         oid_to_hex_r(p, oid);
4379                         for (; i < GIT_SHA1_HEXSZ; i++) {
4380                                 char save = p[i];
4381                                 p[i] = '\0';
4382                                 if (!hashmap_get_from_hash(&state->labels,
4383                                                            strihash(p), p))
4384                                         break;
4385                                 p[i] = save;
4386                         }
4387                 }
4388         } else if (((len = strlen(label)) == the_hash_algo->hexsz &&
4389                     !get_oid_hex(label, &dummy)) ||
4390                    (len == 1 && *label == '#') ||
4391                    hashmap_get_from_hash(&state->labels,
4392                                          strihash(label), label)) {
4393                 /*
4394                  * If the label already exists, or if the label is a valid full
4395                  * OID, or the label is a '#' (which we use as a separator
4396                  * between merge heads and oneline), we append a dash and a
4397                  * number to make it unique.
4398                  */
4399                 struct strbuf *buf = &state->buf;
4400
4401                 strbuf_reset(buf);
4402                 strbuf_add(buf, label, len);
4403
4404                 for (i = 2; ; i++) {
4405                         strbuf_setlen(buf, len);
4406                         strbuf_addf(buf, "-%d", i);
4407                         if (!hashmap_get_from_hash(&state->labels,
4408                                                    strihash(buf->buf),
4409                                                    buf->buf))
4410                                 break;
4411                 }
4412
4413                 label = buf->buf;
4414         }
4415
4416         FLEX_ALLOC_STR(labels_entry, label, label);
4417         hashmap_entry_init(labels_entry, strihash(label));
4418         hashmap_add(&state->labels, labels_entry);
4419
4420         FLEX_ALLOC_STR(string_entry, string, label);
4421         oidcpy(&string_entry->entry.oid, oid);
4422         oidmap_put(&state->commit2label, string_entry);
4423
4424         return string_entry->string;
4425 }
4426
4427 static int make_script_with_merges(struct pretty_print_context *pp,
4428                                    struct rev_info *revs, struct strbuf *out,
4429                                    unsigned flags)
4430 {
4431         int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4432         int rebase_cousins = flags & TODO_LIST_REBASE_COUSINS;
4433         struct strbuf buf = STRBUF_INIT, oneline = STRBUF_INIT;
4434         struct strbuf label = STRBUF_INIT;
4435         struct commit_list *commits = NULL, **tail = &commits, *iter;
4436         struct commit_list *tips = NULL, **tips_tail = &tips;
4437         struct commit *commit;
4438         struct oidmap commit2todo = OIDMAP_INIT;
4439         struct string_entry *entry;
4440         struct oidset interesting = OIDSET_INIT, child_seen = OIDSET_INIT,
4441                 shown = OIDSET_INIT;
4442         struct label_state state = { OIDMAP_INIT, { NULL }, STRBUF_INIT };
4443
4444         int abbr = flags & TODO_LIST_ABBREVIATE_CMDS;
4445         const char *cmd_pick = abbr ? "p" : "pick",
4446                 *cmd_label = abbr ? "l" : "label",
4447                 *cmd_reset = abbr ? "t" : "reset",
4448                 *cmd_merge = abbr ? "m" : "merge";
4449
4450         oidmap_init(&commit2todo, 0);
4451         oidmap_init(&state.commit2label, 0);
4452         hashmap_init(&state.labels, (hashmap_cmp_fn) labels_cmp, NULL, 0);
4453         strbuf_init(&state.buf, 32);
4454
4455         if (revs->cmdline.nr && (revs->cmdline.rev[0].flags & BOTTOM)) {
4456                 struct object_id *oid = &revs->cmdline.rev[0].item->oid;
4457                 FLEX_ALLOC_STR(entry, string, "onto");
4458                 oidcpy(&entry->entry.oid, oid);
4459                 oidmap_put(&state.commit2label, entry);
4460         }
4461
4462         /*
4463          * First phase:
4464          * - get onelines for all commits
4465          * - gather all branch tips (i.e. 2nd or later parents of merges)
4466          * - label all branch tips
4467          */
4468         while ((commit = get_revision(revs))) {
4469                 struct commit_list *to_merge;
4470                 const char *p1, *p2;
4471                 struct object_id *oid;
4472                 int is_empty;
4473
4474                 tail = &commit_list_insert(commit, tail)->next;
4475                 oidset_insert(&interesting, &commit->object.oid);
4476
4477                 is_empty = is_original_commit_empty(commit);
4478                 if (!is_empty && (commit->object.flags & PATCHSAME))
4479                         continue;
4480
4481                 strbuf_reset(&oneline);
4482                 pretty_print_commit(pp, commit, &oneline);
4483
4484                 to_merge = commit->parents ? commit->parents->next : NULL;
4485                 if (!to_merge) {
4486                         /* non-merge commit: easy case */
4487                         strbuf_reset(&buf);
4488                         if (!keep_empty && is_empty)
4489                                 strbuf_addf(&buf, "%c ", comment_line_char);
4490                         strbuf_addf(&buf, "%s %s %s", cmd_pick,
4491                                     oid_to_hex(&commit->object.oid),
4492                                     oneline.buf);
4493
4494                         FLEX_ALLOC_STR(entry, string, buf.buf);
4495                         oidcpy(&entry->entry.oid, &commit->object.oid);
4496                         oidmap_put(&commit2todo, entry);
4497
4498                         continue;
4499                 }
4500
4501                 /* Create a label */
4502                 strbuf_reset(&label);
4503                 if (skip_prefix(oneline.buf, "Merge ", &p1) &&
4504                     (p1 = strchr(p1, '\'')) &&
4505                     (p2 = strchr(++p1, '\'')))
4506                         strbuf_add(&label, p1, p2 - p1);
4507                 else if (skip_prefix(oneline.buf, "Merge pull request ",
4508                                      &p1) &&
4509                          (p1 = strstr(p1, " from ")))
4510                         strbuf_addstr(&label, p1 + strlen(" from "));
4511                 else
4512                         strbuf_addbuf(&label, &oneline);
4513
4514                 for (p1 = label.buf; *p1; p1++)
4515                         if (isspace(*p1))
4516                                 *(char *)p1 = '-';
4517
4518                 strbuf_reset(&buf);
4519                 strbuf_addf(&buf, "%s -C %s",
4520                             cmd_merge, oid_to_hex(&commit->object.oid));
4521
4522                 /* label the tips of merged branches */
4523                 for (; to_merge; to_merge = to_merge->next) {
4524                         oid = &to_merge->item->object.oid;
4525                         strbuf_addch(&buf, ' ');
4526
4527                         if (!oidset_contains(&interesting, oid)) {
4528                                 strbuf_addstr(&buf, label_oid(oid, NULL,
4529                                                               &state));
4530                                 continue;
4531                         }
4532
4533                         tips_tail = &commit_list_insert(to_merge->item,
4534                                                         tips_tail)->next;
4535
4536                         strbuf_addstr(&buf, label_oid(oid, label.buf, &state));
4537                 }
4538                 strbuf_addf(&buf, " # %s", oneline.buf);
4539
4540                 FLEX_ALLOC_STR(entry, string, buf.buf);
4541                 oidcpy(&entry->entry.oid, &commit->object.oid);
4542                 oidmap_put(&commit2todo, entry);
4543         }
4544
4545         /*
4546          * Second phase:
4547          * - label branch points
4548          * - add HEAD to the branch tips
4549          */
4550         for (iter = commits; iter; iter = iter->next) {
4551                 struct commit_list *parent = iter->item->parents;
4552                 for (; parent; parent = parent->next) {
4553                         struct object_id *oid = &parent->item->object.oid;
4554                         if (!oidset_contains(&interesting, oid))
4555                                 continue;
4556                         if (oidset_insert(&child_seen, oid))
4557                                 label_oid(oid, "branch-point", &state);
4558                 }
4559
4560                 /* Add HEAD as implict "tip of branch" */
4561                 if (!iter->next)
4562                         tips_tail = &commit_list_insert(iter->item,
4563                                                         tips_tail)->next;
4564         }
4565
4566         /*
4567          * Third phase: output the todo list. This is a bit tricky, as we
4568          * want to avoid jumping back and forth between revisions. To
4569          * accomplish that goal, we walk backwards from the branch tips,
4570          * gathering commits not yet shown, reversing the list on the fly,
4571          * then outputting that list (labeling revisions as needed).
4572          */
4573         strbuf_addf(out, "%s onto\n", cmd_label);
4574         for (iter = tips; iter; iter = iter->next) {
4575                 struct commit_list *list = NULL, *iter2;
4576
4577                 commit = iter->item;
4578                 if (oidset_contains(&shown, &commit->object.oid))
4579                         continue;
4580                 entry = oidmap_get(&state.commit2label, &commit->object.oid);
4581
4582                 if (entry)
4583                         strbuf_addf(out, "\n%c Branch %s\n", comment_line_char, entry->string);
4584                 else
4585                         strbuf_addch(out, '\n');
4586
4587                 while (oidset_contains(&interesting, &commit->object.oid) &&
4588                        !oidset_contains(&shown, &commit->object.oid)) {
4589                         commit_list_insert(commit, &list);
4590                         if (!commit->parents) {
4591                                 commit = NULL;
4592                                 break;
4593                         }
4594                         commit = commit->parents->item;
4595                 }
4596
4597                 if (!commit)
4598                         strbuf_addf(out, "%s %s\n", cmd_reset,
4599                                     rebase_cousins ? "onto" : "[new root]");
4600                 else {
4601                         const char *to = NULL;
4602
4603                         entry = oidmap_get(&state.commit2label,
4604                                            &commit->object.oid);
4605                         if (entry)
4606                                 to = entry->string;
4607                         else if (!rebase_cousins)
4608                                 to = label_oid(&commit->object.oid, NULL,
4609                                                &state);
4610
4611                         if (!to || !strcmp(to, "onto"))
4612                                 strbuf_addf(out, "%s onto\n", cmd_reset);
4613                         else {
4614                                 strbuf_reset(&oneline);
4615                                 pretty_print_commit(pp, commit, &oneline);
4616                                 strbuf_addf(out, "%s %s # %s\n",
4617                                             cmd_reset, to, oneline.buf);
4618                         }
4619                 }
4620
4621                 for (iter2 = list; iter2; iter2 = iter2->next) {
4622                         struct object_id *oid = &iter2->item->object.oid;
4623                         entry = oidmap_get(&commit2todo, oid);
4624                         /* only show if not already upstream */
4625                         if (entry)
4626                                 strbuf_addf(out, "%s\n", entry->string);
4627                         entry = oidmap_get(&state.commit2label, oid);
4628                         if (entry)
4629                                 strbuf_addf(out, "%s %s\n",
4630                                             cmd_label, entry->string);
4631                         oidset_insert(&shown, oid);
4632                 }
4633
4634                 free_commit_list(list);
4635         }
4636
4637         free_commit_list(commits);
4638         free_commit_list(tips);
4639
4640         strbuf_release(&label);
4641         strbuf_release(&oneline);
4642         strbuf_release(&buf);
4643
4644         oidmap_free(&commit2todo, 1);
4645         oidmap_free(&state.commit2label, 1);
4646         hashmap_free(&state.labels, 1);
4647         strbuf_release(&state.buf);
4648
4649         return 0;
4650 }
4651
4652 int sequencer_make_script(struct repository *r, struct strbuf *out, int argc,
4653                           const char **argv, unsigned flags)
4654 {
4655         char *format = NULL;
4656         struct pretty_print_context pp = {0};
4657         struct rev_info revs;
4658         struct commit *commit;
4659         int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4660         const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";
4661         int rebase_merges = flags & TODO_LIST_REBASE_MERGES;
4662
4663         repo_init_revisions(r, &revs, NULL);
4664         revs.verbose_header = 1;
4665         if (!rebase_merges)
4666                 revs.max_parents = 1;
4667         revs.cherry_mark = 1;
4668         revs.limited = 1;
4669         revs.reverse = 1;
4670         revs.right_only = 1;
4671         revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
4672         revs.topo_order = 1;
4673
4674         revs.pretty_given = 1;
4675         git_config_get_string("rebase.instructionFormat", &format);
4676         if (!format || !*format) {
4677                 free(format);
4678                 format = xstrdup("%s");
4679         }
4680         get_commit_format(format, &revs);
4681         free(format);
4682         pp.fmt = revs.commit_format;
4683         pp.output_encoding = get_log_output_encoding();
4684
4685         if (setup_revisions(argc, argv, &revs, NULL) > 1)
4686                 return error(_("make_script: unhandled options"));
4687
4688         if (prepare_revision_walk(&revs) < 0)
4689                 return error(_("make_script: error preparing revisions"));
4690
4691         if (rebase_merges)
4692                 return make_script_with_merges(&pp, &revs, out, flags);
4693
4694         while ((commit = get_revision(&revs))) {
4695                 int is_empty  = is_original_commit_empty(commit);
4696
4697                 if (!is_empty && (commit->object.flags & PATCHSAME))
4698                         continue;
4699                 if (!keep_empty && is_empty)
4700                         strbuf_addf(out, "%c ", comment_line_char);
4701                 strbuf_addf(out, "%s %s ", insn,
4702                             oid_to_hex(&commit->object.oid));
4703                 pretty_print_commit(&pp, commit, out);
4704                 strbuf_addch(out, '\n');
4705         }
4706         return 0;
4707 }
4708
4709 /*
4710  * Add commands after pick and (series of) squash/fixup commands
4711  * in the todo list.
4712  */
4713 void todo_list_add_exec_commands(struct todo_list *todo_list,
4714                                  struct string_list *commands)
4715 {
4716         struct strbuf *buf = &todo_list->buf;
4717         size_t base_offset = buf->len;
4718         int i, insert, nr = 0, alloc = 0;
4719         struct todo_item *items = NULL, *base_items = NULL;
4720
4721         base_items = xcalloc(commands->nr, sizeof(struct todo_item));
4722         for (i = 0; i < commands->nr; i++) {
4723                 size_t command_len = strlen(commands->items[i].string);
4724
4725                 strbuf_addstr(buf, commands->items[i].string);
4726                 strbuf_addch(buf, '\n');
4727
4728                 base_items[i].command = TODO_EXEC;
4729                 base_items[i].offset_in_buf = base_offset;
4730                 base_items[i].arg_offset = base_offset + strlen("exec ");
4731                 base_items[i].arg_len = command_len - strlen("exec ");
4732
4733                 base_offset += command_len + 1;
4734         }
4735
4736         /*
4737          * Insert <commands> after every pick. Here, fixup/squash chains
4738          * are considered part of the pick, so we insert the commands *after*
4739          * those chains if there are any.
4740          *
4741          * As we insert the exec commands immediatly after rearranging
4742          * any fixups and before the user edits the list, a fixup chain
4743          * can never contain comments (any comments are empty picks that
4744          * have been commented out because the user did not specify
4745          * --keep-empty).  So, it is safe to insert an exec command
4746          * without looking at the command following a comment.
4747          */
4748         insert = 0;
4749         for (i = 0; i < todo_list->nr; i++) {
4750                 enum todo_command command = todo_list->items[i].command;
4751                 if (insert && !is_fixup(command)) {
4752                         ALLOC_GROW(items, nr + commands->nr, alloc);
4753                         COPY_ARRAY(items + nr, base_items, commands->nr);
4754                         nr += commands->nr;
4755
4756                         insert = 0;
4757                 }
4758
4759                 ALLOC_GROW(items, nr + 1, alloc);
4760                 items[nr++] = todo_list->items[i];
4761
4762                 if (command == TODO_PICK || command == TODO_MERGE)
4763                         insert = 1;
4764         }
4765
4766         /* insert or append final <commands> */
4767         if (insert || nr == todo_list->nr) {
4768                 ALLOC_GROW(items, nr + commands->nr, alloc);
4769                 COPY_ARRAY(items + nr, base_items, commands->nr);
4770                 nr += commands->nr;
4771         }
4772
4773         free(base_items);
4774         FREE_AND_NULL(todo_list->items);
4775         todo_list->items = items;
4776         todo_list->nr = nr;
4777         todo_list->alloc = alloc;
4778 }
4779
4780 static void todo_list_to_strbuf(struct repository *r, struct todo_list *todo_list,
4781                                 struct strbuf *buf, int num, unsigned flags)
4782 {
4783         struct todo_item *item;
4784         int i, max = todo_list->nr;
4785
4786         if (num > 0 && num < max)
4787                 max = num;
4788
4789         for (item = todo_list->items, i = 0; i < max; i++, item++) {
4790                 /* if the item is not a command write it and continue */
4791                 if (item->command >= TODO_COMMENT) {
4792                         strbuf_addf(buf, "%.*s\n", item->arg_len,
4793                                     todo_item_get_arg(todo_list, item));
4794                         continue;
4795                 }
4796
4797                 /* add command to the buffer */
4798                 if (flags & TODO_LIST_ABBREVIATE_CMDS)
4799                         strbuf_addch(buf, command_to_char(item->command));
4800                 else
4801                         strbuf_addstr(buf, command_to_string(item->command));
4802
4803                 /* add commit id */
4804                 if (item->commit) {
4805                         const char *oid = flags & TODO_LIST_SHORTEN_IDS ?
4806                                           short_commit_name(item->commit) :
4807                                           oid_to_hex(&item->commit->object.oid);
4808
4809                         if (item->command == TODO_MERGE) {
4810                                 if (item->flags & TODO_EDIT_MERGE_MSG)
4811                                         strbuf_addstr(buf, " -c");
4812                                 else
4813                                         strbuf_addstr(buf, " -C");
4814                         }
4815
4816                         strbuf_addf(buf, " %s", oid);
4817                 }
4818
4819                 /* add all the rest */
4820                 if (!item->arg_len)
4821                         strbuf_addch(buf, '\n');
4822                 else
4823                         strbuf_addf(buf, " %.*s\n", item->arg_len,
4824                                     todo_item_get_arg(todo_list, item));
4825         }
4826 }
4827
4828 int todo_list_write_to_file(struct repository *r, struct todo_list *todo_list,
4829                             const char *file, const char *shortrevisions,
4830                             const char *shortonto, int num, unsigned flags)
4831 {
4832         int res;
4833         struct strbuf buf = STRBUF_INIT;
4834
4835         todo_list_to_strbuf(r, todo_list, &buf, num, flags);
4836         if (flags & TODO_LIST_APPEND_TODO_HELP)
4837                 append_todo_help(flags & TODO_LIST_KEEP_EMPTY, count_commands(todo_list),
4838                                  shortrevisions, shortonto, &buf);
4839
4840         res = write_message(buf.buf, buf.len, file, 0);
4841         strbuf_release(&buf);
4842
4843         return res;
4844 }
4845
4846 static const char edit_todo_list_advice[] =
4847 N_("You can fix this with 'git rebase --edit-todo' "
4848 "and then run 'git rebase --continue'.\n"
4849 "Or you can abort the rebase with 'git rebase"
4850 " --abort'.\n");
4851
4852 int check_todo_list_from_file(struct repository *r)
4853 {
4854         struct todo_list old_todo = TODO_LIST_INIT, new_todo = TODO_LIST_INIT;
4855         int res = 0;
4856
4857         if (strbuf_read_file_or_whine(&new_todo.buf, rebase_path_todo()) < 0) {
4858                 res = -1;
4859                 goto out;
4860         }
4861
4862         if (strbuf_read_file_or_whine(&old_todo.buf, rebase_path_todo_backup()) < 0) {
4863                 res = -1;
4864                 goto out;
4865         }
4866
4867         res = todo_list_parse_insn_buffer(r, old_todo.buf.buf, &old_todo);
4868         if (!res)
4869                 res = todo_list_parse_insn_buffer(r, new_todo.buf.buf, &new_todo);
4870         if (!res)
4871                 res = todo_list_check(&old_todo, &new_todo);
4872         if (res)
4873                 fprintf(stderr, _(edit_todo_list_advice));
4874 out:
4875         todo_list_release(&old_todo);
4876         todo_list_release(&new_todo);
4877
4878         return res;
4879 }
4880
4881 /* skip picking commits whose parents are unchanged */
4882 static int skip_unnecessary_picks(struct repository *r,
4883                                   struct todo_list *todo_list,
4884                                   struct object_id *base_oid)
4885 {
4886         struct object_id *parent_oid;
4887         int i;
4888
4889         for (i = 0; i < todo_list->nr; i++) {
4890                 struct todo_item *item = todo_list->items + i;
4891
4892                 if (item->command >= TODO_NOOP)
4893                         continue;
4894                 if (item->command != TODO_PICK)
4895                         break;
4896                 if (parse_commit(item->commit)) {
4897                         return error(_("could not parse commit '%s'"),
4898                                 oid_to_hex(&item->commit->object.oid));
4899                 }
4900                 if (!item->commit->parents)
4901                         break; /* root commit */
4902                 if (item->commit->parents->next)
4903                         break; /* merge commit */
4904                 parent_oid = &item->commit->parents->item->object.oid;
4905                 if (!oideq(parent_oid, base_oid))
4906                         break;
4907                 oidcpy(base_oid, &item->commit->object.oid);
4908         }
4909         if (i > 0) {
4910                 const char *done_path = rebase_path_done();
4911
4912                 if (todo_list_write_to_file(r, todo_list, done_path, NULL, NULL, i, 0)) {
4913                         error_errno(_("could not write to '%s'"), done_path);
4914                         return -1;
4915                 }
4916
4917                 MOVE_ARRAY(todo_list->items, todo_list->items + i, todo_list->nr - i);
4918                 todo_list->nr -= i;
4919                 todo_list->current = 0;
4920
4921                 if (is_fixup(peek_command(todo_list, 0)))
4922                         record_in_rewritten(base_oid, peek_command(todo_list, 0));
4923         }
4924
4925         return 0;
4926 }
4927
4928 int complete_action(struct repository *r, struct replay_opts *opts, unsigned flags,
4929                     const char *shortrevisions, const char *onto_name,
4930                     struct commit *onto, const char *orig_head,
4931                     struct string_list *commands, unsigned autosquash,
4932                     struct todo_list *todo_list)
4933 {
4934         const char *shortonto, *todo_file = rebase_path_todo();
4935         struct todo_list new_todo = TODO_LIST_INIT;
4936         struct strbuf *buf = &todo_list->buf;
4937         struct object_id oid = onto->object.oid;
4938         int res;
4939
4940         shortonto = find_unique_abbrev(&oid, DEFAULT_ABBREV);
4941
4942         if (buf->len == 0) {
4943                 struct todo_item *item = append_new_todo(todo_list);
4944                 item->command = TODO_NOOP;
4945                 item->commit = NULL;
4946                 item->arg_len = item->arg_offset = item->flags = item->offset_in_buf = 0;
4947         }
4948
4949         if (autosquash && todo_list_rearrange_squash(todo_list))
4950                 return -1;
4951
4952         if (commands->nr)
4953                 todo_list_add_exec_commands(todo_list, commands);
4954
4955         if (count_commands(todo_list) == 0) {
4956                 apply_autostash(opts);
4957                 sequencer_remove_state(opts);
4958
4959                 return error(_("nothing to do"));
4960         }
4961
4962         res = edit_todo_list(r, todo_list, &new_todo, shortrevisions,
4963                              shortonto, flags);
4964         if (res == -1)
4965                 return -1;
4966         else if (res == -2) {
4967                 apply_autostash(opts);
4968                 sequencer_remove_state(opts);
4969
4970                 return -1;
4971         } else if (res == -3) {
4972                 apply_autostash(opts);
4973                 sequencer_remove_state(opts);
4974                 todo_list_release(&new_todo);
4975
4976                 return error(_("nothing to do"));
4977         }
4978
4979         if (todo_list_parse_insn_buffer(r, new_todo.buf.buf, &new_todo) ||
4980             todo_list_check(todo_list, &new_todo)) {
4981                 fprintf(stderr, _(edit_todo_list_advice));
4982                 checkout_onto(r, opts, onto_name, &onto->object.oid, orig_head);
4983                 todo_list_release(&new_todo);
4984
4985                 return -1;
4986         }
4987
4988         if (opts->allow_ff && skip_unnecessary_picks(r, &new_todo, &oid)) {
4989                 todo_list_release(&new_todo);
4990                 return error(_("could not skip unnecessary pick commands"));
4991         }
4992
4993         if (todo_list_write_to_file(r, &new_todo, todo_file, NULL, NULL, -1,
4994                                     flags & ~(TODO_LIST_SHORTEN_IDS))) {
4995                 todo_list_release(&new_todo);
4996                 return error_errno(_("could not write '%s'"), todo_file);
4997         }
4998
4999         todo_list_release(&new_todo);
5000
5001         if (checkout_onto(r, opts, onto_name, &oid, orig_head))
5002                 return -1;
5003
5004         if (require_clean_work_tree(r, "rebase", "", 1, 1))
5005                 return -1;
5006
5007         return sequencer_continue(r, opts);
5008 }
5009
5010 struct subject2item_entry {
5011         struct hashmap_entry entry;
5012         int i;
5013         char subject[FLEX_ARRAY];
5014 };
5015
5016 static int subject2item_cmp(const void *fndata,
5017                             const struct subject2item_entry *a,
5018                             const struct subject2item_entry *b, const void *key)
5019 {
5020         return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
5021 }
5022
5023 define_commit_slab(commit_todo_item, struct todo_item *);
5024
5025 /*
5026  * Rearrange the todo list that has both "pick commit-id msg" and "pick
5027  * commit-id fixup!/squash! msg" in it so that the latter is put immediately
5028  * after the former, and change "pick" to "fixup"/"squash".
5029  *
5030  * Note that if the config has specified a custom instruction format, each log
5031  * message will have to be retrieved from the commit (as the oneline in the
5032  * script cannot be trusted) in order to normalize the autosquash arrangement.
5033  */
5034 int todo_list_rearrange_squash(struct todo_list *todo_list)
5035 {
5036         struct hashmap subject2item;
5037         int rearranged = 0, *next, *tail, i, nr = 0, alloc = 0;
5038         char **subjects;
5039         struct commit_todo_item commit_todo;
5040         struct todo_item *items = NULL;
5041
5042         init_commit_todo_item(&commit_todo);
5043         /*
5044          * The hashmap maps onelines to the respective todo list index.
5045          *
5046          * If any items need to be rearranged, the next[i] value will indicate
5047          * which item was moved directly after the i'th.
5048          *
5049          * In that case, last[i] will indicate the index of the latest item to
5050          * be moved to appear after the i'th.
5051          */
5052         hashmap_init(&subject2item, (hashmap_cmp_fn) subject2item_cmp,
5053                      NULL, todo_list->nr);
5054         ALLOC_ARRAY(next, todo_list->nr);
5055         ALLOC_ARRAY(tail, todo_list->nr);
5056         ALLOC_ARRAY(subjects, todo_list->nr);
5057         for (i = 0; i < todo_list->nr; i++) {
5058                 struct strbuf buf = STRBUF_INIT;
5059                 struct todo_item *item = todo_list->items + i;
5060                 const char *commit_buffer, *subject, *p;
5061                 size_t subject_len;
5062                 int i2 = -1;
5063                 struct subject2item_entry *entry;
5064
5065                 next[i] = tail[i] = -1;
5066                 if (!item->commit || item->command == TODO_DROP) {
5067                         subjects[i] = NULL;
5068                         continue;
5069                 }
5070
5071                 if (is_fixup(item->command)) {
5072                         clear_commit_todo_item(&commit_todo);
5073                         return error(_("the script was already rearranged."));
5074                 }
5075
5076                 *commit_todo_item_at(&commit_todo, item->commit) = item;
5077
5078                 parse_commit(item->commit);
5079                 commit_buffer = get_commit_buffer(item->commit, NULL);
5080                 find_commit_subject(commit_buffer, &subject);
5081                 format_subject(&buf, subject, " ");
5082                 subject = subjects[i] = strbuf_detach(&buf, &subject_len);
5083                 unuse_commit_buffer(item->commit, commit_buffer);
5084                 if ((skip_prefix(subject, "fixup! ", &p) ||
5085                      skip_prefix(subject, "squash! ", &p))) {
5086                         struct commit *commit2;
5087
5088                         for (;;) {
5089                                 while (isspace(*p))
5090                                         p++;
5091                                 if (!skip_prefix(p, "fixup! ", &p) &&
5092                                     !skip_prefix(p, "squash! ", &p))
5093                                         break;
5094                         }
5095
5096                         if ((entry = hashmap_get_from_hash(&subject2item,
5097                                                            strhash(p), p)))
5098                                 /* found by title */
5099                                 i2 = entry->i;
5100                         else if (!strchr(p, ' ') &&
5101                                  (commit2 =
5102                                   lookup_commit_reference_by_name(p)) &&
5103                                  *commit_todo_item_at(&commit_todo, commit2))
5104                                 /* found by commit name */
5105                                 i2 = *commit_todo_item_at(&commit_todo, commit2)
5106                                         - todo_list->items;
5107                         else {
5108                                 /* copy can be a prefix of the commit subject */
5109                                 for (i2 = 0; i2 < i; i2++)
5110                                         if (subjects[i2] &&
5111                                             starts_with(subjects[i2], p))
5112                                                 break;
5113                                 if (i2 == i)
5114                                         i2 = -1;
5115                         }
5116                 }
5117                 if (i2 >= 0) {
5118                         rearranged = 1;
5119                         todo_list->items[i].command =
5120                                 starts_with(subject, "fixup!") ?
5121                                 TODO_FIXUP : TODO_SQUASH;
5122                         if (next[i2] < 0)
5123                                 next[i2] = i;
5124                         else
5125                                 next[tail[i2]] = i;
5126                         tail[i2] = i;
5127                 } else if (!hashmap_get_from_hash(&subject2item,
5128                                                 strhash(subject), subject)) {
5129                         FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
5130                         entry->i = i;
5131                         hashmap_entry_init(entry, strhash(entry->subject));
5132                         hashmap_put(&subject2item, entry);
5133                 }
5134         }
5135
5136         if (rearranged) {
5137                 for (i = 0; i < todo_list->nr; i++) {
5138                         enum todo_command command = todo_list->items[i].command;
5139                         int cur = i;
5140
5141                         /*
5142                          * Initially, all commands are 'pick's. If it is a
5143                          * fixup or a squash now, we have rearranged it.
5144                          */
5145                         if (is_fixup(command))
5146                                 continue;
5147
5148                         while (cur >= 0) {
5149                                 ALLOC_GROW(items, nr + 1, alloc);
5150                                 items[nr++] = todo_list->items[cur];
5151                                 cur = next[cur];
5152                         }
5153                 }
5154
5155                 FREE_AND_NULL(todo_list->items);
5156                 todo_list->items = items;
5157                 todo_list->nr = nr;
5158                 todo_list->alloc = alloc;
5159         }
5160
5161         free(next);
5162         free(tail);
5163         for (i = 0; i < todo_list->nr; i++)
5164                 free(subjects[i]);
5165         free(subjects);
5166         hashmap_free(&subject2item, 1);
5167
5168         clear_commit_todo_item(&commit_todo);
5169
5170         return 0;
5171 }