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"
24 #include "notes-utils.h"
27 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
29 const char sign_off_header
[] = "Signed-off-by: ";
30 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
32 GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
34 GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
36 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
37 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
38 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
39 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
41 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
43 * The file containing rebase commands, comments, and empty lines.
44 * This file is created by "git rebase -i" then edited by the user. As
45 * the lines are processed, they are removed from the front of this
46 * file and written to the tail of 'done'.
48 static GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
50 * The rebase command lines that have already been processed. A line
51 * is moved here when it is first handled, before any associated user
54 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
56 * The file to keep track of how many commands were already processed (e.g.
59 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum");
61 * The file to keep track of how many commands are to be processed in total
62 * (e.g. for the prompt).
64 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end");
66 * The commit message that is planned to be used for any changes that
67 * need to be committed following a user interaction.
69 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
71 * The file into which is accumulated the suggested commit message for
72 * squash/fixup commands. When the first of a series of squash/fixups
73 * is seen, the file is created and the commit message from the
74 * previous commit and from the first squash/fixup commit are written
75 * to it. The commit message for each subsequent squash/fixup commit
76 * is appended to the file as it is processed.
78 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
80 * If the current series of squash/fixups has not yet included a squash
81 * command, then this file exists and holds the commit message of the
82 * original "pick" commit. (If the series ends without a "squash"
83 * command, then this can be used as the commit message of the combined
84 * commit without opening the editor.)
86 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
88 * This file contains the list fixup/squash commands that have been
89 * accumulated into message-fixup or message-squash so far.
91 static GIT_PATH_FUNC(rebase_path_current_fixups
, "rebase-merge/current-fixups")
93 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
94 * GIT_AUTHOR_DATE that will be used for the commit that is currently
97 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
99 * When an "edit" rebase command is being processed, the SHA1 of the
100 * commit to be edited is recorded in this file. When "git rebase
101 * --continue" is executed, if there are any staged changes then they
102 * will be amended to the HEAD commit, but only provided the HEAD
103 * commit is still the commit to be edited. When any other rebase
104 * command is processed, this file is deleted.
106 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
108 * When we stop at a given patch via the "edit" command, this file contains
109 * the abbreviated commit name of the corresponding patch.
111 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
113 * For the post-rewrite hook, we make a list of rewritten commits and
114 * their new sha1s. The rewritten-pending list keeps the sha1s of
115 * commits that have been processed, but not committed yet,
116 * e.g. because they are waiting for a 'squash' command.
118 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
119 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
120 "rebase-merge/rewritten-pending")
122 * The following files are written by git-rebase just after parsing the
123 * command-line (and are only consumed, not modified, by the sequencer).
125 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
126 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
127 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
128 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
129 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
130 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
131 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
132 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
133 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
135 static int git_sequencer_config(const char *k
, const char *v
, void *cb
)
137 struct replay_opts
*opts
= cb
;
140 if (!strcmp(k
, "commit.cleanup")) {
143 status
= git_config_string(&s
, k
, v
);
147 if (!strcmp(s
, "verbatim"))
148 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
149 else if (!strcmp(s
, "whitespace"))
150 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
151 else if (!strcmp(s
, "strip"))
152 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_ALL
;
153 else if (!strcmp(s
, "scissors"))
154 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
156 warning(_("invalid commit message cleanup mode '%s'"),
162 if (!strcmp(k
, "commit.gpgsign")) {
163 opts
->gpg_sign
= git_config_bool(k
, v
) ? xstrdup("") : NULL
;
167 status
= git_gpg_config(k
, v
, NULL
);
171 return git_diff_basic_config(k
, v
, NULL
);
174 void sequencer_init_config(struct replay_opts
*opts
)
176 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
177 git_config(git_sequencer_config
, opts
);
180 static inline int is_rebase_i(const struct replay_opts
*opts
)
182 return opts
->action
== REPLAY_INTERACTIVE_REBASE
;
185 static const char *get_dir(const struct replay_opts
*opts
)
187 if (is_rebase_i(opts
))
188 return rebase_path();
189 return git_path_seq_dir();
192 static const char *get_todo_path(const struct replay_opts
*opts
)
194 if (is_rebase_i(opts
))
195 return rebase_path_todo();
196 return git_path_todo_file();
200 * Returns 0 for non-conforming footer
201 * Returns 1 for conforming footer
202 * Returns 2 when sob exists within conforming footer
203 * Returns 3 when sob exists within conforming footer as last entry
205 static int has_conforming_footer(struct strbuf
*sb
, struct strbuf
*sob
,
208 struct trailer_info info
;
210 int found_sob
= 0, found_sob_last
= 0;
212 trailer_info_get(&info
, sb
->buf
);
214 if (info
.trailer_start
== info
.trailer_end
)
217 for (i
= 0; i
< info
.trailer_nr
; i
++)
218 if (sob
&& !strncmp(info
.trailers
[i
], sob
->buf
, sob
->len
)) {
220 if (i
== info
.trailer_nr
- 1)
224 trailer_info_release(&info
);
233 static const char *gpg_sign_opt_quoted(struct replay_opts
*opts
)
235 static struct strbuf buf
= STRBUF_INIT
;
239 sq_quotef(&buf
, "-S%s", opts
->gpg_sign
);
243 int sequencer_remove_state(struct replay_opts
*opts
)
245 struct strbuf dir
= STRBUF_INIT
;
248 free(opts
->gpg_sign
);
249 free(opts
->strategy
);
250 for (i
= 0; i
< opts
->xopts_nr
; i
++)
251 free(opts
->xopts
[i
]);
253 strbuf_release(&opts
->current_fixups
);
255 strbuf_addstr(&dir
, get_dir(opts
));
256 remove_dir_recursively(&dir
, 0);
257 strbuf_release(&dir
);
262 static const char *action_name(const struct replay_opts
*opts
)
264 switch (opts
->action
) {
268 return N_("cherry-pick");
269 case REPLAY_INTERACTIVE_REBASE
:
270 return N_("rebase -i");
272 die(_("Unknown action: %d"), opts
->action
);
275 struct commit_message
{
282 static const char *short_commit_name(struct commit
*commit
)
284 return find_unique_abbrev(commit
->object
.oid
.hash
, DEFAULT_ABBREV
);
287 static int get_message(struct commit
*commit
, struct commit_message
*out
)
289 const char *abbrev
, *subject
;
292 out
->message
= logmsg_reencode(commit
, NULL
, get_commit_output_encoding());
293 abbrev
= short_commit_name(commit
);
295 subject_len
= find_commit_subject(out
->message
, &subject
);
297 out
->subject
= xmemdupz(subject
, subject_len
);
298 out
->label
= xstrfmt("%s... %s", abbrev
, out
->subject
);
299 out
->parent_label
= xstrfmt("parent of %s", out
->label
);
304 static void free_message(struct commit
*commit
, struct commit_message
*msg
)
306 free(msg
->parent_label
);
309 unuse_commit_buffer(commit
, msg
->message
);
312 static void print_advice(int show_hint
, struct replay_opts
*opts
)
314 char *msg
= getenv("GIT_CHERRY_PICK_HELP");
317 fprintf(stderr
, "%s\n", msg
);
319 * A conflict has occurred but the porcelain
320 * (typically rebase --interactive) wants to take care
321 * of the commit itself so remove CHERRY_PICK_HEAD
323 unlink(git_path_cherry_pick_head());
329 advise(_("after resolving the conflicts, mark the corrected paths\n"
330 "with 'git add <paths>' or 'git rm <paths>'"));
332 advise(_("after resolving the conflicts, mark the corrected paths\n"
333 "with 'git add <paths>' or 'git rm <paths>'\n"
334 "and commit the result with 'git commit'"));
338 static int write_message(const void *buf
, size_t len
, const char *filename
,
341 struct lock_file msg_file
= LOCK_INIT
;
343 int msg_fd
= hold_lock_file_for_update(&msg_file
, filename
, 0);
345 return error_errno(_("could not lock '%s'"), filename
);
346 if (write_in_full(msg_fd
, buf
, len
) < 0) {
347 rollback_lock_file(&msg_file
);
348 return error_errno(_("could not write to '%s'"), filename
);
350 if (append_eol
&& write(msg_fd
, "\n", 1) < 0) {
351 rollback_lock_file(&msg_file
);
352 return error_errno(_("could not write eol to '%s'"), filename
);
354 if (commit_lock_file(&msg_file
) < 0)
355 return error(_("failed to finalize '%s'"), filename
);
361 * Reads a file that was presumably written by a shell script, i.e. with an
362 * end-of-line marker that needs to be stripped.
364 * Note that only the last end-of-line marker is stripped, consistent with the
365 * behavior of "$(cat path)" in a shell script.
367 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
369 static int read_oneliner(struct strbuf
*buf
,
370 const char *path
, int skip_if_empty
)
372 int orig_len
= buf
->len
;
374 if (!file_exists(path
))
377 if (strbuf_read_file(buf
, path
, 0) < 0) {
378 warning_errno(_("could not read '%s'"), path
);
382 if (buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\n') {
383 if (--buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\r')
385 buf
->buf
[buf
->len
] = '\0';
388 if (skip_if_empty
&& buf
->len
== orig_len
)
394 static struct tree
*empty_tree(void)
396 return lookup_tree(the_hash_algo
->empty_tree
);
399 static int error_dirty_index(struct replay_opts
*opts
)
401 if (read_cache_unmerged())
402 return error_resolve_conflict(_(action_name(opts
)));
404 error(_("your local changes would be overwritten by %s."),
405 _(action_name(opts
)));
407 if (advice_commit_before_merge
)
408 advise(_("commit your changes or stash them to proceed."));
412 static void update_abort_safety_file(void)
414 struct object_id head
;
416 /* Do nothing on a single-pick */
417 if (!file_exists(git_path_seq_dir()))
420 if (!get_oid("HEAD", &head
))
421 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head
));
423 write_file(git_path_abort_safety_file(), "%s", "");
426 static int fast_forward_to(const struct object_id
*to
, const struct object_id
*from
,
427 int unborn
, struct replay_opts
*opts
)
429 struct ref_transaction
*transaction
;
430 struct strbuf sb
= STRBUF_INIT
;
431 struct strbuf err
= STRBUF_INIT
;
434 if (checkout_fast_forward(from
, to
, 1))
435 return -1; /* the callee should have complained already */
437 strbuf_addf(&sb
, _("%s: fast-forward"), _(action_name(opts
)));
439 transaction
= ref_transaction_begin(&err
);
441 ref_transaction_update(transaction
, "HEAD",
442 to
, unborn
? &null_oid
: from
,
444 ref_transaction_commit(transaction
, &err
)) {
445 ref_transaction_free(transaction
);
446 error("%s", err
.buf
);
448 strbuf_release(&err
);
453 strbuf_release(&err
);
454 ref_transaction_free(transaction
);
455 update_abort_safety_file();
459 void append_conflicts_hint(struct strbuf
*msgbuf
)
463 strbuf_addch(msgbuf
, '\n');
464 strbuf_commented_addf(msgbuf
, "Conflicts:\n");
465 for (i
= 0; i
< active_nr
;) {
466 const struct cache_entry
*ce
= active_cache
[i
++];
468 strbuf_commented_addf(msgbuf
, "\t%s\n", ce
->name
);
469 while (i
< active_nr
&& !strcmp(ce
->name
,
470 active_cache
[i
]->name
))
476 static int do_recursive_merge(struct commit
*base
, struct commit
*next
,
477 const char *base_label
, const char *next_label
,
478 struct object_id
*head
, struct strbuf
*msgbuf
,
479 struct replay_opts
*opts
)
481 struct merge_options o
;
482 struct tree
*result
, *next_tree
, *base_tree
, *head_tree
;
485 struct lock_file index_lock
= LOCK_INIT
;
487 if (hold_locked_index(&index_lock
, LOCK_REPORT_ON_ERROR
) < 0)
492 init_merge_options(&o
);
493 o
.ancestor
= base
? base_label
: "(empty tree)";
495 o
.branch2
= next
? next_label
: "(empty tree)";
496 if (is_rebase_i(opts
))
498 o
.show_rename_progress
= 1;
500 head_tree
= parse_tree_indirect(head
);
501 next_tree
= next
? next
->tree
: empty_tree();
502 base_tree
= base
? base
->tree
: empty_tree();
504 for (xopt
= opts
->xopts
; xopt
!= opts
->xopts
+ opts
->xopts_nr
; xopt
++)
505 parse_merge_opt(&o
, *xopt
);
507 clean
= merge_trees(&o
,
509 next_tree
, base_tree
, &result
);
510 if (is_rebase_i(opts
) && clean
<= 0)
511 fputs(o
.obuf
.buf
, stdout
);
512 strbuf_release(&o
.obuf
);
513 diff_warn_rename_limit("merge.renamelimit", o
.needed_rename_limit
, 0);
515 rollback_lock_file(&index_lock
);
519 if (write_locked_index(&the_index
, &index_lock
,
520 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
522 * TRANSLATORS: %s will be "revert", "cherry-pick" or
525 return error(_("%s: Unable to write new index file"),
526 _(action_name(opts
)));
529 append_conflicts_hint(msgbuf
);
534 static int is_index_unchanged(void)
536 struct object_id head_oid
;
537 struct commit
*head_commit
;
539 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
540 return error(_("could not resolve HEAD commit"));
542 head_commit
= lookup_commit(&head_oid
);
545 * If head_commit is NULL, check_commit, called from
546 * lookup_commit, would have indicated that head_commit is not
547 * a commit object already. parse_commit() will return failure
548 * without further complaints in such a case. Otherwise, if
549 * the commit is invalid, parse_commit() will complain. So
550 * there is nothing for us to say here. Just return failure.
552 if (parse_commit(head_commit
))
555 if (!active_cache_tree
)
556 active_cache_tree
= cache_tree();
558 if (!cache_tree_fully_valid(active_cache_tree
))
559 if (cache_tree_update(&the_index
, 0))
560 return error(_("unable to update cache tree"));
562 return !oidcmp(&active_cache_tree
->oid
,
563 &head_commit
->tree
->object
.oid
);
566 static int write_author_script(const char *message
)
568 struct strbuf buf
= STRBUF_INIT
;
573 if (!*message
|| starts_with(message
, "\n")) {
575 /* Missing 'author' line? */
576 unlink(rebase_path_author_script());
578 } else if (skip_prefix(message
, "author ", &message
))
580 else if ((eol
= strchr(message
, '\n')))
585 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
586 while (*message
&& *message
!= '\n' && *message
!= '\r')
587 if (skip_prefix(message
, " <", &message
))
589 else if (*message
!= '\'')
590 strbuf_addch(&buf
, *(message
++));
592 strbuf_addf(&buf
, "'\\\\%c'", *(message
++));
593 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
594 while (*message
&& *message
!= '\n' && *message
!= '\r')
595 if (skip_prefix(message
, "> ", &message
))
597 else if (*message
!= '\'')
598 strbuf_addch(&buf
, *(message
++));
600 strbuf_addf(&buf
, "'\\\\%c'", *(message
++));
601 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
602 while (*message
&& *message
!= '\n' && *message
!= '\r')
603 if (*message
!= '\'')
604 strbuf_addch(&buf
, *(message
++));
606 strbuf_addf(&buf
, "'\\\\%c'", *(message
++));
607 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
608 strbuf_release(&buf
);
613 * Read a list of environment variable assignments (such as the author-script
614 * file) into an environment block. Returns -1 on error, 0 otherwise.
616 static int read_env_script(struct argv_array
*env
)
618 struct strbuf script
= STRBUF_INIT
;
622 if (strbuf_read_file(&script
, rebase_path_author_script(), 256) <= 0)
625 for (p
= script
.buf
; *p
; p
++)
626 if (skip_prefix(p
, "'\\\\''", (const char **)&p2
))
627 strbuf_splice(&script
, p
- script
.buf
, p2
- p
, "'", 1);
629 strbuf_splice(&script
, p
-- - script
.buf
, 1, "", 0);
630 else if (*p
== '\n') {
635 for (i
= 0, p
= script
.buf
; i
< count
; i
++) {
636 argv_array_push(env
, p
);
643 static char *get_author(const char *message
)
648 a
= find_commit_header(message
, "author", &len
);
650 return xmemdupz(a
, len
);
655 static const char staged_changes_advice
[] =
656 N_("you have staged changes in your working tree\n"
657 "If these changes are meant to be squashed into the previous commit, run:\n"
659 " git commit --amend %s\n"
661 "If they are meant to go into a new commit, run:\n"
665 "In both cases, once you're done, continue with:\n"
667 " git rebase --continue\n");
669 #define ALLOW_EMPTY (1<<0)
670 #define EDIT_MSG (1<<1)
671 #define AMEND_MSG (1<<2)
672 #define CLEANUP_MSG (1<<3)
673 #define VERIFY_MSG (1<<4)
676 * If we are cherry-pick, and if the merge did not result in
677 * hand-editing, we will hit this commit and inherit the original
678 * author date and name.
680 * If we are revert, or if our cherry-pick results in a hand merge,
681 * we had better say that the current user is responsible for that.
683 * An exception is when run_git_commit() is called during an
684 * interactive rebase: in that case, we will want to retain the
687 static int run_git_commit(const char *defmsg
, struct replay_opts
*opts
,
690 struct child_process cmd
= CHILD_PROCESS_INIT
;
695 if (is_rebase_i(opts
)) {
696 if (!(flags
& EDIT_MSG
)) {
697 cmd
.stdout_to_stderr
= 1;
701 if (read_env_script(&cmd
.env_array
)) {
702 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
704 return error(_(staged_changes_advice
),
709 argv_array_push(&cmd
.args
, "commit");
711 if (!(flags
& VERIFY_MSG
))
712 argv_array_push(&cmd
.args
, "-n");
713 if ((flags
& AMEND_MSG
))
714 argv_array_push(&cmd
.args
, "--amend");
716 argv_array_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
718 argv_array_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
719 else if (!(flags
& EDIT_MSG
))
720 argv_array_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
721 if ((flags
& CLEANUP_MSG
))
722 argv_array_push(&cmd
.args
, "--cleanup=strip");
723 if ((flags
& EDIT_MSG
))
724 argv_array_push(&cmd
.args
, "-e");
725 else if (!(flags
& CLEANUP_MSG
) &&
726 !opts
->signoff
&& !opts
->record_origin
&&
727 git_config_get_value("commit.cleanup", &value
))
728 argv_array_push(&cmd
.args
, "--cleanup=verbatim");
730 if ((flags
& ALLOW_EMPTY
))
731 argv_array_push(&cmd
.args
, "--allow-empty");
733 if (opts
->allow_empty_message
)
734 argv_array_push(&cmd
.args
, "--allow-empty-message");
737 /* hide stderr on success */
738 struct strbuf buf
= STRBUF_INIT
;
739 int rc
= pipe_command(&cmd
,
741 /* stdout is already redirected */
745 fputs(buf
.buf
, stderr
);
746 strbuf_release(&buf
);
750 return run_command(&cmd
);
753 static int rest_is_empty(const struct strbuf
*sb
, int start
)
758 /* Check if the rest is just whitespace and Signed-off-by's. */
759 for (i
= start
; i
< sb
->len
; i
++) {
760 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
766 if (strlen(sign_off_header
) <= eol
- i
&&
767 starts_with(sb
->buf
+ i
, sign_off_header
)) {
772 if (!isspace(sb
->buf
[i
++]))
780 * Find out if the message in the strbuf contains only whitespace and
781 * Signed-off-by lines.
783 int message_is_empty(const struct strbuf
*sb
,
784 enum commit_msg_cleanup_mode cleanup_mode
)
786 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
788 return rest_is_empty(sb
, 0);
792 * See if the user edited the message in the editor or left what
793 * was in the template intact
795 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
796 enum commit_msg_cleanup_mode cleanup_mode
)
798 struct strbuf tmpl
= STRBUF_INIT
;
801 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
804 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
807 strbuf_stripspace(&tmpl
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
808 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
810 strbuf_release(&tmpl
);
811 return rest_is_empty(sb
, start
- sb
->buf
);
814 int update_head_with_reflog(const struct commit
*old_head
,
815 const struct object_id
*new_head
,
816 const char *action
, const struct strbuf
*msg
,
819 struct ref_transaction
*transaction
;
820 struct strbuf sb
= STRBUF_INIT
;
825 strbuf_addstr(&sb
, action
);
826 strbuf_addstr(&sb
, ": ");
829 nl
= strchr(msg
->buf
, '\n');
831 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
833 strbuf_addbuf(&sb
, msg
);
834 strbuf_addch(&sb
, '\n');
837 transaction
= ref_transaction_begin(err
);
839 ref_transaction_update(transaction
, "HEAD", new_head
,
840 old_head
? &old_head
->object
.oid
: &null_oid
,
842 ref_transaction_commit(transaction
, err
)) {
845 ref_transaction_free(transaction
);
851 static int run_rewrite_hook(const struct object_id
*oldoid
,
852 const struct object_id
*newoid
)
854 struct child_process proc
= CHILD_PROCESS_INIT
;
857 struct strbuf sb
= STRBUF_INIT
;
859 argv
[0] = find_hook("post-rewrite");
868 proc
.stdout_to_stderr
= 1;
870 code
= start_command(&proc
);
873 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
874 sigchain_push(SIGPIPE
, SIG_IGN
);
875 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
878 sigchain_pop(SIGPIPE
);
879 return finish_command(&proc
);
882 void commit_post_rewrite(const struct commit
*old_head
,
883 const struct object_id
*new_head
)
885 struct notes_rewrite_cfg
*cfg
;
887 cfg
= init_copy_notes_for_rewrite("amend");
889 /* we are amending, so old_head is not NULL */
890 copy_note_for_rewrite(cfg
, &old_head
->object
.oid
, new_head
);
891 finish_copy_notes_for_rewrite(cfg
, "Notes added by 'git commit --amend'");
893 run_rewrite_hook(&old_head
->object
.oid
, new_head
);
896 static int run_prepare_commit_msg_hook(struct strbuf
*msg
, const char *commit
)
898 struct argv_array hook_env
= ARGV_ARRAY_INIT
;
902 name
= git_path_commit_editmsg();
903 if (write_message(msg
->buf
, msg
->len
, name
, 0))
906 argv_array_pushf(&hook_env
, "GIT_INDEX_FILE=%s", get_index_file());
907 argv_array_push(&hook_env
, "GIT_EDITOR=:");
909 ret
= run_hook_le(hook_env
.argv
, "prepare-commit-msg", name
,
910 "commit", commit
, NULL
);
912 ret
= run_hook_le(hook_env
.argv
, "prepare-commit-msg", name
,
915 ret
= error(_("'prepare-commit-msg' hook failed"));
916 argv_array_clear(&hook_env
);
921 static const char implicit_ident_advice_noconfig
[] =
922 N_("Your name and email address were configured automatically based\n"
923 "on your username and hostname. Please check that they are accurate.\n"
924 "You can suppress this message by setting them explicitly. Run the\n"
925 "following command and follow the instructions in your editor to edit\n"
926 "your configuration file:\n"
928 " git config --global --edit\n"
930 "After doing this, you may fix the identity used for this commit with:\n"
932 " git commit --amend --reset-author\n");
934 static const char implicit_ident_advice_config
[] =
935 N_("Your name and email address were configured automatically based\n"
936 "on your username and hostname. Please check that they are accurate.\n"
937 "You can suppress this message by setting them explicitly:\n"
939 " git config --global user.name \"Your Name\"\n"
940 " git config --global user.email you@example.com\n"
942 "After doing this, you may fix the identity used for this commit with:\n"
944 " git commit --amend --reset-author\n");
946 static const char *implicit_ident_advice(void)
948 char *user_config
= expand_user_path("~/.gitconfig", 0);
949 char *xdg_config
= xdg_config_home("config");
950 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
956 return _(implicit_ident_advice_config
);
958 return _(implicit_ident_advice_noconfig
);
962 void print_commit_summary(const char *prefix
, const struct object_id
*oid
,
966 struct commit
*commit
;
967 struct strbuf format
= STRBUF_INIT
;
969 struct pretty_print_context pctx
= {0};
970 struct strbuf author_ident
= STRBUF_INIT
;
971 struct strbuf committer_ident
= STRBUF_INIT
;
973 commit
= lookup_commit(oid
);
975 die(_("couldn't look up newly created commit"));
976 if (parse_commit(commit
))
977 die(_("could not parse newly created commit"));
979 strbuf_addstr(&format
, "format:%h] %s");
981 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
982 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
983 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
984 strbuf_addstr(&format
, "\n Author: ");
985 strbuf_addbuf_percentquote(&format
, &author_ident
);
987 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
988 struct strbuf date
= STRBUF_INIT
;
990 format_commit_message(commit
, "%ad", &date
, &pctx
);
991 strbuf_addstr(&format
, "\n Date: ");
992 strbuf_addbuf_percentquote(&format
, &date
);
993 strbuf_release(&date
);
995 if (!committer_ident_sufficiently_given()) {
996 strbuf_addstr(&format
, "\n Committer: ");
997 strbuf_addbuf_percentquote(&format
, &committer_ident
);
998 if (advice_implicit_identity
) {
999 strbuf_addch(&format
, '\n');
1000 strbuf_addstr(&format
, implicit_ident_advice());
1003 strbuf_release(&author_ident
);
1004 strbuf_release(&committer_ident
);
1006 init_revisions(&rev
, prefix
);
1007 setup_revisions(0, NULL
, &rev
, NULL
);
1010 rev
.diffopt
.output_format
=
1011 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1013 rev
.verbose_header
= 1;
1014 rev
.show_root_diff
= 1;
1015 get_commit_format(format
.buf
, &rev
);
1016 rev
.always_show_header
= 0;
1017 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1018 rev
.diffopt
.break_opt
= 0;
1019 diff_setup_done(&rev
.diffopt
);
1021 head
= resolve_ref_unsafe("HEAD", 0, NULL
, NULL
);
1023 die_errno(_("unable to resolve HEAD after creating commit"));
1024 if (!strcmp(head
, "HEAD"))
1025 head
= _("detached HEAD");
1027 skip_prefix(head
, "refs/heads/", &head
);
1028 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1029 _(" (root-commit)") : "");
1031 if (!log_tree_commit(&rev
, commit
)) {
1032 rev
.always_show_header
= 1;
1033 rev
.use_terminator
= 1;
1034 log_tree_commit(&rev
, commit
);
1037 strbuf_release(&format
);
1040 static int parse_head(struct commit
**head
)
1042 struct commit
*current_head
;
1043 struct object_id oid
;
1045 if (get_oid("HEAD", &oid
)) {
1046 current_head
= NULL
;
1048 current_head
= lookup_commit_reference(&oid
);
1050 return error(_("could not parse HEAD"));
1051 if (oidcmp(&oid
, ¤t_head
->object
.oid
)) {
1052 warning(_("HEAD %s is not a commit!"),
1055 if (parse_commit(current_head
))
1056 return error(_("could not parse HEAD commit"));
1058 *head
= current_head
;
1064 * Try to commit without forking 'git commit'. In some cases we need
1065 * to run 'git commit' to display an error message
1068 * -1 - error unable to commit
1070 * 1 - run 'git commit'
1072 static int try_to_commit(struct strbuf
*msg
, const char *author
,
1073 struct replay_opts
*opts
, unsigned int flags
,
1074 struct object_id
*oid
)
1076 struct object_id tree
;
1077 struct commit
*current_head
;
1078 struct commit_list
*parents
= NULL
;
1079 struct commit_extra_header
*extra
= NULL
;
1080 struct strbuf err
= STRBUF_INIT
;
1081 struct strbuf commit_msg
= STRBUF_INIT
;
1082 char *amend_author
= NULL
;
1083 const char *hook_commit
= NULL
;
1084 enum commit_msg_cleanup_mode cleanup
;
1087 if (parse_head(¤t_head
))
1090 if (flags
& AMEND_MSG
) {
1091 const char *exclude_gpgsig
[] = { "gpgsig", NULL
};
1092 const char *out_enc
= get_commit_output_encoding();
1093 const char *message
= logmsg_reencode(current_head
, NULL
,
1097 const char *orig_message
= NULL
;
1099 find_commit_subject(message
, &orig_message
);
1101 strbuf_addstr(msg
, orig_message
);
1102 hook_commit
= "HEAD";
1104 author
= amend_author
= get_author(message
);
1105 unuse_commit_buffer(current_head
, message
);
1107 res
= error(_("unable to parse commit author"));
1110 parents
= copy_commit_list(current_head
->parents
);
1111 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1112 } else if (current_head
) {
1113 commit_list_insert(current_head
, &parents
);
1116 if (write_cache_as_tree(tree
.hash
, 0, NULL
)) {
1117 res
= error(_("git write-tree failed to write a tree"));
1121 if (!(flags
& ALLOW_EMPTY
) && !oidcmp(current_head
?
1122 ¤t_head
->tree
->object
.oid
:
1123 &empty_tree_oid
, &tree
)) {
1124 res
= 1; /* run 'git commit' to display error message */
1128 if (find_hook("prepare-commit-msg")) {
1129 res
= run_prepare_commit_msg_hook(msg
, hook_commit
);
1132 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1134 res
= error_errno(_("unable to read commit message "
1136 git_path_commit_editmsg());
1142 cleanup
= (flags
& CLEANUP_MSG
) ? COMMIT_MSG_CLEANUP_ALL
:
1143 opts
->default_msg_cleanup
;
1145 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1146 strbuf_stripspace(msg
, cleanup
== COMMIT_MSG_CLEANUP_ALL
);
1147 if (!opts
->allow_empty_message
&& message_is_empty(msg
, cleanup
)) {
1148 res
= 1; /* run 'git commit' to display error message */
1152 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
,
1153 oid
, author
, opts
->gpg_sign
, extra
)) {
1154 res
= error(_("failed to write commit object"));
1158 if (update_head_with_reflog(current_head
, oid
,
1159 getenv("GIT_REFLOG_ACTION"), msg
, &err
)) {
1160 res
= error("%s", err
.buf
);
1164 if (flags
& AMEND_MSG
)
1165 commit_post_rewrite(current_head
, oid
);
1168 free_commit_extra_headers(extra
);
1169 strbuf_release(&err
);
1170 strbuf_release(&commit_msg
);
1176 static int do_commit(const char *msg_file
, const char *author
,
1177 struct replay_opts
*opts
, unsigned int flags
)
1181 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
)) {
1182 struct object_id oid
;
1183 struct strbuf sb
= STRBUF_INIT
;
1185 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1186 return error_errno(_("unable to read commit message "
1190 res
= try_to_commit(msg_file
? &sb
: NULL
, author
, opts
, flags
,
1192 strbuf_release(&sb
);
1194 unlink(git_path_cherry_pick_head());
1195 unlink(git_path_merge_msg());
1196 if (!is_rebase_i(opts
))
1197 print_commit_summary(NULL
, &oid
,
1198 SUMMARY_SHOW_AUTHOR_DATE
);
1203 return run_git_commit(msg_file
, opts
, flags
);
1208 static int is_original_commit_empty(struct commit
*commit
)
1210 const struct object_id
*ptree_oid
;
1212 if (parse_commit(commit
))
1213 return error(_("could not parse commit %s"),
1214 oid_to_hex(&commit
->object
.oid
));
1215 if (commit
->parents
) {
1216 struct commit
*parent
= commit
->parents
->item
;
1217 if (parse_commit(parent
))
1218 return error(_("could not parse parent commit %s"),
1219 oid_to_hex(&parent
->object
.oid
));
1220 ptree_oid
= &parent
->tree
->object
.oid
;
1222 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1225 return !oidcmp(ptree_oid
, &commit
->tree
->object
.oid
);
1229 * Do we run "git commit" with "--allow-empty"?
1231 static int allow_empty(struct replay_opts
*opts
, struct commit
*commit
)
1233 int index_unchanged
, empty_commit
;
1238 * (1) we do not allow empty at all and error out.
1240 * (2) we allow ones that were initially empty, but
1241 * forbid the ones that become empty;
1243 * (3) we allow both.
1245 if (!opts
->allow_empty
)
1246 return 0; /* let "git commit" barf as necessary */
1248 index_unchanged
= is_index_unchanged();
1249 if (index_unchanged
< 0)
1250 return index_unchanged
;
1251 if (!index_unchanged
)
1252 return 0; /* we do not have to say --allow-empty */
1254 if (opts
->keep_redundant_commits
)
1257 empty_commit
= is_original_commit_empty(commit
);
1258 if (empty_commit
< 0)
1259 return empty_commit
;
1267 * Note that ordering matters in this enum. Not only must it match the mapping
1268 * below, it is also divided into several sections that matter. When adding
1269 * new commands, make sure you add it in the right section.
1272 /* commands that handle commits */
1279 /* commands that do something else than handling a single commit */
1281 /* commands that do nothing but are counted for reporting progress */
1284 /* comments (not counted for reporting progress) */
1291 } todo_command_info
[] = {
1304 static const char *command_to_string(const enum todo_command command
)
1306 if (command
< TODO_COMMENT
)
1307 return todo_command_info
[command
].str
;
1308 die("Unknown command: %d", command
);
1311 static char command_to_char(const enum todo_command command
)
1313 if (command
< TODO_COMMENT
&& todo_command_info
[command
].c
)
1314 return todo_command_info
[command
].c
;
1315 return comment_line_char
;
1318 static int is_noop(const enum todo_command command
)
1320 return TODO_NOOP
<= command
;
1323 static int is_fixup(enum todo_command command
)
1325 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1328 static int update_squash_messages(enum todo_command command
,
1329 struct commit
*commit
, struct replay_opts
*opts
)
1331 struct strbuf buf
= STRBUF_INIT
;
1333 const char *message
, *body
;
1335 if (opts
->current_fixup_count
> 0) {
1336 struct strbuf header
= STRBUF_INIT
;
1339 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
1340 return error(_("could not read '%s'"),
1341 rebase_path_squash_msg());
1343 eol
= buf
.buf
[0] != comment_line_char
?
1344 buf
.buf
: strchrnul(buf
.buf
, '\n');
1346 strbuf_addf(&header
, "%c ", comment_line_char
);
1347 strbuf_addf(&header
, _("This is a combination of %d commits."),
1348 opts
->current_fixup_count
+ 2);
1349 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
1350 strbuf_release(&header
);
1352 struct object_id head
;
1353 struct commit
*head_commit
;
1354 const char *head_message
, *body
;
1356 if (get_oid("HEAD", &head
))
1357 return error(_("need a HEAD to fixup"));
1358 if (!(head_commit
= lookup_commit_reference(&head
)))
1359 return error(_("could not read HEAD"));
1360 if (!(head_message
= get_commit_buffer(head_commit
, NULL
)))
1361 return error(_("could not read HEAD's commit message"));
1363 find_commit_subject(head_message
, &body
);
1364 if (write_message(body
, strlen(body
),
1365 rebase_path_fixup_msg(), 0)) {
1366 unuse_commit_buffer(head_commit
, head_message
);
1367 return error(_("cannot write '%s'"),
1368 rebase_path_fixup_msg());
1371 strbuf_addf(&buf
, "%c ", comment_line_char
);
1372 strbuf_addf(&buf
, _("This is a combination of %d commits."), 2);
1373 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1374 strbuf_addstr(&buf
, _("This is the 1st commit message:"));
1375 strbuf_addstr(&buf
, "\n\n");
1376 strbuf_addstr(&buf
, body
);
1378 unuse_commit_buffer(head_commit
, head_message
);
1381 if (!(message
= get_commit_buffer(commit
, NULL
)))
1382 return error(_("could not read commit message of %s"),
1383 oid_to_hex(&commit
->object
.oid
));
1384 find_commit_subject(message
, &body
);
1386 if (command
== TODO_SQUASH
) {
1387 unlink(rebase_path_fixup_msg());
1388 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1389 strbuf_addf(&buf
, _("This is the commit message #%d:"),
1390 ++opts
->current_fixup_count
);
1391 strbuf_addstr(&buf
, "\n\n");
1392 strbuf_addstr(&buf
, body
);
1393 } else if (command
== TODO_FIXUP
) {
1394 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1395 strbuf_addf(&buf
, _("The commit message #%d will be skipped:"),
1396 ++opts
->current_fixup_count
);
1397 strbuf_addstr(&buf
, "\n\n");
1398 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
1400 return error(_("unknown command: %d"), command
);
1401 unuse_commit_buffer(commit
, message
);
1403 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(), 0);
1404 strbuf_release(&buf
);
1407 strbuf_addf(&opts
->current_fixups
, "%s%s %s",
1408 opts
->current_fixups
.len
? "\n" : "",
1409 command_to_string(command
),
1410 oid_to_hex(&commit
->object
.oid
));
1411 res
= write_message(opts
->current_fixups
.buf
,
1412 opts
->current_fixups
.len
,
1413 rebase_path_current_fixups(), 0);
1419 static void flush_rewritten_pending(void) {
1420 struct strbuf buf
= STRBUF_INIT
;
1421 struct object_id newoid
;
1424 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
1425 !get_oid("HEAD", &newoid
) &&
1426 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1427 char *bol
= buf
.buf
, *eol
;
1430 eol
= strchrnul(bol
, '\n');
1431 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
1432 bol
, oid_to_hex(&newoid
));
1438 unlink(rebase_path_rewritten_pending());
1440 strbuf_release(&buf
);
1443 static void record_in_rewritten(struct object_id
*oid
,
1444 enum todo_command next_command
) {
1445 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
1450 fprintf(out
, "%s\n", oid_to_hex(oid
));
1453 if (!is_fixup(next_command
))
1454 flush_rewritten_pending();
1457 static int do_pick_commit(enum todo_command command
, struct commit
*commit
,
1458 struct replay_opts
*opts
, int final_fixup
)
1460 unsigned int flags
= opts
->edit
? EDIT_MSG
: 0;
1461 const char *msg_file
= opts
->edit
? NULL
: git_path_merge_msg();
1462 struct object_id head
;
1463 struct commit
*base
, *next
, *parent
;
1464 const char *base_label
, *next_label
;
1465 char *author
= NULL
;
1466 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
1467 struct strbuf msgbuf
= STRBUF_INIT
;
1468 int res
, unborn
= 0, allow
;
1470 if (opts
->no_commit
) {
1472 * We do not intend to commit immediately. We just want to
1473 * merge the differences in, so let's compute the tree
1474 * that represents the "current" state for merge-recursive
1477 if (write_cache_as_tree(head
.hash
, 0, NULL
))
1478 return error(_("your index file is unmerged."));
1480 unborn
= get_oid("HEAD", &head
);
1482 oidcpy(&head
, the_hash_algo
->empty_tree
);
1483 if (index_differs_from(unborn
? EMPTY_TREE_SHA1_HEX
: "HEAD",
1485 return error_dirty_index(opts
);
1489 if (!commit
->parents
)
1491 else if (commit
->parents
->next
) {
1492 /* Reverting or cherry-picking a merge commit */
1494 struct commit_list
*p
;
1496 if (!opts
->mainline
)
1497 return error(_("commit %s is a merge but no -m option was given."),
1498 oid_to_hex(&commit
->object
.oid
));
1500 for (cnt
= 1, p
= commit
->parents
;
1501 cnt
!= opts
->mainline
&& p
;
1504 if (cnt
!= opts
->mainline
|| !p
)
1505 return error(_("commit %s does not have parent %d"),
1506 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
1508 } else if (0 < opts
->mainline
)
1509 return error(_("mainline was specified but commit %s is not a merge."),
1510 oid_to_hex(&commit
->object
.oid
));
1512 parent
= commit
->parents
->item
;
1514 if (get_message(commit
, &msg
) != 0)
1515 return error(_("cannot get commit message for %s"),
1516 oid_to_hex(&commit
->object
.oid
));
1518 if (opts
->allow_ff
&& !is_fixup(command
) &&
1519 ((parent
&& !oidcmp(&parent
->object
.oid
, &head
)) ||
1520 (!parent
&& unborn
))) {
1521 if (is_rebase_i(opts
))
1522 write_author_script(msg
.message
);
1523 res
= fast_forward_to(&commit
->object
.oid
, &head
, unborn
,
1525 if (res
|| command
!= TODO_REWORD
)
1527 flags
|= EDIT_MSG
| AMEND_MSG
| VERIFY_MSG
;
1529 goto fast_forward_edit
;
1531 if (parent
&& parse_commit(parent
) < 0)
1532 /* TRANSLATORS: The first %s will be a "todo" command like
1533 "revert" or "pick", the second %s a SHA1. */
1534 return error(_("%s: cannot parse parent commit %s"),
1535 command_to_string(command
),
1536 oid_to_hex(&parent
->object
.oid
));
1539 * "commit" is an existing commit. We would want to apply
1540 * the difference it introduces since its first parent "prev"
1541 * on top of the current HEAD if we are cherry-pick. Or the
1542 * reverse of it if we are revert.
1545 if (command
== TODO_REVERT
) {
1547 base_label
= msg
.label
;
1549 next_label
= msg
.parent_label
;
1550 strbuf_addstr(&msgbuf
, "Revert \"");
1551 strbuf_addstr(&msgbuf
, msg
.subject
);
1552 strbuf_addstr(&msgbuf
, "\"\n\nThis reverts commit ");
1553 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
1555 if (commit
->parents
&& commit
->parents
->next
) {
1556 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
1557 strbuf_addstr(&msgbuf
, oid_to_hex(&parent
->object
.oid
));
1559 strbuf_addstr(&msgbuf
, ".\n");
1564 base_label
= msg
.parent_label
;
1566 next_label
= msg
.label
;
1568 /* Append the commit log message to msgbuf. */
1569 if (find_commit_subject(msg
.message
, &p
))
1570 strbuf_addstr(&msgbuf
, p
);
1572 if (opts
->record_origin
) {
1573 strbuf_complete_line(&msgbuf
);
1574 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
1575 strbuf_addch(&msgbuf
, '\n');
1576 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
1577 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
1578 strbuf_addstr(&msgbuf
, ")\n");
1580 if (!is_fixup(command
))
1581 author
= get_author(msg
.message
);
1584 if (command
== TODO_REWORD
)
1585 flags
|= EDIT_MSG
| VERIFY_MSG
;
1586 else if (is_fixup(command
)) {
1587 if (update_squash_messages(command
, commit
, opts
))
1591 msg_file
= rebase_path_squash_msg();
1592 else if (file_exists(rebase_path_fixup_msg())) {
1593 flags
|= CLEANUP_MSG
;
1594 msg_file
= rebase_path_fixup_msg();
1596 const char *dest
= git_path_squash_msg();
1598 if (copy_file(dest
, rebase_path_squash_msg(), 0666))
1599 return error(_("could not rename '%s' to '%s'"),
1600 rebase_path_squash_msg(), dest
);
1601 unlink(git_path_merge_msg());
1608 append_signoff(&msgbuf
, 0, 0);
1610 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
1612 else if (!opts
->strategy
|| !strcmp(opts
->strategy
, "recursive") || command
== TODO_REVERT
) {
1613 res
= do_recursive_merge(base
, next
, base_label
, next_label
,
1614 &head
, &msgbuf
, opts
);
1617 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
1618 git_path_merge_msg(), 0);
1620 struct commit_list
*common
= NULL
;
1621 struct commit_list
*remotes
= NULL
;
1623 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
1624 git_path_merge_msg(), 0);
1626 commit_list_insert(base
, &common
);
1627 commit_list_insert(next
, &remotes
);
1628 res
|= try_merge_command(opts
->strategy
,
1629 opts
->xopts_nr
, (const char **)opts
->xopts
,
1630 common
, oid_to_hex(&head
), remotes
);
1631 free_commit_list(common
);
1632 free_commit_list(remotes
);
1634 strbuf_release(&msgbuf
);
1637 * If the merge was clean or if it failed due to conflict, we write
1638 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1639 * However, if the merge did not even start, then we don't want to
1642 if (command
== TODO_PICK
&& !opts
->no_commit
&& (res
== 0 || res
== 1) &&
1643 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
1644 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1646 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
1647 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
1648 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1652 error(command
== TODO_REVERT
1653 ? _("could not revert %s... %s")
1654 : _("could not apply %s... %s"),
1655 short_commit_name(commit
), msg
.subject
);
1656 print_advice(res
== 1, opts
);
1657 rerere(opts
->allow_rerere_auto
);
1661 allow
= allow_empty(opts
, commit
);
1666 flags
|= ALLOW_EMPTY
;
1667 if (!opts
->no_commit
) {
1669 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
1670 res
= do_commit(msg_file
, author
, opts
, flags
);
1672 res
= error(_("unable to parse commit author"));
1675 if (!res
&& final_fixup
) {
1676 unlink(rebase_path_fixup_msg());
1677 unlink(rebase_path_squash_msg());
1678 unlink(rebase_path_current_fixups());
1679 strbuf_reset(&opts
->current_fixups
);
1680 opts
->current_fixup_count
= 0;
1684 free_message(commit
, &msg
);
1686 update_abort_safety_file();
1691 static int prepare_revs(struct replay_opts
*opts
)
1694 * picking (but not reverting) ranges (but not individual revisions)
1695 * should be done in reverse
1697 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
1698 opts
->revs
->reverse
^= 1;
1700 if (prepare_revision_walk(opts
->revs
))
1701 return error(_("revision walk setup failed"));
1703 if (!opts
->revs
->commits
)
1704 return error(_("empty commit set passed"));
1708 static int read_and_refresh_cache(struct replay_opts
*opts
)
1710 struct lock_file index_lock
= LOCK_INIT
;
1711 int index_fd
= hold_locked_index(&index_lock
, 0);
1712 if (read_index_preload(&the_index
, NULL
) < 0) {
1713 rollback_lock_file(&index_lock
);
1714 return error(_("git %s: failed to read the index"),
1715 _(action_name(opts
)));
1717 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
1718 if (index_fd
>= 0) {
1719 if (write_locked_index(&the_index
, &index_lock
,
1720 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
1721 return error(_("git %s: failed to refresh the index"),
1722 _(action_name(opts
)));
1729 enum todo_command command
;
1730 struct commit
*commit
;
1733 size_t offset_in_buf
;
1738 struct todo_item
*items
;
1739 int nr
, alloc
, current
;
1740 int done_nr
, total_nr
;
1741 struct stat_data stat
;
1744 #define TODO_LIST_INIT { STRBUF_INIT }
1746 static void todo_list_release(struct todo_list
*todo_list
)
1748 strbuf_release(&todo_list
->buf
);
1749 FREE_AND_NULL(todo_list
->items
);
1750 todo_list
->nr
= todo_list
->alloc
= 0;
1753 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
1755 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
1756 return todo_list
->items
+ todo_list
->nr
++;
1759 static int parse_insn_line(struct todo_item
*item
, const char *bol
, char *eol
)
1761 struct object_id commit_oid
;
1762 char *end_of_object_name
;
1763 int i
, saved
, status
, padding
;
1766 bol
+= strspn(bol
, " \t");
1768 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
1769 item
->command
= TODO_COMMENT
;
1770 item
->commit
= NULL
;
1772 item
->arg_len
= eol
- bol
;
1776 for (i
= 0; i
< TODO_COMMENT
; i
++)
1777 if (skip_prefix(bol
, todo_command_info
[i
].str
, &bol
)) {
1780 } else if (bol
[1] == ' ' && *bol
== todo_command_info
[i
].c
) {
1785 if (i
>= TODO_COMMENT
)
1788 /* Eat up extra spaces/ tabs before object name */
1789 padding
= strspn(bol
, " \t");
1792 if (item
->command
== TODO_NOOP
) {
1794 return error(_("%s does not accept arguments: '%s'"),
1795 command_to_string(item
->command
), bol
);
1796 item
->commit
= NULL
;
1798 item
->arg_len
= eol
- bol
;
1803 return error(_("missing arguments for %s"),
1804 command_to_string(item
->command
));
1806 if (item
->command
== TODO_EXEC
) {
1807 item
->commit
= NULL
;
1809 item
->arg_len
= (int)(eol
- bol
);
1813 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
1814 saved
= *end_of_object_name
;
1815 *end_of_object_name
= '\0';
1816 status
= get_oid(bol
, &commit_oid
);
1817 *end_of_object_name
= saved
;
1819 item
->arg
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
1820 item
->arg_len
= (int)(eol
- item
->arg
);
1825 item
->commit
= lookup_commit_reference(&commit_oid
);
1826 return !item
->commit
;
1829 static int parse_insn_buffer(char *buf
, struct todo_list
*todo_list
)
1831 struct todo_item
*item
;
1832 char *p
= buf
, *next_p
;
1833 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
1835 for (i
= 1; *p
; i
++, p
= next_p
) {
1836 char *eol
= strchrnul(p
, '\n');
1838 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
1840 if (p
!= eol
&& eol
[-1] == '\r')
1841 eol
--; /* strip Carriage Return */
1843 item
= append_new_todo(todo_list
);
1844 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
1845 if (parse_insn_line(item
, p
, eol
)) {
1846 res
= error(_("invalid line %d: %.*s"),
1847 i
, (int)(eol
- p
), p
);
1848 item
->command
= TODO_NOOP
;
1853 else if (is_fixup(item
->command
))
1854 return error(_("cannot '%s' without a previous commit"),
1855 command_to_string(item
->command
));
1856 else if (!is_noop(item
->command
))
1863 static int count_commands(struct todo_list
*todo_list
)
1867 for (i
= 0; i
< todo_list
->nr
; i
++)
1868 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
1874 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
1879 fd
= open(path
, O_RDONLY
);
1881 return error_errno(_("could not open '%s'"), path
);
1882 len
= strbuf_read(sb
, fd
, 0);
1885 return error(_("could not read '%s'."), path
);
1889 static int read_populate_todo(struct todo_list
*todo_list
,
1890 struct replay_opts
*opts
)
1893 const char *todo_file
= get_todo_path(opts
);
1896 strbuf_reset(&todo_list
->buf
);
1897 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
1900 res
= stat(todo_file
, &st
);
1902 return error(_("could not stat '%s'"), todo_file
);
1903 fill_stat_data(&todo_list
->stat
, &st
);
1905 res
= parse_insn_buffer(todo_list
->buf
.buf
, todo_list
);
1907 if (is_rebase_i(opts
))
1908 return error(_("please fix this using "
1909 "'git rebase --edit-todo'."));
1910 return error(_("unusable instruction sheet: '%s'"), todo_file
);
1913 if (!todo_list
->nr
&&
1914 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
1915 return error(_("no commits parsed."));
1917 if (!is_rebase_i(opts
)) {
1918 enum todo_command valid
=
1919 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
1922 for (i
= 0; i
< todo_list
->nr
; i
++)
1923 if (valid
== todo_list
->items
[i
].command
)
1925 else if (valid
== TODO_PICK
)
1926 return error(_("cannot cherry-pick during a revert."));
1928 return error(_("cannot revert during a cherry-pick."));
1931 if (is_rebase_i(opts
)) {
1932 struct todo_list done
= TODO_LIST_INIT
;
1933 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
1935 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
1936 !parse_insn_buffer(done
.buf
.buf
, &done
))
1937 todo_list
->done_nr
= count_commands(&done
);
1939 todo_list
->done_nr
= 0;
1941 todo_list
->total_nr
= todo_list
->done_nr
1942 + count_commands(todo_list
);
1943 todo_list_release(&done
);
1946 fprintf(f
, "%d\n", todo_list
->total_nr
);
1954 static int git_config_string_dup(char **dest
,
1955 const char *var
, const char *value
)
1958 return config_error_nonbool(var
);
1960 *dest
= xstrdup(value
);
1964 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
1966 struct replay_opts
*opts
= data
;
1971 else if (!strcmp(key
, "options.no-commit"))
1972 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
1973 else if (!strcmp(key
, "options.edit"))
1974 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
1975 else if (!strcmp(key
, "options.signoff"))
1976 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
1977 else if (!strcmp(key
, "options.record-origin"))
1978 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
1979 else if (!strcmp(key
, "options.allow-ff"))
1980 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
1981 else if (!strcmp(key
, "options.mainline"))
1982 opts
->mainline
= git_config_int(key
, value
);
1983 else if (!strcmp(key
, "options.strategy"))
1984 git_config_string_dup(&opts
->strategy
, key
, value
);
1985 else if (!strcmp(key
, "options.gpg-sign"))
1986 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
1987 else if (!strcmp(key
, "options.strategy-option")) {
1988 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
1989 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(value
);
1990 } else if (!strcmp(key
, "options.allow-rerere-auto"))
1991 opts
->allow_rerere_auto
=
1992 git_config_bool_or_int(key
, value
, &error_flag
) ?
1993 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
1995 return error(_("invalid key: %s"), key
);
1998 return error(_("invalid value for %s: %s"), key
, value
);
2003 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2008 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2010 opts
->strategy
= strbuf_detach(buf
, NULL
);
2011 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2014 opts
->xopts_nr
= split_cmdline(buf
->buf
, (const char ***)&opts
->xopts
);
2015 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
2016 const char *arg
= opts
->xopts
[i
];
2018 skip_prefix(arg
, "--", &arg
);
2019 opts
->xopts
[i
] = xstrdup(arg
);
2023 static int read_populate_opts(struct replay_opts
*opts
)
2025 if (is_rebase_i(opts
)) {
2026 struct strbuf buf
= STRBUF_INIT
;
2028 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(), 1)) {
2029 if (!starts_with(buf
.buf
, "-S"))
2032 free(opts
->gpg_sign
);
2033 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2038 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(), 1)) {
2039 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2040 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2041 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2042 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2046 if (file_exists(rebase_path_verbose()))
2049 read_strategy_opts(opts
, &buf
);
2050 strbuf_release(&buf
);
2052 if (read_oneliner(&opts
->current_fixups
,
2053 rebase_path_current_fixups(), 1)) {
2054 const char *p
= opts
->current_fixups
.buf
;
2055 opts
->current_fixup_count
= 1;
2056 while ((p
= strchr(p
, '\n'))) {
2057 opts
->current_fixup_count
++;
2065 if (!file_exists(git_path_opts_file()))
2068 * The function git_parse_source(), called from git_config_from_file(),
2069 * may die() in case of a syntactically incorrect file. We do not care
2070 * about this case, though, because we wrote that file ourselves, so we
2071 * are pretty certain that it is syntactically correct.
2073 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
2074 return error(_("malformed options sheet: '%s'"),
2075 git_path_opts_file());
2079 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
2080 struct replay_opts
*opts
)
2082 enum todo_command command
= opts
->action
== REPLAY_PICK
?
2083 TODO_PICK
: TODO_REVERT
;
2084 const char *command_string
= todo_command_info
[command
].str
;
2085 struct commit
*commit
;
2087 if (prepare_revs(opts
))
2090 while ((commit
= get_revision(opts
->revs
))) {
2091 struct todo_item
*item
= append_new_todo(todo_list
);
2092 const char *commit_buffer
= get_commit_buffer(commit
, NULL
);
2093 const char *subject
;
2096 item
->command
= command
;
2097 item
->commit
= commit
;
2100 item
->offset_in_buf
= todo_list
->buf
.len
;
2101 subject_len
= find_commit_subject(commit_buffer
, &subject
);
2102 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
2103 short_commit_name(commit
), subject_len
, subject
);
2104 unuse_commit_buffer(commit
, commit_buffer
);
2109 static int create_seq_dir(void)
2111 if (file_exists(git_path_seq_dir())) {
2112 error(_("a cherry-pick or revert is already in progress"));
2113 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
2115 } else if (mkdir(git_path_seq_dir(), 0777) < 0)
2116 return error_errno(_("could not create sequencer directory '%s'"),
2117 git_path_seq_dir());
2121 static int save_head(const char *head
)
2123 struct lock_file head_lock
= LOCK_INIT
;
2124 struct strbuf buf
= STRBUF_INIT
;
2128 fd
= hold_lock_file_for_update(&head_lock
, git_path_head_file(), 0);
2130 return error_errno(_("could not lock HEAD"));
2131 strbuf_addf(&buf
, "%s\n", head
);
2132 written
= write_in_full(fd
, buf
.buf
, buf
.len
);
2133 strbuf_release(&buf
);
2135 rollback_lock_file(&head_lock
);
2136 return error_errno(_("could not write to '%s'"),
2137 git_path_head_file());
2139 if (commit_lock_file(&head_lock
) < 0)
2140 return error(_("failed to finalize '%s'"), git_path_head_file());
2144 static int rollback_is_safe(void)
2146 struct strbuf sb
= STRBUF_INIT
;
2147 struct object_id expected_head
, actual_head
;
2149 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
2151 if (get_oid_hex(sb
.buf
, &expected_head
)) {
2152 strbuf_release(&sb
);
2153 die(_("could not parse %s"), git_path_abort_safety_file());
2155 strbuf_release(&sb
);
2157 else if (errno
== ENOENT
)
2158 oidclr(&expected_head
);
2160 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2162 if (get_oid("HEAD", &actual_head
))
2163 oidclr(&actual_head
);
2165 return !oidcmp(&actual_head
, &expected_head
);
2168 static int reset_for_rollback(const struct object_id
*oid
)
2170 const char *argv
[4]; /* reset --merge <arg> + NULL */
2173 argv
[1] = "--merge";
2174 argv
[2] = oid_to_hex(oid
);
2176 return run_command_v_opt(argv
, RUN_GIT_CMD
);
2179 static int rollback_single_pick(void)
2181 struct object_id head_oid
;
2183 if (!file_exists(git_path_cherry_pick_head()) &&
2184 !file_exists(git_path_revert_head()))
2185 return error(_("no cherry-pick or revert in progress"));
2186 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
2187 return error(_("cannot resolve HEAD"));
2188 if (is_null_oid(&head_oid
))
2189 return error(_("cannot abort from a branch yet to be born"));
2190 return reset_for_rollback(&head_oid
);
2193 int sequencer_rollback(struct replay_opts
*opts
)
2196 struct object_id oid
;
2197 struct strbuf buf
= STRBUF_INIT
;
2200 f
= fopen(git_path_head_file(), "r");
2201 if (!f
&& errno
== ENOENT
) {
2203 * There is no multiple-cherry-pick in progress.
2204 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2205 * a single-cherry-pick in progress, abort that.
2207 return rollback_single_pick();
2210 return error_errno(_("cannot open '%s'"), git_path_head_file());
2211 if (strbuf_getline_lf(&buf
, f
)) {
2212 error(_("cannot read '%s': %s"), git_path_head_file(),
2213 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
2218 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
2219 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2220 git_path_head_file());
2223 if (is_null_oid(&oid
)) {
2224 error(_("cannot abort from a branch yet to be born"));
2228 if (!rollback_is_safe()) {
2229 /* Do not error, just do not rollback */
2230 warning(_("You seem to have moved HEAD. "
2231 "Not rewinding, check your HEAD!"));
2233 if (reset_for_rollback(&oid
))
2235 strbuf_release(&buf
);
2236 return sequencer_remove_state(opts
);
2238 strbuf_release(&buf
);
2242 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
2244 struct lock_file todo_lock
= LOCK_INIT
;
2245 const char *todo_path
= get_todo_path(opts
);
2246 int next
= todo_list
->current
, offset
, fd
;
2249 * rebase -i writes "git-rebase-todo" without the currently executing
2250 * command, appending it to "done" instead.
2252 if (is_rebase_i(opts
))
2255 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
2257 return error_errno(_("could not lock '%s'"), todo_path
);
2258 offset
= next
< todo_list
->nr
?
2259 todo_list
->items
[next
].offset_in_buf
: todo_list
->buf
.len
;
2260 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
2261 todo_list
->buf
.len
- offset
) < 0)
2262 return error_errno(_("could not write to '%s'"), todo_path
);
2263 if (commit_lock_file(&todo_lock
) < 0)
2264 return error(_("failed to finalize '%s'"), todo_path
);
2266 if (is_rebase_i(opts
)) {
2267 const char *done_path
= rebase_path_done();
2268 int fd
= open(done_path
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
2269 int prev_offset
= !next
? 0 :
2270 todo_list
->items
[next
- 1].offset_in_buf
;
2272 if (fd
>= 0 && offset
> prev_offset
&&
2273 write_in_full(fd
, todo_list
->buf
.buf
+ prev_offset
,
2274 offset
- prev_offset
) < 0) {
2276 return error_errno(_("could not write to '%s'"),
2285 static int save_opts(struct replay_opts
*opts
)
2287 const char *opts_file
= git_path_opts_file();
2290 if (opts
->no_commit
)
2291 res
|= git_config_set_in_file_gently(opts_file
, "options.no-commit", "true");
2293 res
|= git_config_set_in_file_gently(opts_file
, "options.edit", "true");
2295 res
|= git_config_set_in_file_gently(opts_file
, "options.signoff", "true");
2296 if (opts
->record_origin
)
2297 res
|= git_config_set_in_file_gently(opts_file
, "options.record-origin", "true");
2299 res
|= git_config_set_in_file_gently(opts_file
, "options.allow-ff", "true");
2300 if (opts
->mainline
) {
2301 struct strbuf buf
= STRBUF_INIT
;
2302 strbuf_addf(&buf
, "%d", opts
->mainline
);
2303 res
|= git_config_set_in_file_gently(opts_file
, "options.mainline", buf
.buf
);
2304 strbuf_release(&buf
);
2307 res
|= git_config_set_in_file_gently(opts_file
, "options.strategy", opts
->strategy
);
2309 res
|= git_config_set_in_file_gently(opts_file
, "options.gpg-sign", opts
->gpg_sign
);
2312 for (i
= 0; i
< opts
->xopts_nr
; i
++)
2313 res
|= git_config_set_multivar_in_file_gently(opts_file
,
2314 "options.strategy-option",
2315 opts
->xopts
[i
], "^$", 0);
2317 if (opts
->allow_rerere_auto
)
2318 res
|= git_config_set_in_file_gently(opts_file
, "options.allow-rerere-auto",
2319 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
2324 static int make_patch(struct commit
*commit
, struct replay_opts
*opts
)
2326 struct strbuf buf
= STRBUF_INIT
;
2327 struct rev_info log_tree_opt
;
2328 const char *subject
, *p
;
2331 p
= short_commit_name(commit
);
2332 if (write_message(p
, strlen(p
), rebase_path_stopped_sha(), 1) < 0)
2334 if (update_ref("rebase", "REBASE_HEAD", &commit
->object
.oid
,
2335 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2336 res
|= error(_("could not update %s"), "REBASE_HEAD");
2338 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
2339 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
2340 init_revisions(&log_tree_opt
, NULL
);
2341 log_tree_opt
.abbrev
= 0;
2342 log_tree_opt
.diff
= 1;
2343 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
2344 log_tree_opt
.disable_stdin
= 1;
2345 log_tree_opt
.no_commit_id
= 1;
2346 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
2347 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
2348 if (!log_tree_opt
.diffopt
.file
)
2349 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
2351 res
|= log_tree_commit(&log_tree_opt
, commit
);
2352 fclose(log_tree_opt
.diffopt
.file
);
2356 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
2357 if (!file_exists(buf
.buf
)) {
2358 const char *commit_buffer
= get_commit_buffer(commit
, NULL
);
2359 find_commit_subject(commit_buffer
, &subject
);
2360 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
2361 unuse_commit_buffer(commit
, commit_buffer
);
2363 strbuf_release(&buf
);
2368 static int intend_to_amend(void)
2370 struct object_id head
;
2373 if (get_oid("HEAD", &head
))
2374 return error(_("cannot read HEAD"));
2376 p
= oid_to_hex(&head
);
2377 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
2380 static int error_with_patch(struct commit
*commit
,
2381 const char *subject
, int subject_len
,
2382 struct replay_opts
*opts
, int exit_code
, int to_amend
)
2384 if (make_patch(commit
, opts
))
2388 if (intend_to_amend())
2391 fprintf(stderr
, "You can amend the commit now, with\n"
2393 " git commit --amend %s\n"
2395 "Once you are satisfied with your changes, run\n"
2397 " git rebase --continue\n", gpg_sign_opt_quoted(opts
));
2398 } else if (exit_code
)
2399 fprintf(stderr
, "Could not apply %s... %.*s\n",
2400 short_commit_name(commit
), subject_len
, subject
);
2405 static int error_failed_squash(struct commit
*commit
,
2406 struct replay_opts
*opts
, int subject_len
, const char *subject
)
2408 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
2409 return error(_("could not copy '%s' to '%s'"),
2410 rebase_path_squash_msg(), rebase_path_message());
2411 unlink(git_path_merge_msg());
2412 if (copy_file(git_path_merge_msg(), rebase_path_message(), 0666))
2413 return error(_("could not copy '%s' to '%s'"),
2414 rebase_path_message(), git_path_merge_msg());
2415 return error_with_patch(commit
, subject
, subject_len
, opts
, 1, 0);
2418 static int do_exec(const char *command_line
)
2420 struct argv_array child_env
= ARGV_ARRAY_INIT
;
2421 const char *child_argv
[] = { NULL
, NULL
};
2424 fprintf(stderr
, "Executing: %s\n", command_line
);
2425 child_argv
[0] = command_line
;
2426 argv_array_pushf(&child_env
, "GIT_DIR=%s", absolute_path(get_git_dir()));
2427 status
= run_command_v_opt_cd_env(child_argv
, RUN_USING_SHELL
, NULL
,
2430 /* force re-reading of the cache */
2431 if (discard_cache() < 0 || read_cache() < 0)
2432 return error(_("could not read index"));
2434 dirty
= require_clean_work_tree("rebase", NULL
, 1, 1);
2437 warning(_("execution failed: %s\n%s"
2438 "You can fix the problem, and then run\n"
2440 " git rebase --continue\n"
2443 dirty
? N_("and made changes to the index and/or the "
2444 "working tree\n") : "");
2446 /* command not found */
2449 warning(_("execution succeeded: %s\nbut "
2450 "left changes to the index and/or the working tree\n"
2451 "Commit or stash your changes, and then run\n"
2453 " git rebase --continue\n"
2454 "\n"), command_line
);
2458 argv_array_clear(&child_env
);
2463 static int is_final_fixup(struct todo_list
*todo_list
)
2465 int i
= todo_list
->current
;
2467 if (!is_fixup(todo_list
->items
[i
].command
))
2470 while (++i
< todo_list
->nr
)
2471 if (is_fixup(todo_list
->items
[i
].command
))
2473 else if (!is_noop(todo_list
->items
[i
].command
))
2478 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
2482 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
2483 if (!is_noop(todo_list
->items
[i
].command
))
2484 return todo_list
->items
[i
].command
;
2489 static int apply_autostash(struct replay_opts
*opts
)
2491 struct strbuf stash_sha1
= STRBUF_INIT
;
2492 struct child_process child
= CHILD_PROCESS_INIT
;
2495 if (!read_oneliner(&stash_sha1
, rebase_path_autostash(), 1)) {
2496 strbuf_release(&stash_sha1
);
2499 strbuf_trim(&stash_sha1
);
2502 child
.no_stdout
= 1;
2503 child
.no_stderr
= 1;
2504 argv_array_push(&child
.args
, "stash");
2505 argv_array_push(&child
.args
, "apply");
2506 argv_array_push(&child
.args
, stash_sha1
.buf
);
2507 if (!run_command(&child
))
2508 fprintf(stderr
, _("Applied autostash.\n"));
2510 struct child_process store
= CHILD_PROCESS_INIT
;
2513 argv_array_push(&store
.args
, "stash");
2514 argv_array_push(&store
.args
, "store");
2515 argv_array_push(&store
.args
, "-m");
2516 argv_array_push(&store
.args
, "autostash");
2517 argv_array_push(&store
.args
, "-q");
2518 argv_array_push(&store
.args
, stash_sha1
.buf
);
2519 if (run_command(&store
))
2520 ret
= error(_("cannot store %s"), stash_sha1
.buf
);
2523 _("Applying autostash resulted in conflicts.\n"
2524 "Your changes are safe in the stash.\n"
2525 "You can run \"git stash pop\" or"
2526 " \"git stash drop\" at any time.\n"));
2529 strbuf_release(&stash_sha1
);
2533 static const char *reflog_message(struct replay_opts
*opts
,
2534 const char *sub_action
, const char *fmt
, ...)
2537 static struct strbuf buf
= STRBUF_INIT
;
2541 strbuf_addstr(&buf
, action_name(opts
));
2543 strbuf_addf(&buf
, " (%s)", sub_action
);
2545 strbuf_addstr(&buf
, ": ");
2546 strbuf_vaddf(&buf
, fmt
, ap
);
2553 static int pick_commits(struct todo_list
*todo_list
, struct replay_opts
*opts
)
2557 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
2559 assert(!(opts
->signoff
|| opts
->no_commit
||
2560 opts
->record_origin
|| opts
->edit
));
2561 if (read_and_refresh_cache(opts
))
2564 while (todo_list
->current
< todo_list
->nr
) {
2565 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
2566 if (save_todo(todo_list
, opts
))
2568 if (is_rebase_i(opts
)) {
2569 if (item
->command
!= TODO_COMMENT
) {
2570 FILE *f
= fopen(rebase_path_msgnum(), "w");
2572 todo_list
->done_nr
++;
2575 fprintf(f
, "%d\n", todo_list
->done_nr
);
2578 fprintf(stderr
, "Rebasing (%d/%d)%s",
2580 todo_list
->total_nr
,
2581 opts
->verbose
? "\n" : "\r");
2583 unlink(rebase_path_message());
2584 unlink(rebase_path_author_script());
2585 unlink(rebase_path_stopped_sha());
2586 unlink(rebase_path_amend());
2587 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
2589 if (item
->command
<= TODO_SQUASH
) {
2590 if (is_rebase_i(opts
))
2591 setenv("GIT_REFLOG_ACTION", reflog_message(opts
,
2592 command_to_string(item
->command
), NULL
),
2594 res
= do_pick_commit(item
->command
, item
->commit
,
2595 opts
, is_final_fixup(todo_list
));
2596 if (is_rebase_i(opts
) && res
< 0) {
2598 todo_list
->current
--;
2599 if (save_todo(todo_list
, opts
))
2602 if (item
->command
== TODO_EDIT
) {
2603 struct commit
*commit
= item
->commit
;
2606 _("Stopped at %s... %.*s\n"),
2607 short_commit_name(commit
),
2608 item
->arg_len
, item
->arg
);
2609 return error_with_patch(commit
,
2610 item
->arg
, item
->arg_len
, opts
, res
,
2613 if (is_rebase_i(opts
) && !res
)
2614 record_in_rewritten(&item
->commit
->object
.oid
,
2615 peek_command(todo_list
, 1));
2616 if (res
&& is_fixup(item
->command
)) {
2619 return error_failed_squash(item
->commit
, opts
,
2620 item
->arg_len
, item
->arg
);
2621 } else if (res
&& is_rebase_i(opts
))
2622 return res
| error_with_patch(item
->commit
,
2623 item
->arg
, item
->arg_len
, opts
, res
,
2624 item
->command
== TODO_REWORD
);
2625 } else if (item
->command
== TODO_EXEC
) {
2626 char *end_of_arg
= (char *)(item
->arg
+ item
->arg_len
);
2627 int saved
= *end_of_arg
;
2631 res
= do_exec(item
->arg
);
2632 *end_of_arg
= saved
;
2634 /* Reread the todo file if it has changed. */
2636 ; /* fall through */
2637 else if (stat(get_todo_path(opts
), &st
))
2638 res
= error_errno(_("could not stat '%s'"),
2639 get_todo_path(opts
));
2640 else if (match_stat_data(&todo_list
->stat
, &st
)) {
2641 todo_list_release(todo_list
);
2642 if (read_populate_todo(todo_list
, opts
))
2643 res
= -1; /* message was printed */
2644 /* `current` will be incremented below */
2645 todo_list
->current
= -1;
2647 } else if (!is_noop(item
->command
))
2648 return error(_("unknown command %d"), item
->command
);
2650 todo_list
->current
++;
2655 if (is_rebase_i(opts
)) {
2656 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
2659 /* Stopped in the middle, as planned? */
2660 if (todo_list
->current
< todo_list
->nr
)
2663 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
2664 starts_with(head_ref
.buf
, "refs/")) {
2666 struct object_id head
, orig
;
2669 if (get_oid("HEAD", &head
)) {
2670 res
= error(_("cannot read HEAD"));
2672 strbuf_release(&head_ref
);
2673 strbuf_release(&buf
);
2676 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
2677 get_oid_hex(buf
.buf
, &orig
)) {
2678 res
= error(_("could not read orig-head"));
2679 goto cleanup_head_ref
;
2682 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
2683 res
= error(_("could not read 'onto'"));
2684 goto cleanup_head_ref
;
2686 msg
= reflog_message(opts
, "finish", "%s onto %s",
2687 head_ref
.buf
, buf
.buf
);
2688 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
2689 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
2690 res
= error(_("could not update %s"),
2692 goto cleanup_head_ref
;
2694 msg
= reflog_message(opts
, "finish", "returning to %s",
2696 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
2697 res
= error(_("could not update HEAD to %s"),
2699 goto cleanup_head_ref
;
2704 if (opts
->verbose
) {
2705 struct rev_info log_tree_opt
;
2706 struct object_id orig
, head
;
2708 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
2709 init_revisions(&log_tree_opt
, NULL
);
2710 log_tree_opt
.diff
= 1;
2711 log_tree_opt
.diffopt
.output_format
=
2712 DIFF_FORMAT_DIFFSTAT
;
2713 log_tree_opt
.disable_stdin
= 1;
2715 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
2716 !get_oid(buf
.buf
, &orig
) &&
2717 !get_oid("HEAD", &head
)) {
2718 diff_tree_oid(&orig
, &head
, "",
2719 &log_tree_opt
.diffopt
);
2720 log_tree_diff_flush(&log_tree_opt
);
2723 flush_rewritten_pending();
2724 if (!stat(rebase_path_rewritten_list(), &st
) &&
2726 struct child_process child
= CHILD_PROCESS_INIT
;
2727 const char *post_rewrite_hook
=
2728 find_hook("post-rewrite");
2730 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
2732 argv_array_push(&child
.args
, "notes");
2733 argv_array_push(&child
.args
, "copy");
2734 argv_array_push(&child
.args
, "--for-rewrite=rebase");
2735 /* we don't care if this copying failed */
2736 run_command(&child
);
2738 if (post_rewrite_hook
) {
2739 struct child_process hook
= CHILD_PROCESS_INIT
;
2741 hook
.in
= open(rebase_path_rewritten_list(),
2743 hook
.stdout_to_stderr
= 1;
2744 argv_array_push(&hook
.args
, post_rewrite_hook
);
2745 argv_array_push(&hook
.args
, "rebase");
2746 /* we don't care if this hook failed */
2750 apply_autostash(opts
);
2752 fprintf(stderr
, "Successfully rebased and updated %s.\n",
2755 strbuf_release(&buf
);
2756 strbuf_release(&head_ref
);
2760 * Sequence of picks finished successfully; cleanup by
2761 * removing the .git/sequencer directory
2763 return sequencer_remove_state(opts
);
2766 static int continue_single_pick(void)
2768 const char *argv
[] = { "commit", NULL
};
2770 if (!file_exists(git_path_cherry_pick_head()) &&
2771 !file_exists(git_path_revert_head()))
2772 return error(_("no cherry-pick or revert in progress"));
2773 return run_command_v_opt(argv
, RUN_GIT_CMD
);
2776 static int commit_staged_changes(struct replay_opts
*opts
,
2777 struct todo_list
*todo_list
)
2779 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
2780 unsigned int final_fixup
= 0, is_clean
;
2782 if (has_unstaged_changes(1))
2783 return error(_("cannot rebase: You have unstaged changes."));
2785 is_clean
= !has_uncommitted_changes(0);
2787 if (file_exists(rebase_path_amend())) {
2788 struct strbuf rev
= STRBUF_INIT
;
2789 struct object_id head
, to_amend
;
2791 if (get_oid("HEAD", &head
))
2792 return error(_("cannot amend non-existing commit"));
2793 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
2794 return error(_("invalid file: '%s'"), rebase_path_amend());
2795 if (get_oid_hex(rev
.buf
, &to_amend
))
2796 return error(_("invalid contents: '%s'"),
2797 rebase_path_amend());
2798 if (!is_clean
&& oidcmp(&head
, &to_amend
))
2799 return error(_("\nYou have uncommitted changes in your "
2800 "working tree. Please, commit them\n"
2801 "first and then run 'git rebase "
2802 "--continue' again."));
2804 * When skipping a failed fixup/squash, we need to edit the
2805 * commit message, the current fixup list and count, and if it
2806 * was the last fixup/squash in the chain, we need to clean up
2807 * the commit message and if there was a squash, let the user
2810 if (is_clean
&& !oidcmp(&head
, &to_amend
) &&
2811 opts
->current_fixup_count
> 0 &&
2812 file_exists(rebase_path_stopped_sha())) {
2813 const char *p
= opts
->current_fixups
.buf
;
2814 int len
= opts
->current_fixups
.len
;
2816 opts
->current_fixup_count
--;
2818 BUG("Incorrect current_fixups:\n%s", p
);
2819 while (len
&& p
[len
- 1] != '\n')
2821 strbuf_setlen(&opts
->current_fixups
, len
);
2822 if (write_message(p
, len
, rebase_path_current_fixups(),
2824 return error(_("could not write file: '%s'"),
2825 rebase_path_current_fixups());
2828 * If a fixup/squash in a fixup/squash chain failed, the
2829 * commit message is already correct, no need to commit
2832 * Only if it is the final command in the fixup/squash
2833 * chain, and only if the chain is longer than a single
2834 * fixup/squash command (which was just skipped), do we
2835 * actually need to re-commit with a cleaned up commit
2838 if (opts
->current_fixup_count
> 0 &&
2839 !is_fixup(peek_command(todo_list
, 0))) {
2842 * If there was not a single "squash" in the
2843 * chain, we only need to clean up the commit
2844 * message, no need to bother the user with
2845 * opening the commit message in the editor.
2847 if (!starts_with(p
, "squash ") &&
2848 !strstr(p
, "\nsquash "))
2849 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
2850 } else if (is_fixup(peek_command(todo_list
, 0))) {
2852 * We need to update the squash message to skip
2853 * the latest commit message.
2855 struct commit
*commit
;
2856 const char *path
= rebase_path_squash_msg();
2858 if (parse_head(&commit
) ||
2859 !(p
= get_commit_buffer(commit
, NULL
)) ||
2860 write_message(p
, strlen(p
), path
, 0)) {
2861 unuse_commit_buffer(commit
, p
);
2862 return error(_("could not write file: "
2865 unuse_commit_buffer(commit
, p
);
2869 strbuf_release(&rev
);
2874 const char *cherry_pick_head
= git_path_cherry_pick_head();
2876 if (file_exists(cherry_pick_head
) && unlink(cherry_pick_head
))
2877 return error(_("could not remove CHERRY_PICK_HEAD"));
2882 if (run_git_commit(final_fixup
? NULL
: rebase_path_message(),
2884 return error(_("could not commit staged changes."));
2885 unlink(rebase_path_amend());
2887 unlink(rebase_path_fixup_msg());
2888 unlink(rebase_path_squash_msg());
2890 if (opts
->current_fixup_count
> 0) {
2892 * Whether final fixup or not, we just cleaned up the commit
2895 unlink(rebase_path_current_fixups());
2896 strbuf_reset(&opts
->current_fixups
);
2897 opts
->current_fixup_count
= 0;
2902 int sequencer_continue(struct replay_opts
*opts
)
2904 struct todo_list todo_list
= TODO_LIST_INIT
;
2907 if (read_and_refresh_cache(opts
))
2910 if (read_populate_opts(opts
))
2912 if (is_rebase_i(opts
)) {
2913 if ((res
= read_populate_todo(&todo_list
, opts
)))
2914 goto release_todo_list
;
2915 if (commit_staged_changes(opts
, &todo_list
))
2917 } else if (!file_exists(get_todo_path(opts
)))
2918 return continue_single_pick();
2919 else if ((res
= read_populate_todo(&todo_list
, opts
)))
2920 goto release_todo_list
;
2922 if (!is_rebase_i(opts
)) {
2923 /* Verify that the conflict has been resolved */
2924 if (file_exists(git_path_cherry_pick_head()) ||
2925 file_exists(git_path_revert_head())) {
2926 res
= continue_single_pick();
2928 goto release_todo_list
;
2930 if (index_differs_from("HEAD", NULL
, 0)) {
2931 res
= error_dirty_index(opts
);
2932 goto release_todo_list
;
2934 todo_list
.current
++;
2935 } else if (file_exists(rebase_path_stopped_sha())) {
2936 struct strbuf buf
= STRBUF_INIT
;
2937 struct object_id oid
;
2939 if (read_oneliner(&buf
, rebase_path_stopped_sha(), 1) &&
2940 !get_oid_committish(buf
.buf
, &oid
))
2941 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
2942 strbuf_release(&buf
);
2945 res
= pick_commits(&todo_list
, opts
);
2947 todo_list_release(&todo_list
);
2951 static int single_pick(struct commit
*cmit
, struct replay_opts
*opts
)
2953 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
2954 return do_pick_commit(opts
->action
== REPLAY_PICK
?
2955 TODO_PICK
: TODO_REVERT
, cmit
, opts
, 0);
2958 int sequencer_pick_revisions(struct replay_opts
*opts
)
2960 struct todo_list todo_list
= TODO_LIST_INIT
;
2961 struct object_id oid
;
2965 if (read_and_refresh_cache(opts
))
2968 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
2969 struct object_id oid
;
2970 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
2972 /* This happens when using --stdin. */
2976 if (!get_oid(name
, &oid
)) {
2977 if (!lookup_commit_reference_gently(&oid
, 1)) {
2978 enum object_type type
= sha1_object_info(oid
.hash
, NULL
);
2979 return error(_("%s: can't cherry-pick a %s"),
2980 name
, type_name(type
));
2983 return error(_("%s: bad revision"), name
);
2987 * If we were called as "git cherry-pick <commit>", just
2988 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
2989 * REVERT_HEAD, and don't touch the sequencer state.
2990 * This means it is possible to cherry-pick in the middle
2991 * of a cherry-pick sequence.
2993 if (opts
->revs
->cmdline
.nr
== 1 &&
2994 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
2995 opts
->revs
->no_walk
&&
2996 !opts
->revs
->cmdline
.rev
->flags
) {
2997 struct commit
*cmit
;
2998 if (prepare_revision_walk(opts
->revs
))
2999 return error(_("revision walk setup failed"));
3000 cmit
= get_revision(opts
->revs
);
3001 if (!cmit
|| get_revision(opts
->revs
))
3002 return error("BUG: expected exactly one commit from walk");
3003 return single_pick(cmit
, opts
);
3007 * Start a new cherry-pick/ revert sequence; but
3008 * first, make sure that an existing one isn't in
3012 if (walk_revs_populate_todo(&todo_list
, opts
) ||
3013 create_seq_dir() < 0)
3015 if (get_oid("HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
3016 return error(_("can't revert as initial commit"));
3017 if (save_head(oid_to_hex(&oid
)))
3019 if (save_opts(opts
))
3021 update_abort_safety_file();
3022 res
= pick_commits(&todo_list
, opts
);
3023 todo_list_release(&todo_list
);
3027 void append_signoff(struct strbuf
*msgbuf
, int ignore_footer
, unsigned flag
)
3029 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
3030 struct strbuf sob
= STRBUF_INIT
;
3033 strbuf_addstr(&sob
, sign_off_header
);
3034 strbuf_addstr(&sob
, fmt_name(getenv("GIT_COMMITTER_NAME"),
3035 getenv("GIT_COMMITTER_EMAIL")));
3036 strbuf_addch(&sob
, '\n');
3039 strbuf_complete_line(msgbuf
);
3042 * If the whole message buffer is equal to the sob, pretend that we
3043 * found a conforming footer with a matching sob
3045 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
3046 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
3049 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
3052 const char *append_newlines
= NULL
;
3053 size_t len
= msgbuf
->len
- ignore_footer
;
3057 * The buffer is completely empty. Leave foom for
3058 * the title and body to be filled in by the user.
3060 append_newlines
= "\n\n";
3061 } else if (len
== 1) {
3063 * Buffer contains a single newline. Add another
3064 * so that we leave room for the title and body.
3066 append_newlines
= "\n";
3067 } else if (msgbuf
->buf
[len
- 2] != '\n') {
3069 * Buffer ends with a single newline. Add another
3070 * so that there is an empty line between the message
3073 append_newlines
= "\n";
3074 } /* else, the buffer already ends with two newlines. */
3076 if (append_newlines
)
3077 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
3078 append_newlines
, strlen(append_newlines
));
3081 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
3082 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
3085 strbuf_release(&sob
);
3088 int sequencer_make_script(FILE *out
, int argc
, const char **argv
,
3091 char *format
= NULL
;
3092 struct pretty_print_context pp
= {0};
3093 struct strbuf buf
= STRBUF_INIT
;
3094 struct rev_info revs
;
3095 struct commit
*commit
;
3096 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
3097 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
3099 init_revisions(&revs
, NULL
);
3100 revs
.verbose_header
= 1;
3101 revs
.max_parents
= 1;
3102 revs
.cherry_pick
= 1;
3105 revs
.right_only
= 1;
3106 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
3107 revs
.topo_order
= 1;
3109 revs
.pretty_given
= 1;
3110 git_config_get_string("rebase.instructionFormat", &format
);
3111 if (!format
|| !*format
) {
3113 format
= xstrdup("%s");
3115 get_commit_format(format
, &revs
);
3117 pp
.fmt
= revs
.commit_format
;
3118 pp
.output_encoding
= get_log_output_encoding();
3120 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1)
3121 return error(_("make_script: unhandled options"));
3123 if (prepare_revision_walk(&revs
) < 0)
3124 return error(_("make_script: error preparing revisions"));
3126 while ((commit
= get_revision(&revs
))) {
3128 if (!keep_empty
&& is_original_commit_empty(commit
))
3129 strbuf_addf(&buf
, "%c ", comment_line_char
);
3130 strbuf_addf(&buf
, "%s %s ", insn
,
3131 oid_to_hex(&commit
->object
.oid
));
3132 pretty_print_commit(&pp
, commit
, &buf
);
3133 strbuf_addch(&buf
, '\n');
3134 fputs(buf
.buf
, out
);
3136 strbuf_release(&buf
);
3141 * Add commands after pick and (series of) squash/fixup commands
3144 int sequencer_add_exec_commands(const char *commands
)
3146 const char *todo_file
= rebase_path_todo();
3147 struct todo_list todo_list
= TODO_LIST_INIT
;
3148 struct todo_item
*item
;
3149 struct strbuf
*buf
= &todo_list
.buf
;
3150 size_t offset
= 0, commands_len
= strlen(commands
);
3153 if (strbuf_read_file(&todo_list
.buf
, todo_file
, 0) < 0)
3154 return error(_("could not read '%s'."), todo_file
);
3156 if (parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
)) {
3157 todo_list_release(&todo_list
);
3158 return error(_("unusable todo list: '%s'"), todo_file
);
3162 /* insert <commands> before every pick except the first one */
3163 for (item
= todo_list
.items
, i
= 0; i
< todo_list
.nr
; i
++, item
++) {
3164 if (item
->command
== TODO_PICK
&& !first
) {
3165 strbuf_insert(buf
, item
->offset_in_buf
+ offset
,
3166 commands
, commands_len
);
3167 offset
+= commands_len
;
3172 /* append final <commands> */
3173 strbuf_add(buf
, commands
, commands_len
);
3175 i
= write_message(buf
->buf
, buf
->len
, todo_file
, 0);
3176 todo_list_release(&todo_list
);
3180 int transform_todos(unsigned flags
)
3182 const char *todo_file
= rebase_path_todo();
3183 struct todo_list todo_list
= TODO_LIST_INIT
;
3184 struct strbuf buf
= STRBUF_INIT
;
3185 struct todo_item
*item
;
3188 if (strbuf_read_file(&todo_list
.buf
, todo_file
, 0) < 0)
3189 return error(_("could not read '%s'."), todo_file
);
3191 if (parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
)) {
3192 todo_list_release(&todo_list
);
3193 return error(_("unusable todo list: '%s'"), todo_file
);
3196 for (item
= todo_list
.items
, i
= 0; i
< todo_list
.nr
; i
++, item
++) {
3197 /* if the item is not a command write it and continue */
3198 if (item
->command
>= TODO_COMMENT
) {
3199 strbuf_addf(&buf
, "%.*s\n", item
->arg_len
, item
->arg
);
3203 /* add command to the buffer */
3204 if (flags
& TODO_LIST_ABBREVIATE_CMDS
)
3205 strbuf_addch(&buf
, command_to_char(item
->command
));
3207 strbuf_addstr(&buf
, command_to_string(item
->command
));
3211 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
3212 short_commit_name(item
->commit
) :
3213 oid_to_hex(&item
->commit
->object
.oid
);
3215 strbuf_addf(&buf
, " %s", oid
);
3217 /* add all the rest */
3219 strbuf_addch(&buf
, '\n');
3221 strbuf_addf(&buf
, " %.*s\n", item
->arg_len
, item
->arg
);
3224 i
= write_message(buf
.buf
, buf
.len
, todo_file
, 0);
3225 todo_list_release(&todo_list
);
3230 CHECK_IGNORE
= 0, CHECK_WARN
, CHECK_ERROR
3233 static enum check_level
get_missing_commit_check_level(void)
3237 if (git_config_get_value("rebase.missingcommitscheck", &value
) ||
3238 !strcasecmp("ignore", value
))
3239 return CHECK_IGNORE
;
3240 if (!strcasecmp("warn", value
))
3242 if (!strcasecmp("error", value
))
3244 warning(_("unrecognized setting %s for option "
3245 "rebase.missingCommitsCheck. Ignoring."), value
);
3246 return CHECK_IGNORE
;
3250 * Check if the user dropped some commits by mistake
3251 * Behaviour determined by rebase.missingCommitsCheck.
3252 * Check if there is an unrecognized command or a
3253 * bad SHA-1 in a command.
3255 int check_todo_list(void)
3257 enum check_level check_level
= get_missing_commit_check_level();
3258 struct strbuf todo_file
= STRBUF_INIT
;
3259 struct todo_list todo_list
= TODO_LIST_INIT
;
3260 struct strbuf missing
= STRBUF_INIT
;
3261 int advise_to_edit_todo
= 0, res
= 0, i
;
3263 strbuf_addstr(&todo_file
, rebase_path_todo());
3264 if (strbuf_read_file_or_whine(&todo_list
.buf
, todo_file
.buf
) < 0) {
3268 advise_to_edit_todo
= res
=
3269 parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
);
3271 if (res
|| check_level
== CHECK_IGNORE
)
3274 /* Mark the commits in git-rebase-todo as seen */
3275 for (i
= 0; i
< todo_list
.nr
; i
++) {
3276 struct commit
*commit
= todo_list
.items
[i
].commit
;
3278 commit
->util
= (void *)1;
3281 todo_list_release(&todo_list
);
3282 strbuf_addstr(&todo_file
, ".backup");
3283 if (strbuf_read_file_or_whine(&todo_list
.buf
, todo_file
.buf
) < 0) {
3287 strbuf_release(&todo_file
);
3288 res
= !!parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
);
3290 /* Find commits in git-rebase-todo.backup yet unseen */
3291 for (i
= todo_list
.nr
- 1; i
>= 0; i
--) {
3292 struct todo_item
*item
= todo_list
.items
+ i
;
3293 struct commit
*commit
= item
->commit
;
3294 if (commit
&& !commit
->util
) {
3295 strbuf_addf(&missing
, " - %s %.*s\n",
3296 short_commit_name(commit
),
3297 item
->arg_len
, item
->arg
);
3298 commit
->util
= (void *)1;
3302 /* Warn about missing commits */
3306 if (check_level
== CHECK_ERROR
)
3307 advise_to_edit_todo
= res
= 1;
3310 _("Warning: some commits may have been dropped accidentally.\n"
3311 "Dropped commits (newer to older):\n"));
3313 /* Make the list user-friendly and display */
3314 fputs(missing
.buf
, stderr
);
3315 strbuf_release(&missing
);
3317 fprintf(stderr
, _("To avoid this message, use \"drop\" to "
3318 "explicitly remove a commit.\n\n"
3319 "Use 'git config rebase.missingCommitsCheck' to change "
3320 "the level of warnings.\n"
3321 "The possible behaviours are: ignore, warn, error.\n\n"));
3324 strbuf_release(&todo_file
);
3325 todo_list_release(&todo_list
);
3327 if (advise_to_edit_todo
)
3329 _("You can fix this with 'git rebase --edit-todo' "
3330 "and then run 'git rebase --continue'.\n"
3331 "Or you can abort the rebase with 'git rebase"
3337 static int rewrite_file(const char *path
, const char *buf
, size_t len
)
3340 int fd
= open(path
, O_WRONLY
| O_TRUNC
);
3342 return error_errno(_("could not open '%s' for writing"), path
);
3343 if (write_in_full(fd
, buf
, len
) < 0)
3344 rc
= error_errno(_("could not write to '%s'"), path
);
3345 if (close(fd
) && !rc
)
3346 rc
= error_errno(_("could not close '%s'"), path
);
3350 /* skip picking commits whose parents are unchanged */
3351 int skip_unnecessary_picks(void)
3353 const char *todo_file
= rebase_path_todo();
3354 struct strbuf buf
= STRBUF_INIT
;
3355 struct todo_list todo_list
= TODO_LIST_INIT
;
3356 struct object_id onto_oid
, *oid
= &onto_oid
, *parent_oid
;
3359 if (!read_oneliner(&buf
, rebase_path_onto(), 0))
3360 return error(_("could not read 'onto'"));
3361 if (get_oid(buf
.buf
, &onto_oid
)) {
3362 strbuf_release(&buf
);
3363 return error(_("need a HEAD to fixup"));
3365 strbuf_release(&buf
);
3367 if (strbuf_read_file_or_whine(&todo_list
.buf
, todo_file
) < 0)
3369 if (parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
) < 0) {
3370 todo_list_release(&todo_list
);
3374 for (i
= 0; i
< todo_list
.nr
; i
++) {
3375 struct todo_item
*item
= todo_list
.items
+ i
;
3377 if (item
->command
>= TODO_NOOP
)
3379 if (item
->command
!= TODO_PICK
)
3381 if (parse_commit(item
->commit
)) {
3382 todo_list_release(&todo_list
);
3383 return error(_("could not parse commit '%s'"),
3384 oid_to_hex(&item
->commit
->object
.oid
));
3386 if (!item
->commit
->parents
)
3387 break; /* root commit */
3388 if (item
->commit
->parents
->next
)
3389 break; /* merge commit */
3390 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
3391 if (hashcmp(parent_oid
->hash
, oid
->hash
))
3393 oid
= &item
->commit
->object
.oid
;
3396 int offset
= i
< todo_list
.nr
?
3397 todo_list
.items
[i
].offset_in_buf
: todo_list
.buf
.len
;
3398 const char *done_path
= rebase_path_done();
3400 fd
= open(done_path
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
3402 error_errno(_("could not open '%s' for writing"),
3404 todo_list_release(&todo_list
);
3407 if (write_in_full(fd
, todo_list
.buf
.buf
, offset
) < 0) {
3408 error_errno(_("could not write to '%s'"), done_path
);
3409 todo_list_release(&todo_list
);
3415 if (rewrite_file(rebase_path_todo(), todo_list
.buf
.buf
+ offset
,
3416 todo_list
.buf
.len
- offset
) < 0) {
3417 todo_list_release(&todo_list
);
3421 todo_list
.current
= i
;
3422 if (is_fixup(peek_command(&todo_list
, 0)))
3423 record_in_rewritten(oid
, peek_command(&todo_list
, 0));
3426 todo_list_release(&todo_list
);
3427 printf("%s\n", oid_to_hex(oid
));
3432 struct subject2item_entry
{
3433 struct hashmap_entry entry
;
3435 char subject
[FLEX_ARRAY
];
3438 static int subject2item_cmp(const void *fndata
,
3439 const struct subject2item_entry
*a
,
3440 const struct subject2item_entry
*b
, const void *key
)
3442 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
3446 * Rearrange the todo list that has both "pick commit-id msg" and "pick
3447 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
3448 * after the former, and change "pick" to "fixup"/"squash".
3450 * Note that if the config has specified a custom instruction format, each log
3451 * message will have to be retrieved from the commit (as the oneline in the
3452 * script cannot be trusted) in order to normalize the autosquash arrangement.
3454 int rearrange_squash(void)
3456 const char *todo_file
= rebase_path_todo();
3457 struct todo_list todo_list
= TODO_LIST_INIT
;
3458 struct hashmap subject2item
;
3459 int res
= 0, rearranged
= 0, *next
, *tail
, i
;
3462 if (strbuf_read_file_or_whine(&todo_list
.buf
, todo_file
) < 0)
3464 if (parse_insn_buffer(todo_list
.buf
.buf
, &todo_list
) < 0) {
3465 todo_list_release(&todo_list
);
3470 * The hashmap maps onelines to the respective todo list index.
3472 * If any items need to be rearranged, the next[i] value will indicate
3473 * which item was moved directly after the i'th.
3475 * In that case, last[i] will indicate the index of the latest item to
3476 * be moved to appear after the i'th.
3478 hashmap_init(&subject2item
, (hashmap_cmp_fn
) subject2item_cmp
,
3479 NULL
, todo_list
.nr
);
3480 ALLOC_ARRAY(next
, todo_list
.nr
);
3481 ALLOC_ARRAY(tail
, todo_list
.nr
);
3482 ALLOC_ARRAY(subjects
, todo_list
.nr
);
3483 for (i
= 0; i
< todo_list
.nr
; i
++) {
3484 struct strbuf buf
= STRBUF_INIT
;
3485 struct todo_item
*item
= todo_list
.items
+ i
;
3486 const char *commit_buffer
, *subject
, *p
;
3489 struct subject2item_entry
*entry
;
3491 next
[i
] = tail
[i
] = -1;
3492 if (item
->command
>= TODO_EXEC
) {
3497 if (is_fixup(item
->command
)) {
3498 todo_list_release(&todo_list
);
3499 return error(_("the script was already rearranged."));
3502 item
->commit
->util
= item
;
3504 parse_commit(item
->commit
);
3505 commit_buffer
= get_commit_buffer(item
->commit
, NULL
);
3506 find_commit_subject(commit_buffer
, &subject
);
3507 format_subject(&buf
, subject
, " ");
3508 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
3509 unuse_commit_buffer(item
->commit
, commit_buffer
);
3510 if ((skip_prefix(subject
, "fixup! ", &p
) ||
3511 skip_prefix(subject
, "squash! ", &p
))) {
3512 struct commit
*commit2
;
3517 if (!skip_prefix(p
, "fixup! ", &p
) &&
3518 !skip_prefix(p
, "squash! ", &p
))
3522 if ((entry
= hashmap_get_from_hash(&subject2item
,
3524 /* found by title */
3526 else if (!strchr(p
, ' ') &&
3528 lookup_commit_reference_by_name(p
)) &&
3530 /* found by commit name */
3531 i2
= (struct todo_item
*)commit2
->util
3534 /* copy can be a prefix of the commit subject */
3535 for (i2
= 0; i2
< i
; i2
++)
3537 starts_with(subjects
[i2
], p
))
3545 todo_list
.items
[i
].command
=
3546 starts_with(subject
, "fixup!") ?
3547 TODO_FIXUP
: TODO_SQUASH
;
3553 } else if (!hashmap_get_from_hash(&subject2item
,
3554 strhash(subject
), subject
)) {
3555 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
3557 hashmap_entry_init(entry
, strhash(entry
->subject
));
3558 hashmap_put(&subject2item
, entry
);
3563 struct strbuf buf
= STRBUF_INIT
;
3565 for (i
= 0; i
< todo_list
.nr
; i
++) {
3566 enum todo_command command
= todo_list
.items
[i
].command
;
3570 * Initially, all commands are 'pick's. If it is a
3571 * fixup or a squash now, we have rearranged it.
3573 if (is_fixup(command
))
3577 int offset
= todo_list
.items
[cur
].offset_in_buf
;
3578 int end_offset
= cur
+ 1 < todo_list
.nr
?
3579 todo_list
.items
[cur
+ 1].offset_in_buf
:
3581 char *bol
= todo_list
.buf
.buf
+ offset
;
3582 char *eol
= todo_list
.buf
.buf
+ end_offset
;
3584 /* replace 'pick', by 'fixup' or 'squash' */
3585 command
= todo_list
.items
[cur
].command
;
3586 if (is_fixup(command
)) {
3588 todo_command_info
[command
].str
);
3589 bol
+= strcspn(bol
, " \t");
3592 strbuf_add(&buf
, bol
, eol
- bol
);
3598 res
= rewrite_file(todo_file
, buf
.buf
, buf
.len
);
3599 strbuf_release(&buf
);
3604 for (i
= 0; i
< todo_list
.nr
; i
++)
3607 hashmap_free(&subject2item
, 1);
3608 todo_list_release(&todo_list
);