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