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