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