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