1#include "cache.h"
2#include "config.h"
3#include "lockfile.h"
4#include "dir.h"
5#include "object.h"
6#include "commit.h"
7#include "sequencer.h"
8#include "tag.h"
9#include "run-command.h"
10#include "exec_cmd.h"
11#include "utf8.h"
12#include "cache-tree.h"
13#include "diff.h"
14#include "revision.h"
15#include "rerere.h"
16#include "merge-recursive.h"
17#include "refs.h"
18#include "argv-array.h"
19#include "quote.h"
20#include "trailer.h"
21#include "log-tree.h"
22#include "wt-status.h"
23#include "hashmap.h"
24#include "notes-utils.h"
25#include "sigchain.h"
26
27#define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
28
29const char sign_off_header[] = "Signed-off-by: ";
30static const char cherry_picked_prefix[] = "(cherry picked from commit ";
31
32GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
33
34GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
35
36static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
37static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
38static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
39static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
40
41static GIT_PATH_FUNC(rebase_path, "rebase-merge")
42/*
43 * The file containing rebase commands, comments, and empty lines.
44 * This file is created by "git rebase -i" then edited by the user. As
45 * the lines are processed, they are removed from the front of this
46 * file and written to the tail of 'done'.
47 */
48static GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
49/*
50 * The rebase command lines that have already been processed. A line
51 * is moved here when it is first handled, before any associated user
52 * actions.
53 */
54static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
55/*
56 * The file to keep track of how many commands were already processed (e.g.
57 * for the prompt).
58 */
59static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum");
60/*
61 * The file to keep track of how many commands are to be processed in total
62 * (e.g. for the prompt).
63 */
64static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end");
65/*
66 * The commit message that is planned to be used for any changes that
67 * need to be committed following a user interaction.
68 */
69static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
70/*
71 * The file into which is accumulated the suggested commit message for
72 * squash/fixup commands. When the first of a series of squash/fixups
73 * is seen, the file is created and the commit message from the
74 * previous commit and from the first squash/fixup commit are written
75 * to it. The commit message for each subsequent squash/fixup commit
76 * is appended to the file as it is processed.
77 *
78 * The first line of the file is of the form
79 * # This is a combination of $count commits.
80 * where $count is the number of commits whose messages have been
81 * written to the file so far (including the initial "pick" commit).
82 * Each time that a commit message is processed, this line is read and
83 * updated. It is deleted just before the combined commit is made.
84 */
85static 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 */
93static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
94/*
95 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
96 * GIT_AUTHOR_DATE that will be used for the commit that is currently
97 * being rebased.
98 */
99static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
100/*
101 * When an "edit" rebase command is being processed, the SHA1 of the
102 * commit to be edited is recorded in this file. When "git rebase
103 * --continue" is executed, if there are any staged changes then they
104 * will be amended to the HEAD commit, but only provided the HEAD
105 * commit is still the commit to be edited. When any other rebase
106 * command is processed, this file is deleted.
107 */
108static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
109/*
110 * When we stop at a given patch via the "edit" command, this file contains
111 * the abbreviated commit name of the corresponding patch.
112 */
113static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
114/*
115 * For the post-rewrite hook, we make a list of rewritten commits and
116 * their new sha1s. The rewritten-pending list keeps the sha1s of
117 * commits that have been processed, but not committed yet,
118 * e.g. because they are waiting for a 'squash' command.
119 */
120static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
121static GIT_PATH_FUNC(rebase_path_rewritten_pending,
122 "rebase-merge/rewritten-pending")
123/*
124 * The following files are written by git-rebase just after parsing the
125 * command-line (and are only consumed, not modified, by the sequencer).
126 */
127static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
128static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
129static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
130static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
131static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
132static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
133static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
134static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
135static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
136
137static int git_sequencer_config(const char *k, const char *v, void *cb)
138{
139 struct replay_opts *opts = cb;
140 int status;
141
142 if (!strcmp(k, "commit.cleanup")) {
143 const char *s;
144
145 status = git_config_string(&s, k, v);
146 if (status)
147 return status;
148
149 if (!strcmp(s, "verbatim"))
150 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
151 else if (!strcmp(s, "whitespace"))
152 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
153 else if (!strcmp(s, "strip"))
154 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
155 else if (!strcmp(s, "scissors"))
156 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
157 else
158 warning(_("invalid commit message cleanup mode '%s'"),
159 s);
160
161 return status;
162 }
163
164 if (!strcmp(k, "commit.gpgsign")) {
165 opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
166 return 0;
167 }
168
169 status = git_gpg_config(k, v, NULL);
170 if (status)
171 return status;
172
173 return git_diff_basic_config(k, v, NULL);
174}
175
176void sequencer_init_config(struct replay_opts *opts)
177{
178 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
179 git_config(git_sequencer_config, opts);
180}
181
182static inline int is_rebase_i(const struct replay_opts *opts)
183{
184 return opts->action == REPLAY_INTERACTIVE_REBASE;
185}
186
187static const char *get_dir(const struct replay_opts *opts)
188{
189 if (is_rebase_i(opts))
190 return rebase_path();
191 return git_path_seq_dir();
192}
193
194static const char *get_todo_path(const struct replay_opts *opts)
195{
196 if (is_rebase_i(opts))
197 return rebase_path_todo();
198 return git_path_todo_file();
199}
200
201/*
202 * Returns 0 for non-conforming footer
203 * Returns 1 for conforming footer
204 * Returns 2 when sob exists within conforming footer
205 * Returns 3 when sob exists within conforming footer as last entry
206 */
207static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
208 int ignore_footer)
209{
210 struct trailer_info info;
211 int i;
212 int found_sob = 0, found_sob_last = 0;
213
214 trailer_info_get(&info, sb->buf);
215
216 if (info.trailer_start == info.trailer_end)
217 return 0;
218
219 for (i = 0; i < info.trailer_nr; i++)
220 if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
221 found_sob = 1;
222 if (i == info.trailer_nr - 1)
223 found_sob_last = 1;
224 }
225
226 trailer_info_release(&info);
227
228 if (found_sob_last)
229 return 3;
230 if (found_sob)
231 return 2;
232 return 1;
233}
234
235static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
236{
237 static struct strbuf buf = STRBUF_INIT;
238
239 strbuf_reset(&buf);
240 if (opts->gpg_sign)
241 sq_quotef(&buf, "-S%s", opts->gpg_sign);
242 return buf.buf;
243}
244
245int sequencer_remove_state(struct replay_opts *opts)
246{
247 struct strbuf dir = STRBUF_INIT;
248 int i;
249
250 free(opts->gpg_sign);
251 free(opts->strategy);
252 for (i = 0; i < opts->xopts_nr; i++)
253 free(opts->xopts[i]);
254 free(opts->xopts);
255
256 strbuf_addstr(&dir, get_dir(opts));
257 remove_dir_recursively(&dir, 0);
258 strbuf_release(&dir);
259
260 return 0;
261}
262
263static const char *action_name(const struct replay_opts *opts)
264{
265 switch (opts->action) {
266 case REPLAY_REVERT:
267 return N_("revert");
268 case REPLAY_PICK:
269 return N_("cherry-pick");
270 case REPLAY_INTERACTIVE_REBASE:
271 return N_("rebase -i");
272 }
273 die(_("Unknown action: %d"), opts->action);
274}
275
276struct commit_message {
277 char *parent_label;
278 char *label;
279 char *subject;
280 const char *message;
281};
282
283static const char *short_commit_name(struct commit *commit)
284{
285 return find_unique_abbrev(commit->object.oid.hash, DEFAULT_ABBREV);
286}
287
288static int get_message(struct commit *commit, struct commit_message *out)
289{
290 const char *abbrev, *subject;
291 int subject_len;
292
293 out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
294 abbrev = short_commit_name(commit);
295
296 subject_len = find_commit_subject(out->message, &subject);
297
298 out->subject = xmemdupz(subject, subject_len);
299 out->label = xstrfmt("%s... %s", abbrev, out->subject);
300 out->parent_label = xstrfmt("parent of %s", out->label);
301
302 return 0;
303}
304
305static void free_message(struct commit *commit, struct commit_message *msg)
306{
307 free(msg->parent_label);
308 free(msg->label);
309 free(msg->subject);
310 unuse_commit_buffer(commit, msg->message);
311}
312
313static void print_advice(int show_hint, struct replay_opts *opts)
314{
315 char *msg = getenv("GIT_CHERRY_PICK_HELP");
316
317 if (msg) {
318 fprintf(stderr, "%s\n", msg);
319 /*
320 * A conflict has occurred but the porcelain
321 * (typically rebase --interactive) wants to take care
322 * of the commit itself so remove CHERRY_PICK_HEAD
323 */
324 unlink(git_path_cherry_pick_head());
325 return;
326 }
327
328 if (show_hint) {
329 if (opts->no_commit)
330 advise(_("after resolving the conflicts, mark the corrected paths\n"
331 "with 'git add <paths>' or 'git rm <paths>'"));
332 else
333 advise(_("after resolving the conflicts, mark the corrected paths\n"
334 "with 'git add <paths>' or 'git rm <paths>'\n"
335 "and commit the result with 'git commit'"));
336 }
337}
338
339static int write_message(const void *buf, size_t len, const char *filename,
340 int append_eol)
341{
342 struct lock_file msg_file = LOCK_INIT;
343
344 int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
345 if (msg_fd < 0)
346 return error_errno(_("could not lock '%s'"), filename);
347 if (write_in_full(msg_fd, buf, len) < 0) {
348 rollback_lock_file(&msg_file);
349 return error_errno(_("could not write to '%s'"), filename);
350 }
351 if (append_eol && write(msg_fd, "\n", 1) < 0) {
352 rollback_lock_file(&msg_file);
353 return error_errno(_("could not write eol to '%s'"), filename);
354 }
355 if (commit_lock_file(&msg_file) < 0)
356 return error(_("failed to finalize '%s'"), filename);
357
358 return 0;
359}
360
361/*
362 * Reads a file that was presumably written by a shell script, i.e. with an
363 * end-of-line marker that needs to be stripped.
364 *
365 * Note that only the last end-of-line marker is stripped, consistent with the
366 * behavior of "$(cat path)" in a shell script.
367 *
368 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
369 */
370static int read_oneliner(struct strbuf *buf,
371 const char *path, int skip_if_empty)
372{
373 int orig_len = buf->len;
374
375 if (!file_exists(path))
376 return 0;
377
378 if (strbuf_read_file(buf, path, 0) < 0) {
379 warning_errno(_("could not read '%s'"), path);
380 return 0;
381 }
382
383 if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
384 if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
385 --buf->len;
386 buf->buf[buf->len] = '\0';
387 }
388
389 if (skip_if_empty && buf->len == orig_len)
390 return 0;
391
392 return 1;
393}
394
395static struct tree *empty_tree(void)
396{
397 return lookup_tree(the_hash_algo->empty_tree);
398}
399
400static int error_dirty_index(struct replay_opts *opts)
401{
402 if (read_cache_unmerged())
403 return error_resolve_conflict(_(action_name(opts)));
404
405 error(_("your local changes would be overwritten by %s."),
406 _(action_name(opts)));
407
408 if (advice_commit_before_merge)
409 advise(_("commit your changes or stash them to proceed."));
410 return -1;
411}
412
413static void update_abort_safety_file(void)
414{
415 struct object_id head;
416
417 /* Do nothing on a single-pick */
418 if (!file_exists(git_path_seq_dir()))
419 return;
420
421 if (!get_oid("HEAD", &head))
422 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
423 else
424 write_file(git_path_abort_safety_file(), "%s", "");
425}
426
427static int fast_forward_to(const struct object_id *to, const struct object_id *from,
428 int unborn, struct replay_opts *opts)
429{
430 struct ref_transaction *transaction;
431 struct strbuf sb = STRBUF_INIT;
432 struct strbuf err = STRBUF_INIT;
433
434 read_cache();
435 if (checkout_fast_forward(from, to, 1))
436 return -1; /* the callee should have complained already */
437
438 strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
439
440 transaction = ref_transaction_begin(&err);
441 if (!transaction ||
442 ref_transaction_update(transaction, "HEAD",
443 to, unborn ? &null_oid : from,
444 0, sb.buf, &err) ||
445 ref_transaction_commit(transaction, &err)) {
446 ref_transaction_free(transaction);
447 error("%s", err.buf);
448 strbuf_release(&sb);
449 strbuf_release(&err);
450 return -1;
451 }
452
453 strbuf_release(&sb);
454 strbuf_release(&err);
455 ref_transaction_free(transaction);
456 update_abort_safety_file();
457 return 0;
458}
459
460void append_conflicts_hint(struct strbuf *msgbuf)
461{
462 int i;
463
464 strbuf_addch(msgbuf, '\n');
465 strbuf_commented_addf(msgbuf, "Conflicts:\n");
466 for (i = 0; i < active_nr;) {
467 const struct cache_entry *ce = active_cache[i++];
468 if (ce_stage(ce)) {
469 strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
470 while (i < active_nr && !strcmp(ce->name,
471 active_cache[i]->name))
472 i++;
473 }
474 }
475}
476
477static int do_recursive_merge(struct commit *base, struct commit *next,
478 const char *base_label, const char *next_label,
479 struct object_id *head, struct strbuf *msgbuf,
480 struct replay_opts *opts)
481{
482 struct merge_options o;
483 struct tree *result, *next_tree, *base_tree, *head_tree;
484 int clean;
485 char **xopt;
486 struct lock_file index_lock = LOCK_INIT;
487
488 if (hold_locked_index(&index_lock, LOCK_REPORT_ON_ERROR) < 0)
489 return -1;
490
491 read_cache();
492
493 init_merge_options(&o);
494 o.ancestor = base ? base_label : "(empty tree)";
495 o.branch1 = "HEAD";
496 o.branch2 = next ? next_label : "(empty tree)";
497 if (is_rebase_i(opts))
498 o.buffer_output = 2;
499 o.show_rename_progress = 1;
500
501 head_tree = parse_tree_indirect(head);
502 next_tree = next ? next->tree : empty_tree();
503 base_tree = base ? base->tree : empty_tree();
504
505 for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)
506 parse_merge_opt(&o, *xopt);
507
508 clean = merge_trees(&o,
509 head_tree,
510 next_tree, base_tree, &result);
511 if (is_rebase_i(opts) && clean <= 0)
512 fputs(o.obuf.buf, stdout);
513 strbuf_release(&o.obuf);
514 diff_warn_rename_limit("merge.renamelimit", o.needed_rename_limit, 0);
515 if (clean < 0) {
516 rollback_lock_file(&index_lock);
517 return clean;
518 }
519
520 if (write_locked_index(&the_index, &index_lock,
521 COMMIT_LOCK | SKIP_IF_UNCHANGED))
522 /*
523 * TRANSLATORS: %s will be "revert", "cherry-pick" or
524 * "rebase -i".
525 */
526 return error(_("%s: Unable to write new index file"),
527 _(action_name(opts)));
528
529 if (!clean)
530 append_conflicts_hint(msgbuf);
531
532 return !clean;
533}
534
535static int is_index_unchanged(void)
536{
537 struct object_id head_oid;
538 struct commit *head_commit;
539
540 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
541 return error(_("could not resolve HEAD commit"));
542
543 head_commit = lookup_commit(&head_oid);
544
545 /*
546 * If head_commit is NULL, check_commit, called from
547 * lookup_commit, would have indicated that head_commit is not
548 * a commit object already. parse_commit() will return failure
549 * without further complaints in such a case. Otherwise, if
550 * the commit is invalid, parse_commit() will complain. So
551 * there is nothing for us to say here. Just return failure.
552 */
553 if (parse_commit(head_commit))
554 return -1;
555
556 if (!active_cache_tree)
557 active_cache_tree = cache_tree();
558
559 if (!cache_tree_fully_valid(active_cache_tree))
560 if (cache_tree_update(&the_index, 0))
561 return error(_("unable to update cache tree"));
562
563 return !oidcmp(&active_cache_tree->oid,
564 &head_commit->tree->object.oid);
565}
566
567static int write_author_script(const char *message)
568{
569 struct strbuf buf = STRBUF_INIT;
570 const char *eol;
571 int res;
572
573 for (;;)
574 if (!*message || starts_with(message, "\n")) {
575missing_author:
576 /* Missing 'author' line? */
577 unlink(rebase_path_author_script());
578 return 0;
579 } else if (skip_prefix(message, "author ", &message))
580 break;
581 else if ((eol = strchr(message, '\n')))
582 message = eol + 1;
583 else
584 goto missing_author;
585
586 strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
587 while (*message && *message != '\n' && *message != '\r')
588 if (skip_prefix(message, " <", &message))
589 break;
590 else if (*message != '\'')
591 strbuf_addch(&buf, *(message++));
592 else
593 strbuf_addf(&buf, "'\\\\%c'", *(message++));
594 strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
595 while (*message && *message != '\n' && *message != '\r')
596 if (skip_prefix(message, "> ", &message))
597 break;
598 else if (*message != '\'')
599 strbuf_addch(&buf, *(message++));
600 else
601 strbuf_addf(&buf, "'\\\\%c'", *(message++));
602 strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
603 while (*message && *message != '\n' && *message != '\r')
604 if (*message != '\'')
605 strbuf_addch(&buf, *(message++));
606 else
607 strbuf_addf(&buf, "'\\\\%c'", *(message++));
608 res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
609 strbuf_release(&buf);
610 return res;
611}
612
613/*
614 * Read a list of environment variable assignments (such as the author-script
615 * file) into an environment block. Returns -1 on error, 0 otherwise.
616 */
617static int read_env_script(struct argv_array *env)
618{
619 struct strbuf script = STRBUF_INIT;
620 int i, count = 0;
621 char *p, *p2;
622
623 if (strbuf_read_file(&script, rebase_path_author_script(), 256) <= 0)
624 return -1;
625
626 for (p = script.buf; *p; p++)
627 if (skip_prefix(p, "'\\\\''", (const char **)&p2))
628 strbuf_splice(&script, p - script.buf, p2 - p, "'", 1);
629 else if (*p == '\'')
630 strbuf_splice(&script, p-- - script.buf, 1, "", 0);
631 else if (*p == '\n') {
632 *p = '\0';
633 count++;
634 }
635
636 for (i = 0, p = script.buf; i < count; i++) {
637 argv_array_push(env, p);
638 p += strlen(p) + 1;
639 }
640
641 return 0;
642}
643
644static char *get_author(const char *message)
645{
646 size_t len;
647 const char *a;
648
649 a = find_commit_header(message, "author", &len);
650 if (a)
651 return xmemdupz(a, len);
652
653 return NULL;
654}
655
656static const char staged_changes_advice[] =
657N_("you have staged changes in your working tree\n"
658"If these changes are meant to be squashed into the previous commit, run:\n"
659"\n"
660" git commit --amend %s\n"
661"\n"
662"If they are meant to go into a new commit, run:\n"
663"\n"
664" git commit %s\n"
665"\n"
666"In both cases, once you're done, continue with:\n"
667"\n"
668" git rebase --continue\n");
669
670#define ALLOW_EMPTY (1<<0)
671#define EDIT_MSG (1<<1)
672#define AMEND_MSG (1<<2)
673#define CLEANUP_MSG (1<<3)
674#define VERIFY_MSG (1<<4)
675
676/*
677 * If we are cherry-pick, and if the merge did not result in
678 * hand-editing, we will hit this commit and inherit the original
679 * author date and name.
680 *
681 * If we are revert, or if our cherry-pick results in a hand merge,
682 * we had better say that the current user is responsible for that.
683 *
684 * An exception is when run_git_commit() is called during an
685 * interactive rebase: in that case, we will want to retain the
686 * author metadata.
687 */
688static int run_git_commit(const char *defmsg, struct replay_opts *opts,
689 unsigned int flags)
690{
691 struct child_process cmd = CHILD_PROCESS_INIT;
692 const char *value;
693
694 cmd.git_cmd = 1;
695
696 if (is_rebase_i(opts)) {
697 if (!(flags & EDIT_MSG)) {
698 cmd.stdout_to_stderr = 1;
699 cmd.err = -1;
700 }
701
702 if (read_env_script(&cmd.env_array)) {
703 const char *gpg_opt = gpg_sign_opt_quoted(opts);
704
705 return error(_(staged_changes_advice),
706 gpg_opt, gpg_opt);
707 }
708 }
709
710 argv_array_push(&cmd.args, "commit");
711
712 if (!(flags & VERIFY_MSG))
713 argv_array_push(&cmd.args, "-n");
714 if ((flags & AMEND_MSG))
715 argv_array_push(&cmd.args, "--amend");
716 if (opts->gpg_sign)
717 argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
718 if (defmsg)
719 argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
720 if ((flags & CLEANUP_MSG))
721 argv_array_push(&cmd.args, "--cleanup=strip");
722 if ((flags & EDIT_MSG))
723 argv_array_push(&cmd.args, "-e");
724 else if (!(flags & CLEANUP_MSG) &&
725 !opts->signoff && !opts->record_origin &&
726 git_config_get_value("commit.cleanup", &value))
727 argv_array_push(&cmd.args, "--cleanup=verbatim");
728
729 if ((flags & ALLOW_EMPTY))
730 argv_array_push(&cmd.args, "--allow-empty");
731
732 if (opts->allow_empty_message)
733 argv_array_push(&cmd.args, "--allow-empty-message");
734
735 if (cmd.err == -1) {
736 /* hide stderr on success */
737 struct strbuf buf = STRBUF_INIT;
738 int rc = pipe_command(&cmd,
739 NULL, 0,
740 /* stdout is already redirected */
741 NULL, 0,
742 &buf, 0);
743 if (rc)
744 fputs(buf.buf, stderr);
745 strbuf_release(&buf);
746 return rc;
747 }
748
749 return run_command(&cmd);
750}
751
752static int rest_is_empty(const struct strbuf *sb, int start)
753{
754 int i, eol;
755 const char *nl;
756
757 /* Check if the rest is just whitespace and Signed-off-by's. */
758 for (i = start; i < sb->len; i++) {
759 nl = memchr(sb->buf + i, '\n', sb->len - i);
760 if (nl)
761 eol = nl - sb->buf;
762 else
763 eol = sb->len;
764
765 if (strlen(sign_off_header) <= eol - i &&
766 starts_with(sb->buf + i, sign_off_header)) {
767 i = eol;
768 continue;
769 }
770 while (i < eol)
771 if (!isspace(sb->buf[i++]))
772 return 0;
773 }
774
775 return 1;
776}
777
778/*
779 * Find out if the message in the strbuf contains only whitespace and
780 * Signed-off-by lines.
781 */
782int message_is_empty(const struct strbuf *sb,
783 enum commit_msg_cleanup_mode cleanup_mode)
784{
785 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
786 return 0;
787 return rest_is_empty(sb, 0);
788}
789
790/*
791 * See if the user edited the message in the editor or left what
792 * was in the template intact
793 */
794int template_untouched(const struct strbuf *sb, const char *template_file,
795 enum commit_msg_cleanup_mode cleanup_mode)
796{
797 struct strbuf tmpl = STRBUF_INIT;
798 const char *start;
799
800 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
801 return 0;
802
803 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
804 return 0;
805
806 strbuf_stripspace(&tmpl, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
807 if (!skip_prefix(sb->buf, tmpl.buf, &start))
808 start = sb->buf;
809 strbuf_release(&tmpl);
810 return rest_is_empty(sb, start - sb->buf);
811}
812
813int update_head_with_reflog(const struct commit *old_head,
814 const struct object_id *new_head,
815 const char *action, const struct strbuf *msg,
816 struct strbuf *err)
817{
818 struct ref_transaction *transaction;
819 struct strbuf sb = STRBUF_INIT;
820 const char *nl;
821 int ret = 0;
822
823 if (action) {
824 strbuf_addstr(&sb, action);
825 strbuf_addstr(&sb, ": ");
826 }
827
828 nl = strchr(msg->buf, '\n');
829 if (nl) {
830 strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
831 } else {
832 strbuf_addbuf(&sb, msg);
833 strbuf_addch(&sb, '\n');
834 }
835
836 transaction = ref_transaction_begin(err);
837 if (!transaction ||
838 ref_transaction_update(transaction, "HEAD", new_head,
839 old_head ? &old_head->object.oid : &null_oid,
840 0, sb.buf, err) ||
841 ref_transaction_commit(transaction, err)) {
842 ret = -1;
843 }
844 ref_transaction_free(transaction);
845 strbuf_release(&sb);
846
847 return ret;
848}
849
850static int run_rewrite_hook(const struct object_id *oldoid,
851 const struct object_id *newoid)
852{
853 struct child_process proc = CHILD_PROCESS_INIT;
854 const char *argv[3];
855 int code;
856 struct strbuf sb = STRBUF_INIT;
857
858 argv[0] = find_hook("post-rewrite");
859 if (!argv[0])
860 return 0;
861
862 argv[1] = "amend";
863 argv[2] = NULL;
864
865 proc.argv = argv;
866 proc.in = -1;
867 proc.stdout_to_stderr = 1;
868
869 code = start_command(&proc);
870 if (code)
871 return code;
872 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
873 sigchain_push(SIGPIPE, SIG_IGN);
874 write_in_full(proc.in, sb.buf, sb.len);
875 close(proc.in);
876 strbuf_release(&sb);
877 sigchain_pop(SIGPIPE);
878 return finish_command(&proc);
879}
880
881void commit_post_rewrite(const struct commit *old_head,
882 const struct object_id *new_head)
883{
884 struct notes_rewrite_cfg *cfg;
885
886 cfg = init_copy_notes_for_rewrite("amend");
887 if (cfg) {
888 /* we are amending, so old_head is not NULL */
889 copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
890 finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
891 }
892 run_rewrite_hook(&old_head->object.oid, new_head);
893}
894
895static int run_prepare_commit_msg_hook(struct strbuf *msg, const char *commit)
896{
897 struct argv_array hook_env = ARGV_ARRAY_INIT;
898 int ret;
899 const char *name;
900
901 name = git_path_commit_editmsg();
902 if (write_message(msg->buf, msg->len, name, 0))
903 return -1;
904
905 argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", get_index_file());
906 argv_array_push(&hook_env, "GIT_EDITOR=:");
907 if (commit)
908 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
909 "commit", commit, NULL);
910 else
911 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
912 "message", NULL);
913 if (ret)
914 ret = error(_("'prepare-commit-msg' hook failed"));
915 argv_array_clear(&hook_env);
916
917 return ret;
918}
919
920static const char implicit_ident_advice_noconfig[] =
921N_("Your name and email address were configured automatically based\n"
922"on your username and hostname. Please check that they are accurate.\n"
923"You can suppress this message by setting them explicitly. Run the\n"
924"following command and follow the instructions in your editor to edit\n"
925"your configuration file:\n"
926"\n"
927" git config --global --edit\n"
928"\n"
929"After doing this, you may fix the identity used for this commit with:\n"
930"\n"
931" git commit --amend --reset-author\n");
932
933static const char implicit_ident_advice_config[] =
934N_("Your name and email address were configured automatically based\n"
935"on your username and hostname. Please check that they are accurate.\n"
936"You can suppress this message by setting them explicitly:\n"
937"\n"
938" git config --global user.name \"Your Name\"\n"
939" git config --global user.email you@example.com\n"
940"\n"
941"After doing this, you may fix the identity used for this commit with:\n"
942"\n"
943" git commit --amend --reset-author\n");
944
945static const char *implicit_ident_advice(void)
946{
947 char *user_config = expand_user_path("~/.gitconfig", 0);
948 char *xdg_config = xdg_config_home("config");
949 int config_exists = file_exists(user_config) || file_exists(xdg_config);
950
951 free(user_config);
952 free(xdg_config);
953
954 if (config_exists)
955 return _(implicit_ident_advice_config);
956 else
957 return _(implicit_ident_advice_noconfig);
958
959}
960
961void print_commit_summary(const char *prefix, const struct object_id *oid,
962 unsigned int flags)
963{
964 struct rev_info rev;
965 struct commit *commit;
966 struct strbuf format = STRBUF_INIT;
967 const char *head;
968 struct pretty_print_context pctx = {0};
969 struct strbuf author_ident = STRBUF_INIT;
970 struct strbuf committer_ident = STRBUF_INIT;
971
972 commit = lookup_commit(oid);
973 if (!commit)
974 die(_("couldn't look up newly created commit"));
975 if (parse_commit(commit))
976 die(_("could not parse newly created commit"));
977
978 strbuf_addstr(&format, "format:%h] %s");
979
980 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
981 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
982 if (strbuf_cmp(&author_ident, &committer_ident)) {
983 strbuf_addstr(&format, "\n Author: ");
984 strbuf_addbuf_percentquote(&format, &author_ident);
985 }
986 if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
987 struct strbuf date = STRBUF_INIT;
988
989 format_commit_message(commit, "%ad", &date, &pctx);
990 strbuf_addstr(&format, "\n Date: ");
991 strbuf_addbuf_percentquote(&format, &date);
992 strbuf_release(&date);
993 }
994 if (!committer_ident_sufficiently_given()) {
995 strbuf_addstr(&format, "\n Committer: ");
996 strbuf_addbuf_percentquote(&format, &committer_ident);
997 if (advice_implicit_identity) {
998 strbuf_addch(&format, '\n');
999 strbuf_addstr(&format, implicit_ident_advice());
1000 }
1001 }
1002 strbuf_release(&author_ident);
1003 strbuf_release(&committer_ident);
1004
1005 init_revisions(&rev, prefix);
1006 setup_revisions(0, NULL, &rev, NULL);
1007
1008 rev.diff = 1;
1009 rev.diffopt.output_format =
1010 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1011
1012 rev.verbose_header = 1;
1013 rev.show_root_diff = 1;
1014 get_commit_format(format.buf, &rev);
1015 rev.always_show_header = 0;
1016 rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1017 rev.diffopt.break_opt = 0;
1018 diff_setup_done(&rev.diffopt);
1019
1020 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1021 if (!head)
1022 die_errno(_("unable to resolve HEAD after creating commit"));
1023 if (!strcmp(head, "HEAD"))
1024 head = _("detached HEAD");
1025 else
1026 skip_prefix(head, "refs/heads/", &head);
1027 printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1028 _(" (root-commit)") : "");
1029
1030 if (!log_tree_commit(&rev, commit)) {
1031 rev.always_show_header = 1;
1032 rev.use_terminator = 1;
1033 log_tree_commit(&rev, commit);
1034 }
1035
1036 strbuf_release(&format);
1037}
1038
1039static int parse_head(struct commit **head)
1040{
1041 struct commit *current_head;
1042 struct object_id oid;
1043
1044 if (get_oid("HEAD", &oid)) {
1045 current_head = NULL;
1046 } else {
1047 current_head = lookup_commit_reference(&oid);
1048 if (!current_head)
1049 return error(_("could not parse HEAD"));
1050 if (oidcmp(&oid, ¤t_head->object.oid)) {
1051 warning(_("HEAD %s is not a commit!"),
1052 oid_to_hex(&oid));
1053 }
1054 if (parse_commit(current_head))
1055 return error(_("could not parse HEAD commit"));
1056 }
1057 *head = current_head;
1058
1059 return 0;
1060}
1061
1062/*
1063 * Try to commit without forking 'git commit'. In some cases we need
1064 * to run 'git commit' to display an error message
1065 *
1066 * Returns:
1067 * -1 - error unable to commit
1068 * 0 - success
1069 * 1 - run 'git commit'
1070 */
1071static int try_to_commit(struct strbuf *msg, const char *author,
1072 struct replay_opts *opts, unsigned int flags,
1073 struct object_id *oid)
1074{
1075 struct object_id tree;
1076 struct commit *current_head;
1077 struct commit_list *parents = NULL;
1078 struct commit_extra_header *extra = NULL;
1079 struct strbuf err = STRBUF_INIT;
1080 struct strbuf commit_msg = STRBUF_INIT;
1081 char *amend_author = NULL;
1082 const char *hook_commit = NULL;
1083 enum commit_msg_cleanup_mode cleanup;
1084 int res = 0;
1085
1086 if (parse_head(¤t_head))
1087 return -1;
1088
1089 if (flags & AMEND_MSG) {
1090 const char *exclude_gpgsig[] = { "gpgsig", NULL };
1091 const char *out_enc = get_commit_output_encoding();
1092 const char *message = logmsg_reencode(current_head, NULL,
1093 out_enc);
1094
1095 if (!msg) {
1096 const char *orig_message = NULL;
1097
1098 find_commit_subject(message, &orig_message);
1099 msg = &commit_msg;
1100 strbuf_addstr(msg, orig_message);
1101 hook_commit = "HEAD";
1102 }
1103 author = amend_author = get_author(message);
1104 unuse_commit_buffer(current_head, message);
1105 if (!author) {
1106 res = error(_("unable to parse commit author"));
1107 goto out;
1108 }
1109 parents = copy_commit_list(current_head->parents);
1110 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1111 } else if (current_head) {
1112 commit_list_insert(current_head, &parents);
1113 }
1114
1115 if (write_cache_as_tree(tree.hash, 0, NULL)) {
1116 res = error(_("git write-tree failed to write a tree"));
1117 goto out;
1118 }
1119
1120 if (!(flags & ALLOW_EMPTY) && !oidcmp(current_head ?
1121 ¤t_head->tree->object.oid :
1122 &empty_tree_oid, &tree)) {
1123 res = 1; /* run 'git commit' to display error message */
1124 goto out;
1125 }
1126
1127 if (find_hook("prepare-commit-msg")) {
1128 res = run_prepare_commit_msg_hook(msg, hook_commit);
1129 if (res)
1130 goto out;
1131 if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1132 2048) < 0) {
1133 res = error_errno(_("unable to read commit message "
1134 "from '%s'"),
1135 git_path_commit_editmsg());
1136 goto out;
1137 }
1138 msg = &commit_msg;
1139 }
1140
1141 cleanup = (flags & CLEANUP_MSG) ? COMMIT_MSG_CLEANUP_ALL :
1142 opts->default_msg_cleanup;
1143
1144 if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1145 strbuf_stripspace(msg, cleanup == COMMIT_MSG_CLEANUP_ALL);
1146 if (!opts->allow_empty_message && message_is_empty(msg, cleanup)) {
1147 res = 1; /* run 'git commit' to display error message */
1148 goto out;
1149 }
1150
1151 reset_ident_date();
1152
1153 if (commit_tree_extended(msg->buf, msg->len, &tree, parents,
1154 oid, author, opts->gpg_sign, extra)) {
1155 res = error(_("failed to write commit object"));
1156 goto out;
1157 }
1158
1159 if (update_head_with_reflog(current_head, oid,
1160 getenv("GIT_REFLOG_ACTION"), msg, &err)) {
1161 res = error("%s", err.buf);
1162 goto out;
1163 }
1164
1165 if (flags & AMEND_MSG)
1166 commit_post_rewrite(current_head, oid);
1167
1168out:
1169 free_commit_extra_headers(extra);
1170 strbuf_release(&err);
1171 strbuf_release(&commit_msg);
1172 free(amend_author);
1173
1174 return res;
1175}
1176
1177static int do_commit(const char *msg_file, const char *author,
1178 struct replay_opts *opts, unsigned int flags)
1179{
1180 int res = 1;
1181
1182 if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG)) {
1183 struct object_id oid;
1184 struct strbuf sb = STRBUF_INIT;
1185
1186 if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1187 return error_errno(_("unable to read commit message "
1188 "from '%s'"),
1189 msg_file);
1190
1191 res = try_to_commit(msg_file ? &sb : NULL, author, opts, flags,
1192 &oid);
1193 strbuf_release(&sb);
1194 if (!res) {
1195 unlink(git_path_cherry_pick_head());
1196 unlink(git_path_merge_msg());
1197 if (!is_rebase_i(opts))
1198 print_commit_summary(NULL, &oid,
1199 SUMMARY_SHOW_AUTHOR_DATE);
1200 return res;
1201 }
1202 }
1203 if (res == 1)
1204 return run_git_commit(msg_file, opts, flags);
1205
1206 return res;
1207}
1208
1209static int is_original_commit_empty(struct commit *commit)
1210{
1211 const struct object_id *ptree_oid;
1212
1213 if (parse_commit(commit))
1214 return error(_("could not parse commit %s"),
1215 oid_to_hex(&commit->object.oid));
1216 if (commit->parents) {
1217 struct commit *parent = commit->parents->item;
1218 if (parse_commit(parent))
1219 return error(_("could not parse parent commit %s"),
1220 oid_to_hex(&parent->object.oid));
1221 ptree_oid = &parent->tree->object.oid;
1222 } else {
1223 ptree_oid = the_hash_algo->empty_tree; /* commit is root */
1224 }
1225
1226 return !oidcmp(ptree_oid, &commit->tree->object.oid);
1227}
1228
1229/*
1230 * Do we run "git commit" with "--allow-empty"?
1231 */
1232static int allow_empty(struct replay_opts *opts, struct commit *commit)
1233{
1234 int index_unchanged, empty_commit;
1235
1236 /*
1237 * Three cases:
1238 *
1239 * (1) we do not allow empty at all and error out.
1240 *
1241 * (2) we allow ones that were initially empty, but
1242 * forbid the ones that become empty;
1243 *
1244 * (3) we allow both.
1245 */
1246 if (!opts->allow_empty)
1247 return 0; /* let "git commit" barf as necessary */
1248
1249 index_unchanged = is_index_unchanged();
1250 if (index_unchanged < 0)
1251 return index_unchanged;
1252 if (!index_unchanged)
1253 return 0; /* we do not have to say --allow-empty */
1254
1255 if (opts->keep_redundant_commits)
1256 return 1;
1257
1258 empty_commit = is_original_commit_empty(commit);
1259 if (empty_commit < 0)
1260 return empty_commit;
1261 if (!empty_commit)
1262 return 0;
1263 else
1264 return 1;
1265}
1266
1267/*
1268 * Note that ordering matters in this enum. Not only must it match the mapping
1269 * below, it is also divided into several sections that matter. When adding
1270 * new commands, make sure you add it in the right section.
1271 */
1272enum todo_command {
1273 /* commands that handle commits */
1274 TODO_PICK = 0,
1275 TODO_REVERT,
1276 TODO_EDIT,
1277 TODO_REWORD,
1278 TODO_FIXUP,
1279 TODO_SQUASH,
1280 /* commands that do something else than handling a single commit */
1281 TODO_EXEC,
1282 /* commands that do nothing but are counted for reporting progress */
1283 TODO_NOOP,
1284 TODO_DROP,
1285 /* comments (not counted for reporting progress) */
1286 TODO_COMMENT
1287};
1288
1289static struct {
1290 char c;
1291 const char *str;
1292} todo_command_info[] = {
1293 { 'p', "pick" },
1294 { 0, "revert" },
1295 { 'e', "edit" },
1296 { 'r', "reword" },
1297 { 'f', "fixup" },
1298 { 's', "squash" },
1299 { 'x', "exec" },
1300 { 0, "noop" },
1301 { 'd', "drop" },
1302 { 0, NULL }
1303};
1304
1305static const char *command_to_string(const enum todo_command command)
1306{
1307 if (command < TODO_COMMENT)
1308 return todo_command_info[command].str;
1309 die("Unknown command: %d", command);
1310}
1311
1312static char command_to_char(const enum todo_command command)
1313{
1314 if (command < TODO_COMMENT && todo_command_info[command].c)
1315 return todo_command_info[command].c;
1316 return comment_line_char;
1317}
1318
1319static int is_noop(const enum todo_command command)
1320{
1321 return TODO_NOOP <= command;
1322}
1323
1324static int is_fixup(enum todo_command command)
1325{
1326 return command == TODO_FIXUP || command == TODO_SQUASH;
1327}
1328
1329static int update_squash_messages(enum todo_command command,
1330 struct commit *commit, struct replay_opts *opts)
1331{
1332 struct strbuf buf = STRBUF_INIT;
1333 int count, res;
1334 const char *message, *body;
1335
1336 if (file_exists(rebase_path_squash_msg())) {
1337 struct strbuf header = STRBUF_INIT;
1338 char *eol, *p;
1339
1340 if (strbuf_read_file(&buf, rebase_path_squash_msg(), 2048) <= 0)
1341 return error(_("could not read '%s'"),
1342 rebase_path_squash_msg());
1343
1344 p = buf.buf + 1;
1345 eol = strchrnul(buf.buf, '\n');
1346 if (buf.buf[0] != comment_line_char ||
1347 (p += strcspn(p, "0123456789\n")) == eol)
1348 return error(_("unexpected 1st line of squash message:"
1349 "\n\n\t%.*s"),
1350 (int)(eol - buf.buf), buf.buf);
1351 count = strtol(p, NULL, 10);
1352
1353 if (count < 1)
1354 return error(_("invalid 1st line of squash message:\n"
1355 "\n\t%.*s"),
1356 (int)(eol - buf.buf), buf.buf);
1357
1358 strbuf_addf(&header, "%c ", comment_line_char);
1359 strbuf_addf(&header,
1360 _("This is a combination of %d commits."), ++count);
1361 strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
1362 strbuf_release(&header);
1363 } else {
1364 struct object_id head;
1365 struct commit *head_commit;
1366 const char *head_message, *body;
1367
1368 if (get_oid("HEAD", &head))
1369 return error(_("need a HEAD to fixup"));
1370 if (!(head_commit = lookup_commit_reference(&head)))
1371 return error(_("could not read HEAD"));
1372 if (!(head_message = get_commit_buffer(head_commit, NULL)))
1373 return error(_("could not read HEAD's commit message"));
1374
1375 find_commit_subject(head_message, &body);
1376 if (write_message(body, strlen(body),
1377 rebase_path_fixup_msg(), 0)) {
1378 unuse_commit_buffer(head_commit, head_message);
1379 return error(_("cannot write '%s'"),
1380 rebase_path_fixup_msg());
1381 }
1382
1383 count = 2;
1384 strbuf_addf(&buf, "%c ", comment_line_char);
1385 strbuf_addf(&buf, _("This is a combination of %d commits."),
1386 count);
1387 strbuf_addf(&buf, "\n%c ", comment_line_char);
1388 strbuf_addstr(&buf, _("This is the 1st commit message:"));
1389 strbuf_addstr(&buf, "\n\n");
1390 strbuf_addstr(&buf, body);
1391
1392 unuse_commit_buffer(head_commit, head_message);
1393 }
1394
1395 if (!(message = get_commit_buffer(commit, NULL)))
1396 return error(_("could not read commit message of %s"),
1397 oid_to_hex(&commit->object.oid));
1398 find_commit_subject(message, &body);
1399
1400 if (command == TODO_SQUASH) {
1401 unlink(rebase_path_fixup_msg());
1402 strbuf_addf(&buf, "\n%c ", comment_line_char);
1403 strbuf_addf(&buf, _("This is the commit message #%d:"), count);
1404 strbuf_addstr(&buf, "\n\n");
1405 strbuf_addstr(&buf, body);
1406 } else if (command == TODO_FIXUP) {
1407 strbuf_addf(&buf, "\n%c ", comment_line_char);
1408 strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
1409 count);
1410 strbuf_addstr(&buf, "\n\n");
1411 strbuf_add_commented_lines(&buf, body, strlen(body));
1412 } else
1413 return error(_("unknown command: %d"), command);
1414 unuse_commit_buffer(commit, message);
1415
1416 res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
1417 strbuf_release(&buf);
1418 return res;
1419}
1420
1421static void flush_rewritten_pending(void) {
1422 struct strbuf buf = STRBUF_INIT;
1423 struct object_id newoid;
1424 FILE *out;
1425
1426 if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
1427 !get_oid("HEAD", &newoid) &&
1428 (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1429 char *bol = buf.buf, *eol;
1430
1431 while (*bol) {
1432 eol = strchrnul(bol, '\n');
1433 fprintf(out, "%.*s %s\n", (int)(eol - bol),
1434 bol, oid_to_hex(&newoid));
1435 if (!*eol)
1436 break;
1437 bol = eol + 1;
1438 }
1439 fclose(out);
1440 unlink(rebase_path_rewritten_pending());
1441 }
1442 strbuf_release(&buf);
1443}
1444
1445static void record_in_rewritten(struct object_id *oid,
1446 enum todo_command next_command) {
1447 FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
1448
1449 if (!out)
1450 return;
1451
1452 fprintf(out, "%s\n", oid_to_hex(oid));
1453 fclose(out);
1454
1455 if (!is_fixup(next_command))
1456 flush_rewritten_pending();
1457}
1458
1459static int do_pick_commit(enum todo_command command, struct commit *commit,
1460 struct replay_opts *opts, int final_fixup)
1461{
1462 unsigned int flags = opts->edit ? EDIT_MSG : 0;
1463 const char *msg_file = opts->edit ? NULL : git_path_merge_msg();
1464 struct object_id head;
1465 struct commit *base, *next, *parent;
1466 const char *base_label, *next_label;
1467 char *author = NULL;
1468 struct commit_message msg = { NULL, NULL, NULL, NULL };
1469 struct strbuf msgbuf = STRBUF_INIT;
1470 int res, unborn = 0, allow;
1471
1472 if (opts->no_commit) {
1473 /*
1474 * We do not intend to commit immediately. We just want to
1475 * merge the differences in, so let's compute the tree
1476 * that represents the "current" state for merge-recursive
1477 * to work on.
1478 */
1479 if (write_cache_as_tree(head.hash, 0, NULL))
1480 return error(_("your index file is unmerged."));
1481 } else {
1482 unborn = get_oid("HEAD", &head);
1483 if (unborn)
1484 oidcpy(&head, the_hash_algo->empty_tree);
1485 if (index_differs_from(unborn ? EMPTY_TREE_SHA1_HEX : "HEAD",
1486 NULL, 0))
1487 return error_dirty_index(opts);
1488 }
1489 discard_cache();
1490
1491 if (!commit->parents)
1492 parent = NULL;
1493 else if (commit->parents->next) {
1494 /* Reverting or cherry-picking a merge commit */
1495 int cnt;
1496 struct commit_list *p;
1497
1498 if (!opts->mainline)
1499 return error(_("commit %s is a merge but no -m option was given."),
1500 oid_to_hex(&commit->object.oid));
1501
1502 for (cnt = 1, p = commit->parents;
1503 cnt != opts->mainline && p;
1504 cnt++)
1505 p = p->next;
1506 if (cnt != opts->mainline || !p)
1507 return error(_("commit %s does not have parent %d"),
1508 oid_to_hex(&commit->object.oid), opts->mainline);
1509 parent = p->item;
1510 } else if (0 < opts->mainline)
1511 return error(_("mainline was specified but commit %s is not a merge."),
1512 oid_to_hex(&commit->object.oid));
1513 else
1514 parent = commit->parents->item;
1515
1516 if (get_message(commit, &msg) != 0)
1517 return error(_("cannot get commit message for %s"),
1518 oid_to_hex(&commit->object.oid));
1519
1520 if (opts->allow_ff && !is_fixup(command) &&
1521 ((parent && !oidcmp(&parent->object.oid, &head)) ||
1522 (!parent && unborn))) {
1523 if (is_rebase_i(opts))
1524 write_author_script(msg.message);
1525 res = fast_forward_to(&commit->object.oid, &head, unborn,
1526 opts);
1527 if (res || command != TODO_REWORD)
1528 goto leave;
1529 flags |= EDIT_MSG | AMEND_MSG | VERIFY_MSG;
1530 msg_file = NULL;
1531 goto fast_forward_edit;
1532 }
1533 if (parent && parse_commit(parent) < 0)
1534 /* TRANSLATORS: The first %s will be a "todo" command like
1535 "revert" or "pick", the second %s a SHA1. */
1536 return error(_("%s: cannot parse parent commit %s"),
1537 command_to_string(command),
1538 oid_to_hex(&parent->object.oid));
1539
1540 /*
1541 * "commit" is an existing commit. We would want to apply
1542 * the difference it introduces since its first parent "prev"
1543 * on top of the current HEAD if we are cherry-pick. Or the
1544 * reverse of it if we are revert.
1545 */
1546
1547 if (command == TODO_REVERT) {
1548 base = commit;
1549 base_label = msg.label;
1550 next = parent;
1551 next_label = msg.parent_label;
1552 strbuf_addstr(&msgbuf, "Revert \"");
1553 strbuf_addstr(&msgbuf, msg.subject);
1554 strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
1555 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1556
1557 if (commit->parents && commit->parents->next) {
1558 strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
1559 strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
1560 }
1561 strbuf_addstr(&msgbuf, ".\n");
1562 } else {
1563 const char *p;
1564
1565 base = parent;
1566 base_label = msg.parent_label;
1567 next = commit;
1568 next_label = msg.label;
1569
1570 /* Append the commit log message to msgbuf. */
1571 if (find_commit_subject(msg.message, &p))
1572 strbuf_addstr(&msgbuf, p);
1573
1574 if (opts->record_origin) {
1575 strbuf_complete_line(&msgbuf);
1576 if (!has_conforming_footer(&msgbuf, NULL, 0))
1577 strbuf_addch(&msgbuf, '\n');
1578 strbuf_addstr(&msgbuf, cherry_picked_prefix);
1579 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1580 strbuf_addstr(&msgbuf, ")\n");
1581 }
1582 if (!is_fixup(command))
1583 author = get_author(msg.message);
1584 }
1585
1586 if (command == TODO_REWORD)
1587 flags |= EDIT_MSG | VERIFY_MSG;
1588 else if (is_fixup(command)) {
1589 if (update_squash_messages(command, commit, opts))
1590 return -1;
1591 flags |= AMEND_MSG;
1592 if (!final_fixup)
1593 msg_file = rebase_path_squash_msg();
1594 else if (file_exists(rebase_path_fixup_msg())) {
1595 flags |= CLEANUP_MSG;
1596 msg_file = rebase_path_fixup_msg();
1597 } else {
1598 const char *dest = git_path_squash_msg();
1599 unlink(dest);
1600 if (copy_file(dest, rebase_path_squash_msg(), 0666))
1601 return error(_("could not rename '%s' to '%s'"),
1602 rebase_path_squash_msg(), dest);
1603 unlink(git_path_merge_msg());
1604 msg_file = dest;
1605 flags |= EDIT_MSG;
1606 }
1607 }
1608
1609 if (opts->signoff)
1610 append_signoff(&msgbuf, 0, 0);
1611
1612 if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1613 res = -1;
1614 else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
1615 res = do_recursive_merge(base, next, base_label, next_label,
1616 &head, &msgbuf, opts);
1617 if (res < 0)
1618 return res;
1619 res |= write_message(msgbuf.buf, msgbuf.len,
1620 git_path_merge_msg(), 0);
1621 } else {
1622 struct commit_list *common = NULL;
1623 struct commit_list *remotes = NULL;
1624
1625 res = write_message(msgbuf.buf, msgbuf.len,
1626 git_path_merge_msg(), 0);
1627
1628 commit_list_insert(base, &common);
1629 commit_list_insert(next, &remotes);
1630 res |= try_merge_command(opts->strategy,
1631 opts->xopts_nr, (const char **)opts->xopts,
1632 common, oid_to_hex(&head), remotes);
1633 free_commit_list(common);
1634 free_commit_list(remotes);
1635 }
1636 strbuf_release(&msgbuf);
1637
1638 /*
1639 * If the merge was clean or if it failed due to conflict, we write
1640 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1641 * However, if the merge did not even start, then we don't want to
1642 * write it at all.
1643 */
1644 if (command == TODO_PICK && !opts->no_commit && (res == 0 || res == 1) &&
1645 update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
1646 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1647 res = -1;
1648 if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
1649 update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
1650 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1651 res = -1;
1652
1653 if (res) {
1654 error(command == TODO_REVERT
1655 ? _("could not revert %s... %s")
1656 : _("could not apply %s... %s"),
1657 short_commit_name(commit), msg.subject);
1658 print_advice(res == 1, opts);
1659 rerere(opts->allow_rerere_auto);
1660 goto leave;
1661 }
1662
1663 allow = allow_empty(opts, commit);
1664 if (allow < 0) {
1665 res = allow;
1666 goto leave;
1667 } else if (allow)
1668 flags |= ALLOW_EMPTY;
1669 if (!opts->no_commit) {
1670fast_forward_edit:
1671 if (author || command == TODO_REVERT || (flags & AMEND_MSG))
1672 res = do_commit(msg_file, author, opts, flags);
1673 else
1674 res = error(_("unable to parse commit author"));
1675 }
1676
1677 if (!res && final_fixup) {
1678 unlink(rebase_path_fixup_msg());
1679 unlink(rebase_path_squash_msg());
1680 }
1681
1682leave:
1683 free_message(commit, &msg);
1684 free(author);
1685 update_abort_safety_file();
1686
1687 return res;
1688}
1689
1690static int prepare_revs(struct replay_opts *opts)
1691{
1692 /*
1693 * picking (but not reverting) ranges (but not individual revisions)
1694 * should be done in reverse
1695 */
1696 if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
1697 opts->revs->reverse ^= 1;
1698
1699 if (prepare_revision_walk(opts->revs))
1700 return error(_("revision walk setup failed"));
1701
1702 if (!opts->revs->commits)
1703 return error(_("empty commit set passed"));
1704 return 0;
1705}
1706
1707static int read_and_refresh_cache(struct replay_opts *opts)
1708{
1709 struct lock_file index_lock = LOCK_INIT;
1710 int index_fd = hold_locked_index(&index_lock, 0);
1711 if (read_index_preload(&the_index, NULL) < 0) {
1712 rollback_lock_file(&index_lock);
1713 return error(_("git %s: failed to read the index"),
1714 _(action_name(opts)));
1715 }
1716 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
1717 if (index_fd >= 0) {
1718 if (write_locked_index(&the_index, &index_lock,
1719 COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
1720 return error(_("git %s: failed to refresh the index"),
1721 _(action_name(opts)));
1722 }
1723 }
1724 return 0;
1725}
1726
1727struct todo_item {
1728 enum todo_command command;
1729 struct commit *commit;
1730 const char *arg;
1731 int arg_len;
1732 size_t offset_in_buf;
1733};
1734
1735struct todo_list {
1736 struct strbuf buf;
1737 struct todo_item *items;
1738 int nr, alloc, current;
1739 int done_nr, total_nr;
1740 struct stat_data stat;
1741};
1742
1743#define TODO_LIST_INIT { STRBUF_INIT }
1744
1745static void todo_list_release(struct todo_list *todo_list)
1746{
1747 strbuf_release(&todo_list->buf);
1748 FREE_AND_NULL(todo_list->items);
1749 todo_list->nr = todo_list->alloc = 0;
1750}
1751
1752static struct todo_item *append_new_todo(struct todo_list *todo_list)
1753{
1754 ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
1755 return todo_list->items + todo_list->nr++;
1756}
1757
1758static int parse_insn_line(struct todo_item *item, const char *bol, char *eol)
1759{
1760 struct object_id commit_oid;
1761 char *end_of_object_name;
1762 int i, saved, status, padding;
1763
1764 /* left-trim */
1765 bol += strspn(bol, " \t");
1766
1767 if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
1768 item->command = TODO_COMMENT;
1769 item->commit = NULL;
1770 item->arg = bol;
1771 item->arg_len = eol - bol;
1772 return 0;
1773 }
1774
1775 for (i = 0; i < TODO_COMMENT; i++)
1776 if (skip_prefix(bol, todo_command_info[i].str, &bol)) {
1777 item->command = i;
1778 break;
1779 } else if (bol[1] == ' ' && *bol == todo_command_info[i].c) {
1780 bol++;
1781 item->command = i;
1782 break;
1783 }
1784 if (i >= TODO_COMMENT)
1785 return -1;
1786
1787 /* Eat up extra spaces/ tabs before object name */
1788 padding = strspn(bol, " \t");
1789 bol += padding;
1790
1791 if (item->command == TODO_NOOP) {
1792 if (bol != eol)
1793 return error(_("%s does not accept arguments: '%s'"),
1794 command_to_string(item->command), bol);
1795 item->commit = NULL;
1796 item->arg = bol;
1797 item->arg_len = eol - bol;
1798 return 0;
1799 }
1800
1801 if (!padding)
1802 return error(_("missing arguments for %s"),
1803 command_to_string(item->command));
1804
1805 if (item->command == TODO_EXEC) {
1806 item->commit = NULL;
1807 item->arg = bol;
1808 item->arg_len = (int)(eol - bol);
1809 return 0;
1810 }
1811
1812 end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
1813 saved = *end_of_object_name;
1814 *end_of_object_name = '\0';
1815 status = get_oid(bol, &commit_oid);
1816 *end_of_object_name = saved;
1817
1818 item->arg = end_of_object_name + strspn(end_of_object_name, " \t");
1819 item->arg_len = (int)(eol - item->arg);
1820
1821 if (status < 0)
1822 return -1;
1823
1824 item->commit = lookup_commit_reference(&commit_oid);
1825 return !item->commit;
1826}
1827
1828static int parse_insn_buffer(char *buf, struct todo_list *todo_list)
1829{
1830 struct todo_item *item;
1831 char *p = buf, *next_p;
1832 int i, res = 0, fixup_okay = file_exists(rebase_path_done());
1833
1834 for (i = 1; *p; i++, p = next_p) {
1835 char *eol = strchrnul(p, '\n');
1836
1837 next_p = *eol ? eol + 1 /* skip LF */ : eol;
1838
1839 if (p != eol && eol[-1] == '\r')
1840 eol--; /* strip Carriage Return */
1841
1842 item = append_new_todo(todo_list);
1843 item->offset_in_buf = p - todo_list->buf.buf;
1844 if (parse_insn_line(item, p, eol)) {
1845 res = error(_("invalid line %d: %.*s"),
1846 i, (int)(eol - p), p);
1847 item->command = TODO_NOOP;
1848 }
1849
1850 if (fixup_okay)
1851 ; /* do nothing */
1852 else if (is_fixup(item->command))
1853 return error(_("cannot '%s' without a previous commit"),
1854 command_to_string(item->command));
1855 else if (!is_noop(item->command))
1856 fixup_okay = 1;
1857 }
1858
1859 return res;
1860}
1861
1862static int count_commands(struct todo_list *todo_list)
1863{
1864 int count = 0, i;
1865
1866 for (i = 0; i < todo_list->nr; i++)
1867 if (todo_list->items[i].command != TODO_COMMENT)
1868 count++;
1869
1870 return count;
1871}
1872
1873static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
1874{
1875 int fd;
1876 ssize_t len;
1877
1878 fd = open(path, O_RDONLY);
1879 if (fd < 0)
1880 return error_errno(_("could not open '%s'"), path);
1881 len = strbuf_read(sb, fd, 0);
1882 close(fd);
1883 if (len < 0)
1884 return error(_("could not read '%s'."), path);
1885 return len;
1886}
1887
1888static int read_populate_todo(struct todo_list *todo_list,
1889 struct replay_opts *opts)
1890{
1891 struct stat st;
1892 const char *todo_file = get_todo_path(opts);
1893 int res;
1894
1895 strbuf_reset(&todo_list->buf);
1896 if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
1897 return -1;
1898
1899 res = stat(todo_file, &st);
1900 if (res)
1901 return error(_("could not stat '%s'"), todo_file);
1902 fill_stat_data(&todo_list->stat, &st);
1903
1904 res = parse_insn_buffer(todo_list->buf.buf, todo_list);
1905 if (res) {
1906 if (is_rebase_i(opts))
1907 return error(_("please fix this using "
1908 "'git rebase --edit-todo'."));
1909 return error(_("unusable instruction sheet: '%s'"), todo_file);
1910 }
1911
1912 if (!todo_list->nr &&
1913 (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
1914 return error(_("no commits parsed."));
1915
1916 if (!is_rebase_i(opts)) {
1917 enum todo_command valid =
1918 opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
1919 int i;
1920
1921 for (i = 0; i < todo_list->nr; i++)
1922 if (valid == todo_list->items[i].command)
1923 continue;
1924 else if (valid == TODO_PICK)
1925 return error(_("cannot cherry-pick during a revert."));
1926 else
1927 return error(_("cannot revert during a cherry-pick."));
1928 }
1929
1930 if (is_rebase_i(opts)) {
1931 struct todo_list done = TODO_LIST_INIT;
1932 FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
1933
1934 if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
1935 !parse_insn_buffer(done.buf.buf, &done))
1936 todo_list->done_nr = count_commands(&done);
1937 else
1938 todo_list->done_nr = 0;
1939
1940 todo_list->total_nr = todo_list->done_nr
1941 + count_commands(todo_list);
1942 todo_list_release(&done);
1943
1944 if (f) {
1945 fprintf(f, "%d\n", todo_list->total_nr);
1946 fclose(f);
1947 }
1948 }
1949
1950 return 0;
1951}
1952
1953static int git_config_string_dup(char **dest,
1954 const char *var, const char *value)
1955{
1956 if (!value)
1957 return config_error_nonbool(var);
1958 free(*dest);
1959 *dest = xstrdup(value);
1960 return 0;
1961}
1962
1963static int populate_opts_cb(const char *key, const char *value, void *data)
1964{
1965 struct replay_opts *opts = data;
1966 int error_flag = 1;
1967
1968 if (!value)
1969 error_flag = 0;
1970 else if (!strcmp(key, "options.no-commit"))
1971 opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
1972 else if (!strcmp(key, "options.edit"))
1973 opts->edit = git_config_bool_or_int(key, value, &error_flag);
1974 else if (!strcmp(key, "options.signoff"))
1975 opts->signoff = git_config_bool_or_int(key, value, &error_flag);
1976 else if (!strcmp(key, "options.record-origin"))
1977 opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
1978 else if (!strcmp(key, "options.allow-ff"))
1979 opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
1980 else if (!strcmp(key, "options.mainline"))
1981 opts->mainline = git_config_int(key, value);
1982 else if (!strcmp(key, "options.strategy"))
1983 git_config_string_dup(&opts->strategy, key, value);
1984 else if (!strcmp(key, "options.gpg-sign"))
1985 git_config_string_dup(&opts->gpg_sign, key, value);
1986 else if (!strcmp(key, "options.strategy-option")) {
1987 ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
1988 opts->xopts[opts->xopts_nr++] = xstrdup(value);
1989 } else if (!strcmp(key, "options.allow-rerere-auto"))
1990 opts->allow_rerere_auto =
1991 git_config_bool_or_int(key, value, &error_flag) ?
1992 RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
1993 else
1994 return error(_("invalid key: %s"), key);
1995
1996 if (!error_flag)
1997 return error(_("invalid value for %s: %s"), key, value);
1998
1999 return 0;
2000}
2001
2002static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
2003{
2004 int i;
2005
2006 strbuf_reset(buf);
2007 if (!read_oneliner(buf, rebase_path_strategy(), 0))
2008 return;
2009 opts->strategy = strbuf_detach(buf, NULL);
2010 if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2011 return;
2012
2013 opts->xopts_nr = split_cmdline(buf->buf, (const char ***)&opts->xopts);
2014 for (i = 0; i < opts->xopts_nr; i++) {
2015 const char *arg = opts->xopts[i];
2016
2017 skip_prefix(arg, "--", &arg);
2018 opts->xopts[i] = xstrdup(arg);
2019 }
2020}
2021
2022static int read_populate_opts(struct replay_opts *opts)
2023{
2024 if (is_rebase_i(opts)) {
2025 struct strbuf buf = STRBUF_INIT;
2026
2027 if (read_oneliner(&buf, rebase_path_gpg_sign_opt(), 1)) {
2028 if (!starts_with(buf.buf, "-S"))
2029 strbuf_reset(&buf);
2030 else {
2031 free(opts->gpg_sign);
2032 opts->gpg_sign = xstrdup(buf.buf + 2);
2033 }
2034 strbuf_reset(&buf);
2035 }
2036
2037 if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(), 1)) {
2038 if (!strcmp(buf.buf, "--rerere-autoupdate"))
2039 opts->allow_rerere_auto = RERERE_AUTOUPDATE;
2040 else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
2041 opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
2042 strbuf_reset(&buf);
2043 }
2044
2045 if (file_exists(rebase_path_verbose()))
2046 opts->verbose = 1;
2047
2048 read_strategy_opts(opts, &buf);
2049 strbuf_release(&buf);
2050
2051 return 0;
2052 }
2053
2054 if (!file_exists(git_path_opts_file()))
2055 return 0;
2056 /*
2057 * The function git_parse_source(), called from git_config_from_file(),
2058 * may die() in case of a syntactically incorrect file. We do not care
2059 * about this case, though, because we wrote that file ourselves, so we
2060 * are pretty certain that it is syntactically correct.
2061 */
2062 if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
2063 return error(_("malformed options sheet: '%s'"),
2064 git_path_opts_file());
2065 return 0;
2066}
2067
2068static int walk_revs_populate_todo(struct todo_list *todo_list,
2069 struct replay_opts *opts)
2070{
2071 enum todo_command command = opts->action == REPLAY_PICK ?
2072 TODO_PICK : TODO_REVERT;
2073 const char *command_string = todo_command_info[command].str;
2074 struct commit *commit;
2075
2076 if (prepare_revs(opts))
2077 return -1;
2078
2079 while ((commit = get_revision(opts->revs))) {
2080 struct todo_item *item = append_new_todo(todo_list);
2081 const char *commit_buffer = get_commit_buffer(commit, NULL);
2082 const char *subject;
2083 int subject_len;
2084
2085 item->command = command;
2086 item->commit = commit;
2087 item->arg = NULL;
2088 item->arg_len = 0;
2089 item->offset_in_buf = todo_list->buf.len;
2090 subject_len = find_commit_subject(commit_buffer, &subject);
2091 strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
2092 short_commit_name(commit), subject_len, subject);
2093 unuse_commit_buffer(commit, commit_buffer);
2094 }
2095 return 0;
2096}
2097
2098static int create_seq_dir(void)
2099{
2100 if (file_exists(git_path_seq_dir())) {
2101 error(_("a cherry-pick or revert is already in progress"));
2102 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
2103 return -1;
2104 } else if (mkdir(git_path_seq_dir(), 0777) < 0)
2105 return error_errno(_("could not create sequencer directory '%s'"),
2106 git_path_seq_dir());
2107 return 0;
2108}
2109
2110static int save_head(const char *head)
2111{
2112 struct lock_file head_lock = LOCK_INIT;
2113 struct strbuf buf = STRBUF_INIT;
2114 int fd;
2115 ssize_t written;
2116
2117 fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
2118 if (fd < 0)
2119 return error_errno(_("could not lock HEAD"));
2120 strbuf_addf(&buf, "%s\n", head);
2121 written = write_in_full(fd, buf.buf, buf.len);
2122 strbuf_release(&buf);
2123 if (written < 0) {
2124 rollback_lock_file(&head_lock);
2125 return error_errno(_("could not write to '%s'"),
2126 git_path_head_file());
2127 }
2128 if (commit_lock_file(&head_lock) < 0)
2129 return error(_("failed to finalize '%s'"), git_path_head_file());
2130 return 0;
2131}
2132
2133static int rollback_is_safe(void)
2134{
2135 struct strbuf sb = STRBUF_INIT;
2136 struct object_id expected_head, actual_head;
2137
2138 if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2139 strbuf_trim(&sb);
2140 if (get_oid_hex(sb.buf, &expected_head)) {
2141 strbuf_release(&sb);
2142 die(_("could not parse %s"), git_path_abort_safety_file());
2143 }
2144 strbuf_release(&sb);
2145 }
2146 else if (errno == ENOENT)
2147 oidclr(&expected_head);
2148 else
2149 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2150
2151 if (get_oid("HEAD", &actual_head))
2152 oidclr(&actual_head);
2153
2154 return !oidcmp(&actual_head, &expected_head);
2155}
2156
2157static int reset_for_rollback(const struct object_id *oid)
2158{
2159 const char *argv[4]; /* reset --merge <arg> + NULL */
2160
2161 argv[0] = "reset";
2162 argv[1] = "--merge";
2163 argv[2] = oid_to_hex(oid);
2164 argv[3] = NULL;
2165 return run_command_v_opt(argv, RUN_GIT_CMD);
2166}
2167
2168static int rollback_single_pick(void)
2169{
2170 struct object_id head_oid;
2171
2172 if (!file_exists(git_path_cherry_pick_head()) &&
2173 !file_exists(git_path_revert_head()))
2174 return error(_("no cherry-pick or revert in progress"));
2175 if (read_ref_full("HEAD", 0, &head_oid, NULL))
2176 return error(_("cannot resolve HEAD"));
2177 if (is_null_oid(&head_oid))
2178 return error(_("cannot abort from a branch yet to be born"));
2179 return reset_for_rollback(&head_oid);
2180}
2181
2182int sequencer_rollback(struct replay_opts *opts)
2183{
2184 FILE *f;
2185 struct object_id oid;
2186 struct strbuf buf = STRBUF_INIT;
2187 const char *p;
2188
2189 f = fopen(git_path_head_file(), "r");
2190 if (!f && errno == ENOENT) {
2191 /*
2192 * There is no multiple-cherry-pick in progress.
2193 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2194 * a single-cherry-pick in progress, abort that.
2195 */
2196 return rollback_single_pick();
2197 }
2198 if (!f)
2199 return error_errno(_("cannot open '%s'"), git_path_head_file());
2200 if (strbuf_getline_lf(&buf, f)) {
2201 error(_("cannot read '%s': %s"), git_path_head_file(),
2202 ferror(f) ? strerror(errno) : _("unexpected end of file"));
2203 fclose(f);
2204 goto fail;
2205 }
2206 fclose(f);
2207 if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
2208 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2209 git_path_head_file());
2210 goto fail;
2211 }
2212 if (is_null_oid(&oid)) {
2213 error(_("cannot abort from a branch yet to be born"));
2214 goto fail;
2215 }
2216
2217 if (!rollback_is_safe()) {
2218 /* Do not error, just do not rollback */
2219 warning(_("You seem to have moved HEAD. "
2220 "Not rewinding, check your HEAD!"));
2221 } else
2222 if (reset_for_rollback(&oid))
2223 goto fail;
2224 strbuf_release(&buf);
2225 return sequencer_remove_state(opts);
2226fail:
2227 strbuf_release(&buf);
2228 return -1;
2229}
2230
2231static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
2232{
2233 struct lock_file todo_lock = LOCK_INIT;
2234 const char *todo_path = get_todo_path(opts);
2235 int next = todo_list->current, offset, fd;
2236
2237 /*
2238 * rebase -i writes "git-rebase-todo" without the currently executing
2239 * command, appending it to "done" instead.
2240 */
2241 if (is_rebase_i(opts))
2242 next++;
2243
2244 fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
2245 if (fd < 0)
2246 return error_errno(_("could not lock '%s'"), todo_path);
2247 offset = next < todo_list->nr ?
2248 todo_list->items[next].offset_in_buf : todo_list->buf.len;
2249 if (write_in_full(fd, todo_list->buf.buf + offset,
2250 todo_list->buf.len - offset) < 0)
2251 return error_errno(_("could not write to '%s'"), todo_path);
2252 if (commit_lock_file(&todo_lock) < 0)
2253 return error(_("failed to finalize '%s'"), todo_path);
2254
2255 if (is_rebase_i(opts)) {
2256 const char *done_path = rebase_path_done();
2257 int fd = open(done_path, O_CREAT | O_WRONLY | O_APPEND, 0666);
2258 int prev_offset = !next ? 0 :
2259 todo_list->items[next - 1].offset_in_buf;
2260
2261 if (fd >= 0 && offset > prev_offset &&
2262 write_in_full(fd, todo_list->buf.buf + prev_offset,
2263 offset - prev_offset) < 0) {
2264 close(fd);
2265 return error_errno(_("could not write to '%s'"),
2266 done_path);
2267 }
2268 if (fd >= 0)
2269 close(fd);
2270 }
2271 return 0;
2272}
2273
2274static int save_opts(struct replay_opts *opts)
2275{
2276 const char *opts_file = git_path_opts_file();
2277 int res = 0;
2278
2279 if (opts->no_commit)
2280 res |= git_config_set_in_file_gently(opts_file, "options.no-commit", "true");
2281 if (opts->edit)
2282 res |= git_config_set_in_file_gently(opts_file, "options.edit", "true");
2283 if (opts->signoff)
2284 res |= git_config_set_in_file_gently(opts_file, "options.signoff", "true");
2285 if (opts->record_origin)
2286 res |= git_config_set_in_file_gently(opts_file, "options.record-origin", "true");
2287 if (opts->allow_ff)
2288 res |= git_config_set_in_file_gently(opts_file, "options.allow-ff", "true");
2289 if (opts->mainline) {
2290 struct strbuf buf = STRBUF_INIT;
2291 strbuf_addf(&buf, "%d", opts->mainline);
2292 res |= git_config_set_in_file_gently(opts_file, "options.mainline", buf.buf);
2293 strbuf_release(&buf);
2294 }
2295 if (opts->strategy)
2296 res |= git_config_set_in_file_gently(opts_file, "options.strategy", opts->strategy);
2297 if (opts->gpg_sign)
2298 res |= git_config_set_in_file_gently(opts_file, "options.gpg-sign", opts->gpg_sign);
2299 if (opts->xopts) {
2300 int i;
2301 for (i = 0; i < opts->xopts_nr; i++)
2302 res |= git_config_set_multivar_in_file_gently(opts_file,
2303 "options.strategy-option",
2304 opts->xopts[i], "^$", 0);
2305 }
2306 if (opts->allow_rerere_auto)
2307 res |= git_config_set_in_file_gently(opts_file, "options.allow-rerere-auto",
2308 opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
2309 "true" : "false");
2310 return res;
2311}
2312
2313static int make_patch(struct commit *commit, struct replay_opts *opts)
2314{
2315 struct strbuf buf = STRBUF_INIT;
2316 struct rev_info log_tree_opt;
2317 const char *subject, *p;
2318 int res = 0;
2319
2320 p = short_commit_name(commit);
2321 if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
2322 return -1;
2323 if (update_ref("rebase", "REBASE_HEAD", &commit->object.oid,
2324 NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2325 res |= error(_("could not update %s"), "REBASE_HEAD");
2326
2327 strbuf_addf(&buf, "%s/patch", get_dir(opts));
2328 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
2329 init_revisions(&log_tree_opt, NULL);
2330 log_tree_opt.abbrev = 0;
2331 log_tree_opt.diff = 1;
2332 log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
2333 log_tree_opt.disable_stdin = 1;
2334 log_tree_opt.no_commit_id = 1;
2335 log_tree_opt.diffopt.file = fopen(buf.buf, "w");
2336 log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
2337 if (!log_tree_opt.diffopt.file)
2338 res |= error_errno(_("could not open '%s'"), buf.buf);
2339 else {
2340 res |= log_tree_commit(&log_tree_opt, commit);
2341 fclose(log_tree_opt.diffopt.file);
2342 }
2343 strbuf_reset(&buf);
2344
2345 strbuf_addf(&buf, "%s/message", get_dir(opts));
2346 if (!file_exists(buf.buf)) {
2347 const char *commit_buffer = get_commit_buffer(commit, NULL);
2348 find_commit_subject(commit_buffer, &subject);
2349 res |= write_message(subject, strlen(subject), buf.buf, 1);
2350 unuse_commit_buffer(commit, commit_buffer);
2351 }
2352 strbuf_release(&buf);
2353
2354 return res;
2355}
2356
2357static int intend_to_amend(void)
2358{
2359 struct object_id head;
2360 char *p;
2361
2362 if (get_oid("HEAD", &head))
2363 return error(_("cannot read HEAD"));
2364
2365 p = oid_to_hex(&head);
2366 return write_message(p, strlen(p), rebase_path_amend(), 1);
2367}
2368
2369static int error_with_patch(struct commit *commit,
2370 const char *subject, int subject_len,
2371 struct replay_opts *opts, int exit_code, int to_amend)
2372{
2373 if (make_patch(commit, opts))
2374 return -1;
2375
2376 if (to_amend) {
2377 if (intend_to_amend())
2378 return -1;
2379
2380 fprintf(stderr, "You can amend the commit now, with\n"
2381 "\n"
2382 " git commit --amend %s\n"
2383 "\n"
2384 "Once you are satisfied with your changes, run\n"
2385 "\n"
2386 " git rebase --continue\n", gpg_sign_opt_quoted(opts));
2387 } else if (exit_code)
2388 fprintf(stderr, "Could not apply %s... %.*s\n",
2389 short_commit_name(commit), subject_len, subject);
2390
2391 return exit_code;
2392}
2393
2394static int error_failed_squash(struct commit *commit,
2395 struct replay_opts *opts, int subject_len, const char *subject)
2396{
2397 if (rename(rebase_path_squash_msg(), rebase_path_message()))
2398 return error(_("could not rename '%s' to '%s'"),
2399 rebase_path_squash_msg(), rebase_path_message());
2400 unlink(rebase_path_fixup_msg());
2401 unlink(git_path_merge_msg());
2402 if (copy_file(git_path_merge_msg(), rebase_path_message(), 0666))
2403 return error(_("could not copy '%s' to '%s'"),
2404 rebase_path_message(), git_path_merge_msg());
2405 return error_with_patch(commit, subject, subject_len, opts, 1, 0);
2406}
2407
2408static int do_exec(const char *command_line)
2409{
2410 struct argv_array child_env = ARGV_ARRAY_INIT;
2411 const char *child_argv[] = { NULL, NULL };
2412 int dirty, status;
2413
2414 fprintf(stderr, "Executing: %s\n", command_line);
2415 child_argv[0] = command_line;
2416 argv_array_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
2417 status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
2418 child_env.argv);
2419
2420 /* force re-reading of the cache */
2421 if (discard_cache() < 0 || read_cache() < 0)
2422 return error(_("could not read index"));
2423
2424 dirty = require_clean_work_tree("rebase", NULL, 1, 1);
2425
2426 if (status) {
2427 warning(_("execution failed: %s\n%s"
2428 "You can fix the problem, and then run\n"
2429 "\n"
2430 " git rebase --continue\n"
2431 "\n"),
2432 command_line,
2433 dirty ? N_("and made changes to the index and/or the "
2434 "working tree\n") : "");
2435 if (status == 127)
2436 /* command not found */
2437 status = 1;
2438 } else if (dirty) {
2439 warning(_("execution succeeded: %s\nbut "
2440 "left changes to the index and/or the working tree\n"
2441 "Commit or stash your changes, and then run\n"
2442 "\n"
2443 " git rebase --continue\n"
2444 "\n"), command_line);
2445 status = 1;
2446 }
2447
2448 argv_array_clear(&child_env);
2449
2450 return status;
2451}
2452
2453static int is_final_fixup(struct todo_list *todo_list)
2454{
2455 int i = todo_list->current;
2456
2457 if (!is_fixup(todo_list->items[i].command))
2458 return 0;
2459
2460 while (++i < todo_list->nr)
2461 if (is_fixup(todo_list->items[i].command))
2462 return 0;
2463 else if (!is_noop(todo_list->items[i].command))
2464 break;
2465 return 1;
2466}
2467
2468static enum todo_command peek_command(struct todo_list *todo_list, int offset)
2469{
2470 int i;
2471
2472 for (i = todo_list->current + offset; i < todo_list->nr; i++)
2473 if (!is_noop(todo_list->items[i].command))
2474 return todo_list->items[i].command;
2475
2476 return -1;
2477}
2478
2479static int apply_autostash(struct replay_opts *opts)
2480{
2481 struct strbuf stash_sha1 = STRBUF_INIT;
2482 struct child_process child = CHILD_PROCESS_INIT;
2483 int ret = 0;
2484
2485 if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
2486 strbuf_release(&stash_sha1);
2487 return 0;
2488 }
2489 strbuf_trim(&stash_sha1);
2490
2491 child.git_cmd = 1;
2492 child.no_stdout = 1;
2493 child.no_stderr = 1;
2494 argv_array_push(&child.args, "stash");
2495 argv_array_push(&child.args, "apply");
2496 argv_array_push(&child.args, stash_sha1.buf);
2497 if (!run_command(&child))
2498 fprintf(stderr, _("Applied autostash.\n"));
2499 else {
2500 struct child_process store = CHILD_PROCESS_INIT;
2501
2502 store.git_cmd = 1;
2503 argv_array_push(&store.args, "stash");
2504 argv_array_push(&store.args, "store");
2505 argv_array_push(&store.args, "-m");
2506 argv_array_push(&store.args, "autostash");
2507 argv_array_push(&store.args, "-q");
2508 argv_array_push(&store.args, stash_sha1.buf);
2509 if (run_command(&store))
2510 ret = error(_("cannot store %s"), stash_sha1.buf);
2511 else
2512 fprintf(stderr,
2513 _("Applying autostash resulted in conflicts.\n"
2514 "Your changes are safe in the stash.\n"
2515 "You can run \"git stash pop\" or"
2516 " \"git stash drop\" at any time.\n"));
2517 }
2518
2519 strbuf_release(&stash_sha1);
2520 return ret;
2521}
2522
2523static const char *reflog_message(struct replay_opts *opts,
2524 const char *sub_action, const char *fmt, ...)
2525{
2526 va_list ap;
2527 static struct strbuf buf = STRBUF_INIT;
2528
2529 va_start(ap, fmt);
2530 strbuf_reset(&buf);
2531 strbuf_addstr(&buf, action_name(opts));
2532 if (sub_action)
2533 strbuf_addf(&buf, " (%s)", sub_action);
2534 if (fmt) {
2535 strbuf_addstr(&buf, ": ");
2536 strbuf_vaddf(&buf, fmt, ap);
2537 }
2538 va_end(ap);
2539
2540 return buf.buf;
2541}
2542
2543static int pick_commits(struct todo_list *todo_list, struct replay_opts *opts)
2544{
2545 int res = 0;
2546
2547 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
2548 if (opts->allow_ff)
2549 assert(!(opts->signoff || opts->no_commit ||
2550 opts->record_origin || opts->edit));
2551 if (read_and_refresh_cache(opts))
2552 return -1;
2553
2554 while (todo_list->current < todo_list->nr) {
2555 struct todo_item *item = todo_list->items + todo_list->current;
2556 if (save_todo(todo_list, opts))
2557 return -1;
2558 if (is_rebase_i(opts)) {
2559 if (item->command != TODO_COMMENT) {
2560 FILE *f = fopen(rebase_path_msgnum(), "w");
2561
2562 todo_list->done_nr++;
2563
2564 if (f) {
2565 fprintf(f, "%d\n", todo_list->done_nr);
2566 fclose(f);
2567 }
2568 fprintf(stderr, "Rebasing (%d/%d)%s",
2569 todo_list->done_nr,
2570 todo_list->total_nr,
2571 opts->verbose ? "\n" : "\r");
2572 }
2573 unlink(rebase_path_message());
2574 unlink(rebase_path_author_script());
2575 unlink(rebase_path_stopped_sha());
2576 unlink(rebase_path_amend());
2577 delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
2578 }
2579 if (item->command <= TODO_SQUASH) {
2580 if (is_rebase_i(opts))
2581 setenv("GIT_REFLOG_ACTION", reflog_message(opts,
2582 command_to_string(item->command), NULL),
2583 1);
2584 res = do_pick_commit(item->command, item->commit,
2585 opts, is_final_fixup(todo_list));
2586 if (is_rebase_i(opts) && res < 0) {
2587 /* Reschedule */
2588 todo_list->current--;
2589 if (save_todo(todo_list, opts))
2590 return -1;
2591 }
2592 if (item->command == TODO_EDIT) {
2593 struct commit *commit = item->commit;
2594 if (!res)
2595 fprintf(stderr,
2596 _("Stopped at %s... %.*s\n"),
2597 short_commit_name(commit),
2598 item->arg_len, item->arg);
2599 return error_with_patch(commit,
2600 item->arg, item->arg_len, opts, res,
2601 !res);
2602 }
2603 if (is_rebase_i(opts) && !res)
2604 record_in_rewritten(&item->commit->object.oid,
2605 peek_command(todo_list, 1));
2606 if (res && is_fixup(item->command)) {
2607 if (res == 1)
2608 intend_to_amend();
2609 return error_failed_squash(item->commit, opts,
2610 item->arg_len, item->arg);
2611 } else if (res && is_rebase_i(opts))
2612 return res | error_with_patch(item->commit,
2613 item->arg, item->arg_len, opts, res,
2614 item->command == TODO_REWORD);
2615 } else if (item->command == TODO_EXEC) {
2616 char *end_of_arg = (char *)(item->arg + item->arg_len);
2617 int saved = *end_of_arg;
2618 struct stat st;
2619
2620 *end_of_arg = '\0';
2621 res = do_exec(item->arg);
2622 *end_of_arg = saved;
2623
2624 /* Reread the todo file if it has changed. */
2625 if (res)
2626 ; /* fall through */
2627 else if (stat(get_todo_path(opts), &st))
2628 res = error_errno(_("could not stat '%s'"),
2629 get_todo_path(opts));
2630 else if (match_stat_data(&todo_list->stat, &st)) {
2631 todo_list_release(todo_list);
2632 if (read_populate_todo(todo_list, opts))
2633 res = -1; /* message was printed */
2634 /* `current` will be incremented below */
2635 todo_list->current = -1;
2636 }
2637 } else if (!is_noop(item->command))
2638 return error(_("unknown command %d"), item->command);
2639
2640 todo_list->current++;
2641 if (res)
2642 return res;
2643 }
2644
2645 if (is_rebase_i(opts)) {
2646 struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
2647 struct stat st;
2648
2649 /* Stopped in the middle, as planned? */
2650 if (todo_list->current < todo_list->nr)
2651 return 0;
2652
2653 if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
2654 starts_with(head_ref.buf, "refs/")) {
2655 const char *msg;
2656 struct object_id head, orig;
2657 int res;
2658
2659 if (get_oid("HEAD", &head)) {
2660 res = error(_("cannot read HEAD"));
2661cleanup_head_ref:
2662 strbuf_release(&head_ref);
2663 strbuf_release(&buf);
2664 return res;
2665 }
2666 if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
2667 get_oid_hex(buf.buf, &orig)) {
2668 res = error(_("could not read orig-head"));
2669 goto cleanup_head_ref;
2670 }
2671 strbuf_reset(&buf);
2672 if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
2673 res = error(_("could not read 'onto'"));
2674 goto cleanup_head_ref;
2675 }
2676 msg = reflog_message(opts, "finish", "%s onto %s",
2677 head_ref.buf, buf.buf);
2678 if (update_ref(msg, head_ref.buf, &head, &orig,
2679 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
2680 res = error(_("could not update %s"),
2681 head_ref.buf);
2682 goto cleanup_head_ref;
2683 }
2684 msg = reflog_message(opts, "finish", "returning to %s",
2685 head_ref.buf);
2686 if (create_symref("HEAD", head_ref.buf, msg)) {
2687 res = error(_("could not update HEAD to %s"),
2688 head_ref.buf);
2689 goto cleanup_head_ref;
2690 }
2691 strbuf_reset(&buf);
2692 }
2693
2694 if (opts->verbose) {
2695 struct rev_info log_tree_opt;
2696 struct object_id orig, head;
2697
2698 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
2699 init_revisions(&log_tree_opt, NULL);
2700 log_tree_opt.diff = 1;
2701 log_tree_opt.diffopt.output_format =
2702 DIFF_FORMAT_DIFFSTAT;
2703 log_tree_opt.disable_stdin = 1;
2704
2705 if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
2706 !get_oid(buf.buf, &orig) &&
2707 !get_oid("HEAD", &head)) {
2708 diff_tree_oid(&orig, &head, "",
2709 &log_tree_opt.diffopt);
2710 log_tree_diff_flush(&log_tree_opt);
2711 }
2712 }
2713 flush_rewritten_pending();
2714 if (!stat(rebase_path_rewritten_list(), &st) &&
2715 st.st_size > 0) {
2716 struct child_process child = CHILD_PROCESS_INIT;
2717 const char *post_rewrite_hook =
2718 find_hook("post-rewrite");
2719
2720 child.in = open(rebase_path_rewritten_list(), O_RDONLY);
2721 child.git_cmd = 1;
2722 argv_array_push(&child.args, "notes");
2723 argv_array_push(&child.args, "copy");
2724 argv_array_push(&child.args, "--for-rewrite=rebase");
2725 /* we don't care if this copying failed */
2726 run_command(&child);
2727
2728 if (post_rewrite_hook) {
2729 struct child_process hook = CHILD_PROCESS_INIT;
2730
2731 hook.in = open(rebase_path_rewritten_list(),
2732 O_RDONLY);
2733 hook.stdout_to_stderr = 1;
2734 argv_array_push(&hook.args, post_rewrite_hook);
2735 argv_array_push(&hook.args, "rebase");
2736 /* we don't care if this hook failed */
2737 run_command(&hook);
2738 }
2739 }
2740 apply_autostash(opts);
2741
2742 fprintf(stderr, "Successfully rebased and updated %s.\n",
2743 head_ref.buf);
2744
2745 strbuf_release(&buf);
2746 strbuf_release(&head_ref);
2747 }
2748
2749 /*
2750 * Sequence of picks finished successfully; cleanup by
2751 * removing the .git/sequencer directory
2752 */
2753 return sequencer_remove_state(opts);
2754}
2755
2756static int continue_single_pick(void)
2757{
2758 const char *argv[] = { "commit", NULL };
2759
2760 if (!file_exists(git_path_cherry_pick_head()) &&
2761 !file_exists(git_path_revert_head()))
2762 return error(_("no cherry-pick or revert in progress"));
2763 return run_command_v_opt(argv, RUN_GIT_CMD);
2764}
2765
2766static int commit_staged_changes(struct replay_opts *opts)
2767{
2768 unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
2769
2770 if (has_unstaged_changes(1))
2771 return error(_("cannot rebase: You have unstaged changes."));
2772 if (!has_uncommitted_changes(0)) {
2773 const char *cherry_pick_head = git_path_cherry_pick_head();
2774
2775 if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
2776 return error(_("could not remove CHERRY_PICK_HEAD"));
2777 return 0;
2778 }
2779
2780 if (file_exists(rebase_path_amend())) {
2781 struct strbuf rev = STRBUF_INIT;
2782 struct object_id head, to_amend;
2783
2784 if (get_oid("HEAD", &head))
2785 return error(_("cannot amend non-existing commit"));
2786 if (!read_oneliner(&rev, rebase_path_amend(), 0))
2787 return error(_("invalid file: '%s'"), rebase_path_amend());
2788 if (get_oid_hex(rev.buf, &to_amend))
2789 return error(_("invalid contents: '%s'"),
2790 rebase_path_amend());
2791 if (oidcmp(&head, &to_amend))
2792 return error(_("\nYou have uncommitted changes in your "
2793 "working tree. Please, commit them\n"
2794 "first and then run 'git rebase "
2795 "--continue' again."));
2796
2797 strbuf_release(&rev);
2798 flags |= AMEND_MSG;
2799 }
2800
2801 if (run_git_commit(rebase_path_message(), opts, flags))
2802 return error(_("could not commit staged changes."));
2803 unlink(rebase_path_amend());
2804 return 0;
2805}
2806
2807int sequencer_continue(struct replay_opts *opts)
2808{
2809 struct todo_list todo_list = TODO_LIST_INIT;
2810 int res;
2811
2812 if (read_and_refresh_cache(opts))
2813 return -1;
2814
2815 if (is_rebase_i(opts)) {
2816 if (commit_staged_changes(opts))
2817 return -1;
2818 } else if (!file_exists(get_todo_path(opts)))
2819 return continue_single_pick();
2820 if (read_populate_opts(opts))
2821 return -1;
2822 if ((res = read_populate_todo(&todo_list, opts)))
2823 goto release_todo_list;
2824
2825 if (!is_rebase_i(opts)) {
2826 /* Verify that the conflict has been resolved */
2827 if (file_exists(git_path_cherry_pick_head()) ||
2828 file_exists(git_path_revert_head())) {
2829 res = continue_single_pick();
2830 if (res)
2831 goto release_todo_list;
2832 }
2833 if (index_differs_from("HEAD", NULL, 0)) {
2834 res = error_dirty_index(opts);
2835 goto release_todo_list;
2836 }
2837 todo_list.current++;
2838 } else if (file_exists(rebase_path_stopped_sha())) {
2839 struct strbuf buf = STRBUF_INIT;
2840 struct object_id oid;
2841
2842 if (read_oneliner(&buf, rebase_path_stopped_sha(), 1) &&
2843 !get_oid_committish(buf.buf, &oid))
2844 record_in_rewritten(&oid, peek_command(&todo_list, 0));
2845 strbuf_release(&buf);
2846 }
2847
2848 res = pick_commits(&todo_list, opts);
2849release_todo_list:
2850 todo_list_release(&todo_list);
2851 return res;
2852}
2853
2854static int single_pick(struct commit *cmit, struct replay_opts *opts)
2855{
2856 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
2857 return do_pick_commit(opts->action == REPLAY_PICK ?
2858 TODO_PICK : TODO_REVERT, cmit, opts, 0);
2859}
2860
2861int sequencer_pick_revisions(struct replay_opts *opts)
2862{
2863 struct todo_list todo_list = TODO_LIST_INIT;
2864 struct object_id oid;
2865 int i, res;
2866
2867 assert(opts->revs);
2868 if (read_and_refresh_cache(opts))
2869 return -1;
2870
2871 for (i = 0; i < opts->revs->pending.nr; i++) {
2872 struct object_id oid;
2873 const char *name = opts->revs->pending.objects[i].name;
2874
2875 /* This happens when using --stdin. */
2876 if (!strlen(name))
2877 continue;
2878
2879 if (!get_oid(name, &oid)) {
2880 if (!lookup_commit_reference_gently(&oid, 1)) {
2881 enum object_type type = sha1_object_info(oid.hash, NULL);
2882 return error(_("%s: can't cherry-pick a %s"),
2883 name, type_name(type));
2884 }
2885 } else
2886 return error(_("%s: bad revision"), name);
2887 }
2888
2889 /*
2890 * If we were called as "git cherry-pick <commit>", just
2891 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
2892 * REVERT_HEAD, and don't touch the sequencer state.
2893 * This means it is possible to cherry-pick in the middle
2894 * of a cherry-pick sequence.
2895 */
2896 if (opts->revs->cmdline.nr == 1 &&
2897 opts->revs->cmdline.rev->whence == REV_CMD_REV &&
2898 opts->revs->no_walk &&
2899 !opts->revs->cmdline.rev->flags) {
2900 struct commit *cmit;
2901 if (prepare_revision_walk(opts->revs))
2902 return error(_("revision walk setup failed"));
2903 cmit = get_revision(opts->revs);
2904 if (!cmit || get_revision(opts->revs))
2905 return error("BUG: expected exactly one commit from walk");
2906 return single_pick(cmit, opts);
2907 }
2908
2909 /*
2910 * Start a new cherry-pick/ revert sequence; but
2911 * first, make sure that an existing one isn't in
2912 * progress
2913 */
2914
2915 if (walk_revs_populate_todo(&todo_list, opts) ||
2916 create_seq_dir() < 0)
2917 return -1;
2918 if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
2919 return error(_("can't revert as initial commit"));
2920 if (save_head(oid_to_hex(&oid)))
2921 return -1;
2922 if (save_opts(opts))
2923 return -1;
2924 update_abort_safety_file();
2925 res = pick_commits(&todo_list, opts);
2926 todo_list_release(&todo_list);
2927 return res;
2928}
2929
2930void append_signoff(struct strbuf *msgbuf, int ignore_footer, unsigned flag)
2931{
2932 unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
2933 struct strbuf sob = STRBUF_INIT;
2934 int has_footer;
2935
2936 strbuf_addstr(&sob, sign_off_header);
2937 strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
2938 getenv("GIT_COMMITTER_EMAIL")));
2939 strbuf_addch(&sob, '\n');
2940
2941 if (!ignore_footer)
2942 strbuf_complete_line(msgbuf);
2943
2944 /*
2945 * If the whole message buffer is equal to the sob, pretend that we
2946 * found a conforming footer with a matching sob
2947 */
2948 if (msgbuf->len - ignore_footer == sob.len &&
2949 !strncmp(msgbuf->buf, sob.buf, sob.len))
2950 has_footer = 3;
2951 else
2952 has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
2953
2954 if (!has_footer) {
2955 const char *append_newlines = NULL;
2956 size_t len = msgbuf->len - ignore_footer;
2957
2958 if (!len) {
2959 /*
2960 * The buffer is completely empty. Leave foom for
2961 * the title and body to be filled in by the user.
2962 */
2963 append_newlines = "\n\n";
2964 } else if (len == 1) {
2965 /*
2966 * Buffer contains a single newline. Add another
2967 * so that we leave room for the title and body.
2968 */
2969 append_newlines = "\n";
2970 } else if (msgbuf->buf[len - 2] != '\n') {
2971 /*
2972 * Buffer ends with a single newline. Add another
2973 * so that there is an empty line between the message
2974 * body and the sob.
2975 */
2976 append_newlines = "\n";
2977 } /* else, the buffer already ends with two newlines. */
2978
2979 if (append_newlines)
2980 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
2981 append_newlines, strlen(append_newlines));
2982 }
2983
2984 if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
2985 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
2986 sob.buf, sob.len);
2987
2988 strbuf_release(&sob);
2989}
2990
2991int sequencer_make_script(FILE *out, int argc, const char **argv,
2992 unsigned flags)
2993{
2994 char *format = NULL;
2995 struct pretty_print_context pp = {0};
2996 struct strbuf buf = STRBUF_INIT;
2997 struct rev_info revs;
2998 struct commit *commit;
2999 int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
3000 const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";
3001
3002 init_revisions(&revs, NULL);
3003 revs.verbose_header = 1;
3004 revs.max_parents = 1;
3005 revs.cherry_pick = 1;
3006 revs.limited = 1;
3007 revs.reverse = 1;
3008 revs.right_only = 1;
3009 revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
3010 revs.topo_order = 1;
3011
3012 revs.pretty_given = 1;
3013 git_config_get_string("rebase.instructionFormat", &format);
3014 if (!format || !*format) {
3015 free(format);
3016 format = xstrdup("%s");
3017 }
3018 get_commit_format(format, &revs);
3019 free(format);
3020 pp.fmt = revs.commit_format;
3021 pp.output_encoding = get_log_output_encoding();
3022
3023 if (setup_revisions(argc, argv, &revs, NULL) > 1)
3024 return error(_("make_script: unhandled options"));
3025
3026 if (prepare_revision_walk(&revs) < 0)
3027 return error(_("make_script: error preparing revisions"));
3028
3029 while ((commit = get_revision(&revs))) {
3030 strbuf_reset(&buf);
3031 if (!keep_empty && is_original_commit_empty(commit))
3032 strbuf_addf(&buf, "%c ", comment_line_char);
3033 strbuf_addf(&buf, "%s %s ", insn,
3034 oid_to_hex(&commit->object.oid));
3035 pretty_print_commit(&pp, commit, &buf);
3036 strbuf_addch(&buf, '\n');
3037 fputs(buf.buf, out);
3038 }
3039 strbuf_release(&buf);
3040 return 0;
3041}
3042
3043/*
3044 * Add commands after pick and (series of) squash/fixup commands
3045 * in the todo list.
3046 */
3047int sequencer_add_exec_commands(const char *commands)
3048{
3049 const char *todo_file = rebase_path_todo();
3050 struct todo_list todo_list = TODO_LIST_INIT;
3051 struct todo_item *item;
3052 struct strbuf *buf = &todo_list.buf;
3053 size_t offset = 0, commands_len = strlen(commands);
3054 int i, first;
3055
3056 if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
3057 return error(_("could not read '%s'."), todo_file);
3058
3059 if (parse_insn_buffer(todo_list.buf.buf, &todo_list)) {
3060 todo_list_release(&todo_list);
3061 return error(_("unusable todo list: '%s'"), todo_file);
3062 }
3063
3064 first = 1;
3065 /* insert <commands> before every pick except the first one */
3066 for (item = todo_list.items, i = 0; i < todo_list.nr; i++, item++) {
3067 if (item->command == TODO_PICK && !first) {
3068 strbuf_insert(buf, item->offset_in_buf + offset,
3069 commands, commands_len);
3070 offset += commands_len;
3071 }
3072 first = 0;
3073 }
3074
3075 /* append final <commands> */
3076 strbuf_add(buf, commands, commands_len);
3077
3078 i = write_message(buf->buf, buf->len, todo_file, 0);
3079 todo_list_release(&todo_list);
3080 return i;
3081}
3082
3083int transform_todos(unsigned flags)
3084{
3085 const char *todo_file = rebase_path_todo();
3086 struct todo_list todo_list = TODO_LIST_INIT;
3087 struct strbuf buf = STRBUF_INIT;
3088 struct todo_item *item;
3089 int i;
3090
3091 if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
3092 return error(_("could not read '%s'."), todo_file);
3093
3094 if (parse_insn_buffer(todo_list.buf.buf, &todo_list)) {
3095 todo_list_release(&todo_list);
3096 return error(_("unusable todo list: '%s'"), todo_file);
3097 }
3098
3099 for (item = todo_list.items, i = 0; i < todo_list.nr; i++, item++) {
3100 /* if the item is not a command write it and continue */
3101 if (item->command >= TODO_COMMENT) {
3102 strbuf_addf(&buf, "%.*s\n", item->arg_len, item->arg);
3103 continue;
3104 }
3105
3106 /* add command to the buffer */
3107 if (flags & TODO_LIST_ABBREVIATE_CMDS)
3108 strbuf_addch(&buf, command_to_char(item->command));
3109 else
3110 strbuf_addstr(&buf, command_to_string(item->command));
3111
3112 /* add commit id */
3113 if (item->commit) {
3114 const char *oid = flags & TODO_LIST_SHORTEN_IDS ?
3115 short_commit_name(item->commit) :
3116 oid_to_hex(&item->commit->object.oid);
3117
3118 strbuf_addf(&buf, " %s", oid);
3119 }
3120 /* add all the rest */
3121 if (!item->arg_len)
3122 strbuf_addch(&buf, '\n');
3123 else
3124 strbuf_addf(&buf, " %.*s\n", item->arg_len, item->arg);
3125 }
3126
3127 i = write_message(buf.buf, buf.len, todo_file, 0);
3128 todo_list_release(&todo_list);
3129 return i;
3130}
3131
3132enum check_level {
3133 CHECK_IGNORE = 0, CHECK_WARN, CHECK_ERROR
3134};
3135
3136static enum check_level get_missing_commit_check_level(void)
3137{
3138 const char *value;
3139
3140 if (git_config_get_value("rebase.missingcommitscheck", &value) ||
3141 !strcasecmp("ignore", value))
3142 return CHECK_IGNORE;
3143 if (!strcasecmp("warn", value))
3144 return CHECK_WARN;
3145 if (!strcasecmp("error", value))
3146 return CHECK_ERROR;
3147 warning(_("unrecognized setting %s for option "
3148 "rebase.missingCommitsCheck. Ignoring."), value);
3149 return CHECK_IGNORE;
3150}
3151
3152/*
3153 * Check if the user dropped some commits by mistake
3154 * Behaviour determined by rebase.missingCommitsCheck.
3155 * Check if there is an unrecognized command or a
3156 * bad SHA-1 in a command.
3157 */
3158int check_todo_list(void)
3159{
3160 enum check_level check_level = get_missing_commit_check_level();
3161 struct strbuf todo_file = STRBUF_INIT;
3162 struct todo_list todo_list = TODO_LIST_INIT;
3163 struct strbuf missing = STRBUF_INIT;
3164 int advise_to_edit_todo = 0, res = 0, i;
3165
3166 strbuf_addstr(&todo_file, rebase_path_todo());
3167 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file.buf) < 0) {
3168 res = -1;
3169 goto leave_check;
3170 }
3171 advise_to_edit_todo = res =
3172 parse_insn_buffer(todo_list.buf.buf, &todo_list);
3173
3174 if (res || check_level == CHECK_IGNORE)
3175 goto leave_check;
3176
3177 /* Mark the commits in git-rebase-todo as seen */
3178 for (i = 0; i < todo_list.nr; i++) {
3179 struct commit *commit = todo_list.items[i].commit;
3180 if (commit)
3181 commit->util = (void *)1;
3182 }
3183
3184 todo_list_release(&todo_list);
3185 strbuf_addstr(&todo_file, ".backup");
3186 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file.buf) < 0) {
3187 res = -1;
3188 goto leave_check;
3189 }
3190 strbuf_release(&todo_file);
3191 res = !!parse_insn_buffer(todo_list.buf.buf, &todo_list);
3192
3193 /* Find commits in git-rebase-todo.backup yet unseen */
3194 for (i = todo_list.nr - 1; i >= 0; i--) {
3195 struct todo_item *item = todo_list.items + i;
3196 struct commit *commit = item->commit;
3197 if (commit && !commit->util) {
3198 strbuf_addf(&missing, " - %s %.*s\n",
3199 short_commit_name(commit),
3200 item->arg_len, item->arg);
3201 commit->util = (void *)1;
3202 }
3203 }
3204
3205 /* Warn about missing commits */
3206 if (!missing.len)
3207 goto leave_check;
3208
3209 if (check_level == CHECK_ERROR)
3210 advise_to_edit_todo = res = 1;
3211
3212 fprintf(stderr,
3213 _("Warning: some commits may have been dropped accidentally.\n"
3214 "Dropped commits (newer to older):\n"));
3215
3216 /* Make the list user-friendly and display */
3217 fputs(missing.buf, stderr);
3218 strbuf_release(&missing);
3219
3220 fprintf(stderr, _("To avoid this message, use \"drop\" to "
3221 "explicitly remove a commit.\n\n"
3222 "Use 'git config rebase.missingCommitsCheck' to change "
3223 "the level of warnings.\n"
3224 "The possible behaviours are: ignore, warn, error.\n\n"));
3225
3226leave_check:
3227 strbuf_release(&todo_file);
3228 todo_list_release(&todo_list);
3229
3230 if (advise_to_edit_todo)
3231 fprintf(stderr,
3232 _("You can fix this with 'git rebase --edit-todo' "
3233 "and then run 'git rebase --continue'.\n"
3234 "Or you can abort the rebase with 'git rebase"
3235 " --abort'.\n"));
3236
3237 return res;
3238}
3239
3240static int rewrite_file(const char *path, const char *buf, size_t len)
3241{
3242 int rc = 0;
3243 int fd = open(path, O_WRONLY | O_TRUNC);
3244 if (fd < 0)
3245 return error_errno(_("could not open '%s' for writing"), path);
3246 if (write_in_full(fd, buf, len) < 0)
3247 rc = error_errno(_("could not write to '%s'"), path);
3248 if (close(fd) && !rc)
3249 rc = error_errno(_("could not close '%s'"), path);
3250 return rc;
3251}
3252
3253/* skip picking commits whose parents are unchanged */
3254int skip_unnecessary_picks(void)
3255{
3256 const char *todo_file = rebase_path_todo();
3257 struct strbuf buf = STRBUF_INIT;
3258 struct todo_list todo_list = TODO_LIST_INIT;
3259 struct object_id onto_oid, *oid = &onto_oid, *parent_oid;
3260 int fd, i;
3261
3262 if (!read_oneliner(&buf, rebase_path_onto(), 0))
3263 return error(_("could not read 'onto'"));
3264 if (get_oid(buf.buf, &onto_oid)) {
3265 strbuf_release(&buf);
3266 return error(_("need a HEAD to fixup"));
3267 }
3268 strbuf_release(&buf);
3269
3270 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file) < 0)
3271 return -1;
3272 if (parse_insn_buffer(todo_list.buf.buf, &todo_list) < 0) {
3273 todo_list_release(&todo_list);
3274 return -1;
3275 }
3276
3277 for (i = 0; i < todo_list.nr; i++) {
3278 struct todo_item *item = todo_list.items + i;
3279
3280 if (item->command >= TODO_NOOP)
3281 continue;
3282 if (item->command != TODO_PICK)
3283 break;
3284 if (parse_commit(item->commit)) {
3285 todo_list_release(&todo_list);
3286 return error(_("could not parse commit '%s'"),
3287 oid_to_hex(&item->commit->object.oid));
3288 }
3289 if (!item->commit->parents)
3290 break; /* root commit */
3291 if (item->commit->parents->next)
3292 break; /* merge commit */
3293 parent_oid = &item->commit->parents->item->object.oid;
3294 if (hashcmp(parent_oid->hash, oid->hash))
3295 break;
3296 oid = &item->commit->object.oid;
3297 }
3298 if (i > 0) {
3299 int offset = i < todo_list.nr ?
3300 todo_list.items[i].offset_in_buf : todo_list.buf.len;
3301 const char *done_path = rebase_path_done();
3302
3303 fd = open(done_path, O_CREAT | O_WRONLY | O_APPEND, 0666);
3304 if (fd < 0) {
3305 error_errno(_("could not open '%s' for writing"),
3306 done_path);
3307 todo_list_release(&todo_list);
3308 return -1;
3309 }
3310 if (write_in_full(fd, todo_list.buf.buf, offset) < 0) {
3311 error_errno(_("could not write to '%s'"), done_path);
3312 todo_list_release(&todo_list);
3313 close(fd);
3314 return -1;
3315 }
3316 close(fd);
3317
3318 if (rewrite_file(rebase_path_todo(), todo_list.buf.buf + offset,
3319 todo_list.buf.len - offset) < 0) {
3320 todo_list_release(&todo_list);
3321 return -1;
3322 }
3323
3324 todo_list.current = i;
3325 if (is_fixup(peek_command(&todo_list, 0)))
3326 record_in_rewritten(oid, peek_command(&todo_list, 0));
3327 }
3328
3329 todo_list_release(&todo_list);
3330 printf("%s\n", oid_to_hex(oid));
3331
3332 return 0;
3333}
3334
3335struct subject2item_entry {
3336 struct hashmap_entry entry;
3337 int i;
3338 char subject[FLEX_ARRAY];
3339};
3340
3341static int subject2item_cmp(const void *fndata,
3342 const struct subject2item_entry *a,
3343 const struct subject2item_entry *b, const void *key)
3344{
3345 return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
3346}
3347
3348/*
3349 * Rearrange the todo list that has both "pick commit-id msg" and "pick
3350 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
3351 * after the former, and change "pick" to "fixup"/"squash".
3352 *
3353 * Note that if the config has specified a custom instruction format, each log
3354 * message will have to be retrieved from the commit (as the oneline in the
3355 * script cannot be trusted) in order to normalize the autosquash arrangement.
3356 */
3357int rearrange_squash(void)
3358{
3359 const char *todo_file = rebase_path_todo();
3360 struct todo_list todo_list = TODO_LIST_INIT;
3361 struct hashmap subject2item;
3362 int res = 0, rearranged = 0, *next, *tail, i;
3363 char **subjects;
3364
3365 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file) < 0)
3366 return -1;
3367 if (parse_insn_buffer(todo_list.buf.buf, &todo_list) < 0) {
3368 todo_list_release(&todo_list);
3369 return -1;
3370 }
3371
3372 /*
3373 * The hashmap maps onelines to the respective todo list index.
3374 *
3375 * If any items need to be rearranged, the next[i] value will indicate
3376 * which item was moved directly after the i'th.
3377 *
3378 * In that case, last[i] will indicate the index of the latest item to
3379 * be moved to appear after the i'th.
3380 */
3381 hashmap_init(&subject2item, (hashmap_cmp_fn) subject2item_cmp,
3382 NULL, todo_list.nr);
3383 ALLOC_ARRAY(next, todo_list.nr);
3384 ALLOC_ARRAY(tail, todo_list.nr);
3385 ALLOC_ARRAY(subjects, todo_list.nr);
3386 for (i = 0; i < todo_list.nr; i++) {
3387 struct strbuf buf = STRBUF_INIT;
3388 struct todo_item *item = todo_list.items + i;
3389 const char *commit_buffer, *subject, *p;
3390 size_t subject_len;
3391 int i2 = -1;
3392 struct subject2item_entry *entry;
3393
3394 next[i] = tail[i] = -1;
3395 if (item->command >= TODO_EXEC) {
3396 subjects[i] = NULL;
3397 continue;
3398 }
3399
3400 if (is_fixup(item->command)) {
3401 todo_list_release(&todo_list);
3402 return error(_("the script was already rearranged."));
3403 }
3404
3405 item->commit->util = item;
3406
3407 parse_commit(item->commit);
3408 commit_buffer = get_commit_buffer(item->commit, NULL);
3409 find_commit_subject(commit_buffer, &subject);
3410 format_subject(&buf, subject, " ");
3411 subject = subjects[i] = strbuf_detach(&buf, &subject_len);
3412 unuse_commit_buffer(item->commit, commit_buffer);
3413 if ((skip_prefix(subject, "fixup! ", &p) ||
3414 skip_prefix(subject, "squash! ", &p))) {
3415 struct commit *commit2;
3416
3417 for (;;) {
3418 while (isspace(*p))
3419 p++;
3420 if (!skip_prefix(p, "fixup! ", &p) &&
3421 !skip_prefix(p, "squash! ", &p))
3422 break;
3423 }
3424
3425 if ((entry = hashmap_get_from_hash(&subject2item,
3426 strhash(p), p)))
3427 /* found by title */
3428 i2 = entry->i;
3429 else if (!strchr(p, ' ') &&
3430 (commit2 =
3431 lookup_commit_reference_by_name(p)) &&
3432 commit2->util)
3433 /* found by commit name */
3434 i2 = (struct todo_item *)commit2->util
3435 - todo_list.items;
3436 else {
3437 /* copy can be a prefix of the commit subject */
3438 for (i2 = 0; i2 < i; i2++)
3439 if (subjects[i2] &&
3440 starts_with(subjects[i2], p))
3441 break;
3442 if (i2 == i)
3443 i2 = -1;
3444 }
3445 }
3446 if (i2 >= 0) {
3447 rearranged = 1;
3448 todo_list.items[i].command =
3449 starts_with(subject, "fixup!") ?
3450 TODO_FIXUP : TODO_SQUASH;
3451 if (next[i2] < 0)
3452 next[i2] = i;
3453 else
3454 next[tail[i2]] = i;
3455 tail[i2] = i;
3456 } else if (!hashmap_get_from_hash(&subject2item,
3457 strhash(subject), subject)) {
3458 FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
3459 entry->i = i;
3460 hashmap_entry_init(entry, strhash(entry->subject));
3461 hashmap_put(&subject2item, entry);
3462 }
3463 }
3464
3465 if (rearranged) {
3466 struct strbuf buf = STRBUF_INIT;
3467
3468 for (i = 0; i < todo_list.nr; i++) {
3469 enum todo_command command = todo_list.items[i].command;
3470 int cur = i;
3471
3472 /*
3473 * Initially, all commands are 'pick's. If it is a
3474 * fixup or a squash now, we have rearranged it.
3475 */
3476 if (is_fixup(command))
3477 continue;
3478
3479 while (cur >= 0) {
3480 int offset = todo_list.items[cur].offset_in_buf;
3481 int end_offset = cur + 1 < todo_list.nr ?
3482 todo_list.items[cur + 1].offset_in_buf :
3483 todo_list.buf.len;
3484 char *bol = todo_list.buf.buf + offset;
3485 char *eol = todo_list.buf.buf + end_offset;
3486
3487 /* replace 'pick', by 'fixup' or 'squash' */
3488 command = todo_list.items[cur].command;
3489 if (is_fixup(command)) {
3490 strbuf_addstr(&buf,
3491 todo_command_info[command].str);
3492 bol += strcspn(bol, " \t");
3493 }
3494
3495 strbuf_add(&buf, bol, eol - bol);
3496
3497 cur = next[cur];
3498 }
3499 }
3500
3501 res = rewrite_file(todo_file, buf.buf, buf.len);
3502 strbuf_release(&buf);
3503 }
3504
3505 free(next);
3506 free(tail);
3507 for (i = 0; i < todo_list.nr; i++)
3508 free(subjects[i]);
3509 free(subjects);
3510 hashmap_free(&subject2item, 1);
3511 todo_list_release(&todo_list);
3512
3513 return res;
3514}