9 #include "run-command.h"
12 #include "cache-tree.h"
16 #include "merge-recursive.h"
18 #include "argv-array.h"
22 #include "wt-status.h"
25 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
27 const char sign_off_header
[] = "Signed-off-by: ";
28 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
30 GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
32 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
33 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
34 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
35 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
37 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
39 * The file containing rebase commands, comments, and empty lines.
40 * This file is created by "git rebase -i" then edited by the user. As
41 * the lines are processed, they are removed from the front of this
42 * file and written to the tail of 'done'.
44 static GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
46 * The rebase command lines that have already been processed. A line
47 * is moved here when it is first handled, before any associated user
50 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
52 * The file to keep track of how many commands were already processed (e.g.
55 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum");
57 * The file to keep track of how many commands are to be processed in total
58 * (e.g. for the prompt).
60 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end");
62 * The commit message that is planned to be used for any changes that
63 * need to be committed following a user interaction.
65 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
67 * The file into which is accumulated the suggested commit message for
68 * squash/fixup commands. When the first of a series of squash/fixups
69 * is seen, the file is created and the commit message from the
70 * previous commit and from the first squash/fixup commit are written
71 * to it. The commit message for each subsequent squash/fixup commit
72 * is appended to the file as it is processed.
74 * The first line of the file is of the form
75 * # This is a combination of $count commits.
76 * where $count is the number of commits whose messages have been
77 * written to the file so far (including the initial "pick" commit).
78 * Each time that a commit message is processed, this line is read and
79 * updated. It is deleted just before the combined commit is made.
81 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
83 * If the current series of squash/fixups has not yet included a squash
84 * command, then this file exists and holds the commit message of the
85 * original "pick" commit. (If the series ends without a "squash"
86 * command, then this can be used as the commit message of the combined
87 * commit without opening the editor.)
89 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
91 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
92 * GIT_AUTHOR_DATE that will be used for the commit that is currently
95 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
97 * When an "edit" rebase command is being processed, the SHA1 of the
98 * commit to be edited is recorded in this file. When "git rebase
99 * --continue" is executed, if there are any staged changes then they
100 * will be amended to the HEAD commit, but only provided the HEAD
101 * commit is still the commit to be edited. When any other rebase
102 * command is processed, this file is deleted.
104 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
106 * When we stop at a given patch via the "edit" command, this file contains
107 * the abbreviated commit name of the corresponding patch.
109 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
111 * For the post-rewrite hook, we make a list of rewritten commits and
112 * their new sha1s. The rewritten-pending list keeps the sha1s of
113 * commits that have been processed, but not committed yet,
114 * e.g. because they are waiting for a 'squash' command.
116 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
117 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
118 "rebase-merge/rewritten-pending")
120 * The following files are written by git-rebase just after parsing the
121 * command-line (and are only consumed, not modified, by the sequencer).
123 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
124 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
125 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
126 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
127 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
128 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
129 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
130 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
131 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
133 static inline int is_rebase_i(const struct replay_opts
*opts
)
135 return opts
->action
== REPLAY_INTERACTIVE_REBASE
;
138 static const char *get_dir(const struct replay_opts
*opts
)
140 if (is_rebase_i(opts
))
141 return rebase_path();
142 return git_path_seq_dir();
145 static const char *get_todo_path(const struct replay_opts
*opts
)
147 if (is_rebase_i(opts
))
148 return rebase_path_todo();
149 return git_path_todo_file();
153 * Returns 0 for non-conforming footer
154 * Returns 1 for conforming footer
155 * Returns 2 when sob exists within conforming footer
156 * Returns 3 when sob exists within conforming footer as last entry
158 static int has_conforming_footer(struct strbuf
*sb
, struct strbuf
*sob
,
161 struct trailer_info info
;
163 int found_sob
= 0, found_sob_last
= 0;
165 trailer_info_get(&info
, sb
->buf
);
167 if (info
.trailer_start
== info
.trailer_end
)
170 for (i
= 0; i
< info
.trailer_nr
; i
++)
171 if (sob
&& !strncmp(info
.trailers
[i
], sob
->buf
, sob
->len
)) {
173 if (i
== info
.trailer_nr
- 1)
177 trailer_info_release(&info
);
186 static const char *gpg_sign_opt_quoted(struct replay_opts
*opts
)
188 static struct strbuf buf
= STRBUF_INIT
;
192 sq_quotef(&buf
, "-S%s", opts
->gpg_sign
);
196 int sequencer_remove_state(struct replay_opts
*opts
)
198 struct strbuf dir
= STRBUF_INIT
;
201 free(opts
->gpg_sign
);
202 free(opts
->strategy
);
203 for (i
= 0; i
< opts
->xopts_nr
; i
++)
204 free(opts
->xopts
[i
]);
207 strbuf_addstr(&dir
, get_dir(opts
));
208 remove_dir_recursively(&dir
, 0);
209 strbuf_release(&dir
);
214 static const char *action_name(const struct replay_opts
*opts
)
216 switch (opts
->action
) {
220 return N_("cherry-pick");
221 case REPLAY_INTERACTIVE_REBASE
:
222 return N_("rebase -i");
224 die(_("Unknown action: %d"), opts
->action
);
227 struct commit_message
{
234 static const char *short_commit_name(struct commit
*commit
)
236 return find_unique_abbrev(commit
->object
.oid
.hash
, DEFAULT_ABBREV
);
239 static int get_message(struct commit
*commit
, struct commit_message
*out
)
241 const char *abbrev
, *subject
;
244 out
->message
= logmsg_reencode(commit
, NULL
, get_commit_output_encoding());
245 abbrev
= short_commit_name(commit
);
247 subject_len
= find_commit_subject(out
->message
, &subject
);
249 out
->subject
= xmemdupz(subject
, subject_len
);
250 out
->label
= xstrfmt("%s... %s", abbrev
, out
->subject
);
251 out
->parent_label
= xstrfmt("parent of %s", out
->label
);
256 static void free_message(struct commit
*commit
, struct commit_message
*msg
)
258 free(msg
->parent_label
);
261 unuse_commit_buffer(commit
, msg
->message
);
264 static void print_advice(int show_hint
, struct replay_opts
*opts
)
266 char *msg
= getenv("GIT_CHERRY_PICK_HELP");
269 fprintf(stderr
, "%s\n", msg
);
271 * A conflict has occurred but the porcelain
272 * (typically rebase --interactive) wants to take care
273 * of the commit itself so remove CHERRY_PICK_HEAD
275 unlink(git_path_cherry_pick_head());
281 advise(_("after resolving the conflicts, mark the corrected paths\n"
282 "with 'git add <paths>' or 'git rm <paths>'"));
284 advise(_("after resolving the conflicts, mark the corrected paths\n"
285 "with 'git add <paths>' or 'git rm <paths>'\n"
286 "and commit the result with 'git commit'"));
290 static int write_message(const void *buf
, size_t len
, const char *filename
,
293 static struct lock_file msg_file
;
295 int msg_fd
= hold_lock_file_for_update(&msg_file
, filename
, 0);
297 return error_errno(_("could not lock '%s'"), filename
);
298 if (write_in_full(msg_fd
, buf
, len
) < 0) {
299 rollback_lock_file(&msg_file
);
300 return error_errno(_("could not write to '%s'"), filename
);
302 if (append_eol
&& write(msg_fd
, "\n", 1) < 0) {
303 rollback_lock_file(&msg_file
);
304 return error_errno(_("could not write eol to '%s'"), filename
);
306 if (commit_lock_file(&msg_file
) < 0) {
307 rollback_lock_file(&msg_file
);
308 return error(_("failed to finalize '%s'."), filename
);
315 * Reads a file that was presumably written by a shell script, i.e. with an
316 * end-of-line marker that needs to be stripped.
318 * Note that only the last end-of-line marker is stripped, consistent with the
319 * behavior of "$(cat path)" in a shell script.
321 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
323 static int read_oneliner(struct strbuf
*buf
,
324 const char *path
, int skip_if_empty
)
326 int orig_len
= buf
->len
;
328 if (!file_exists(path
))
331 if (strbuf_read_file(buf
, path
, 0) < 0) {
332 warning_errno(_("could not read '%s'"), path
);
336 if (buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\n') {
337 if (--buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\r')
339 buf
->buf
[buf
->len
] = '\0';
342 if (skip_if_empty
&& buf
->len
== orig_len
)
348 static struct tree
*empty_tree(void)
350 return lookup_tree(&empty_tree_oid
);
353 static int error_dirty_index(struct replay_opts
*opts
)
355 if (read_cache_unmerged())
356 return error_resolve_conflict(_(action_name(opts
)));
358 error(_("your local changes would be overwritten by %s."),
359 _(action_name(opts
)));
361 if (advice_commit_before_merge
)
362 advise(_("commit your changes or stash them to proceed."));
366 static void update_abort_safety_file(void)
368 struct object_id head
;
370 /* Do nothing on a single-pick */
371 if (!file_exists(git_path_seq_dir()))
374 if (!get_oid("HEAD", &head
))
375 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head
));
377 write_file(git_path_abort_safety_file(), "%s", "");
380 static int fast_forward_to(const struct object_id
*to
, const struct object_id
*from
,
381 int unborn
, struct replay_opts
*opts
)
383 struct ref_transaction
*transaction
;
384 struct strbuf sb
= STRBUF_INIT
;
385 struct strbuf err
= STRBUF_INIT
;
388 if (checkout_fast_forward(from
, to
, 1))
389 return -1; /* the callee should have complained already */
391 strbuf_addf(&sb
, _("%s: fast-forward"), _(action_name(opts
)));
393 transaction
= ref_transaction_begin(&err
);
395 ref_transaction_update(transaction
, "HEAD",
396 to
, unborn
? &null_oid
: from
,
398 ref_transaction_commit(transaction
, &err
)) {
399 ref_transaction_free(transaction
);
400 error("%s", err
.buf
);
402 strbuf_release(&err
);
407 strbuf_release(&err
);
408 ref_transaction_free(transaction
);
409 update_abort_safety_file();
413 void append_conflicts_hint(struct strbuf
*msgbuf
)
417 strbuf_addch(msgbuf
, '\n');
418 strbuf_commented_addf(msgbuf
, "Conflicts:\n");
419 for (i
= 0; i
< active_nr
;) {
420 const struct cache_entry
*ce
= active_cache
[i
++];
422 strbuf_commented_addf(msgbuf
, "\t%s\n", ce
->name
);
423 while (i
< active_nr
&& !strcmp(ce
->name
,
424 active_cache
[i
]->name
))
430 static int do_recursive_merge(struct commit
*base
, struct commit
*next
,
431 const char *base_label
, const char *next_label
,
432 struct object_id
*head
, struct strbuf
*msgbuf
,
433 struct replay_opts
*opts
)
435 struct merge_options o
;
436 struct tree
*result
, *next_tree
, *base_tree
, *head_tree
;
439 static struct lock_file index_lock
;
441 hold_locked_index(&index_lock
, LOCK_DIE_ON_ERROR
);
445 init_merge_options(&o
);
446 o
.ancestor
= base
? base_label
: "(empty tree)";
448 o
.branch2
= next
? next_label
: "(empty tree)";
449 if (is_rebase_i(opts
))
451 o
.show_rename_progress
= 1;
453 head_tree
= parse_tree_indirect(head
);
454 next_tree
= next
? next
->tree
: empty_tree();
455 base_tree
= base
? base
->tree
: empty_tree();
457 for (xopt
= opts
->xopts
; xopt
!= opts
->xopts
+ opts
->xopts_nr
; xopt
++)
458 parse_merge_opt(&o
, *xopt
);
460 clean
= merge_trees(&o
,
462 next_tree
, base_tree
, &result
);
463 if (is_rebase_i(opts
) && clean
<= 0)
464 fputs(o
.obuf
.buf
, stdout
);
465 strbuf_release(&o
.obuf
);
466 diff_warn_rename_limit("merge.renamelimit", o
.needed_rename_limit
, 0);
470 if (active_cache_changed
&&
471 write_locked_index(&the_index
, &index_lock
, COMMIT_LOCK
))
473 * TRANSLATORS: %s will be "revert", "cherry-pick" or
476 return error(_("%s: Unable to write new index file"),
477 _(action_name(opts
)));
478 rollback_lock_file(&index_lock
);
481 append_signoff(msgbuf
, 0, 0);
484 append_conflicts_hint(msgbuf
);
489 static int is_index_unchanged(void)
491 struct object_id head_oid
;
492 struct commit
*head_commit
;
494 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
495 return error(_("could not resolve HEAD commit\n"));
497 head_commit
= lookup_commit(&head_oid
);
500 * If head_commit is NULL, check_commit, called from
501 * lookup_commit, would have indicated that head_commit is not
502 * a commit object already. parse_commit() will return failure
503 * without further complaints in such a case. Otherwise, if
504 * the commit is invalid, parse_commit() will complain. So
505 * there is nothing for us to say here. Just return failure.
507 if (parse_commit(head_commit
))
510 if (!active_cache_tree
)
511 active_cache_tree
= cache_tree();
513 if (!cache_tree_fully_valid(active_cache_tree
))
514 if (cache_tree_update(&the_index
, 0))
515 return error(_("unable to update cache tree\n"));
517 return !oidcmp(&active_cache_tree
->oid
,
518 &head_commit
->tree
->object
.oid
);
521 static int write_author_script(const char *message
)
523 struct strbuf buf
= STRBUF_INIT
;
528 if (!*message
|| starts_with(message
, "\n")) {
530 /* Missing 'author' line? */
531 unlink(rebase_path_author_script());
533 } else if (skip_prefix(message
, "author ", &message
))
535 else if ((eol
= strchr(message
, '\n')))
540 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
541 while (*message
&& *message
!= '\n' && *message
!= '\r')
542 if (skip_prefix(message
, " <", &message
))
544 else if (*message
!= '\'')
545 strbuf_addch(&buf
, *(message
++));
547 strbuf_addf(&buf
, "'\\\\%c'", *(message
++));
548 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
549 while (*message
&& *message
!= '\n' && *message
!= '\r')
550 if (skip_prefix(message
, "> ", &message
))
552 else if (*message
!= '\'')
553 strbuf_addch(&buf
, *(message
++));
555 strbuf_addf(&buf
, "'\\\\%c'", *(message
++));
556 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
557 while (*message
&& *message
!= '\n' && *message
!= '\r')
558 if (*message
!= '\'')
559 strbuf_addch(&buf
, *(message
++));
561 strbuf_addf(&buf
, "'\\\\%c'", *(message
++));
562 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
563 strbuf_release(&buf
);
568 * Read a list of environment variable assignments (such as the author-script
569 * file) into an environment block. Returns -1 on error, 0 otherwise.
571 static int read_env_script(struct argv_array
*env
)
573 struct strbuf script
= STRBUF_INIT
;
577 if (strbuf_read_file(&script
, rebase_path_author_script(), 256) <= 0)
580 for (p
= script
.buf
; *p
; p
++)
581 if (skip_prefix(p
, "'\\\\''", (const char **)&p2
))
582 strbuf_splice(&script
, p
- script
.buf
, p2
- p
, "'", 1);
584 strbuf_splice(&script
, p
-- - script
.buf
, 1, "", 0);
585 else if (*p
== '\n') {
590 for (i
= 0, p
= script
.buf
; i
< count
; i
++) {
591 argv_array_push(env
, p
);
598 static const char staged_changes_advice
[] =
599 N_("you have staged changes in your working tree\n"
600 "If these changes are meant to be squashed into the previous commit, run:\n"
602 " git commit --amend %s\n"
604 "If they are meant to go into a new commit, run:\n"
608 "In both cases, once you're done, continue with:\n"
610 " git rebase --continue\n");
612 #define ALLOW_EMPTY (1<<0)
613 #define EDIT_MSG (1<<1)
614 #define AMEND_MSG (1<<2)
615 #define CLEANUP_MSG (1<<3)
616 #define VERIFY_MSG (1<<4)
619 * If we are cherry-pick, and if the merge did not result in
620 * hand-editing, we will hit this commit and inherit the original
621 * author date and name.
623 * If we are revert, or if our cherry-pick results in a hand merge,
624 * we had better say that the current user is responsible for that.
626 * An exception is when run_git_commit() is called during an
627 * interactive rebase: in that case, we will want to retain the
630 static int run_git_commit(const char *defmsg
, struct replay_opts
*opts
,
633 struct child_process cmd
= CHILD_PROCESS_INIT
;
638 if (is_rebase_i(opts
)) {
639 if (!(flags
& EDIT_MSG
)) {
640 cmd
.stdout_to_stderr
= 1;
644 if (read_env_script(&cmd
.env_array
)) {
645 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
647 return error(_(staged_changes_advice
),
652 argv_array_push(&cmd
.args
, "commit");
654 if (!(flags
& VERIFY_MSG
))
655 argv_array_push(&cmd
.args
, "-n");
656 if ((flags
& AMEND_MSG
))
657 argv_array_push(&cmd
.args
, "--amend");
659 argv_array_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
661 argv_array_push(&cmd
.args
, "-s");
663 argv_array_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
664 if ((flags
& CLEANUP_MSG
))
665 argv_array_push(&cmd
.args
, "--cleanup=strip");
666 if ((flags
& EDIT_MSG
))
667 argv_array_push(&cmd
.args
, "-e");
668 else if (!(flags
& CLEANUP_MSG
) &&
669 !opts
->signoff
&& !opts
->record_origin
&&
670 git_config_get_value("commit.cleanup", &value
))
671 argv_array_push(&cmd
.args
, "--cleanup=verbatim");
673 if ((flags
& ALLOW_EMPTY
))
674 argv_array_push(&cmd
.args
, "--allow-empty");
676 if (opts
->allow_empty_message
)
677 argv_array_push(&cmd
.args
, "--allow-empty-message");
680 /* hide stderr on success */
681 struct strbuf buf
= STRBUF_INIT
;
682 int rc
= pipe_command(&cmd
,
684 /* stdout is already redirected */
688 fputs(buf
.buf
, stderr
);
689 strbuf_release(&buf
);
693 return run_command(&cmd
);
696 static int is_original_commit_empty(struct commit
*commit
)
698 const struct object_id
*ptree_oid
;
700 if (parse_commit(commit
))
701 return error(_("could not parse commit %s\n"),
702 oid_to_hex(&commit
->object
.oid
));
703 if (commit
->parents
) {
704 struct commit
*parent
= commit
->parents
->item
;
705 if (parse_commit(parent
))
706 return error(_("could not parse parent commit %s\n"),
707 oid_to_hex(&parent
->object
.oid
));
708 ptree_oid
= &parent
->tree
->object
.oid
;
710 ptree_oid
= &empty_tree_oid
; /* commit is root */
713 return !oidcmp(ptree_oid
, &commit
->tree
->object
.oid
);
717 * Do we run "git commit" with "--allow-empty"?
719 static int allow_empty(struct replay_opts
*opts
, struct commit
*commit
)
721 int index_unchanged
, empty_commit
;
726 * (1) we do not allow empty at all and error out.
728 * (2) we allow ones that were initially empty, but
729 * forbid the ones that become empty;
733 if (!opts
->allow_empty
)
734 return 0; /* let "git commit" barf as necessary */
736 index_unchanged
= is_index_unchanged();
737 if (index_unchanged
< 0)
738 return index_unchanged
;
739 if (!index_unchanged
)
740 return 0; /* we do not have to say --allow-empty */
742 if (opts
->keep_redundant_commits
)
745 empty_commit
= is_original_commit_empty(commit
);
746 if (empty_commit
< 0)
755 * Note that ordering matters in this enum. Not only must it match the mapping
756 * below, it is also divided into several sections that matter. When adding
757 * new commands, make sure you add it in the right section.
760 /* commands that handle commits */
767 /* commands that do something else than handling a single commit */
769 /* commands that do nothing but are counted for reporting progress */
772 /* comments (not counted for reporting progress) */
779 } todo_command_info
[] = {
792 static const char *command_to_string(const enum todo_command command
)
794 if (command
< TODO_COMMENT
)
795 return todo_command_info
[command
].str
;
796 die("Unknown command: %d", command
);
799 static int is_noop(const enum todo_command command
)
801 return TODO_NOOP
<= command
;
804 static int is_fixup(enum todo_command command
)
806 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
809 static int update_squash_messages(enum todo_command command
,
810 struct commit
*commit
, struct replay_opts
*opts
)
812 struct strbuf buf
= STRBUF_INIT
;
814 const char *message
, *body
;
816 if (file_exists(rebase_path_squash_msg())) {
817 struct strbuf header
= STRBUF_INIT
;
820 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 2048) <= 0)
821 return error(_("could not read '%s'"),
822 rebase_path_squash_msg());
825 eol
= strchrnul(buf
.buf
, '\n');
826 if (buf
.buf
[0] != comment_line_char
||
827 (p
+= strcspn(p
, "0123456789\n")) == eol
)
828 return error(_("unexpected 1st line of squash message:"
830 (int)(eol
- buf
.buf
), buf
.buf
);
831 count
= strtol(p
, NULL
, 10);
834 return error(_("invalid 1st line of squash message:\n"
836 (int)(eol
- buf
.buf
), buf
.buf
);
838 strbuf_addf(&header
, "%c ", comment_line_char
);
840 _("This is a combination of %d commits."), ++count
);
841 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
842 strbuf_release(&header
);
844 struct object_id head
;
845 struct commit
*head_commit
;
846 const char *head_message
, *body
;
848 if (get_oid("HEAD", &head
))
849 return error(_("need a HEAD to fixup"));
850 if (!(head_commit
= lookup_commit_reference(&head
)))
851 return error(_("could not read HEAD"));
852 if (!(head_message
= get_commit_buffer(head_commit
, NULL
)))
853 return error(_("could not read HEAD's commit message"));
855 find_commit_subject(head_message
, &body
);
856 if (write_message(body
, strlen(body
),
857 rebase_path_fixup_msg(), 0)) {
858 unuse_commit_buffer(head_commit
, head_message
);
859 return error(_("cannot write '%s'"),
860 rebase_path_fixup_msg());
864 strbuf_addf(&buf
, "%c ", comment_line_char
);
865 strbuf_addf(&buf
, _("This is a combination of %d commits."),
867 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
868 strbuf_addstr(&buf
, _("This is the 1st commit message:"));
869 strbuf_addstr(&buf
, "\n\n");
870 strbuf_addstr(&buf
, body
);
872 unuse_commit_buffer(head_commit
, head_message
);
875 if (!(message
= get_commit_buffer(commit
, NULL
)))
876 return error(_("could not read commit message of %s"),
877 oid_to_hex(&commit
->object
.oid
));
878 find_commit_subject(message
, &body
);
880 if (command
== TODO_SQUASH
) {
881 unlink(rebase_path_fixup_msg());
882 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
883 strbuf_addf(&buf
, _("This is the commit message #%d:"), count
);
884 strbuf_addstr(&buf
, "\n\n");
885 strbuf_addstr(&buf
, body
);
886 } else if (command
== TODO_FIXUP
) {
887 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
888 strbuf_addf(&buf
, _("The commit message #%d will be skipped:"),
890 strbuf_addstr(&buf
, "\n\n");
891 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
893 return error(_("unknown command: %d"), command
);
894 unuse_commit_buffer(commit
, message
);
896 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(), 0);
897 strbuf_release(&buf
);
901 static void flush_rewritten_pending(void) {
902 struct strbuf buf
= STRBUF_INIT
;
903 struct object_id newoid
;
906 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
907 !get_oid("HEAD", &newoid
) &&
908 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
909 char *bol
= buf
.buf
, *eol
;
912 eol
= strchrnul(bol
, '\n');
913 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
914 bol
, oid_to_hex(&newoid
));
920 unlink(rebase_path_rewritten_pending());
922 strbuf_release(&buf
);
925 static void record_in_rewritten(struct object_id
*oid
,
926 enum todo_command next_command
) {
927 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
932 fprintf(out
, "%s\n", oid_to_hex(oid
));
935 if (!is_fixup(next_command
))
936 flush_rewritten_pending();
939 static int do_pick_commit(enum todo_command command
, struct commit
*commit
,
940 struct replay_opts
*opts
, int final_fixup
)
942 unsigned int flags
= opts
->edit
? EDIT_MSG
: 0;
943 const char *msg_file
= opts
->edit
? NULL
: git_path_merge_msg();
944 struct object_id head
;
945 struct commit
*base
, *next
, *parent
;
946 const char *base_label
, *next_label
;
947 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
948 struct strbuf msgbuf
= STRBUF_INIT
;
949 int res
, unborn
= 0, allow
;
951 if (opts
->no_commit
) {
953 * We do not intend to commit immediately. We just want to
954 * merge the differences in, so let's compute the tree
955 * that represents the "current" state for merge-recursive
958 if (write_cache_as_tree(head
.hash
, 0, NULL
))
959 return error(_("your index file is unmerged."));
961 unborn
= get_oid("HEAD", &head
);
963 oidcpy(&head
, &empty_tree_oid
);
964 if (index_differs_from(unborn
? EMPTY_TREE_SHA1_HEX
: "HEAD",
966 return error_dirty_index(opts
);
970 if (!commit
->parents
)
972 else if (commit
->parents
->next
) {
973 /* Reverting or cherry-picking a merge commit */
975 struct commit_list
*p
;
978 return error(_("commit %s is a merge but no -m option was given."),
979 oid_to_hex(&commit
->object
.oid
));
981 for (cnt
= 1, p
= commit
->parents
;
982 cnt
!= opts
->mainline
&& p
;
985 if (cnt
!= opts
->mainline
|| !p
)
986 return error(_("commit %s does not have parent %d"),
987 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
989 } else if (0 < opts
->mainline
)
990 return error(_("mainline was specified but commit %s is not a merge."),
991 oid_to_hex(&commit
->object
.oid
));
993 parent
= commit
->parents
->item
;
995 if (get_message(commit
, &msg
) != 0)
996 return error(_("cannot get commit message for %s"),
997 oid_to_hex(&commit
->object
.oid
));
999 if (opts
->allow_ff
&& !is_fixup(command
) &&
1000 ((parent
&& !oidcmp(&parent
->object
.oid
, &head
)) ||
1001 (!parent
&& unborn
))) {
1002 if (is_rebase_i(opts
))
1003 write_author_script(msg
.message
);
1004 res
= fast_forward_to(&commit
->object
.oid
, &head
, unborn
,
1006 if (res
|| command
!= TODO_REWORD
)
1008 flags
|= EDIT_MSG
| AMEND_MSG
;
1009 if (command
== TODO_REWORD
)
1010 flags
|= VERIFY_MSG
;
1012 goto fast_forward_edit
;
1014 if (parent
&& parse_commit(parent
) < 0)
1015 /* TRANSLATORS: The first %s will be a "todo" command like
1016 "revert" or "pick", the second %s a SHA1. */
1017 return error(_("%s: cannot parse parent commit %s"),
1018 command_to_string(command
),
1019 oid_to_hex(&parent
->object
.oid
));
1022 * "commit" is an existing commit. We would want to apply
1023 * the difference it introduces since its first parent "prev"
1024 * on top of the current HEAD if we are cherry-pick. Or the
1025 * reverse of it if we are revert.
1028 if (command
== TODO_REVERT
) {
1030 base_label
= msg
.label
;
1032 next_label
= msg
.parent_label
;
1033 strbuf_addstr(&msgbuf
, "Revert \"");
1034 strbuf_addstr(&msgbuf
, msg
.subject
);
1035 strbuf_addstr(&msgbuf
, "\"\n\nThis reverts commit ");
1036 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
1038 if (commit
->parents
&& commit
->parents
->next
) {
1039 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
1040 strbuf_addstr(&msgbuf
, oid_to_hex(&parent
->object
.oid
));
1042 strbuf_addstr(&msgbuf
, ".\n");
1047 base_label
= msg
.parent_label
;
1049 next_label
= msg
.label
;
1051 /* Append the commit log message to msgbuf. */
1052 if (find_commit_subject(msg
.message
, &p
))
1053 strbuf_addstr(&msgbuf
, p
);
1055 if (opts
->record_origin
) {
1056 strbuf_complete_line(&msgbuf
);
1057 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
1058 strbuf_addch(&msgbuf
, '\n');
1059 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
1060 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
1061 strbuf_addstr(&msgbuf
, ")\n");
1065 if (command
== TODO_REWORD
)
1066 flags
|= EDIT_MSG
| VERIFY_MSG
;
1067 else if (is_fixup(command
)) {
1068 if (update_squash_messages(command
, commit
, opts
))
1072 msg_file
= rebase_path_squash_msg();
1073 else if (file_exists(rebase_path_fixup_msg())) {
1074 flags
|= CLEANUP_MSG
;
1075 msg_file
= rebase_path_fixup_msg();
1077 const char *dest
= git_path_squash_msg();
1079 if (copy_file(dest
, rebase_path_squash_msg(), 0666))
1080 return error(_("could not rename '%s' to '%s'"),
1081 rebase_path_squash_msg(), dest
);
1082 unlink(git_path_merge_msg());
1088 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
1090 else if (!opts
->strategy
|| !strcmp(opts
->strategy
, "recursive") || command
== TODO_REVERT
) {
1091 res
= do_recursive_merge(base
, next
, base_label
, next_label
,
1092 &head
, &msgbuf
, opts
);
1095 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
1096 git_path_merge_msg(), 0);
1098 struct commit_list
*common
= NULL
;
1099 struct commit_list
*remotes
= NULL
;
1101 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
1102 git_path_merge_msg(), 0);
1104 commit_list_insert(base
, &common
);
1105 commit_list_insert(next
, &remotes
);
1106 res
|= try_merge_command(opts
->strategy
,
1107 opts
->xopts_nr
, (const char **)opts
->xopts
,
1108 common
, oid_to_hex(&head
), remotes
);
1109 free_commit_list(common
);
1110 free_commit_list(remotes
);
1112 strbuf_release(&msgbuf
);
1115 * If the merge was clean or if it failed due to conflict, we write
1116 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1117 * However, if the merge did not even start, then we don't want to
1120 if (command
== TODO_PICK
&& !opts
->no_commit
&& (res
== 0 || res
== 1) &&
1121 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
1122 REF_NODEREF
, UPDATE_REFS_MSG_ON_ERR
))
1124 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
1125 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
1126 REF_NODEREF
, UPDATE_REFS_MSG_ON_ERR
))
1130 error(command
== TODO_REVERT
1131 ? _("could not revert %s... %s")
1132 : _("could not apply %s... %s"),
1133 short_commit_name(commit
), msg
.subject
);
1134 print_advice(res
== 1, opts
);
1135 rerere(opts
->allow_rerere_auto
);
1139 allow
= allow_empty(opts
, commit
);
1144 flags
|= ALLOW_EMPTY
;
1145 if (!opts
->no_commit
)
1147 res
= run_git_commit(msg_file
, opts
, flags
);
1149 if (!res
&& final_fixup
) {
1150 unlink(rebase_path_fixup_msg());
1151 unlink(rebase_path_squash_msg());
1155 free_message(commit
, &msg
);
1156 update_abort_safety_file();
1161 static int prepare_revs(struct replay_opts
*opts
)
1164 * picking (but not reverting) ranges (but not individual revisions)
1165 * should be done in reverse
1167 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
1168 opts
->revs
->reverse
^= 1;
1170 if (prepare_revision_walk(opts
->revs
))
1171 return error(_("revision walk setup failed"));
1173 if (!opts
->revs
->commits
)
1174 return error(_("empty commit set passed"));
1178 static int read_and_refresh_cache(struct replay_opts
*opts
)
1180 static struct lock_file index_lock
;
1181 int index_fd
= hold_locked_index(&index_lock
, 0);
1182 if (read_index_preload(&the_index
, NULL
) < 0) {
1183 rollback_lock_file(&index_lock
);
1184 return error(_("git %s: failed to read the index"),
1185 _(action_name(opts
)));
1187 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
1188 if (the_index
.cache_changed
&& index_fd
>= 0) {
1189 if (write_locked_index(&the_index
, &index_lock
, COMMIT_LOCK
)) {
1190 return error(_("git %s: failed to refresh the index"),
1191 _(action_name(opts
)));
1194 rollback_lock_file(&index_lock
);
1199 enum todo_command command
;
1200 struct commit
*commit
;
1203 size_t offset_in_buf
;
1208 struct todo_item
*items
;
1209 int nr
, alloc
, current
;
1210 int done_nr
, total_nr
;
1211 struct stat_data stat
;
1214 #define TODO_LIST_INIT { STRBUF_INIT }
1216 static void todo_list_release(struct todo_list
*todo_list
)
1218 strbuf_release(&todo_list
->buf
);
1219 FREE_AND_NULL(todo_list
->items
);
1220 todo_list
->nr
= todo_list
->alloc
= 0;
1223 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
1225 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
1226 return todo_list
->items
+ todo_list
->nr
++;
1229 static int parse_insn_line(struct todo_item
*item
, const char *bol
, char *eol
)
1231 struct object_id commit_oid
;
1232 char *end_of_object_name
;
1233 int i
, saved
, status
, padding
;
1236 bol
+= strspn(bol
, " \t");
1238 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
1239 item
->command
= TODO_COMMENT
;
1240 item
->commit
= NULL
;
1242 item
->arg_len
= eol
- bol
;
1246 for (i
= 0; i
< TODO_COMMENT
; i
++)
1247 if (skip_prefix(bol
, todo_command_info
[i
].str
, &bol
)) {
1250 } else if (bol
[1] == ' ' && *bol
== todo_command_info
[i
].c
) {
1255 if (i
>= TODO_COMMENT
)
1258 if (item
->command
== TODO_NOOP
) {
1259 item
->commit
= NULL
;
1261 item
->arg_len
= eol
- bol
;
1265 /* Eat up extra spaces/ tabs before object name */
1266 padding
= strspn(bol
, " \t");
1271 if (item
->command
== TODO_EXEC
) {
1273 item
->arg_len
= (int)(eol
- bol
);
1277 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
1278 saved
= *end_of_object_name
;
1279 *end_of_object_name
= '\0';
1280 status
= get_oid(bol
, &commit_oid
);
1281 *end_of_object_name
= saved
;
1283 item
->arg
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
1284 item
->arg_len
= (int)(eol
- item
->arg
);
1289 item
->commit
= lookup_commit_reference(&commit_oid
);
1290 return !item
->commit
;
1293 static int parse_insn_buffer(char *buf
, struct todo_list
*todo_list
)
1295 struct todo_item
*item
;
1296 char *p
= buf
, *next_p
;
1297 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
1299 for (i
= 1; *p
; i
++, p
= next_p
) {
1300 char *eol
= strchrnul(p
, '\n');
1302 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
1304 if (p
!= eol
&& eol
[-1] == '\r')
1305 eol
--; /* strip Carriage Return */
1307 item
= append_new_todo(todo_list
);
1308 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
1309 if (parse_insn_line(item
, p
, eol
)) {
1310 res
= error(_("invalid line %d: %.*s"),
1311 i
, (int)(eol
- p
), p
);
1312 item
->command
= TODO_NOOP
;
1317 else if (is_fixup(item
->command
))
1318 return error(_("cannot '%s' without a previous commit"),
1319 command_to_string(item
->command
));
1320 else if (!is_noop(item
->command
))
1327 static int count_commands(struct todo_list
*todo_list
)
1331 for (i
= 0; i
< todo_list
->nr
; i
++)
1332 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
1338 static int read_populate_todo(struct todo_list
*todo_list
,
1339 struct replay_opts
*opts
)
1342 const char *todo_file
= get_todo_path(opts
);
1345 strbuf_reset(&todo_list
->buf
);
1346 fd
= open(todo_file
, O_RDONLY
);
1348 return error_errno(_("could not open '%s'"), todo_file
);
1349 if (strbuf_read(&todo_list
->buf
, fd
, 0) < 0) {
1351 return error(_("could not read '%s'."), todo_file
);
1355 res
= stat(todo_file
, &st
);
1357 return error(_("could not stat '%s'"), todo_file
);
1358 fill_stat_data(&todo_list
->stat
, &st
);
1360 res
= parse_insn_buffer(todo_list
->buf
.buf
, todo_list
);
1362 if (is_rebase_i(opts
))
1363 return error(_("please fix this using "
1364 "'git rebase --edit-todo'."));
1365 return error(_("unusable instruction sheet: '%s'"), todo_file
);
1368 if (!todo_list
->nr
&&
1369 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
1370 return error(_("no commits parsed."));
1372 if (!is_rebase_i(opts
)) {
1373 enum todo_command valid
=
1374 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
1377 for (i
= 0; i
< todo_list
->nr
; i
++)
1378 if (valid
== todo_list
->items
[i
].command
)
1380 else if (valid
== TODO_PICK
)
1381 return error(_("cannot cherry-pick during a revert."));
1383 return error(_("cannot revert during a cherry-pick."));
1386 if (is_rebase_i(opts
)) {
1387 struct todo_list done
= TODO_LIST_INIT
;
1388 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
1390 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
1391 !parse_insn_buffer(done
.buf
.buf
, &done
))
1392 todo_list
->done_nr
= count_commands(&done
);
1394 todo_list
->done_nr
= 0;
1396 todo_list
->total_nr
= todo_list
->done_nr
1397 + count_commands(todo_list
);
1398 todo_list_release(&done
);
1401 fprintf(f
, "%d\n", todo_list
->total_nr
);
1409 static int git_config_string_dup(char **dest
,
1410 const char *var
, const char *value
)
1413 return config_error_nonbool(var
);
1415 *dest
= xstrdup(value
);
1419 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
1421 struct replay_opts
*opts
= data
;
1426 else if (!strcmp(key
, "options.no-commit"))
1427 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
1428 else if (!strcmp(key
, "options.edit"))
1429 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
1430 else if (!strcmp(key
, "options.signoff"))
1431 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
1432 else if (!strcmp(key
, "options.record-origin"))
1433 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
1434 else if (!strcmp(key
, "options.allow-ff"))
1435 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
1436 else if (!strcmp(key
, "options.mainline"))
1437 opts
->mainline
= git_config_int(key
, value
);
1438 else if (!strcmp(key
, "options.strategy"))
1439 git_config_string_dup(&opts
->strategy
, key
, value
);
1440 else if (!strcmp(key
, "options.gpg-sign"))
1441 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
1442 else if (!strcmp(key
, "options.strategy-option")) {
1443 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
1444 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(value
);
1445 } else if (!strcmp(key
, "options.allow-rerere-auto"))
1446 opts
->allow_rerere_auto
=
1447 git_config_bool_or_int(key
, value
, &error_flag
) ?
1448 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
1450 return error(_("invalid key: %s"), key
);
1453 return error(_("invalid value for %s: %s"), key
, value
);
1458 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
1463 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
1465 opts
->strategy
= strbuf_detach(buf
, NULL
);
1466 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
1469 opts
->xopts_nr
= split_cmdline(buf
->buf
, (const char ***)&opts
->xopts
);
1470 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
1471 const char *arg
= opts
->xopts
[i
];
1473 skip_prefix(arg
, "--", &arg
);
1474 opts
->xopts
[i
] = xstrdup(arg
);
1478 static int read_populate_opts(struct replay_opts
*opts
)
1480 if (is_rebase_i(opts
)) {
1481 struct strbuf buf
= STRBUF_INIT
;
1483 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(), 1)) {
1484 if (!starts_with(buf
.buf
, "-S"))
1487 free(opts
->gpg_sign
);
1488 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
1493 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(), 1)) {
1494 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
1495 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
1496 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
1497 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
1501 if (file_exists(rebase_path_verbose()))
1504 read_strategy_opts(opts
, &buf
);
1505 strbuf_release(&buf
);
1510 if (!file_exists(git_path_opts_file()))
1513 * The function git_parse_source(), called from git_config_from_file(),
1514 * may die() in case of a syntactically incorrect file. We do not care
1515 * about this case, though, because we wrote that file ourselves, so we
1516 * are pretty certain that it is syntactically correct.
1518 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
1519 return error(_("malformed options sheet: '%s'"),
1520 git_path_opts_file());
1524 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
1525 struct replay_opts
*opts
)
1527 enum todo_command command
= opts
->action
== REPLAY_PICK
?
1528 TODO_PICK
: TODO_REVERT
;
1529 const char *command_string
= todo_command_info
[command
].str
;
1530 struct commit
*commit
;
1532 if (prepare_revs(opts
))
1535 while ((commit
= get_revision(opts
->revs
))) {
1536 struct todo_item
*item
= append_new_todo(todo_list
);
1537 const char *commit_buffer
= get_commit_buffer(commit
, NULL
);
1538 const char *subject
;
1541 item
->command
= command
;
1542 item
->commit
= commit
;
1545 item
->offset_in_buf
= todo_list
->buf
.len
;
1546 subject_len
= find_commit_subject(commit_buffer
, &subject
);
1547 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
1548 short_commit_name(commit
), subject_len
, subject
);
1549 unuse_commit_buffer(commit
, commit_buffer
);
1554 static int create_seq_dir(void)
1556 if (file_exists(git_path_seq_dir())) {
1557 error(_("a cherry-pick or revert is already in progress"));
1558 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
1560 } else if (mkdir(git_path_seq_dir(), 0777) < 0)
1561 return error_errno(_("could not create sequencer directory '%s'"),
1562 git_path_seq_dir());
1566 static int save_head(const char *head
)
1568 static struct lock_file head_lock
;
1569 struct strbuf buf
= STRBUF_INIT
;
1573 fd
= hold_lock_file_for_update(&head_lock
, git_path_head_file(), 0);
1575 rollback_lock_file(&head_lock
);
1576 return error_errno(_("could not lock HEAD"));
1578 strbuf_addf(&buf
, "%s\n", head
);
1579 written
= write_in_full(fd
, buf
.buf
, buf
.len
);
1580 strbuf_release(&buf
);
1582 rollback_lock_file(&head_lock
);
1583 return error_errno(_("could not write to '%s'"),
1584 git_path_head_file());
1586 if (commit_lock_file(&head_lock
) < 0) {
1587 rollback_lock_file(&head_lock
);
1588 return error(_("failed to finalize '%s'."), git_path_head_file());
1593 static int rollback_is_safe(void)
1595 struct strbuf sb
= STRBUF_INIT
;
1596 struct object_id expected_head
, actual_head
;
1598 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
1600 if (get_oid_hex(sb
.buf
, &expected_head
)) {
1601 strbuf_release(&sb
);
1602 die(_("could not parse %s"), git_path_abort_safety_file());
1604 strbuf_release(&sb
);
1606 else if (errno
== ENOENT
)
1607 oidclr(&expected_head
);
1609 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
1611 if (get_oid("HEAD", &actual_head
))
1612 oidclr(&actual_head
);
1614 return !oidcmp(&actual_head
, &expected_head
);
1617 static int reset_for_rollback(const struct object_id
*oid
)
1619 const char *argv
[4]; /* reset --merge <arg> + NULL */
1622 argv
[1] = "--merge";
1623 argv
[2] = oid_to_hex(oid
);
1625 return run_command_v_opt(argv
, RUN_GIT_CMD
);
1628 static int rollback_single_pick(void)
1630 struct object_id head_oid
;
1632 if (!file_exists(git_path_cherry_pick_head()) &&
1633 !file_exists(git_path_revert_head()))
1634 return error(_("no cherry-pick or revert in progress"));
1635 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
1636 return error(_("cannot resolve HEAD"));
1637 if (is_null_oid(&head_oid
))
1638 return error(_("cannot abort from a branch yet to be born"));
1639 return reset_for_rollback(&head_oid
);
1642 int sequencer_rollback(struct replay_opts
*opts
)
1645 struct object_id oid
;
1646 struct strbuf buf
= STRBUF_INIT
;
1649 f
= fopen(git_path_head_file(), "r");
1650 if (!f
&& errno
== ENOENT
) {
1652 * There is no multiple-cherry-pick in progress.
1653 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
1654 * a single-cherry-pick in progress, abort that.
1656 return rollback_single_pick();
1659 return error_errno(_("cannot open '%s'"), git_path_head_file());
1660 if (strbuf_getline_lf(&buf
, f
)) {
1661 error(_("cannot read '%s': %s"), git_path_head_file(),
1662 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
1667 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
1668 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
1669 git_path_head_file());
1672 if (is_null_oid(&oid
)) {
1673 error(_("cannot abort from a branch yet to be born"));
1677 if (!rollback_is_safe()) {
1678 /* Do not error, just do not rollback */
1679 warning(_("You seem to have moved HEAD. "
1680 "Not rewinding, check your HEAD!"));
1682 if (reset_for_rollback(&oid
))
1684 strbuf_release(&buf
);
1685 return sequencer_remove_state(opts
);
1687 strbuf_release(&buf
);
1691 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
1693 static struct lock_file todo_lock
;
1694 const char *todo_path
= get_todo_path(opts
);
1695 int next
= todo_list
->current
, offset
, fd
;
1698 * rebase -i writes "git-rebase-todo" without the currently executing
1699 * command, appending it to "done" instead.
1701 if (is_rebase_i(opts
))
1704 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
1706 return error_errno(_("could not lock '%s'"), todo_path
);
1707 offset
= next
< todo_list
->nr
?
1708 todo_list
->items
[next
].offset_in_buf
: todo_list
->buf
.len
;
1709 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
1710 todo_list
->buf
.len
- offset
) < 0)
1711 return error_errno(_("could not write to '%s'"), todo_path
);
1712 if (commit_lock_file(&todo_lock
) < 0)
1713 return error(_("failed to finalize '%s'."), todo_path
);
1715 if (is_rebase_i(opts
)) {
1716 const char *done_path
= rebase_path_done();
1717 int fd
= open(done_path
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
1718 int prev_offset
= !next
? 0 :
1719 todo_list
->items
[next
- 1].offset_in_buf
;
1721 if (fd
>= 0 && offset
> prev_offset
&&
1722 write_in_full(fd
, todo_list
->buf
.buf
+ prev_offset
,
1723 offset
- prev_offset
) < 0) {
1725 return error_errno(_("could not write to '%s'"),
1734 static int save_opts(struct replay_opts
*opts
)
1736 const char *opts_file
= git_path_opts_file();
1739 if (opts
->no_commit
)
1740 res
|= git_config_set_in_file_gently(opts_file
, "options.no-commit", "true");
1742 res
|= git_config_set_in_file_gently(opts_file
, "options.edit", "true");
1744 res
|= git_config_set_in_file_gently(opts_file
, "options.signoff", "true");
1745 if (opts
->record_origin
)
1746 res
|= git_config_set_in_file_gently(opts_file
, "options.record-origin", "true");
1748 res
|= git_config_set_in_file_gently(opts_file
, "options.allow-ff", "true");
1749 if (opts
->mainline
) {
1750 struct strbuf buf
= STRBUF_INIT
;
1751 strbuf_addf(&buf
, "%d", opts
->mainline
);
1752 res
|= git_config_set_in_file_gently(opts_file
, "options.mainline", buf
.buf
);
1753 strbuf_release(&buf
);
1756 res
|= git_config_set_in_file_gently(opts_file
, "options.strategy", opts
->strategy
);
1758 res
|= git_config_set_in_file_gently(opts_file
, "options.gpg-sign", opts
->gpg_sign
);
1761 for (i
= 0; i
< opts
->xopts_nr
; i
++)
1762 res
|= git_config_set_multivar_in_file_gently(opts_file
,
1763 "options.strategy-option",
1764 opts
->xopts
[i
], "^$", 0);
1766 if (opts
->allow_rerere_auto
)
1767 res
|= git_config_set_in_file_gently(opts_file
, "options.allow-rerere-auto",
1768 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
1773 static int make_patch(struct commit
*commit
, struct replay_opts
*opts
)
1775 struct strbuf buf
= STRBUF_INIT
;
1776 struct rev_info log_tree_opt
;
1777 const char *subject
, *p
;
1780 p
= short_commit_name(commit
);
1781 if (write_message(p
, strlen(p
), rebase_path_stopped_sha(), 1) < 0)
1784 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
1785 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
1786 init_revisions(&log_tree_opt
, NULL
);
1787 log_tree_opt
.abbrev
= 0;
1788 log_tree_opt
.diff
= 1;
1789 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
1790 log_tree_opt
.disable_stdin
= 1;
1791 log_tree_opt
.no_commit_id
= 1;
1792 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
1793 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
1794 if (!log_tree_opt
.diffopt
.file
)
1795 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
1797 res
|= log_tree_commit(&log_tree_opt
, commit
);
1798 fclose(log_tree_opt
.diffopt
.file
);
1802 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
1803 if (!file_exists(buf
.buf
)) {
1804 const char *commit_buffer
= get_commit_buffer(commit
, NULL
);
1805 find_commit_subject(commit_buffer
, &subject
);
1806 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
1807 unuse_commit_buffer(commit
, commit_buffer
);
1809 strbuf_release(&buf
);
1814 static int intend_to_amend(void)
1816 struct object_id head
;
1819 if (get_oid("HEAD", &head
))
1820 return error(_("cannot read HEAD"));
1822 p
= oid_to_hex(&head
);
1823 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
1826 static int error_with_patch(struct commit
*commit
,
1827 const char *subject
, int subject_len
,
1828 struct replay_opts
*opts
, int exit_code
, int to_amend
)
1830 if (make_patch(commit
, opts
))
1834 if (intend_to_amend())
1837 fprintf(stderr
, "You can amend the commit now, with\n"
1839 " git commit --amend %s\n"
1841 "Once you are satisfied with your changes, run\n"
1843 " git rebase --continue\n", gpg_sign_opt_quoted(opts
));
1844 } else if (exit_code
)
1845 fprintf(stderr
, "Could not apply %s... %.*s\n",
1846 short_commit_name(commit
), subject_len
, subject
);
1851 static int error_failed_squash(struct commit
*commit
,
1852 struct replay_opts
*opts
, int subject_len
, const char *subject
)
1854 if (rename(rebase_path_squash_msg(), rebase_path_message()))
1855 return error(_("could not rename '%s' to '%s'"),
1856 rebase_path_squash_msg(), rebase_path_message());
1857 unlink(rebase_path_fixup_msg());
1858 unlink(git_path_merge_msg());
1859 if (copy_file(git_path_merge_msg(), rebase_path_message(), 0666))
1860 return error(_("could not copy '%s' to '%s'"),
1861 rebase_path_message(), git_path_merge_msg());
1862 return error_with_patch(commit
, subject
, subject_len
, opts
, 1, 0);
1865 static int do_exec(const char *command_line
)
1867 struct argv_array child_env
= ARGV_ARRAY_INIT
;
1868 const char *child_argv
[] = { NULL
, NULL
};
1871 fprintf(stderr
, "Executing: %s\n", command_line
);
1872 child_argv
[0] = command_line
;
1873 argv_array_pushf(&child_env
, "GIT_DIR=%s", absolute_path(get_git_dir()));
1874 status
= run_command_v_opt_cd_env(child_argv
, RUN_USING_SHELL
, NULL
,
1877 /* force re-reading of the cache */
1878 if (discard_cache() < 0 || read_cache() < 0)
1879 return error(_("could not read index"));
1881 dirty
= require_clean_work_tree("rebase", NULL
, 1, 1);
1884 warning(_("execution failed: %s\n%s"
1885 "You can fix the problem, and then run\n"
1887 " git rebase --continue\n"
1890 dirty
? N_("and made changes to the index and/or the "
1891 "working tree\n") : "");
1893 /* command not found */
1896 warning(_("execution succeeded: %s\nbut "
1897 "left changes to the index and/or the working tree\n"
1898 "Commit or stash your changes, and then run\n"
1900 " git rebase --continue\n"
1901 "\n"), command_line
);
1905 argv_array_clear(&child_env
);
1910 static int is_final_fixup(struct todo_list
*todo_list
)
1912 int i
= todo_list
->current
;
1914 if (!is_fixup(todo_list
->items
[i
].command
))
1917 while (++i
< todo_list
->nr
)
1918 if (is_fixup(todo_list
->items
[i
].command
))
1920 else if (!is_noop(todo_list
->items
[i
].command
))
1925 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
1929 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
1930 if (!is_noop(todo_list
->items
[i
].command
))
1931 return todo_list
->items
[i
].command
;
1936 static int apply_autostash(struct replay_opts
*opts
)
1938 struct strbuf stash_sha1
= STRBUF_INIT
;
1939 struct child_process child
= CHILD_PROCESS_INIT
;
1942 if (!read_oneliner(&stash_sha1
, rebase_path_autostash(), 1)) {
1943 strbuf_release(&stash_sha1
);
1946 strbuf_trim(&stash_sha1
);
1949 child
.no_stdout
= 1;
1950 child
.no_stderr
= 1;
1951 argv_array_push(&child
.args
, "stash");
1952 argv_array_push(&child
.args
, "apply");
1953 argv_array_push(&child
.args
, stash_sha1
.buf
);
1954 if (!run_command(&child
))
1955 fprintf(stderr
, _("Applied autostash.\n"));
1957 struct child_process store
= CHILD_PROCESS_INIT
;
1960 argv_array_push(&store
.args
, "stash");
1961 argv_array_push(&store
.args
, "store");
1962 argv_array_push(&store
.args
, "-m");
1963 argv_array_push(&store
.args
, "autostash");
1964 argv_array_push(&store
.args
, "-q");
1965 argv_array_push(&store
.args
, stash_sha1
.buf
);
1966 if (run_command(&store
))
1967 ret
= error(_("cannot store %s"), stash_sha1
.buf
);
1970 _("Applying autostash resulted in conflicts.\n"
1971 "Your changes are safe in the stash.\n"
1972 "You can run \"git stash pop\" or"
1973 " \"git stash drop\" at any time.\n"));
1976 strbuf_release(&stash_sha1
);
1980 static const char *reflog_message(struct replay_opts
*opts
,
1981 const char *sub_action
, const char *fmt
, ...)
1984 static struct strbuf buf
= STRBUF_INIT
;
1988 strbuf_addstr(&buf
, action_name(opts
));
1990 strbuf_addf(&buf
, " (%s)", sub_action
);
1992 strbuf_addstr(&buf
, ": ");
1993 strbuf_vaddf(&buf
, fmt
, ap
);
2000 static int pick_commits(struct todo_list
*todo_list
, struct replay_opts
*opts
)
2004 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
2006 assert(!(opts
->signoff
|| opts
->no_commit
||
2007 opts
->record_origin
|| opts
->edit
));
2008 if (read_and_refresh_cache(opts
))
2011 while (todo_list
->current
< todo_list
->nr
) {
2012 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
2013 if (save_todo(todo_list
, opts
))
2015 if (is_rebase_i(opts
)) {
2016 if (item
->command
!= TODO_COMMENT
) {
2017 FILE *f
= fopen(rebase_path_msgnum(), "w");
2019 todo_list
->done_nr
++;
2022 fprintf(f
, "%d\n", todo_list
->done_nr
);
2025 fprintf(stderr
, "Rebasing (%d/%d)%s",
2027 todo_list
->total_nr
,
2028 opts
->verbose
? "\n" : "\r");
2030 unlink(rebase_path_message());
2031 unlink(rebase_path_author_script());
2032 unlink(rebase_path_stopped_sha());
2033 unlink(rebase_path_amend());
2035 if (item
->command
<= TODO_SQUASH
) {
2036 if (is_rebase_i(opts
))
2037 setenv("GIT_REFLOG_ACTION", reflog_message(opts
,
2038 command_to_string(item
->command
), NULL
),
2040 res
= do_pick_commit(item
->command
, item
->commit
,
2041 opts
, is_final_fixup(todo_list
));
2042 if (is_rebase_i(opts
) && res
< 0) {
2044 todo_list
->current
--;
2045 if (save_todo(todo_list
, opts
))
2048 if (item
->command
== TODO_EDIT
) {
2049 struct commit
*commit
= item
->commit
;
2052 _("Stopped at %s... %.*s\n"),
2053 short_commit_name(commit
),
2054 item
->arg_len
, item
->arg
);
2055 return error_with_patch(commit
,
2056 item
->arg
, item
->arg_len
, opts
, res
,
2059 if (is_rebase_i(opts
) && !res
)
2060 record_in_rewritten(&item
->commit
->object
.oid
,
2061 peek_command(todo_list
, 1));
2062 if (res
&& is_fixup(item
->command
)) {
2065 return error_failed_squash(item
->commit
, opts
,
2066 item
->arg_len
, item
->arg
);
2067 } else if (res
&& is_rebase_i(opts
))
2068 return res
| error_with_patch(item
->commit
,
2069 item
->arg
, item
->arg_len
, opts
, res
,
2070 item
->command
== TODO_REWORD
);
2071 } else if (item
->command
== TODO_EXEC
) {
2072 char *end_of_arg
= (char *)(item
->arg
+ item
->arg_len
);
2073 int saved
= *end_of_arg
;
2077 res
= do_exec(item
->arg
);
2078 *end_of_arg
= saved
;
2080 /* Reread the todo file if it has changed. */
2082 ; /* fall through */
2083 else if (stat(get_todo_path(opts
), &st
))
2084 res
= error_errno(_("could not stat '%s'"),
2085 get_todo_path(opts
));
2086 else if (match_stat_data(&todo_list
->stat
, &st
)) {
2087 todo_list_release(todo_list
);
2088 if (read_populate_todo(todo_list
, opts
))
2089 res
= -1; /* message was printed */
2090 /* `current` will be incremented below */
2091 todo_list
->current
= -1;
2093 } else if (!is_noop(item
->command
))
2094 return error(_("unknown command %d"), item
->command
);
2096 todo_list
->current
++;
2101 if (is_rebase_i(opts
)) {
2102 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
2105 /* Stopped in the middle, as planned? */
2106 if (todo_list
->current
< todo_list
->nr
)
2109 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
2110 starts_with(head_ref
.buf
, "refs/")) {
2112 struct object_id head
, orig
;
2115 if (get_oid("HEAD", &head
)) {
2116 res
= error(_("cannot read HEAD"));
2118 strbuf_release(&head_ref
);
2119 strbuf_release(&buf
);
2122 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
2123 get_oid_hex(buf
.buf
, &orig
)) {
2124 res
= error(_("could not read orig-head"));
2125 goto cleanup_head_ref
;
2128 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
2129 res
= error(_("could not read 'onto'"));
2130 goto cleanup_head_ref
;
2132 msg
= reflog_message(opts
, "finish", "%s onto %s",
2133 head_ref
.buf
, buf
.buf
);
2134 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
2135 REF_NODEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
2136 res
= error(_("could not update %s"),
2138 goto cleanup_head_ref
;
2140 msg
= reflog_message(opts
, "finish", "returning to %s",
2142 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
2143 res
= error(_("could not update HEAD to %s"),
2145 goto cleanup_head_ref
;
2150 if (opts
->verbose
) {
2151 struct rev_info log_tree_opt
;
2152 struct object_id orig
, head
;
2154 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
2155 init_revisions(&log_tree_opt
, NULL
);
2156 log_tree_opt
.diff
= 1;
2157 log_tree_opt
.diffopt
.output_format
=
2158 DIFF_FORMAT_DIFFSTAT
;
2159 log_tree_opt
.disable_stdin
= 1;
2161 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
2162 !get_oid(buf
.buf
, &orig
) &&
2163 !get_oid("HEAD", &head
)) {
2164 diff_tree_oid(&orig
, &head
, "",
2165 &log_tree_opt
.diffopt
);
2166 log_tree_diff_flush(&log_tree_opt
);
2169 flush_rewritten_pending();
2170 if (!stat(rebase_path_rewritten_list(), &st
) &&
2172 struct child_process child
= CHILD_PROCESS_INIT
;
2173 const char *post_rewrite_hook
=
2174 find_hook("post-rewrite");
2176 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
2178 argv_array_push(&child
.args
, "notes");
2179 argv_array_push(&child
.args
, "copy");
2180 argv_array_push(&child
.args
, "--for-rewrite=rebase");
2181 /* we don't care if this copying failed */
2182 run_command(&child
);
2184 if (post_rewrite_hook
) {
2185 struct child_process hook
= CHILD_PROCESS_INIT
;
2187 hook
.in
= open(rebase_path_rewritten_list(),
2189 hook
.stdout_to_stderr
= 1;
2190 argv_array_push(&hook
.args
, post_rewrite_hook
);
2191 argv_array_push(&hook
.args
, "rebase");
2192 /* we don't care if this hook failed */
2196 apply_autostash(opts
);
2198 fprintf(stderr
, "Successfully rebased and updated %s.\n",
2201 strbuf_release(&buf
);
2202 strbuf_release(&head_ref
);
2206 * Sequence of picks finished successfully; cleanup by
2207 * removing the .git/sequencer directory
2209 return sequencer_remove_state(opts
);
2212 static int continue_single_pick(void)
2214 const char *argv
[] = { "commit", NULL
};
2216 if (!file_exists(git_path_cherry_pick_head()) &&
2217 !file_exists(git_path_revert_head()))
2218 return error(_("no cherry-pick or revert in progress"));
2219 return run_command_v_opt(argv
, RUN_GIT_CMD
);
2222 static int commit_staged_changes(struct replay_opts
*opts
)
2224 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
2226 if (has_unstaged_changes(1))
2227 return error(_("cannot rebase: You have unstaged changes."));
2228 if (!has_uncommitted_changes(0)) {
2229 const char *cherry_pick_head
= git_path_cherry_pick_head();
2231 if (file_exists(cherry_pick_head
) && unlink(cherry_pick_head
))
2232 return error(_("could not remove CHERRY_PICK_HEAD"));
2236 if (file_exists(rebase_path_amend())) {
2237 struct strbuf rev
= STRBUF_INIT
;
2238 struct object_id head
, to_amend
;
2240 if (get_oid("HEAD", &head
))
2241 return error(_("cannot amend non-existing commit"));
2242 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
2243 return error(_("invalid file: '%s'"), rebase_path_amend());
2244 if (get_oid_hex(rev
.buf
, &to_amend
))
2245 return error(_("invalid contents: '%s'"),
2246 rebase_path_amend());
2247 if (oidcmp(&head
, &to_amend
))
2248 return error(_("\nYou have uncommitted changes in your "
2249 "working tree. Please, commit them\n"
2250 "first and then run 'git rebase "
2251 "--continue' again."));
2253 strbuf_release(&rev
);
2257 if (run_git_commit(rebase_path_message(), opts
, flags
))
2258 return error(_("could not commit staged changes."));
2259 unlink(rebase_path_amend());
2263 int sequencer_continue(struct replay_opts
*opts
)
2265 struct todo_list todo_list
= TODO_LIST_INIT
;
2268 if (read_and_refresh_cache(opts
))
2271 if (is_rebase_i(opts
)) {
2272 if (commit_staged_changes(opts
))
2274 } else if (!file_exists(get_todo_path(opts
)))
2275 return continue_single_pick();
2276 if (read_populate_opts(opts
))
2278 if ((res
= read_populate_todo(&todo_list
, opts
)))
2279 goto release_todo_list
;
2281 if (!is_rebase_i(opts
)) {
2282 /* Verify that the conflict has been resolved */
2283 if (file_exists(git_path_cherry_pick_head()) ||
2284 file_exists(git_path_revert_head())) {
2285 res
= continue_single_pick();
2287 goto release_todo_list
;
2289 if (index_differs_from("HEAD", NULL
, 0)) {
2290 res
= error_dirty_index(opts
);
2291 goto release_todo_list
;
2293 todo_list
.current
++;
2294 } else if (file_exists(rebase_path_stopped_sha())) {
2295 struct strbuf buf
= STRBUF_INIT
;
2296 struct object_id oid
;
2298 if (read_oneliner(&buf
, rebase_path_stopped_sha(), 1) &&
2299 !get_oid_committish(buf
.buf
, &oid
))
2300 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
2301 strbuf_release(&buf
);
2304 res
= pick_commits(&todo_list
, opts
);
2306 todo_list_release(&todo_list
);
2310 static int single_pick(struct commit
*cmit
, struct replay_opts
*opts
)
2312 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
2313 return do_pick_commit(opts
->action
== REPLAY_PICK
?
2314 TODO_PICK
: TODO_REVERT
, cmit
, opts
, 0);
2317 int sequencer_pick_revisions(struct replay_opts
*opts
)
2319 struct todo_list todo_list
= TODO_LIST_INIT
;
2320 struct object_id oid
;
2324 if (read_and_refresh_cache(opts
))
2327 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
2328 struct object_id oid
;
2329 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
2331 /* This happens when using --stdin. */
2335 if (!get_oid(name
, &oid
)) {
2336 if (!lookup_commit_reference_gently(&oid
, 1)) {
2337 enum object_type type
= sha1_object_info(oid
.hash
, NULL
);
2338 return error(_("%s: can't cherry-pick a %s"),
2339 name
, typename(type
));
2342 return error(_("%s: bad revision"), name
);
2346 * If we were called as "git cherry-pick <commit>", just
2347 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
2348 * REVERT_HEAD, and don't touch the sequencer state.
2349 * This means it is possible to cherry-pick in the middle
2350 * of a cherry-pick sequence.
2352 if (opts
->revs
->cmdline
.nr
== 1 &&
2353 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
2354 opts
->revs
->no_walk
&&
2355 !opts
->revs
->cmdline
.rev
->flags
) {
2356 struct commit
*cmit
;
2357 if (prepare_revision_walk(opts
->revs
))
2358 return error(_("revision walk setup failed"));
2359 cmit
= get_revision(opts
->revs
);
2360 if (!cmit
|| get_revision(opts
->revs
))
2361 return error("BUG: expected exactly one commit from walk");
2362 return single_pick(cmit
, opts
);
2366 * Start a new cherry-pick/ revert sequence; but
2367 * first, make sure that an existing one isn't in
2371 if (walk_revs_populate_todo(&todo_list
, opts
) ||
2372 create_seq_dir() < 0)
2374 if (get_oid("HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
2375 return error(_("can't revert as initial commit"));
2376 if (save_head(oid_to_hex(&oid
)))
2378 if (save_opts(opts
))
2380 update_abort_safety_file();
2381 res
= pick_commits(&todo_list
, opts
);
2382 todo_list_release(&todo_list
);
2386 void append_signoff(struct strbuf
*msgbuf
, int ignore_footer
, unsigned flag
)
2388 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
2389 struct strbuf sob
= STRBUF_INIT
;
2392 strbuf_addstr(&sob
, sign_off_header
);
2393 strbuf_addstr(&sob
, fmt_name(getenv("GIT_COMMITTER_NAME"),
2394 getenv("GIT_COMMITTER_EMAIL")));
2395 strbuf_addch(&sob
, '\n');
2398 strbuf_complete_line(msgbuf
);
2401 * If the whole message buffer is equal to the sob, pretend that we
2402 * found a conforming footer with a matching sob
2404 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
2405 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
2408 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
2411 const char *append_newlines
= NULL
;
2412 size_t len
= msgbuf
->len
- ignore_footer
;
2416 * The buffer is completely empty. Leave foom for
2417 * the title and body to be filled in by the user.
2419 append_newlines
= "\n\n";
2420 } else if (len
== 1) {
2422 * Buffer contains a single newline. Add another
2423 * so that we leave room for the title and body.
2425 append_newlines
= "\n";
2426 } else if (msgbuf
->buf
[len
- 2] != '\n') {
2428 * Buffer ends with a single newline. Add another
2429 * so that there is an empty line between the message
2432 append_newlines
= "\n";
2433 } /* else, the buffer already ends with two newlines. */
2435 if (append_newlines
)
2436 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
2437 append_newlines
, strlen(append_newlines
));
2440 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
2441 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
2444 strbuf_release(&sob
);
2447 int sequencer_make_script(int keep_empty
, FILE *out
,
2448 int argc
, const char **argv
)
2450 char *format
= NULL
;
2451 struct pretty_print_context pp
= {0};
2452 struct strbuf buf
= STRBUF_INIT
;
2453 struct rev_info revs
;
2454 struct commit
*commit
;
2456 init_revisions(&revs
, NULL
);
2457 revs
.verbose_header
= 1;
2458 revs
.max_parents
= 1;
2459 revs
.cherry_pick
= 1;
2462 revs
.right_only
= 1;
2463 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
2464 revs
.topo_order
= 1;
2466 revs
.pretty_given
= 1;
2467 git_config_get_string("rebase.instructionFormat", &format
);
2468 if (!format
|| !*format
) {
2470 format
= xstrdup("%s");
2472 get_commit_format(format
, &revs
);
2474 pp
.fmt
= revs
.commit_format
;
2475 pp
.output_encoding
= get_log_output_encoding();
2477 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1)
2478 return error(_("make_script: unhandled options"));
2480 if (prepare_revision_walk(&revs
) < 0)
2481 return error(_("make_script: error preparing revisions"));
2483 while ((commit
= get_revision(&revs
))) {
2485 if (!keep_empty
&& is_original_commit_empty(commit
))
2486 strbuf_addf(&buf
, "%c ", comment_line_char
);
2487 strbuf_addf(&buf
, "pick %s ", oid_to_hex(&commit
->object
.oid
));
2488 pretty_print_commit(&pp
, commit
, &buf
);
2489 strbuf_addch(&buf
, '\n');
2490 fputs(buf
.buf
, out
);
2492 strbuf_release(&buf
);
2497 int transform_todo_ids(int shorten_ids
)
2499 const char *todo_file
= rebase_path_todo();
2500 struct todo_list todo_list
= TODO_LIST_INIT
;
2504 strbuf_reset(&todo_list
.buf
);
2505 fd
= open(todo_file
, O_RDONLY
);
2507 return error_errno(_("could not open '%s'"), todo_file
);
2508 if (strbuf_read(&todo_list
.buf
, fd
, 0) < 0) {
2510 return error(_("could not read '%s'."), todo_file
);
2514 res
= parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
);
2516 todo_list_release(&todo_list
);
2517 return error(_("unusable todo list: '%s'"), todo_file
);
2520 out
= fopen(todo_file
, "w");
2522 todo_list_release(&todo_list
);
2523 return error(_("unable to open '%s' for writing"), todo_file
);
2525 for (i
= 0; i
< todo_list
.nr
; i
++) {
2526 struct todo_item
*item
= todo_list
.items
+ i
;
2527 int bol
= item
->offset_in_buf
;
2528 const char *p
= todo_list
.buf
.buf
+ bol
;
2529 int eol
= i
+ 1 < todo_list
.nr
?
2530 todo_list
.items
[i
+ 1].offset_in_buf
:
2533 if (item
->command
>= TODO_EXEC
&& item
->command
!= TODO_DROP
)
2534 fwrite(p
, eol
- bol
, 1, out
);
2536 const char *id
= shorten_ids
?
2537 short_commit_name(item
->commit
) :
2538 oid_to_hex(&item
->commit
->object
.oid
);
2541 p
+= strspn(p
, " \t"); /* left-trim command */
2542 len
= strcspn(p
, " \t"); /* length of command */
2544 fprintf(out
, "%.*s %s %.*s\n",
2545 len
, p
, id
, item
->arg_len
, item
->arg
);
2549 todo_list_release(&todo_list
);
2554 CHECK_IGNORE
= 0, CHECK_WARN
, CHECK_ERROR
2557 static enum check_level
get_missing_commit_check_level(void)
2561 if (git_config_get_value("rebase.missingcommitscheck", &value
) ||
2562 !strcasecmp("ignore", value
))
2563 return CHECK_IGNORE
;
2564 if (!strcasecmp("warn", value
))
2566 if (!strcasecmp("error", value
))
2568 warning(_("unrecognized setting %s for option "
2569 "rebase.missingCommitsCheck. Ignoring."), value
);
2570 return CHECK_IGNORE
;
2574 * Check if the user dropped some commits by mistake
2575 * Behaviour determined by rebase.missingCommitsCheck.
2576 * Check if there is an unrecognized command or a
2577 * bad SHA-1 in a command.
2579 int check_todo_list(void)
2581 enum check_level check_level
= get_missing_commit_check_level();
2582 struct strbuf todo_file
= STRBUF_INIT
;
2583 struct todo_list todo_list
= TODO_LIST_INIT
;
2584 struct strbuf missing
= STRBUF_INIT
;
2585 int advise_to_edit_todo
= 0, res
= 0, fd
, i
;
2587 strbuf_addstr(&todo_file
, rebase_path_todo());
2588 fd
= open(todo_file
.buf
, O_RDONLY
);
2590 res
= error_errno(_("could not open '%s'"), todo_file
.buf
);
2593 if (strbuf_read(&todo_list
.buf
, fd
, 0) < 0) {
2595 res
= error(_("could not read '%s'."), todo_file
.buf
);
2599 advise_to_edit_todo
= res
=
2600 parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
);
2602 if (res
|| check_level
== CHECK_IGNORE
)
2605 /* Mark the commits in git-rebase-todo as seen */
2606 for (i
= 0; i
< todo_list
.nr
; i
++) {
2607 struct commit
*commit
= todo_list
.items
[i
].commit
;
2609 commit
->util
= (void *)1;
2612 todo_list_release(&todo_list
);
2613 strbuf_addstr(&todo_file
, ".backup");
2614 fd
= open(todo_file
.buf
, O_RDONLY
);
2616 res
= error_errno(_("could not open '%s'"), todo_file
.buf
);
2619 if (strbuf_read(&todo_list
.buf
, fd
, 0) < 0) {
2621 res
= error(_("could not read '%s'."), todo_file
.buf
);
2625 strbuf_release(&todo_file
);
2626 res
= !!parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
);
2628 /* Find commits in git-rebase-todo.backup yet unseen */
2629 for (i
= todo_list
.nr
- 1; i
>= 0; i
--) {
2630 struct todo_item
*item
= todo_list
.items
+ i
;
2631 struct commit
*commit
= item
->commit
;
2632 if (commit
&& !commit
->util
) {
2633 strbuf_addf(&missing
, " - %s %.*s\n",
2634 short_commit_name(commit
),
2635 item
->arg_len
, item
->arg
);
2636 commit
->util
= (void *)1;
2640 /* Warn about missing commits */
2644 if (check_level
== CHECK_ERROR
)
2645 advise_to_edit_todo
= res
= 1;
2648 _("Warning: some commits may have been dropped accidentally.\n"
2649 "Dropped commits (newer to older):\n"));
2651 /* Make the list user-friendly and display */
2652 fputs(missing
.buf
, stderr
);
2653 strbuf_release(&missing
);
2655 fprintf(stderr
, _("To avoid this message, use \"drop\" to "
2656 "explicitly remove a commit.\n\n"
2657 "Use 'git config rebase.missingCommitsCheck' to change "
2658 "the level of warnings.\n"
2659 "The possible behaviours are: ignore, warn, error.\n\n"));
2662 strbuf_release(&todo_file
);
2663 todo_list_release(&todo_list
);
2665 if (advise_to_edit_todo
)
2667 _("You can fix this with 'git rebase --edit-todo' "
2668 "and then run 'git rebase --continue'.\n"
2669 "Or you can abort the rebase with 'git rebase"
2675 /* skip picking commits whose parents are unchanged */
2676 int skip_unnecessary_picks(void)
2678 const char *todo_file
= rebase_path_todo();
2679 struct strbuf buf
= STRBUF_INIT
;
2680 struct todo_list todo_list
= TODO_LIST_INIT
;
2681 struct object_id onto_oid
, *oid
= &onto_oid
, *parent_oid
;
2684 if (!read_oneliner(&buf
, rebase_path_onto(), 0))
2685 return error(_("could not read 'onto'"));
2686 if (get_oid(buf
.buf
, &onto_oid
)) {
2687 strbuf_release(&buf
);
2688 return error(_("need a HEAD to fixup"));
2690 strbuf_release(&buf
);
2692 fd
= open(todo_file
, O_RDONLY
);
2694 return error_errno(_("could not open '%s'"), todo_file
);
2696 if (strbuf_read(&todo_list
.buf
, fd
, 0) < 0) {
2698 return error(_("could not read '%s'."), todo_file
);
2701 if (parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
) < 0) {
2702 todo_list_release(&todo_list
);
2706 for (i
= 0; i
< todo_list
.nr
; i
++) {
2707 struct todo_item
*item
= todo_list
.items
+ i
;
2709 if (item
->command
>= TODO_NOOP
)
2711 if (item
->command
!= TODO_PICK
)
2713 if (parse_commit(item
->commit
)) {
2714 todo_list_release(&todo_list
);
2715 return error(_("could not parse commit '%s'"),
2716 oid_to_hex(&item
->commit
->object
.oid
));
2718 if (!item
->commit
->parents
)
2719 break; /* root commit */
2720 if (item
->commit
->parents
->next
)
2721 break; /* merge commit */
2722 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
2723 if (hashcmp(parent_oid
->hash
, oid
->hash
))
2725 oid
= &item
->commit
->object
.oid
;
2728 int offset
= i
< todo_list
.nr
?
2729 todo_list
.items
[i
].offset_in_buf
: todo_list
.buf
.len
;
2730 const char *done_path
= rebase_path_done();
2732 fd
= open(done_path
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
2734 error_errno(_("could not open '%s' for writing"),
2736 todo_list_release(&todo_list
);
2739 if (write_in_full(fd
, todo_list
.buf
.buf
, offset
) < 0) {
2740 error_errno(_("could not write to '%s'"), done_path
);
2741 todo_list_release(&todo_list
);
2747 fd
= open(rebase_path_todo(), O_WRONLY
, 0666);
2749 error_errno(_("could not open '%s' for writing"),
2750 rebase_path_todo());
2751 todo_list_release(&todo_list
);
2754 if (write_in_full(fd
, todo_list
.buf
.buf
+ offset
,
2755 todo_list
.buf
.len
- offset
) < 0) {
2756 error_errno(_("could not write to '%s'"),
2757 rebase_path_todo());
2759 todo_list_release(&todo_list
);
2762 if (ftruncate(fd
, todo_list
.buf
.len
- offset
) < 0) {
2763 error_errno(_("could not truncate '%s'"),
2764 rebase_path_todo());
2765 todo_list_release(&todo_list
);
2771 todo_list
.current
= i
;
2772 if (is_fixup(peek_command(&todo_list
, 0)))
2773 record_in_rewritten(oid
, peek_command(&todo_list
, 0));
2776 todo_list_release(&todo_list
);
2777 printf("%s\n", oid_to_hex(oid
));
2782 struct subject2item_entry
{
2783 struct hashmap_entry entry
;
2785 char subject
[FLEX_ARRAY
];
2788 static int subject2item_cmp(const void *fndata
,
2789 const struct subject2item_entry
*a
,
2790 const struct subject2item_entry
*b
, const void *key
)
2792 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
2796 * Rearrange the todo list that has both "pick commit-id msg" and "pick
2797 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
2798 * after the former, and change "pick" to "fixup"/"squash".
2800 * Note that if the config has specified a custom instruction format, each log
2801 * message will have to be retrieved from the commit (as the oneline in the
2802 * script cannot be trusted) in order to normalize the autosquash arrangement.
2804 int rearrange_squash(void)
2806 const char *todo_file
= rebase_path_todo();
2807 struct todo_list todo_list
= TODO_LIST_INIT
;
2808 struct hashmap subject2item
;
2809 int res
= 0, rearranged
= 0, *next
, *tail
, fd
, i
;
2812 fd
= open(todo_file
, O_RDONLY
);
2814 return error_errno(_("could not open '%s'"), todo_file
);
2815 if (strbuf_read(&todo_list
.buf
, fd
, 0) < 0) {
2817 return error(_("could not read '%s'."), todo_file
);
2820 if (parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
) < 0) {
2821 todo_list_release(&todo_list
);
2826 * The hashmap maps onelines to the respective todo list index.
2828 * If any items need to be rearranged, the next[i] value will indicate
2829 * which item was moved directly after the i'th.
2831 * In that case, last[i] will indicate the index of the latest item to
2832 * be moved to appear after the i'th.
2834 hashmap_init(&subject2item
, (hashmap_cmp_fn
) subject2item_cmp
,
2835 NULL
, todo_list
.nr
);
2836 ALLOC_ARRAY(next
, todo_list
.nr
);
2837 ALLOC_ARRAY(tail
, todo_list
.nr
);
2838 ALLOC_ARRAY(subjects
, todo_list
.nr
);
2839 for (i
= 0; i
< todo_list
.nr
; i
++) {
2840 struct strbuf buf
= STRBUF_INIT
;
2841 struct todo_item
*item
= todo_list
.items
+ i
;
2842 const char *commit_buffer
, *subject
, *p
;
2845 struct subject2item_entry
*entry
;
2847 next
[i
] = tail
[i
] = -1;
2848 if (item
->command
>= TODO_EXEC
) {
2853 if (is_fixup(item
->command
)) {
2854 todo_list_release(&todo_list
);
2855 return error(_("the script was already rearranged."));
2858 item
->commit
->util
= item
;
2860 parse_commit(item
->commit
);
2861 commit_buffer
= get_commit_buffer(item
->commit
, NULL
);
2862 find_commit_subject(commit_buffer
, &subject
);
2863 format_subject(&buf
, subject
, " ");
2864 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
2865 unuse_commit_buffer(item
->commit
, commit_buffer
);
2866 if ((skip_prefix(subject
, "fixup! ", &p
) ||
2867 skip_prefix(subject
, "squash! ", &p
))) {
2868 struct commit
*commit2
;
2873 if (!skip_prefix(p
, "fixup! ", &p
) &&
2874 !skip_prefix(p
, "squash! ", &p
))
2878 if ((entry
= hashmap_get_from_hash(&subject2item
,
2880 /* found by title */
2882 else if (!strchr(p
, ' ') &&
2884 lookup_commit_reference_by_name(p
)) &&
2886 /* found by commit name */
2887 i2
= (struct todo_item
*)commit2
->util
2890 /* copy can be a prefix of the commit subject */
2891 for (i2
= 0; i2
< i
; i2
++)
2893 starts_with(subjects
[i2
], p
))
2901 todo_list
.items
[i
].command
=
2902 starts_with(subject
, "fixup!") ?
2903 TODO_FIXUP
: TODO_SQUASH
;
2909 } else if (!hashmap_get_from_hash(&subject2item
,
2910 strhash(subject
), subject
)) {
2911 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
2913 hashmap_entry_init(entry
, strhash(entry
->subject
));
2914 hashmap_put(&subject2item
, entry
);
2919 struct strbuf buf
= STRBUF_INIT
;
2921 for (i
= 0; i
< todo_list
.nr
; i
++) {
2922 enum todo_command command
= todo_list
.items
[i
].command
;
2926 * Initially, all commands are 'pick's. If it is a
2927 * fixup or a squash now, we have rearranged it.
2929 if (is_fixup(command
))
2933 int offset
= todo_list
.items
[cur
].offset_in_buf
;
2934 int end_offset
= cur
+ 1 < todo_list
.nr
?
2935 todo_list
.items
[cur
+ 1].offset_in_buf
:
2937 char *bol
= todo_list
.buf
.buf
+ offset
;
2938 char *eol
= todo_list
.buf
.buf
+ end_offset
;
2940 /* replace 'pick', by 'fixup' or 'squash' */
2941 command
= todo_list
.items
[cur
].command
;
2942 if (is_fixup(command
)) {
2944 todo_command_info
[command
].str
);
2945 bol
+= strcspn(bol
, " \t");
2948 strbuf_add(&buf
, bol
, eol
- bol
);
2954 fd
= open(todo_file
, O_WRONLY
);
2956 res
= error_errno(_("could not open '%s'"), todo_file
);
2957 else if (write(fd
, buf
.buf
, buf
.len
) < 0)
2958 res
= error_errno(_("could not write to '%s'"), todo_file
);
2959 else if (ftruncate(fd
, buf
.len
) < 0)
2960 res
= error_errno(_("could not truncate '%s'"),
2963 strbuf_release(&buf
);
2968 for (i
= 0; i
< todo_list
.nr
; i
++)
2971 hashmap_free(&subject2item
, 1);
2972 todo_list_release(&todo_list
);