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