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(the_hash_algo
->empty_tree
);
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 if (hold_locked_index(&index_lock
, LOCK_REPORT_ON_ERROR
) < 0)
446 init_merge_options(&o
);
447 o
.ancestor
= base
? base_label
: "(empty tree)";
449 o
.branch2
= next
? next_label
: "(empty tree)";
450 if (is_rebase_i(opts
))
452 o
.show_rename_progress
= 1;
454 head_tree
= parse_tree_indirect(head
);
455 next_tree
= next
? next
->tree
: empty_tree();
456 base_tree
= base
? base
->tree
: empty_tree();
458 for (xopt
= opts
->xopts
; xopt
!= opts
->xopts
+ opts
->xopts_nr
; xopt
++)
459 parse_merge_opt(&o
, *xopt
);
461 clean
= merge_trees(&o
,
463 next_tree
, base_tree
, &result
);
464 if (is_rebase_i(opts
) && clean
<= 0)
465 fputs(o
.obuf
.buf
, stdout
);
466 strbuf_release(&o
.obuf
);
467 diff_warn_rename_limit("merge.renamelimit", o
.needed_rename_limit
, 0);
471 if (active_cache_changed
&&
472 write_locked_index(&the_index
, &index_lock
, COMMIT_LOCK
))
474 * TRANSLATORS: %s will be "revert", "cherry-pick" or
477 return error(_("%s: Unable to write new index file"),
478 _(action_name(opts
)));
479 rollback_lock_file(&index_lock
);
482 append_signoff(msgbuf
, 0, 0);
485 append_conflicts_hint(msgbuf
);
490 static int is_index_unchanged(void)
492 struct object_id head_oid
;
493 struct commit
*head_commit
;
495 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
496 return error(_("could not resolve HEAD commit\n"));
498 head_commit
= lookup_commit(&head_oid
);
501 * If head_commit is NULL, check_commit, called from
502 * lookup_commit, would have indicated that head_commit is not
503 * a commit object already. parse_commit() will return failure
504 * without further complaints in such a case. Otherwise, if
505 * the commit is invalid, parse_commit() will complain. So
506 * there is nothing for us to say here. Just return failure.
508 if (parse_commit(head_commit
))
511 if (!active_cache_tree
)
512 active_cache_tree
= cache_tree();
514 if (!cache_tree_fully_valid(active_cache_tree
))
515 if (cache_tree_update(&the_index
, 0))
516 return error(_("unable to update cache tree\n"));
518 return !oidcmp(&active_cache_tree
->oid
,
519 &head_commit
->tree
->object
.oid
);
522 static int write_author_script(const char *message
)
524 struct strbuf buf
= STRBUF_INIT
;
529 if (!*message
|| starts_with(message
, "\n")) {
531 /* Missing 'author' line? */
532 unlink(rebase_path_author_script());
534 } else if (skip_prefix(message
, "author ", &message
))
536 else if ((eol
= strchr(message
, '\n')))
541 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
542 while (*message
&& *message
!= '\n' && *message
!= '\r')
543 if (skip_prefix(message
, " <", &message
))
545 else if (*message
!= '\'')
546 strbuf_addch(&buf
, *(message
++));
548 strbuf_addf(&buf
, "'\\\\%c'", *(message
++));
549 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
550 while (*message
&& *message
!= '\n' && *message
!= '\r')
551 if (skip_prefix(message
, "> ", &message
))
553 else if (*message
!= '\'')
554 strbuf_addch(&buf
, *(message
++));
556 strbuf_addf(&buf
, "'\\\\%c'", *(message
++));
557 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
558 while (*message
&& *message
!= '\n' && *message
!= '\r')
559 if (*message
!= '\'')
560 strbuf_addch(&buf
, *(message
++));
562 strbuf_addf(&buf
, "'\\\\%c'", *(message
++));
563 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
564 strbuf_release(&buf
);
569 * Read a list of environment variable assignments (such as the author-script
570 * file) into an environment block. Returns -1 on error, 0 otherwise.
572 static int read_env_script(struct argv_array
*env
)
574 struct strbuf script
= STRBUF_INIT
;
578 if (strbuf_read_file(&script
, rebase_path_author_script(), 256) <= 0)
581 for (p
= script
.buf
; *p
; p
++)
582 if (skip_prefix(p
, "'\\\\''", (const char **)&p2
))
583 strbuf_splice(&script
, p
- script
.buf
, p2
- p
, "'", 1);
585 strbuf_splice(&script
, p
-- - script
.buf
, 1, "", 0);
586 else if (*p
== '\n') {
591 for (i
= 0, p
= script
.buf
; i
< count
; i
++) {
592 argv_array_push(env
, p
);
599 static const char staged_changes_advice
[] =
600 N_("you have staged changes in your working tree\n"
601 "If these changes are meant to be squashed into the previous commit, run:\n"
603 " git commit --amend %s\n"
605 "If they are meant to go into a new commit, run:\n"
609 "In both cases, once you're done, continue with:\n"
611 " git rebase --continue\n");
613 #define ALLOW_EMPTY (1<<0)
614 #define EDIT_MSG (1<<1)
615 #define AMEND_MSG (1<<2)
616 #define CLEANUP_MSG (1<<3)
617 #define VERIFY_MSG (1<<4)
620 * If we are cherry-pick, and if the merge did not result in
621 * hand-editing, we will hit this commit and inherit the original
622 * author date and name.
624 * If we are revert, or if our cherry-pick results in a hand merge,
625 * we had better say that the current user is responsible for that.
627 * An exception is when run_git_commit() is called during an
628 * interactive rebase: in that case, we will want to retain the
631 static int run_git_commit(const char *defmsg
, struct replay_opts
*opts
,
634 struct child_process cmd
= CHILD_PROCESS_INIT
;
639 if (is_rebase_i(opts
)) {
640 if (!(flags
& EDIT_MSG
)) {
641 cmd
.stdout_to_stderr
= 1;
645 if (read_env_script(&cmd
.env_array
)) {
646 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
648 return error(_(staged_changes_advice
),
653 argv_array_push(&cmd
.args
, "commit");
655 if (!(flags
& VERIFY_MSG
))
656 argv_array_push(&cmd
.args
, "-n");
657 if ((flags
& AMEND_MSG
))
658 argv_array_push(&cmd
.args
, "--amend");
660 argv_array_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
662 argv_array_push(&cmd
.args
, "-s");
664 argv_array_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
665 if ((flags
& CLEANUP_MSG
))
666 argv_array_push(&cmd
.args
, "--cleanup=strip");
667 if ((flags
& EDIT_MSG
))
668 argv_array_push(&cmd
.args
, "-e");
669 else if (!(flags
& CLEANUP_MSG
) &&
670 !opts
->signoff
&& !opts
->record_origin
&&
671 git_config_get_value("commit.cleanup", &value
))
672 argv_array_push(&cmd
.args
, "--cleanup=verbatim");
674 if ((flags
& ALLOW_EMPTY
))
675 argv_array_push(&cmd
.args
, "--allow-empty");
677 if (opts
->allow_empty_message
)
678 argv_array_push(&cmd
.args
, "--allow-empty-message");
681 /* hide stderr on success */
682 struct strbuf buf
= STRBUF_INIT
;
683 int rc
= pipe_command(&cmd
,
685 /* stdout is already redirected */
689 fputs(buf
.buf
, stderr
);
690 strbuf_release(&buf
);
694 return run_command(&cmd
);
697 static int is_original_commit_empty(struct commit
*commit
)
699 const struct object_id
*ptree_oid
;
701 if (parse_commit(commit
))
702 return error(_("could not parse commit %s\n"),
703 oid_to_hex(&commit
->object
.oid
));
704 if (commit
->parents
) {
705 struct commit
*parent
= commit
->parents
->item
;
706 if (parse_commit(parent
))
707 return error(_("could not parse parent commit %s\n"),
708 oid_to_hex(&parent
->object
.oid
));
709 ptree_oid
= &parent
->tree
->object
.oid
;
711 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
714 return !oidcmp(ptree_oid
, &commit
->tree
->object
.oid
);
718 * Do we run "git commit" with "--allow-empty"?
720 static int allow_empty(struct replay_opts
*opts
, struct commit
*commit
)
722 int index_unchanged
, empty_commit
;
727 * (1) we do not allow empty at all and error out.
729 * (2) we allow ones that were initially empty, but
730 * forbid the ones that become empty;
734 if (!opts
->allow_empty
)
735 return 0; /* let "git commit" barf as necessary */
737 index_unchanged
= is_index_unchanged();
738 if (index_unchanged
< 0)
739 return index_unchanged
;
740 if (!index_unchanged
)
741 return 0; /* we do not have to say --allow-empty */
743 if (opts
->keep_redundant_commits
)
746 empty_commit
= is_original_commit_empty(commit
);
747 if (empty_commit
< 0)
756 * Note that ordering matters in this enum. Not only must it match the mapping
757 * below, it is also divided into several sections that matter. When adding
758 * new commands, make sure you add it in the right section.
761 /* commands that handle commits */
768 /* commands that do something else than handling a single commit */
770 /* commands that do nothing but are counted for reporting progress */
773 /* comments (not counted for reporting progress) */
780 } todo_command_info
[] = {
793 static const char *command_to_string(const enum todo_command command
)
795 if (command
< TODO_COMMENT
)
796 return todo_command_info
[command
].str
;
797 die("Unknown command: %d", command
);
800 static int is_noop(const enum todo_command command
)
802 return TODO_NOOP
<= command
;
805 static int is_fixup(enum todo_command command
)
807 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
810 static int update_squash_messages(enum todo_command command
,
811 struct commit
*commit
, struct replay_opts
*opts
)
813 struct strbuf buf
= STRBUF_INIT
;
815 const char *message
, *body
;
817 if (file_exists(rebase_path_squash_msg())) {
818 struct strbuf header
= STRBUF_INIT
;
821 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 2048) <= 0)
822 return error(_("could not read '%s'"),
823 rebase_path_squash_msg());
826 eol
= strchrnul(buf
.buf
, '\n');
827 if (buf
.buf
[0] != comment_line_char
||
828 (p
+= strcspn(p
, "0123456789\n")) == eol
)
829 return error(_("unexpected 1st line of squash message:"
831 (int)(eol
- buf
.buf
), buf
.buf
);
832 count
= strtol(p
, NULL
, 10);
835 return error(_("invalid 1st line of squash message:\n"
837 (int)(eol
- buf
.buf
), buf
.buf
);
839 strbuf_addf(&header
, "%c ", comment_line_char
);
841 _("This is a combination of %d commits."), ++count
);
842 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
843 strbuf_release(&header
);
845 struct object_id head
;
846 struct commit
*head_commit
;
847 const char *head_message
, *body
;
849 if (get_oid("HEAD", &head
))
850 return error(_("need a HEAD to fixup"));
851 if (!(head_commit
= lookup_commit_reference(&head
)))
852 return error(_("could not read HEAD"));
853 if (!(head_message
= get_commit_buffer(head_commit
, NULL
)))
854 return error(_("could not read HEAD's commit message"));
856 find_commit_subject(head_message
, &body
);
857 if (write_message(body
, strlen(body
),
858 rebase_path_fixup_msg(), 0)) {
859 unuse_commit_buffer(head_commit
, head_message
);
860 return error(_("cannot write '%s'"),
861 rebase_path_fixup_msg());
865 strbuf_addf(&buf
, "%c ", comment_line_char
);
866 strbuf_addf(&buf
, _("This is a combination of %d commits."),
868 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
869 strbuf_addstr(&buf
, _("This is the 1st commit message:"));
870 strbuf_addstr(&buf
, "\n\n");
871 strbuf_addstr(&buf
, body
);
873 unuse_commit_buffer(head_commit
, head_message
);
876 if (!(message
= get_commit_buffer(commit
, NULL
)))
877 return error(_("could not read commit message of %s"),
878 oid_to_hex(&commit
->object
.oid
));
879 find_commit_subject(message
, &body
);
881 if (command
== TODO_SQUASH
) {
882 unlink(rebase_path_fixup_msg());
883 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
884 strbuf_addf(&buf
, _("This is the commit message #%d:"), count
);
885 strbuf_addstr(&buf
, "\n\n");
886 strbuf_addstr(&buf
, body
);
887 } else if (command
== TODO_FIXUP
) {
888 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
889 strbuf_addf(&buf
, _("The commit message #%d will be skipped:"),
891 strbuf_addstr(&buf
, "\n\n");
892 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
894 return error(_("unknown command: %d"), command
);
895 unuse_commit_buffer(commit
, message
);
897 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(), 0);
898 strbuf_release(&buf
);
902 static void flush_rewritten_pending(void) {
903 struct strbuf buf
= STRBUF_INIT
;
904 struct object_id newoid
;
907 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
908 !get_oid("HEAD", &newoid
) &&
909 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
910 char *bol
= buf
.buf
, *eol
;
913 eol
= strchrnul(bol
, '\n');
914 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
915 bol
, oid_to_hex(&newoid
));
921 unlink(rebase_path_rewritten_pending());
923 strbuf_release(&buf
);
926 static void record_in_rewritten(struct object_id
*oid
,
927 enum todo_command next_command
) {
928 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
933 fprintf(out
, "%s\n", oid_to_hex(oid
));
936 if (!is_fixup(next_command
))
937 flush_rewritten_pending();
940 static int do_pick_commit(enum todo_command command
, struct commit
*commit
,
941 struct replay_opts
*opts
, int final_fixup
)
943 unsigned int flags
= opts
->edit
? EDIT_MSG
: 0;
944 const char *msg_file
= opts
->edit
? NULL
: git_path_merge_msg();
945 struct object_id head
;
946 struct commit
*base
, *next
, *parent
;
947 const char *base_label
, *next_label
;
948 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
949 struct strbuf msgbuf
= STRBUF_INIT
;
950 int res
, unborn
= 0, allow
;
952 if (opts
->no_commit
) {
954 * We do not intend to commit immediately. We just want to
955 * merge the differences in, so let's compute the tree
956 * that represents the "current" state for merge-recursive
959 if (write_cache_as_tree(head
.hash
, 0, NULL
))
960 return error(_("your index file is unmerged."));
962 unborn
= get_oid("HEAD", &head
);
964 oidcpy(&head
, the_hash_algo
->empty_tree
);
965 if (index_differs_from(unborn
? EMPTY_TREE_SHA1_HEX
: "HEAD",
967 return error_dirty_index(opts
);
971 if (!commit
->parents
)
973 else if (commit
->parents
->next
) {
974 /* Reverting or cherry-picking a merge commit */
976 struct commit_list
*p
;
979 return error(_("commit %s is a merge but no -m option was given."),
980 oid_to_hex(&commit
->object
.oid
));
982 for (cnt
= 1, p
= commit
->parents
;
983 cnt
!= opts
->mainline
&& p
;
986 if (cnt
!= opts
->mainline
|| !p
)
987 return error(_("commit %s does not have parent %d"),
988 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
990 } else if (0 < opts
->mainline
)
991 return error(_("mainline was specified but commit %s is not a merge."),
992 oid_to_hex(&commit
->object
.oid
));
994 parent
= commit
->parents
->item
;
996 if (get_message(commit
, &msg
) != 0)
997 return error(_("cannot get commit message for %s"),
998 oid_to_hex(&commit
->object
.oid
));
1000 if (opts
->allow_ff
&& !is_fixup(command
) &&
1001 ((parent
&& !oidcmp(&parent
->object
.oid
, &head
)) ||
1002 (!parent
&& unborn
))) {
1003 if (is_rebase_i(opts
))
1004 write_author_script(msg
.message
);
1005 res
= fast_forward_to(&commit
->object
.oid
, &head
, unborn
,
1007 if (res
|| command
!= TODO_REWORD
)
1009 flags
|= EDIT_MSG
| AMEND_MSG
;
1010 if (command
== TODO_REWORD
)
1011 flags
|= VERIFY_MSG
;
1013 goto fast_forward_edit
;
1015 if (parent
&& parse_commit(parent
) < 0)
1016 /* TRANSLATORS: The first %s will be a "todo" command like
1017 "revert" or "pick", the second %s a SHA1. */
1018 return error(_("%s: cannot parse parent commit %s"),
1019 command_to_string(command
),
1020 oid_to_hex(&parent
->object
.oid
));
1023 * "commit" is an existing commit. We would want to apply
1024 * the difference it introduces since its first parent "prev"
1025 * on top of the current HEAD if we are cherry-pick. Or the
1026 * reverse of it if we are revert.
1029 if (command
== TODO_REVERT
) {
1031 base_label
= msg
.label
;
1033 next_label
= msg
.parent_label
;
1034 strbuf_addstr(&msgbuf
, "Revert \"");
1035 strbuf_addstr(&msgbuf
, msg
.subject
);
1036 strbuf_addstr(&msgbuf
, "\"\n\nThis reverts commit ");
1037 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
1039 if (commit
->parents
&& commit
->parents
->next
) {
1040 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
1041 strbuf_addstr(&msgbuf
, oid_to_hex(&parent
->object
.oid
));
1043 strbuf_addstr(&msgbuf
, ".\n");
1048 base_label
= msg
.parent_label
;
1050 next_label
= msg
.label
;
1052 /* Append the commit log message to msgbuf. */
1053 if (find_commit_subject(msg
.message
, &p
))
1054 strbuf_addstr(&msgbuf
, p
);
1056 if (opts
->record_origin
) {
1057 strbuf_complete_line(&msgbuf
);
1058 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
1059 strbuf_addch(&msgbuf
, '\n');
1060 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
1061 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
1062 strbuf_addstr(&msgbuf
, ")\n");
1066 if (command
== TODO_REWORD
)
1067 flags
|= EDIT_MSG
| VERIFY_MSG
;
1068 else if (is_fixup(command
)) {
1069 if (update_squash_messages(command
, commit
, opts
))
1073 msg_file
= rebase_path_squash_msg();
1074 else if (file_exists(rebase_path_fixup_msg())) {
1075 flags
|= CLEANUP_MSG
;
1076 msg_file
= rebase_path_fixup_msg();
1078 const char *dest
= git_path_squash_msg();
1080 if (copy_file(dest
, rebase_path_squash_msg(), 0666))
1081 return error(_("could not rename '%s' to '%s'"),
1082 rebase_path_squash_msg(), dest
);
1083 unlink(git_path_merge_msg());
1089 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
1091 else if (!opts
->strategy
|| !strcmp(opts
->strategy
, "recursive") || command
== TODO_REVERT
) {
1092 res
= do_recursive_merge(base
, next
, base_label
, next_label
,
1093 &head
, &msgbuf
, opts
);
1096 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
1097 git_path_merge_msg(), 0);
1099 struct commit_list
*common
= NULL
;
1100 struct commit_list
*remotes
= NULL
;
1102 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
1103 git_path_merge_msg(), 0);
1105 commit_list_insert(base
, &common
);
1106 commit_list_insert(next
, &remotes
);
1107 res
|= try_merge_command(opts
->strategy
,
1108 opts
->xopts_nr
, (const char **)opts
->xopts
,
1109 common
, oid_to_hex(&head
), remotes
);
1110 free_commit_list(common
);
1111 free_commit_list(remotes
);
1113 strbuf_release(&msgbuf
);
1116 * If the merge was clean or if it failed due to conflict, we write
1117 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1118 * However, if the merge did not even start, then we don't want to
1121 if (command
== TODO_PICK
&& !opts
->no_commit
&& (res
== 0 || res
== 1) &&
1122 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
1123 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1125 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
1126 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
1127 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1131 error(command
== TODO_REVERT
1132 ? _("could not revert %s... %s")
1133 : _("could not apply %s... %s"),
1134 short_commit_name(commit
), msg
.subject
);
1135 print_advice(res
== 1, opts
);
1136 rerere(opts
->allow_rerere_auto
);
1140 allow
= allow_empty(opts
, commit
);
1145 flags
|= ALLOW_EMPTY
;
1146 if (!opts
->no_commit
)
1148 res
= run_git_commit(msg_file
, opts
, flags
);
1150 if (!res
&& final_fixup
) {
1151 unlink(rebase_path_fixup_msg());
1152 unlink(rebase_path_squash_msg());
1156 free_message(commit
, &msg
);
1157 update_abort_safety_file();
1162 static int prepare_revs(struct replay_opts
*opts
)
1165 * picking (but not reverting) ranges (but not individual revisions)
1166 * should be done in reverse
1168 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
1169 opts
->revs
->reverse
^= 1;
1171 if (prepare_revision_walk(opts
->revs
))
1172 return error(_("revision walk setup failed"));
1174 if (!opts
->revs
->commits
)
1175 return error(_("empty commit set passed"));
1179 static int read_and_refresh_cache(struct replay_opts
*opts
)
1181 static struct lock_file index_lock
;
1182 int index_fd
= hold_locked_index(&index_lock
, 0);
1183 if (read_index_preload(&the_index
, NULL
) < 0) {
1184 rollback_lock_file(&index_lock
);
1185 return error(_("git %s: failed to read the index"),
1186 _(action_name(opts
)));
1188 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
1189 if (the_index
.cache_changed
&& index_fd
>= 0) {
1190 if (write_locked_index(&the_index
, &index_lock
, COMMIT_LOCK
)) {
1191 return error(_("git %s: failed to refresh the index"),
1192 _(action_name(opts
)));
1195 rollback_lock_file(&index_lock
);
1200 enum todo_command command
;
1201 struct commit
*commit
;
1204 size_t offset_in_buf
;
1209 struct todo_item
*items
;
1210 int nr
, alloc
, current
;
1211 int done_nr
, total_nr
;
1212 struct stat_data stat
;
1215 #define TODO_LIST_INIT { STRBUF_INIT }
1217 static void todo_list_release(struct todo_list
*todo_list
)
1219 strbuf_release(&todo_list
->buf
);
1220 FREE_AND_NULL(todo_list
->items
);
1221 todo_list
->nr
= todo_list
->alloc
= 0;
1224 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
1226 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
1227 return todo_list
->items
+ todo_list
->nr
++;
1230 static int parse_insn_line(struct todo_item
*item
, const char *bol
, char *eol
)
1232 struct object_id commit_oid
;
1233 char *end_of_object_name
;
1234 int i
, saved
, status
, padding
;
1237 bol
+= strspn(bol
, " \t");
1239 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
1240 item
->command
= TODO_COMMENT
;
1241 item
->commit
= NULL
;
1243 item
->arg_len
= eol
- bol
;
1247 for (i
= 0; i
< TODO_COMMENT
; i
++)
1248 if (skip_prefix(bol
, todo_command_info
[i
].str
, &bol
)) {
1251 } else if (bol
[1] == ' ' && *bol
== todo_command_info
[i
].c
) {
1256 if (i
>= TODO_COMMENT
)
1259 if (item
->command
== TODO_NOOP
) {
1260 item
->commit
= NULL
;
1262 item
->arg_len
= eol
- bol
;
1266 /* Eat up extra spaces/ tabs before object name */
1267 padding
= strspn(bol
, " \t");
1272 if (item
->command
== TODO_EXEC
) {
1274 item
->arg_len
= (int)(eol
- bol
);
1278 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
1279 saved
= *end_of_object_name
;
1280 *end_of_object_name
= '\0';
1281 status
= get_oid(bol
, &commit_oid
);
1282 *end_of_object_name
= saved
;
1284 item
->arg
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
1285 item
->arg_len
= (int)(eol
- item
->arg
);
1290 item
->commit
= lookup_commit_reference(&commit_oid
);
1291 return !item
->commit
;
1294 static int parse_insn_buffer(char *buf
, struct todo_list
*todo_list
)
1296 struct todo_item
*item
;
1297 char *p
= buf
, *next_p
;
1298 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
1300 for (i
= 1; *p
; i
++, p
= next_p
) {
1301 char *eol
= strchrnul(p
, '\n');
1303 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
1305 if (p
!= eol
&& eol
[-1] == '\r')
1306 eol
--; /* strip Carriage Return */
1308 item
= append_new_todo(todo_list
);
1309 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
1310 if (parse_insn_line(item
, p
, eol
)) {
1311 res
= error(_("invalid line %d: %.*s"),
1312 i
, (int)(eol
- p
), p
);
1313 item
->command
= TODO_NOOP
;
1318 else if (is_fixup(item
->command
))
1319 return error(_("cannot '%s' without a previous commit"),
1320 command_to_string(item
->command
));
1321 else if (!is_noop(item
->command
))
1328 static int count_commands(struct todo_list
*todo_list
)
1332 for (i
= 0; i
< todo_list
->nr
; i
++)
1333 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
1339 static int read_populate_todo(struct todo_list
*todo_list
,
1340 struct replay_opts
*opts
)
1343 const char *todo_file
= get_todo_path(opts
);
1346 strbuf_reset(&todo_list
->buf
);
1347 fd
= open(todo_file
, O_RDONLY
);
1349 return error_errno(_("could not open '%s'"), todo_file
);
1350 if (strbuf_read(&todo_list
->buf
, fd
, 0) < 0) {
1352 return error(_("could not read '%s'."), todo_file
);
1356 res
= stat(todo_file
, &st
);
1358 return error(_("could not stat '%s'"), todo_file
);
1359 fill_stat_data(&todo_list
->stat
, &st
);
1361 res
= parse_insn_buffer(todo_list
->buf
.buf
, todo_list
);
1363 if (is_rebase_i(opts
))
1364 return error(_("please fix this using "
1365 "'git rebase --edit-todo'."));
1366 return error(_("unusable instruction sheet: '%s'"), todo_file
);
1369 if (!todo_list
->nr
&&
1370 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
1371 return error(_("no commits parsed."));
1373 if (!is_rebase_i(opts
)) {
1374 enum todo_command valid
=
1375 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
1378 for (i
= 0; i
< todo_list
->nr
; i
++)
1379 if (valid
== todo_list
->items
[i
].command
)
1381 else if (valid
== TODO_PICK
)
1382 return error(_("cannot cherry-pick during a revert."));
1384 return error(_("cannot revert during a cherry-pick."));
1387 if (is_rebase_i(opts
)) {
1388 struct todo_list done
= TODO_LIST_INIT
;
1389 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
1391 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
1392 !parse_insn_buffer(done
.buf
.buf
, &done
))
1393 todo_list
->done_nr
= count_commands(&done
);
1395 todo_list
->done_nr
= 0;
1397 todo_list
->total_nr
= todo_list
->done_nr
1398 + count_commands(todo_list
);
1399 todo_list_release(&done
);
1402 fprintf(f
, "%d\n", todo_list
->total_nr
);
1410 static int git_config_string_dup(char **dest
,
1411 const char *var
, const char *value
)
1414 return config_error_nonbool(var
);
1416 *dest
= xstrdup(value
);
1420 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
1422 struct replay_opts
*opts
= data
;
1427 else if (!strcmp(key
, "options.no-commit"))
1428 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
1429 else if (!strcmp(key
, "options.edit"))
1430 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
1431 else if (!strcmp(key
, "options.signoff"))
1432 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
1433 else if (!strcmp(key
, "options.record-origin"))
1434 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
1435 else if (!strcmp(key
, "options.allow-ff"))
1436 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
1437 else if (!strcmp(key
, "options.mainline"))
1438 opts
->mainline
= git_config_int(key
, value
);
1439 else if (!strcmp(key
, "options.strategy"))
1440 git_config_string_dup(&opts
->strategy
, key
, value
);
1441 else if (!strcmp(key
, "options.gpg-sign"))
1442 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
1443 else if (!strcmp(key
, "options.strategy-option")) {
1444 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
1445 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(value
);
1446 } else if (!strcmp(key
, "options.allow-rerere-auto"))
1447 opts
->allow_rerere_auto
=
1448 git_config_bool_or_int(key
, value
, &error_flag
) ?
1449 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
1451 return error(_("invalid key: %s"), key
);
1454 return error(_("invalid value for %s: %s"), key
, value
);
1459 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
1464 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
1466 opts
->strategy
= strbuf_detach(buf
, NULL
);
1467 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
1470 opts
->xopts_nr
= split_cmdline(buf
->buf
, (const char ***)&opts
->xopts
);
1471 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
1472 const char *arg
= opts
->xopts
[i
];
1474 skip_prefix(arg
, "--", &arg
);
1475 opts
->xopts
[i
] = xstrdup(arg
);
1479 static int read_populate_opts(struct replay_opts
*opts
)
1481 if (is_rebase_i(opts
)) {
1482 struct strbuf buf
= STRBUF_INIT
;
1484 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(), 1)) {
1485 if (!starts_with(buf
.buf
, "-S"))
1488 free(opts
->gpg_sign
);
1489 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
1494 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(), 1)) {
1495 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
1496 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
1497 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
1498 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
1502 if (file_exists(rebase_path_verbose()))
1505 read_strategy_opts(opts
, &buf
);
1506 strbuf_release(&buf
);
1511 if (!file_exists(git_path_opts_file()))
1514 * The function git_parse_source(), called from git_config_from_file(),
1515 * may die() in case of a syntactically incorrect file. We do not care
1516 * about this case, though, because we wrote that file ourselves, so we
1517 * are pretty certain that it is syntactically correct.
1519 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
1520 return error(_("malformed options sheet: '%s'"),
1521 git_path_opts_file());
1525 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
1526 struct replay_opts
*opts
)
1528 enum todo_command command
= opts
->action
== REPLAY_PICK
?
1529 TODO_PICK
: TODO_REVERT
;
1530 const char *command_string
= todo_command_info
[command
].str
;
1531 struct commit
*commit
;
1533 if (prepare_revs(opts
))
1536 while ((commit
= get_revision(opts
->revs
))) {
1537 struct todo_item
*item
= append_new_todo(todo_list
);
1538 const char *commit_buffer
= get_commit_buffer(commit
, NULL
);
1539 const char *subject
;
1542 item
->command
= command
;
1543 item
->commit
= commit
;
1546 item
->offset_in_buf
= todo_list
->buf
.len
;
1547 subject_len
= find_commit_subject(commit_buffer
, &subject
);
1548 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
1549 short_commit_name(commit
), subject_len
, subject
);
1550 unuse_commit_buffer(commit
, commit_buffer
);
1555 static int create_seq_dir(void)
1557 if (file_exists(git_path_seq_dir())) {
1558 error(_("a cherry-pick or revert is already in progress"));
1559 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
1561 } else if (mkdir(git_path_seq_dir(), 0777) < 0)
1562 return error_errno(_("could not create sequencer directory '%s'"),
1563 git_path_seq_dir());
1567 static int save_head(const char *head
)
1569 static struct lock_file head_lock
;
1570 struct strbuf buf
= STRBUF_INIT
;
1574 fd
= hold_lock_file_for_update(&head_lock
, git_path_head_file(), 0);
1576 rollback_lock_file(&head_lock
);
1577 return error_errno(_("could not lock HEAD"));
1579 strbuf_addf(&buf
, "%s\n", head
);
1580 written
= write_in_full(fd
, buf
.buf
, buf
.len
);
1581 strbuf_release(&buf
);
1583 rollback_lock_file(&head_lock
);
1584 return error_errno(_("could not write to '%s'"),
1585 git_path_head_file());
1587 if (commit_lock_file(&head_lock
) < 0) {
1588 rollback_lock_file(&head_lock
);
1589 return error(_("failed to finalize '%s'."), git_path_head_file());
1594 static int rollback_is_safe(void)
1596 struct strbuf sb
= STRBUF_INIT
;
1597 struct object_id expected_head
, actual_head
;
1599 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
1601 if (get_oid_hex(sb
.buf
, &expected_head
)) {
1602 strbuf_release(&sb
);
1603 die(_("could not parse %s"), git_path_abort_safety_file());
1605 strbuf_release(&sb
);
1607 else if (errno
== ENOENT
)
1608 oidclr(&expected_head
);
1610 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
1612 if (get_oid("HEAD", &actual_head
))
1613 oidclr(&actual_head
);
1615 return !oidcmp(&actual_head
, &expected_head
);
1618 static int reset_for_rollback(const struct object_id
*oid
)
1620 const char *argv
[4]; /* reset --merge <arg> + NULL */
1623 argv
[1] = "--merge";
1624 argv
[2] = oid_to_hex(oid
);
1626 return run_command_v_opt(argv
, RUN_GIT_CMD
);
1629 static int rollback_single_pick(void)
1631 struct object_id head_oid
;
1633 if (!file_exists(git_path_cherry_pick_head()) &&
1634 !file_exists(git_path_revert_head()))
1635 return error(_("no cherry-pick or revert in progress"));
1636 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
1637 return error(_("cannot resolve HEAD"));
1638 if (is_null_oid(&head_oid
))
1639 return error(_("cannot abort from a branch yet to be born"));
1640 return reset_for_rollback(&head_oid
);
1643 int sequencer_rollback(struct replay_opts
*opts
)
1646 struct object_id oid
;
1647 struct strbuf buf
= STRBUF_INIT
;
1650 f
= fopen(git_path_head_file(), "r");
1651 if (!f
&& errno
== ENOENT
) {
1653 * There is no multiple-cherry-pick in progress.
1654 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
1655 * a single-cherry-pick in progress, abort that.
1657 return rollback_single_pick();
1660 return error_errno(_("cannot open '%s'"), git_path_head_file());
1661 if (strbuf_getline_lf(&buf
, f
)) {
1662 error(_("cannot read '%s': %s"), git_path_head_file(),
1663 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
1668 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
1669 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
1670 git_path_head_file());
1673 if (is_null_oid(&oid
)) {
1674 error(_("cannot abort from a branch yet to be born"));
1678 if (!rollback_is_safe()) {
1679 /* Do not error, just do not rollback */
1680 warning(_("You seem to have moved HEAD. "
1681 "Not rewinding, check your HEAD!"));
1683 if (reset_for_rollback(&oid
))
1685 strbuf_release(&buf
);
1686 return sequencer_remove_state(opts
);
1688 strbuf_release(&buf
);
1692 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
1694 static struct lock_file todo_lock
;
1695 const char *todo_path
= get_todo_path(opts
);
1696 int next
= todo_list
->current
, offset
, fd
;
1699 * rebase -i writes "git-rebase-todo" without the currently executing
1700 * command, appending it to "done" instead.
1702 if (is_rebase_i(opts
))
1705 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
1707 return error_errno(_("could not lock '%s'"), todo_path
);
1708 offset
= next
< todo_list
->nr
?
1709 todo_list
->items
[next
].offset_in_buf
: todo_list
->buf
.len
;
1710 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
1711 todo_list
->buf
.len
- offset
) < 0)
1712 return error_errno(_("could not write to '%s'"), todo_path
);
1713 if (commit_lock_file(&todo_lock
) < 0)
1714 return error(_("failed to finalize '%s'."), todo_path
);
1716 if (is_rebase_i(opts
)) {
1717 const char *done_path
= rebase_path_done();
1718 int fd
= open(done_path
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
1719 int prev_offset
= !next
? 0 :
1720 todo_list
->items
[next
- 1].offset_in_buf
;
1722 if (fd
>= 0 && offset
> prev_offset
&&
1723 write_in_full(fd
, todo_list
->buf
.buf
+ prev_offset
,
1724 offset
- prev_offset
) < 0) {
1726 return error_errno(_("could not write to '%s'"),
1735 static int save_opts(struct replay_opts
*opts
)
1737 const char *opts_file
= git_path_opts_file();
1740 if (opts
->no_commit
)
1741 res
|= git_config_set_in_file_gently(opts_file
, "options.no-commit", "true");
1743 res
|= git_config_set_in_file_gently(opts_file
, "options.edit", "true");
1745 res
|= git_config_set_in_file_gently(opts_file
, "options.signoff", "true");
1746 if (opts
->record_origin
)
1747 res
|= git_config_set_in_file_gently(opts_file
, "options.record-origin", "true");
1749 res
|= git_config_set_in_file_gently(opts_file
, "options.allow-ff", "true");
1750 if (opts
->mainline
) {
1751 struct strbuf buf
= STRBUF_INIT
;
1752 strbuf_addf(&buf
, "%d", opts
->mainline
);
1753 res
|= git_config_set_in_file_gently(opts_file
, "options.mainline", buf
.buf
);
1754 strbuf_release(&buf
);
1757 res
|= git_config_set_in_file_gently(opts_file
, "options.strategy", opts
->strategy
);
1759 res
|= git_config_set_in_file_gently(opts_file
, "options.gpg-sign", opts
->gpg_sign
);
1762 for (i
= 0; i
< opts
->xopts_nr
; i
++)
1763 res
|= git_config_set_multivar_in_file_gently(opts_file
,
1764 "options.strategy-option",
1765 opts
->xopts
[i
], "^$", 0);
1767 if (opts
->allow_rerere_auto
)
1768 res
|= git_config_set_in_file_gently(opts_file
, "options.allow-rerere-auto",
1769 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
1774 static int make_patch(struct commit
*commit
, struct replay_opts
*opts
)
1776 struct strbuf buf
= STRBUF_INIT
;
1777 struct rev_info log_tree_opt
;
1778 const char *subject
, *p
;
1781 p
= short_commit_name(commit
);
1782 if (write_message(p
, strlen(p
), rebase_path_stopped_sha(), 1) < 0)
1785 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
1786 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
1787 init_revisions(&log_tree_opt
, NULL
);
1788 log_tree_opt
.abbrev
= 0;
1789 log_tree_opt
.diff
= 1;
1790 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
1791 log_tree_opt
.disable_stdin
= 1;
1792 log_tree_opt
.no_commit_id
= 1;
1793 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
1794 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
1795 if (!log_tree_opt
.diffopt
.file
)
1796 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
1798 res
|= log_tree_commit(&log_tree_opt
, commit
);
1799 fclose(log_tree_opt
.diffopt
.file
);
1803 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
1804 if (!file_exists(buf
.buf
)) {
1805 const char *commit_buffer
= get_commit_buffer(commit
, NULL
);
1806 find_commit_subject(commit_buffer
, &subject
);
1807 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
1808 unuse_commit_buffer(commit
, commit_buffer
);
1810 strbuf_release(&buf
);
1815 static int intend_to_amend(void)
1817 struct object_id head
;
1820 if (get_oid("HEAD", &head
))
1821 return error(_("cannot read HEAD"));
1823 p
= oid_to_hex(&head
);
1824 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
1827 static int error_with_patch(struct commit
*commit
,
1828 const char *subject
, int subject_len
,
1829 struct replay_opts
*opts
, int exit_code
, int to_amend
)
1831 if (make_patch(commit
, opts
))
1835 if (intend_to_amend())
1838 fprintf(stderr
, "You can amend the commit now, with\n"
1840 " git commit --amend %s\n"
1842 "Once you are satisfied with your changes, run\n"
1844 " git rebase --continue\n", gpg_sign_opt_quoted(opts
));
1845 } else if (exit_code
)
1846 fprintf(stderr
, "Could not apply %s... %.*s\n",
1847 short_commit_name(commit
), subject_len
, subject
);
1852 static int error_failed_squash(struct commit
*commit
,
1853 struct replay_opts
*opts
, int subject_len
, const char *subject
)
1855 if (rename(rebase_path_squash_msg(), rebase_path_message()))
1856 return error(_("could not rename '%s' to '%s'"),
1857 rebase_path_squash_msg(), rebase_path_message());
1858 unlink(rebase_path_fixup_msg());
1859 unlink(git_path_merge_msg());
1860 if (copy_file(git_path_merge_msg(), rebase_path_message(), 0666))
1861 return error(_("could not copy '%s' to '%s'"),
1862 rebase_path_message(), git_path_merge_msg());
1863 return error_with_patch(commit
, subject
, subject_len
, opts
, 1, 0);
1866 static int do_exec(const char *command_line
)
1868 struct argv_array child_env
= ARGV_ARRAY_INIT
;
1869 const char *child_argv
[] = { NULL
, NULL
};
1872 fprintf(stderr
, "Executing: %s\n", command_line
);
1873 child_argv
[0] = command_line
;
1874 argv_array_pushf(&child_env
, "GIT_DIR=%s", absolute_path(get_git_dir()));
1875 status
= run_command_v_opt_cd_env(child_argv
, RUN_USING_SHELL
, NULL
,
1878 /* force re-reading of the cache */
1879 if (discard_cache() < 0 || read_cache() < 0)
1880 return error(_("could not read index"));
1882 dirty
= require_clean_work_tree("rebase", NULL
, 1, 1);
1885 warning(_("execution failed: %s\n%s"
1886 "You can fix the problem, and then run\n"
1888 " git rebase --continue\n"
1891 dirty
? N_("and made changes to the index and/or the "
1892 "working tree\n") : "");
1894 /* command not found */
1897 warning(_("execution succeeded: %s\nbut "
1898 "left changes to the index and/or the working tree\n"
1899 "Commit or stash your changes, and then run\n"
1901 " git rebase --continue\n"
1902 "\n"), command_line
);
1906 argv_array_clear(&child_env
);
1911 static int is_final_fixup(struct todo_list
*todo_list
)
1913 int i
= todo_list
->current
;
1915 if (!is_fixup(todo_list
->items
[i
].command
))
1918 while (++i
< todo_list
->nr
)
1919 if (is_fixup(todo_list
->items
[i
].command
))
1921 else if (!is_noop(todo_list
->items
[i
].command
))
1926 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
1930 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
1931 if (!is_noop(todo_list
->items
[i
].command
))
1932 return todo_list
->items
[i
].command
;
1937 static int apply_autostash(struct replay_opts
*opts
)
1939 struct strbuf stash_sha1
= STRBUF_INIT
;
1940 struct child_process child
= CHILD_PROCESS_INIT
;
1943 if (!read_oneliner(&stash_sha1
, rebase_path_autostash(), 1)) {
1944 strbuf_release(&stash_sha1
);
1947 strbuf_trim(&stash_sha1
);
1950 child
.no_stdout
= 1;
1951 child
.no_stderr
= 1;
1952 argv_array_push(&child
.args
, "stash");
1953 argv_array_push(&child
.args
, "apply");
1954 argv_array_push(&child
.args
, stash_sha1
.buf
);
1955 if (!run_command(&child
))
1956 fprintf(stderr
, _("Applied autostash.\n"));
1958 struct child_process store
= CHILD_PROCESS_INIT
;
1961 argv_array_push(&store
.args
, "stash");
1962 argv_array_push(&store
.args
, "store");
1963 argv_array_push(&store
.args
, "-m");
1964 argv_array_push(&store
.args
, "autostash");
1965 argv_array_push(&store
.args
, "-q");
1966 argv_array_push(&store
.args
, stash_sha1
.buf
);
1967 if (run_command(&store
))
1968 ret
= error(_("cannot store %s"), stash_sha1
.buf
);
1971 _("Applying autostash resulted in conflicts.\n"
1972 "Your changes are safe in the stash.\n"
1973 "You can run \"git stash pop\" or"
1974 " \"git stash drop\" at any time.\n"));
1977 strbuf_release(&stash_sha1
);
1981 static const char *reflog_message(struct replay_opts
*opts
,
1982 const char *sub_action
, const char *fmt
, ...)
1985 static struct strbuf buf
= STRBUF_INIT
;
1989 strbuf_addstr(&buf
, action_name(opts
));
1991 strbuf_addf(&buf
, " (%s)", sub_action
);
1993 strbuf_addstr(&buf
, ": ");
1994 strbuf_vaddf(&buf
, fmt
, ap
);
2001 static int pick_commits(struct todo_list
*todo_list
, struct replay_opts
*opts
)
2005 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
2007 assert(!(opts
->signoff
|| opts
->no_commit
||
2008 opts
->record_origin
|| opts
->edit
));
2009 if (read_and_refresh_cache(opts
))
2012 while (todo_list
->current
< todo_list
->nr
) {
2013 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
2014 if (save_todo(todo_list
, opts
))
2016 if (is_rebase_i(opts
)) {
2017 if (item
->command
!= TODO_COMMENT
) {
2018 FILE *f
= fopen(rebase_path_msgnum(), "w");
2020 todo_list
->done_nr
++;
2023 fprintf(f
, "%d\n", todo_list
->done_nr
);
2026 fprintf(stderr
, "Rebasing (%d/%d)%s",
2028 todo_list
->total_nr
,
2029 opts
->verbose
? "\n" : "\r");
2031 unlink(rebase_path_message());
2032 unlink(rebase_path_author_script());
2033 unlink(rebase_path_stopped_sha());
2034 unlink(rebase_path_amend());
2036 if (item
->command
<= TODO_SQUASH
) {
2037 if (is_rebase_i(opts
))
2038 setenv("GIT_REFLOG_ACTION", reflog_message(opts
,
2039 command_to_string(item
->command
), NULL
),
2041 res
= do_pick_commit(item
->command
, item
->commit
,
2042 opts
, is_final_fixup(todo_list
));
2043 if (is_rebase_i(opts
) && res
< 0) {
2045 todo_list
->current
--;
2046 if (save_todo(todo_list
, opts
))
2049 if (item
->command
== TODO_EDIT
) {
2050 struct commit
*commit
= item
->commit
;
2053 _("Stopped at %s... %.*s\n"),
2054 short_commit_name(commit
),
2055 item
->arg_len
, item
->arg
);
2056 return error_with_patch(commit
,
2057 item
->arg
, item
->arg_len
, opts
, res
,
2060 if (is_rebase_i(opts
) && !res
)
2061 record_in_rewritten(&item
->commit
->object
.oid
,
2062 peek_command(todo_list
, 1));
2063 if (res
&& is_fixup(item
->command
)) {
2066 return error_failed_squash(item
->commit
, opts
,
2067 item
->arg_len
, item
->arg
);
2068 } else if (res
&& is_rebase_i(opts
))
2069 return res
| error_with_patch(item
->commit
,
2070 item
->arg
, item
->arg_len
, opts
, res
,
2071 item
->command
== TODO_REWORD
);
2072 } else if (item
->command
== TODO_EXEC
) {
2073 char *end_of_arg
= (char *)(item
->arg
+ item
->arg_len
);
2074 int saved
= *end_of_arg
;
2078 res
= do_exec(item
->arg
);
2079 *end_of_arg
= saved
;
2081 /* Reread the todo file if it has changed. */
2083 ; /* fall through */
2084 else if (stat(get_todo_path(opts
), &st
))
2085 res
= error_errno(_("could not stat '%s'"),
2086 get_todo_path(opts
));
2087 else if (match_stat_data(&todo_list
->stat
, &st
)) {
2088 todo_list_release(todo_list
);
2089 if (read_populate_todo(todo_list
, opts
))
2090 res
= -1; /* message was printed */
2091 /* `current` will be incremented below */
2092 todo_list
->current
= -1;
2094 } else if (!is_noop(item
->command
))
2095 return error(_("unknown command %d"), item
->command
);
2097 todo_list
->current
++;
2102 if (is_rebase_i(opts
)) {
2103 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
2106 /* Stopped in the middle, as planned? */
2107 if (todo_list
->current
< todo_list
->nr
)
2110 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
2111 starts_with(head_ref
.buf
, "refs/")) {
2113 struct object_id head
, orig
;
2116 if (get_oid("HEAD", &head
)) {
2117 res
= error(_("cannot read HEAD"));
2119 strbuf_release(&head_ref
);
2120 strbuf_release(&buf
);
2123 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
2124 get_oid_hex(buf
.buf
, &orig
)) {
2125 res
= error(_("could not read orig-head"));
2126 goto cleanup_head_ref
;
2129 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
2130 res
= error(_("could not read 'onto'"));
2131 goto cleanup_head_ref
;
2133 msg
= reflog_message(opts
, "finish", "%s onto %s",
2134 head_ref
.buf
, buf
.buf
);
2135 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
2136 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
2137 res
= error(_("could not update %s"),
2139 goto cleanup_head_ref
;
2141 msg
= reflog_message(opts
, "finish", "returning to %s",
2143 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
2144 res
= error(_("could not update HEAD to %s"),
2146 goto cleanup_head_ref
;
2151 if (opts
->verbose
) {
2152 struct rev_info log_tree_opt
;
2153 struct object_id orig
, head
;
2155 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
2156 init_revisions(&log_tree_opt
, NULL
);
2157 log_tree_opt
.diff
= 1;
2158 log_tree_opt
.diffopt
.output_format
=
2159 DIFF_FORMAT_DIFFSTAT
;
2160 log_tree_opt
.disable_stdin
= 1;
2162 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
2163 !get_oid(buf
.buf
, &orig
) &&
2164 !get_oid("HEAD", &head
)) {
2165 diff_tree_oid(&orig
, &head
, "",
2166 &log_tree_opt
.diffopt
);
2167 log_tree_diff_flush(&log_tree_opt
);
2170 flush_rewritten_pending();
2171 if (!stat(rebase_path_rewritten_list(), &st
) &&
2173 struct child_process child
= CHILD_PROCESS_INIT
;
2174 const char *post_rewrite_hook
=
2175 find_hook("post-rewrite");
2177 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
2179 argv_array_push(&child
.args
, "notes");
2180 argv_array_push(&child
.args
, "copy");
2181 argv_array_push(&child
.args
, "--for-rewrite=rebase");
2182 /* we don't care if this copying failed */
2183 run_command(&child
);
2185 if (post_rewrite_hook
) {
2186 struct child_process hook
= CHILD_PROCESS_INIT
;
2188 hook
.in
= open(rebase_path_rewritten_list(),
2190 hook
.stdout_to_stderr
= 1;
2191 argv_array_push(&hook
.args
, post_rewrite_hook
);
2192 argv_array_push(&hook
.args
, "rebase");
2193 /* we don't care if this hook failed */
2197 apply_autostash(opts
);
2199 fprintf(stderr
, "Successfully rebased and updated %s.\n",
2202 strbuf_release(&buf
);
2203 strbuf_release(&head_ref
);
2207 * Sequence of picks finished successfully; cleanup by
2208 * removing the .git/sequencer directory
2210 return sequencer_remove_state(opts
);
2213 static int continue_single_pick(void)
2215 const char *argv
[] = { "commit", NULL
};
2217 if (!file_exists(git_path_cherry_pick_head()) &&
2218 !file_exists(git_path_revert_head()))
2219 return error(_("no cherry-pick or revert in progress"));
2220 return run_command_v_opt(argv
, RUN_GIT_CMD
);
2223 static int commit_staged_changes(struct replay_opts
*opts
)
2225 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
2227 if (has_unstaged_changes(1))
2228 return error(_("cannot rebase: You have unstaged changes."));
2229 if (!has_uncommitted_changes(0)) {
2230 const char *cherry_pick_head
= git_path_cherry_pick_head();
2232 if (file_exists(cherry_pick_head
) && unlink(cherry_pick_head
))
2233 return error(_("could not remove CHERRY_PICK_HEAD"));
2237 if (file_exists(rebase_path_amend())) {
2238 struct strbuf rev
= STRBUF_INIT
;
2239 struct object_id head
, to_amend
;
2241 if (get_oid("HEAD", &head
))
2242 return error(_("cannot amend non-existing commit"));
2243 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
2244 return error(_("invalid file: '%s'"), rebase_path_amend());
2245 if (get_oid_hex(rev
.buf
, &to_amend
))
2246 return error(_("invalid contents: '%s'"),
2247 rebase_path_amend());
2248 if (oidcmp(&head
, &to_amend
))
2249 return error(_("\nYou have uncommitted changes in your "
2250 "working tree. Please, commit them\n"
2251 "first and then run 'git rebase "
2252 "--continue' again."));
2254 strbuf_release(&rev
);
2258 if (run_git_commit(rebase_path_message(), opts
, flags
))
2259 return error(_("could not commit staged changes."));
2260 unlink(rebase_path_amend());
2264 int sequencer_continue(struct replay_opts
*opts
)
2266 struct todo_list todo_list
= TODO_LIST_INIT
;
2269 if (read_and_refresh_cache(opts
))
2272 if (is_rebase_i(opts
)) {
2273 if (commit_staged_changes(opts
))
2275 } else if (!file_exists(get_todo_path(opts
)))
2276 return continue_single_pick();
2277 if (read_populate_opts(opts
))
2279 if ((res
= read_populate_todo(&todo_list
, opts
)))
2280 goto release_todo_list
;
2282 if (!is_rebase_i(opts
)) {
2283 /* Verify that the conflict has been resolved */
2284 if (file_exists(git_path_cherry_pick_head()) ||
2285 file_exists(git_path_revert_head())) {
2286 res
= continue_single_pick();
2288 goto release_todo_list
;
2290 if (index_differs_from("HEAD", NULL
, 0)) {
2291 res
= error_dirty_index(opts
);
2292 goto release_todo_list
;
2294 todo_list
.current
++;
2295 } else if (file_exists(rebase_path_stopped_sha())) {
2296 struct strbuf buf
= STRBUF_INIT
;
2297 struct object_id oid
;
2299 if (read_oneliner(&buf
, rebase_path_stopped_sha(), 1) &&
2300 !get_oid_committish(buf
.buf
, &oid
))
2301 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
2302 strbuf_release(&buf
);
2305 res
= pick_commits(&todo_list
, opts
);
2307 todo_list_release(&todo_list
);
2311 static int single_pick(struct commit
*cmit
, struct replay_opts
*opts
)
2313 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
2314 return do_pick_commit(opts
->action
== REPLAY_PICK
?
2315 TODO_PICK
: TODO_REVERT
, cmit
, opts
, 0);
2318 int sequencer_pick_revisions(struct replay_opts
*opts
)
2320 struct todo_list todo_list
= TODO_LIST_INIT
;
2321 struct object_id oid
;
2325 if (read_and_refresh_cache(opts
))
2328 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
2329 struct object_id oid
;
2330 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
2332 /* This happens when using --stdin. */
2336 if (!get_oid(name
, &oid
)) {
2337 if (!lookup_commit_reference_gently(&oid
, 1)) {
2338 enum object_type type
= sha1_object_info(oid
.hash
, NULL
);
2339 return error(_("%s: can't cherry-pick a %s"),
2340 name
, typename(type
));
2343 return error(_("%s: bad revision"), name
);
2347 * If we were called as "git cherry-pick <commit>", just
2348 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
2349 * REVERT_HEAD, and don't touch the sequencer state.
2350 * This means it is possible to cherry-pick in the middle
2351 * of a cherry-pick sequence.
2353 if (opts
->revs
->cmdline
.nr
== 1 &&
2354 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
2355 opts
->revs
->no_walk
&&
2356 !opts
->revs
->cmdline
.rev
->flags
) {
2357 struct commit
*cmit
;
2358 if (prepare_revision_walk(opts
->revs
))
2359 return error(_("revision walk setup failed"));
2360 cmit
= get_revision(opts
->revs
);
2361 if (!cmit
|| get_revision(opts
->revs
))
2362 return error("BUG: expected exactly one commit from walk");
2363 return single_pick(cmit
, opts
);
2367 * Start a new cherry-pick/ revert sequence; but
2368 * first, make sure that an existing one isn't in
2372 if (walk_revs_populate_todo(&todo_list
, opts
) ||
2373 create_seq_dir() < 0)
2375 if (get_oid("HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
2376 return error(_("can't revert as initial commit"));
2377 if (save_head(oid_to_hex(&oid
)))
2379 if (save_opts(opts
))
2381 update_abort_safety_file();
2382 res
= pick_commits(&todo_list
, opts
);
2383 todo_list_release(&todo_list
);
2387 void append_signoff(struct strbuf
*msgbuf
, int ignore_footer
, unsigned flag
)
2389 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
2390 struct strbuf sob
= STRBUF_INIT
;
2393 strbuf_addstr(&sob
, sign_off_header
);
2394 strbuf_addstr(&sob
, fmt_name(getenv("GIT_COMMITTER_NAME"),
2395 getenv("GIT_COMMITTER_EMAIL")));
2396 strbuf_addch(&sob
, '\n');
2399 strbuf_complete_line(msgbuf
);
2402 * If the whole message buffer is equal to the sob, pretend that we
2403 * found a conforming footer with a matching sob
2405 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
2406 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
2409 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
2412 const char *append_newlines
= NULL
;
2413 size_t len
= msgbuf
->len
- ignore_footer
;
2417 * The buffer is completely empty. Leave foom for
2418 * the title and body to be filled in by the user.
2420 append_newlines
= "\n\n";
2421 } else if (len
== 1) {
2423 * Buffer contains a single newline. Add another
2424 * so that we leave room for the title and body.
2426 append_newlines
= "\n";
2427 } else if (msgbuf
->buf
[len
- 2] != '\n') {
2429 * Buffer ends with a single newline. Add another
2430 * so that there is an empty line between the message
2433 append_newlines
= "\n";
2434 } /* else, the buffer already ends with two newlines. */
2436 if (append_newlines
)
2437 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
2438 append_newlines
, strlen(append_newlines
));
2441 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
2442 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
2445 strbuf_release(&sob
);
2448 int sequencer_make_script(int keep_empty
, FILE *out
,
2449 int argc
, const char **argv
)
2451 char *format
= NULL
;
2452 struct pretty_print_context pp
= {0};
2453 struct strbuf buf
= STRBUF_INIT
;
2454 struct rev_info revs
;
2455 struct commit
*commit
;
2457 init_revisions(&revs
, NULL
);
2458 revs
.verbose_header
= 1;
2459 revs
.max_parents
= 1;
2460 revs
.cherry_pick
= 1;
2463 revs
.right_only
= 1;
2464 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
2465 revs
.topo_order
= 1;
2467 revs
.pretty_given
= 1;
2468 git_config_get_string("rebase.instructionFormat", &format
);
2469 if (!format
|| !*format
) {
2471 format
= xstrdup("%s");
2473 get_commit_format(format
, &revs
);
2475 pp
.fmt
= revs
.commit_format
;
2476 pp
.output_encoding
= get_log_output_encoding();
2478 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1)
2479 return error(_("make_script: unhandled options"));
2481 if (prepare_revision_walk(&revs
) < 0)
2482 return error(_("make_script: error preparing revisions"));
2484 while ((commit
= get_revision(&revs
))) {
2486 if (!keep_empty
&& is_original_commit_empty(commit
))
2487 strbuf_addf(&buf
, "%c ", comment_line_char
);
2488 strbuf_addf(&buf
, "pick %s ", oid_to_hex(&commit
->object
.oid
));
2489 pretty_print_commit(&pp
, commit
, &buf
);
2490 strbuf_addch(&buf
, '\n');
2491 fputs(buf
.buf
, out
);
2493 strbuf_release(&buf
);
2498 int transform_todo_ids(int shorten_ids
)
2500 const char *todo_file
= rebase_path_todo();
2501 struct todo_list todo_list
= TODO_LIST_INIT
;
2505 strbuf_reset(&todo_list
.buf
);
2506 fd
= open(todo_file
, O_RDONLY
);
2508 return error_errno(_("could not open '%s'"), todo_file
);
2509 if (strbuf_read(&todo_list
.buf
, fd
, 0) < 0) {
2511 return error(_("could not read '%s'."), todo_file
);
2515 res
= parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
);
2517 todo_list_release(&todo_list
);
2518 return error(_("unusable todo list: '%s'"), todo_file
);
2521 out
= fopen(todo_file
, "w");
2523 todo_list_release(&todo_list
);
2524 return error(_("unable to open '%s' for writing"), todo_file
);
2526 for (i
= 0; i
< todo_list
.nr
; i
++) {
2527 struct todo_item
*item
= todo_list
.items
+ i
;
2528 int bol
= item
->offset_in_buf
;
2529 const char *p
= todo_list
.buf
.buf
+ bol
;
2530 int eol
= i
+ 1 < todo_list
.nr
?
2531 todo_list
.items
[i
+ 1].offset_in_buf
:
2534 if (item
->command
>= TODO_EXEC
&& item
->command
!= TODO_DROP
)
2535 fwrite(p
, eol
- bol
, 1, out
);
2537 const char *id
= shorten_ids
?
2538 short_commit_name(item
->commit
) :
2539 oid_to_hex(&item
->commit
->object
.oid
);
2542 p
+= strspn(p
, " \t"); /* left-trim command */
2543 len
= strcspn(p
, " \t"); /* length of command */
2545 fprintf(out
, "%.*s %s %.*s\n",
2546 len
, p
, id
, item
->arg_len
, item
->arg
);
2550 todo_list_release(&todo_list
);
2555 CHECK_IGNORE
= 0, CHECK_WARN
, CHECK_ERROR
2558 static enum check_level
get_missing_commit_check_level(void)
2562 if (git_config_get_value("rebase.missingcommitscheck", &value
) ||
2563 !strcasecmp("ignore", value
))
2564 return CHECK_IGNORE
;
2565 if (!strcasecmp("warn", value
))
2567 if (!strcasecmp("error", value
))
2569 warning(_("unrecognized setting %s for option "
2570 "rebase.missingCommitsCheck. Ignoring."), value
);
2571 return CHECK_IGNORE
;
2575 * Check if the user dropped some commits by mistake
2576 * Behaviour determined by rebase.missingCommitsCheck.
2577 * Check if there is an unrecognized command or a
2578 * bad SHA-1 in a command.
2580 int check_todo_list(void)
2582 enum check_level check_level
= get_missing_commit_check_level();
2583 struct strbuf todo_file
= STRBUF_INIT
;
2584 struct todo_list todo_list
= TODO_LIST_INIT
;
2585 struct strbuf missing
= STRBUF_INIT
;
2586 int advise_to_edit_todo
= 0, res
= 0, fd
, i
;
2588 strbuf_addstr(&todo_file
, rebase_path_todo());
2589 fd
= open(todo_file
.buf
, O_RDONLY
);
2591 res
= error_errno(_("could not open '%s'"), todo_file
.buf
);
2594 if (strbuf_read(&todo_list
.buf
, fd
, 0) < 0) {
2596 res
= error(_("could not read '%s'."), todo_file
.buf
);
2600 advise_to_edit_todo
= res
=
2601 parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
);
2603 if (res
|| check_level
== CHECK_IGNORE
)
2606 /* Mark the commits in git-rebase-todo as seen */
2607 for (i
= 0; i
< todo_list
.nr
; i
++) {
2608 struct commit
*commit
= todo_list
.items
[i
].commit
;
2610 commit
->util
= (void *)1;
2613 todo_list_release(&todo_list
);
2614 strbuf_addstr(&todo_file
, ".backup");
2615 fd
= open(todo_file
.buf
, O_RDONLY
);
2617 res
= error_errno(_("could not open '%s'"), todo_file
.buf
);
2620 if (strbuf_read(&todo_list
.buf
, fd
, 0) < 0) {
2622 res
= error(_("could not read '%s'."), todo_file
.buf
);
2626 strbuf_release(&todo_file
);
2627 res
= !!parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
);
2629 /* Find commits in git-rebase-todo.backup yet unseen */
2630 for (i
= todo_list
.nr
- 1; i
>= 0; i
--) {
2631 struct todo_item
*item
= todo_list
.items
+ i
;
2632 struct commit
*commit
= item
->commit
;
2633 if (commit
&& !commit
->util
) {
2634 strbuf_addf(&missing
, " - %s %.*s\n",
2635 short_commit_name(commit
),
2636 item
->arg_len
, item
->arg
);
2637 commit
->util
= (void *)1;
2641 /* Warn about missing commits */
2645 if (check_level
== CHECK_ERROR
)
2646 advise_to_edit_todo
= res
= 1;
2649 _("Warning: some commits may have been dropped accidentally.\n"
2650 "Dropped commits (newer to older):\n"));
2652 /* Make the list user-friendly and display */
2653 fputs(missing
.buf
, stderr
);
2654 strbuf_release(&missing
);
2656 fprintf(stderr
, _("To avoid this message, use \"drop\" to "
2657 "explicitly remove a commit.\n\n"
2658 "Use 'git config rebase.missingCommitsCheck' to change "
2659 "the level of warnings.\n"
2660 "The possible behaviours are: ignore, warn, error.\n\n"));
2663 strbuf_release(&todo_file
);
2664 todo_list_release(&todo_list
);
2666 if (advise_to_edit_todo
)
2668 _("You can fix this with 'git rebase --edit-todo' "
2669 "and then run 'git rebase --continue'.\n"
2670 "Or you can abort the rebase with 'git rebase"
2676 static int rewrite_file(const char *path
, const char *buf
, size_t len
)
2679 int fd
= open(path
, O_WRONLY
| O_TRUNC
);
2681 return error_errno(_("could not open '%s' for writing"), path
);
2682 if (write_in_full(fd
, buf
, len
) < 0)
2683 rc
= error_errno(_("could not write to '%s'"), path
);
2684 if (close(fd
) && !rc
)
2685 rc
= error_errno(_("could not close '%s'"), path
);
2689 /* skip picking commits whose parents are unchanged */
2690 int skip_unnecessary_picks(void)
2692 const char *todo_file
= rebase_path_todo();
2693 struct strbuf buf
= STRBUF_INIT
;
2694 struct todo_list todo_list
= TODO_LIST_INIT
;
2695 struct object_id onto_oid
, *oid
= &onto_oid
, *parent_oid
;
2698 if (!read_oneliner(&buf
, rebase_path_onto(), 0))
2699 return error(_("could not read 'onto'"));
2700 if (get_oid(buf
.buf
, &onto_oid
)) {
2701 strbuf_release(&buf
);
2702 return error(_("need a HEAD to fixup"));
2704 strbuf_release(&buf
);
2706 fd
= open(todo_file
, O_RDONLY
);
2708 return error_errno(_("could not open '%s'"), todo_file
);
2710 if (strbuf_read(&todo_list
.buf
, fd
, 0) < 0) {
2712 return error(_("could not read '%s'."), todo_file
);
2715 if (parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
) < 0) {
2716 todo_list_release(&todo_list
);
2720 for (i
= 0; i
< todo_list
.nr
; i
++) {
2721 struct todo_item
*item
= todo_list
.items
+ i
;
2723 if (item
->command
>= TODO_NOOP
)
2725 if (item
->command
!= TODO_PICK
)
2727 if (parse_commit(item
->commit
)) {
2728 todo_list_release(&todo_list
);
2729 return error(_("could not parse commit '%s'"),
2730 oid_to_hex(&item
->commit
->object
.oid
));
2732 if (!item
->commit
->parents
)
2733 break; /* root commit */
2734 if (item
->commit
->parents
->next
)
2735 break; /* merge commit */
2736 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
2737 if (hashcmp(parent_oid
->hash
, oid
->hash
))
2739 oid
= &item
->commit
->object
.oid
;
2742 int offset
= i
< todo_list
.nr
?
2743 todo_list
.items
[i
].offset_in_buf
: todo_list
.buf
.len
;
2744 const char *done_path
= rebase_path_done();
2746 fd
= open(done_path
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
2748 error_errno(_("could not open '%s' for writing"),
2750 todo_list_release(&todo_list
);
2753 if (write_in_full(fd
, todo_list
.buf
.buf
, offset
) < 0) {
2754 error_errno(_("could not write to '%s'"), done_path
);
2755 todo_list_release(&todo_list
);
2761 if (rewrite_file(rebase_path_todo(), todo_list
.buf
.buf
+ offset
,
2762 todo_list
.buf
.len
- offset
) < 0) {
2763 todo_list_release(&todo_list
);
2767 todo_list
.current
= i
;
2768 if (is_fixup(peek_command(&todo_list
, 0)))
2769 record_in_rewritten(oid
, peek_command(&todo_list
, 0));
2772 todo_list_release(&todo_list
);
2773 printf("%s\n", oid_to_hex(oid
));
2778 struct subject2item_entry
{
2779 struct hashmap_entry entry
;
2781 char subject
[FLEX_ARRAY
];
2784 static int subject2item_cmp(const void *fndata
,
2785 const struct subject2item_entry
*a
,
2786 const struct subject2item_entry
*b
, const void *key
)
2788 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
2792 * Rearrange the todo list that has both "pick commit-id msg" and "pick
2793 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
2794 * after the former, and change "pick" to "fixup"/"squash".
2796 * Note that if the config has specified a custom instruction format, each log
2797 * message will have to be retrieved from the commit (as the oneline in the
2798 * script cannot be trusted) in order to normalize the autosquash arrangement.
2800 int rearrange_squash(void)
2802 const char *todo_file
= rebase_path_todo();
2803 struct todo_list todo_list
= TODO_LIST_INIT
;
2804 struct hashmap subject2item
;
2805 int res
= 0, rearranged
= 0, *next
, *tail
, fd
, i
;
2808 fd
= open(todo_file
, O_RDONLY
);
2810 return error_errno(_("could not open '%s'"), todo_file
);
2811 if (strbuf_read(&todo_list
.buf
, fd
, 0) < 0) {
2813 return error(_("could not read '%s'."), todo_file
);
2816 if (parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
) < 0) {
2817 todo_list_release(&todo_list
);
2822 * The hashmap maps onelines to the respective todo list index.
2824 * If any items need to be rearranged, the next[i] value will indicate
2825 * which item was moved directly after the i'th.
2827 * In that case, last[i] will indicate the index of the latest item to
2828 * be moved to appear after the i'th.
2830 hashmap_init(&subject2item
, (hashmap_cmp_fn
) subject2item_cmp
,
2831 NULL
, todo_list
.nr
);
2832 ALLOC_ARRAY(next
, todo_list
.nr
);
2833 ALLOC_ARRAY(tail
, todo_list
.nr
);
2834 ALLOC_ARRAY(subjects
, todo_list
.nr
);
2835 for (i
= 0; i
< todo_list
.nr
; i
++) {
2836 struct strbuf buf
= STRBUF_INIT
;
2837 struct todo_item
*item
= todo_list
.items
+ i
;
2838 const char *commit_buffer
, *subject
, *p
;
2841 struct subject2item_entry
*entry
;
2843 next
[i
] = tail
[i
] = -1;
2844 if (item
->command
>= TODO_EXEC
) {
2849 if (is_fixup(item
->command
)) {
2850 todo_list_release(&todo_list
);
2851 return error(_("the script was already rearranged."));
2854 item
->commit
->util
= item
;
2856 parse_commit(item
->commit
);
2857 commit_buffer
= get_commit_buffer(item
->commit
, NULL
);
2858 find_commit_subject(commit_buffer
, &subject
);
2859 format_subject(&buf
, subject
, " ");
2860 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
2861 unuse_commit_buffer(item
->commit
, commit_buffer
);
2862 if ((skip_prefix(subject
, "fixup! ", &p
) ||
2863 skip_prefix(subject
, "squash! ", &p
))) {
2864 struct commit
*commit2
;
2869 if (!skip_prefix(p
, "fixup! ", &p
) &&
2870 !skip_prefix(p
, "squash! ", &p
))
2874 if ((entry
= hashmap_get_from_hash(&subject2item
,
2876 /* found by title */
2878 else if (!strchr(p
, ' ') &&
2880 lookup_commit_reference_by_name(p
)) &&
2882 /* found by commit name */
2883 i2
= (struct todo_item
*)commit2
->util
2886 /* copy can be a prefix of the commit subject */
2887 for (i2
= 0; i2
< i
; i2
++)
2889 starts_with(subjects
[i2
], p
))
2897 todo_list
.items
[i
].command
=
2898 starts_with(subject
, "fixup!") ?
2899 TODO_FIXUP
: TODO_SQUASH
;
2905 } else if (!hashmap_get_from_hash(&subject2item
,
2906 strhash(subject
), subject
)) {
2907 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
2909 hashmap_entry_init(entry
, strhash(entry
->subject
));
2910 hashmap_put(&subject2item
, entry
);
2915 struct strbuf buf
= STRBUF_INIT
;
2917 for (i
= 0; i
< todo_list
.nr
; i
++) {
2918 enum todo_command command
= todo_list
.items
[i
].command
;
2922 * Initially, all commands are 'pick's. If it is a
2923 * fixup or a squash now, we have rearranged it.
2925 if (is_fixup(command
))
2929 int offset
= todo_list
.items
[cur
].offset_in_buf
;
2930 int end_offset
= cur
+ 1 < todo_list
.nr
?
2931 todo_list
.items
[cur
+ 1].offset_in_buf
:
2933 char *bol
= todo_list
.buf
.buf
+ offset
;
2934 char *eol
= todo_list
.buf
.buf
+ end_offset
;
2936 /* replace 'pick', by 'fixup' or 'squash' */
2937 command
= todo_list
.items
[cur
].command
;
2938 if (is_fixup(command
)) {
2940 todo_command_info
[command
].str
);
2941 bol
+= strcspn(bol
, " \t");
2944 strbuf_add(&buf
, bol
, eol
- bol
);
2950 res
= rewrite_file(todo_file
, buf
.buf
, buf
.len
);
2951 strbuf_release(&buf
);
2956 for (i
= 0; i
< todo_list
.nr
; i
++)
2959 hashmap_free(&subject2item
, 1);
2960 todo_list_release(&todo_list
);