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