5 #include "object-store.h"
10 #include "run-command.h"
14 #include "cache-tree.h"
18 #include "merge-ort.h"
19 #include "merge-ort-wrappers.h"
25 #include "wt-status.h"
27 #include "notes-utils.h"
29 #include "unpack-trees.h"
33 #include "commit-slab.h"
35 #include "commit-reach.h"
36 #include "rebase-interactive.h"
39 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
41 static const char sign_off_header
[] = "Signed-off-by: ";
42 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
44 GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
46 static GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
48 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
49 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
50 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
51 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
53 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
55 * The file containing rebase commands, comments, and empty lines.
56 * This file is created by "git rebase -i" then edited by the user. As
57 * the lines are processed, they are removed from the front of this
58 * file and written to the tail of 'done'.
60 GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
61 GIT_PATH_FUNC(rebase_path_todo_backup
, "rebase-merge/git-rebase-todo.backup")
63 GIT_PATH_FUNC(rebase_path_dropped
, "rebase-merge/dropped")
66 * The rebase command lines that have already been processed. A line
67 * is moved here when it is first handled, before any associated user
70 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
72 * The file to keep track of how many commands were already processed (e.g.
75 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum")
77 * The file to keep track of how many commands are to be processed in total
78 * (e.g. for the prompt).
80 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end")
82 * The commit message that is planned to be used for any changes that
83 * need to be committed following a user interaction.
85 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
87 * The file into which is accumulated the suggested commit message for
88 * squash/fixup commands. When the first of a series of squash/fixups
89 * is seen, the file is created and the commit message from the
90 * previous commit and from the first squash/fixup commit are written
91 * to it. The commit message for each subsequent squash/fixup commit
92 * is appended to the file as it is processed.
94 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
96 * If the current series of squash/fixups has not yet included a squash
97 * command, then this file exists and holds the commit message of the
98 * original "pick" commit. (If the series ends without a "squash"
99 * command, then this can be used as the commit message of the combined
100 * commit without opening the editor.)
102 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
104 * This file contains the list fixup/squash commands that have been
105 * accumulated into message-fixup or message-squash so far.
107 static GIT_PATH_FUNC(rebase_path_current_fixups
, "rebase-merge/current-fixups")
109 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
110 * GIT_AUTHOR_DATE that will be used for the commit that is currently
113 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
115 * When an "edit" rebase command is being processed, the SHA1 of the
116 * commit to be edited is recorded in this file. When "git rebase
117 * --continue" is executed, if there are any staged changes then they
118 * will be amended to the HEAD commit, but only provided the HEAD
119 * commit is still the commit to be edited. When any other rebase
120 * command is processed, this file is deleted.
122 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
124 * When we stop at a given patch via the "edit" command, this file contains
125 * the commit object name of the corresponding patch.
127 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
129 * For the post-rewrite hook, we make a list of rewritten commits and
130 * their new sha1s. The rewritten-pending list keeps the sha1s of
131 * commits that have been processed, but not committed yet,
132 * e.g. because they are waiting for a 'squash' command.
134 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
135 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
136 "rebase-merge/rewritten-pending")
139 * The path of the file containing the OID of the "squash onto" commit, i.e.
140 * the dummy commit used for `reset [new root]`.
142 static GIT_PATH_FUNC(rebase_path_squash_onto
, "rebase-merge/squash-onto")
145 * The path of the file listing refs that need to be deleted after the rebase
146 * finishes. This is used by the `label` command to record the need for cleanup.
148 static GIT_PATH_FUNC(rebase_path_refs_to_delete
, "rebase-merge/refs-to-delete")
151 * The following files are written by git-rebase just after parsing the
154 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
155 static GIT_PATH_FUNC(rebase_path_cdate_is_adate
, "rebase-merge/cdate_is_adate")
156 static GIT_PATH_FUNC(rebase_path_ignore_date
, "rebase-merge/ignore_date")
157 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
158 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
159 static GIT_PATH_FUNC(rebase_path_quiet
, "rebase-merge/quiet")
160 static GIT_PATH_FUNC(rebase_path_signoff
, "rebase-merge/signoff")
161 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
162 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
163 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
164 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
165 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
166 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
167 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec
, "rebase-merge/reschedule-failed-exec")
168 static GIT_PATH_FUNC(rebase_path_no_reschedule_failed_exec
, "rebase-merge/no-reschedule-failed-exec")
169 static GIT_PATH_FUNC(rebase_path_drop_redundant_commits
, "rebase-merge/drop_redundant_commits")
170 static GIT_PATH_FUNC(rebase_path_keep_redundant_commits
, "rebase-merge/keep_redundant_commits")
172 static int git_sequencer_config(const char *k
, const char *v
, void *cb
)
174 struct replay_opts
*opts
= cb
;
177 if (!strcmp(k
, "commit.cleanup")) {
180 status
= git_config_string(&s
, k
, v
);
184 if (!strcmp(s
, "verbatim")) {
185 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
186 opts
->explicit_cleanup
= 1;
187 } else if (!strcmp(s
, "whitespace")) {
188 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
189 opts
->explicit_cleanup
= 1;
190 } else if (!strcmp(s
, "strip")) {
191 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_ALL
;
192 opts
->explicit_cleanup
= 1;
193 } else if (!strcmp(s
, "scissors")) {
194 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SCISSORS
;
195 opts
->explicit_cleanup
= 1;
197 warning(_("invalid commit message cleanup mode '%s'"),
205 if (!strcmp(k
, "commit.gpgsign")) {
206 opts
->gpg_sign
= git_config_bool(k
, v
) ? xstrdup("") : NULL
;
210 if (!opts
->default_strategy
&& !strcmp(k
, "pull.twohead")) {
211 int ret
= git_config_string((const char**)&opts
->default_strategy
, k
, v
);
214 * pull.twohead is allowed to be multi-valued; we only
215 * care about the first value.
217 char *tmp
= strchr(opts
->default_strategy
, ' ');
224 status
= git_gpg_config(k
, v
, NULL
);
228 return git_diff_basic_config(k
, v
, NULL
);
231 void sequencer_init_config(struct replay_opts
*opts
)
233 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
234 git_config(git_sequencer_config
, opts
);
237 static inline int is_rebase_i(const struct replay_opts
*opts
)
239 return opts
->action
== REPLAY_INTERACTIVE_REBASE
;
242 static const char *get_dir(const struct replay_opts
*opts
)
244 if (is_rebase_i(opts
))
245 return rebase_path();
246 return git_path_seq_dir();
249 static const char *get_todo_path(const struct replay_opts
*opts
)
251 if (is_rebase_i(opts
))
252 return rebase_path_todo();
253 return git_path_todo_file();
257 * Returns 0 for non-conforming footer
258 * Returns 1 for conforming footer
259 * Returns 2 when sob exists within conforming footer
260 * Returns 3 when sob exists within conforming footer as last entry
262 static int has_conforming_footer(struct strbuf
*sb
, struct strbuf
*sob
,
263 size_t ignore_footer
)
265 struct process_trailer_options opts
= PROCESS_TRAILER_OPTIONS_INIT
;
266 struct trailer_info info
;
268 int found_sob
= 0, found_sob_last
= 0;
274 saved_char
= sb
->buf
[sb
->len
- ignore_footer
];
275 sb
->buf
[sb
->len
- ignore_footer
] = '\0';
278 trailer_info_get(&info
, sb
->buf
, &opts
);
281 sb
->buf
[sb
->len
- ignore_footer
] = saved_char
;
283 if (info
.trailer_start
== info
.trailer_end
)
286 for (i
= 0; i
< info
.trailer_nr
; i
++)
287 if (sob
&& !strncmp(info
.trailers
[i
], sob
->buf
, sob
->len
)) {
289 if (i
== info
.trailer_nr
- 1)
293 trailer_info_release(&info
);
302 static const char *gpg_sign_opt_quoted(struct replay_opts
*opts
)
304 static struct strbuf buf
= STRBUF_INIT
;
308 sq_quotef(&buf
, "-S%s", opts
->gpg_sign
);
312 int sequencer_remove_state(struct replay_opts
*opts
)
314 struct strbuf buf
= STRBUF_INIT
;
317 if (is_rebase_i(opts
) &&
318 strbuf_read_file(&buf
, rebase_path_refs_to_delete(), 0) > 0) {
321 char *eol
= strchr(p
, '\n');
324 if (delete_ref("(rebase) cleanup", p
, NULL
, 0) < 0) {
325 warning(_("could not delete '%s'"), p
);
334 free(opts
->gpg_sign
);
335 free(opts
->default_strategy
);
336 free(opts
->strategy
);
337 for (i
= 0; i
< opts
->xopts_nr
; i
++)
338 free(opts
->xopts
[i
]);
340 strbuf_release(&opts
->current_fixups
);
343 strbuf_addstr(&buf
, get_dir(opts
));
344 if (remove_dir_recursively(&buf
, 0))
345 ret
= error(_("could not remove '%s'"), buf
.buf
);
346 strbuf_release(&buf
);
351 static const char *action_name(const struct replay_opts
*opts
)
353 switch (opts
->action
) {
357 return N_("cherry-pick");
358 case REPLAY_INTERACTIVE_REBASE
:
361 die(_("unknown action: %d"), opts
->action
);
364 struct commit_message
{
371 static const char *short_commit_name(struct commit
*commit
)
373 return find_unique_abbrev(&commit
->object
.oid
, DEFAULT_ABBREV
);
376 static int get_message(struct commit
*commit
, struct commit_message
*out
)
378 const char *abbrev
, *subject
;
381 out
->message
= logmsg_reencode(commit
, NULL
, get_commit_output_encoding());
382 abbrev
= short_commit_name(commit
);
384 subject_len
= find_commit_subject(out
->message
, &subject
);
386 out
->subject
= xmemdupz(subject
, subject_len
);
387 out
->label
= xstrfmt("%s (%s)", abbrev
, out
->subject
);
388 out
->parent_label
= xstrfmt("parent of %s", out
->label
);
393 static void free_message(struct commit
*commit
, struct commit_message
*msg
)
395 free(msg
->parent_label
);
398 unuse_commit_buffer(commit
, msg
->message
);
401 static void print_advice(struct repository
*r
, int show_hint
,
402 struct replay_opts
*opts
)
404 char *msg
= getenv("GIT_CHERRY_PICK_HELP");
409 * A conflict has occurred but the porcelain
410 * (typically rebase --interactive) wants to take care
411 * of the commit itself so remove CHERRY_PICK_HEAD
413 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
420 advise(_("after resolving the conflicts, mark the corrected paths\n"
421 "with 'git add <paths>' or 'git rm <paths>'"));
422 else if (opts
->action
== REPLAY_PICK
)
423 advise(_("After resolving the conflicts, mark them with\n"
424 "\"git add/rm <pathspec>\", then run\n"
425 "\"git cherry-pick --continue\".\n"
426 "You can instead skip this commit with \"git cherry-pick --skip\".\n"
427 "To abort and get back to the state before \"git cherry-pick\",\n"
428 "run \"git cherry-pick --abort\"."));
429 else if (opts
->action
== REPLAY_REVERT
)
430 advise(_("After resolving the conflicts, mark them with\n"
431 "\"git add/rm <pathspec>\", then run\n"
432 "\"git revert --continue\".\n"
433 "You can instead skip this commit with \"git revert --skip\".\n"
434 "To abort and get back to the state before \"git revert\",\n"
435 "run \"git revert --abort\"."));
437 BUG("unexpected pick action in print_advice()");
441 static int write_message(const void *buf
, size_t len
, const char *filename
,
444 struct lock_file msg_file
= LOCK_INIT
;
446 int msg_fd
= hold_lock_file_for_update(&msg_file
, filename
, 0);
448 return error_errno(_("could not lock '%s'"), filename
);
449 if (write_in_full(msg_fd
, buf
, len
) < 0) {
450 error_errno(_("could not write to '%s'"), filename
);
451 rollback_lock_file(&msg_file
);
454 if (append_eol
&& write(msg_fd
, "\n", 1) < 0) {
455 error_errno(_("could not write eol to '%s'"), filename
);
456 rollback_lock_file(&msg_file
);
459 if (commit_lock_file(&msg_file
) < 0)
460 return error(_("failed to finalize '%s'"), filename
);
465 int read_oneliner(struct strbuf
*buf
,
466 const char *path
, unsigned flags
)
468 int orig_len
= buf
->len
;
470 if (strbuf_read_file(buf
, path
, 0) < 0) {
471 if ((flags
& READ_ONELINER_WARN_MISSING
) ||
472 (errno
!= ENOENT
&& errno
!= ENOTDIR
))
473 warning_errno(_("could not read '%s'"), path
);
477 if (buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\n') {
478 if (--buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\r')
480 buf
->buf
[buf
->len
] = '\0';
483 if ((flags
& READ_ONELINER_SKIP_IF_EMPTY
) && buf
->len
== orig_len
)
489 static struct tree
*empty_tree(struct repository
*r
)
491 return lookup_tree(r
, the_hash_algo
->empty_tree
);
494 static int error_dirty_index(struct repository
*repo
, struct replay_opts
*opts
)
496 if (repo_read_index_unmerged(repo
))
497 return error_resolve_conflict(_(action_name(opts
)));
499 error(_("your local changes would be overwritten by %s."),
500 _(action_name(opts
)));
502 if (advice_enabled(ADVICE_COMMIT_BEFORE_MERGE
))
503 advise(_("commit your changes or stash them to proceed."));
507 static void update_abort_safety_file(void)
509 struct object_id head
;
511 /* Do nothing on a single-pick */
512 if (!file_exists(git_path_seq_dir()))
515 if (!get_oid("HEAD", &head
))
516 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head
));
518 write_file(git_path_abort_safety_file(), "%s", "");
521 static int fast_forward_to(struct repository
*r
,
522 const struct object_id
*to
,
523 const struct object_id
*from
,
525 struct replay_opts
*opts
)
527 struct ref_transaction
*transaction
;
528 struct strbuf sb
= STRBUF_INIT
;
529 struct strbuf err
= STRBUF_INIT
;
532 if (checkout_fast_forward(r
, from
, to
, 1))
533 return -1; /* the callee should have complained already */
535 strbuf_addf(&sb
, _("%s: fast-forward"), _(action_name(opts
)));
537 transaction
= ref_transaction_begin(&err
);
539 ref_transaction_update(transaction
, "HEAD",
540 to
, unborn
&& !is_rebase_i(opts
) ?
543 ref_transaction_commit(transaction
, &err
)) {
544 ref_transaction_free(transaction
);
545 error("%s", err
.buf
);
547 strbuf_release(&err
);
552 strbuf_release(&err
);
553 ref_transaction_free(transaction
);
554 update_abort_safety_file();
558 enum commit_msg_cleanup_mode
get_cleanup_mode(const char *cleanup_arg
,
561 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
562 return use_editor
? COMMIT_MSG_CLEANUP_ALL
:
563 COMMIT_MSG_CLEANUP_SPACE
;
564 else if (!strcmp(cleanup_arg
, "verbatim"))
565 return COMMIT_MSG_CLEANUP_NONE
;
566 else if (!strcmp(cleanup_arg
, "whitespace"))
567 return COMMIT_MSG_CLEANUP_SPACE
;
568 else if (!strcmp(cleanup_arg
, "strip"))
569 return COMMIT_MSG_CLEANUP_ALL
;
570 else if (!strcmp(cleanup_arg
, "scissors"))
571 return use_editor
? COMMIT_MSG_CLEANUP_SCISSORS
:
572 COMMIT_MSG_CLEANUP_SPACE
;
574 die(_("Invalid cleanup mode %s"), cleanup_arg
);
578 * NB using int rather than enum cleanup_mode to stop clang's
579 * -Wtautological-constant-out-of-range-compare complaining that the comparison
582 static const char *describe_cleanup_mode(int cleanup_mode
)
584 static const char *modes
[] = { "whitespace",
589 if (cleanup_mode
< ARRAY_SIZE(modes
))
590 return modes
[cleanup_mode
];
592 BUG("invalid cleanup_mode provided (%d)", cleanup_mode
);
595 void append_conflicts_hint(struct index_state
*istate
,
596 struct strbuf
*msgbuf
, enum commit_msg_cleanup_mode cleanup_mode
)
600 if (cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
) {
601 strbuf_addch(msgbuf
, '\n');
602 wt_status_append_cut_line(msgbuf
);
603 strbuf_addch(msgbuf
, comment_line_char
);
606 strbuf_addch(msgbuf
, '\n');
607 strbuf_commented_addf(msgbuf
, "Conflicts:\n");
608 for (i
= 0; i
< istate
->cache_nr
;) {
609 const struct cache_entry
*ce
= istate
->cache
[i
++];
611 strbuf_commented_addf(msgbuf
, "\t%s\n", ce
->name
);
612 while (i
< istate
->cache_nr
&&
613 !strcmp(ce
->name
, istate
->cache
[i
]->name
))
619 static int do_recursive_merge(struct repository
*r
,
620 struct commit
*base
, struct commit
*next
,
621 const char *base_label
, const char *next_label
,
622 struct object_id
*head
, struct strbuf
*msgbuf
,
623 struct replay_opts
*opts
)
625 struct merge_options o
;
626 struct merge_result result
;
627 struct tree
*next_tree
, *base_tree
, *head_tree
;
628 int clean
, show_output
;
630 struct lock_file index_lock
= LOCK_INIT
;
632 if (repo_hold_locked_index(r
, &index_lock
, LOCK_REPORT_ON_ERROR
) < 0)
637 init_merge_options(&o
, r
);
638 o
.ancestor
= base
? base_label
: "(empty tree)";
640 o
.branch2
= next
? next_label
: "(empty tree)";
641 if (is_rebase_i(opts
))
643 o
.show_rename_progress
= 1;
645 head_tree
= parse_tree_indirect(head
);
646 next_tree
= next
? get_commit_tree(next
) : empty_tree(r
);
647 base_tree
= base
? get_commit_tree(base
) : empty_tree(r
);
649 for (i
= 0; i
< opts
->xopts_nr
; i
++)
650 parse_merge_opt(&o
, opts
->xopts
[i
]);
652 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
653 memset(&result
, 0, sizeof(result
));
654 merge_incore_nonrecursive(&o
, base_tree
, head_tree
, next_tree
,
656 show_output
= !is_rebase_i(opts
) || !result
.clean
;
658 * TODO: merge_switch_to_result will update index/working tree;
659 * we only really want to do that if !result.clean || this is
660 * the final patch to be picked. But determining this is the
661 * final patch would take some work, and "head_tree" would need
662 * to be replace with the tree the index matched before we
663 * started doing any picks.
665 merge_switch_to_result(&o
, head_tree
, &result
, 1, show_output
);
666 clean
= result
.clean
;
668 ensure_full_index(r
->index
);
669 clean
= merge_trees(&o
, head_tree
, next_tree
, base_tree
);
670 if (is_rebase_i(opts
) && clean
<= 0)
671 fputs(o
.obuf
.buf
, stdout
);
672 strbuf_release(&o
.obuf
);
675 rollback_lock_file(&index_lock
);
679 if (write_locked_index(r
->index
, &index_lock
,
680 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
682 * TRANSLATORS: %s will be "revert", "cherry-pick" or
685 return error(_("%s: Unable to write new index file"),
686 _(action_name(opts
)));
689 append_conflicts_hint(r
->index
, msgbuf
,
690 opts
->default_msg_cleanup
);
695 static struct object_id
*get_cache_tree_oid(struct index_state
*istate
)
697 if (!cache_tree_fully_valid(istate
->cache_tree
))
698 if (cache_tree_update(istate
, 0)) {
699 error(_("unable to update cache tree"));
703 return &istate
->cache_tree
->oid
;
706 static int is_index_unchanged(struct repository
*r
)
708 struct object_id head_oid
, *cache_tree_oid
;
709 struct commit
*head_commit
;
710 struct index_state
*istate
= r
->index
;
712 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
713 return error(_("could not resolve HEAD commit"));
715 head_commit
= lookup_commit(r
, &head_oid
);
718 * If head_commit is NULL, check_commit, called from
719 * lookup_commit, would have indicated that head_commit is not
720 * a commit object already. parse_commit() will return failure
721 * without further complaints in such a case. Otherwise, if
722 * the commit is invalid, parse_commit() will complain. So
723 * there is nothing for us to say here. Just return failure.
725 if (parse_commit(head_commit
))
728 if (!(cache_tree_oid
= get_cache_tree_oid(istate
)))
731 return oideq(cache_tree_oid
, get_commit_tree_oid(head_commit
));
734 static int write_author_script(const char *message
)
736 struct strbuf buf
= STRBUF_INIT
;
741 if (!*message
|| starts_with(message
, "\n")) {
743 /* Missing 'author' line? */
744 unlink(rebase_path_author_script());
746 } else if (skip_prefix(message
, "author ", &message
))
748 else if ((eol
= strchr(message
, '\n')))
753 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
754 while (*message
&& *message
!= '\n' && *message
!= '\r')
755 if (skip_prefix(message
, " <", &message
))
757 else if (*message
!= '\'')
758 strbuf_addch(&buf
, *(message
++));
760 strbuf_addf(&buf
, "'\\%c'", *(message
++));
761 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
762 while (*message
&& *message
!= '\n' && *message
!= '\r')
763 if (skip_prefix(message
, "> ", &message
))
765 else if (*message
!= '\'')
766 strbuf_addch(&buf
, *(message
++));
768 strbuf_addf(&buf
, "'\\%c'", *(message
++));
769 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
770 while (*message
&& *message
!= '\n' && *message
!= '\r')
771 if (*message
!= '\'')
772 strbuf_addch(&buf
, *(message
++));
774 strbuf_addf(&buf
, "'\\%c'", *(message
++));
775 strbuf_addch(&buf
, '\'');
776 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
777 strbuf_release(&buf
);
782 * Take a series of KEY='VALUE' lines where VALUE part is
783 * sq-quoted, and append <KEY, VALUE> at the end of the string list
785 static int parse_key_value_squoted(char *buf
, struct string_list
*list
)
788 struct string_list_item
*item
;
790 char *cp
= strchr(buf
, '=');
792 np
= strchrnul(buf
, '\n');
793 return error(_("no key present in '%.*s'"),
794 (int) (np
- buf
), buf
);
796 np
= strchrnul(cp
, '\n');
798 item
= string_list_append(list
, buf
);
800 buf
= np
+ (*np
== '\n');
804 return error(_("unable to dequote value of '%s'"),
806 item
->util
= xstrdup(cp
);
812 * Reads and parses the state directory's "author-script" file, and sets name,
813 * email and date accordingly.
814 * Returns 0 on success, -1 if the file could not be parsed.
816 * The author script is of the format:
818 * GIT_AUTHOR_NAME='$author_name'
819 * GIT_AUTHOR_EMAIL='$author_email'
820 * GIT_AUTHOR_DATE='$author_date'
822 * where $author_name, $author_email and $author_date are quoted. We are strict
823 * with our parsing, as the file was meant to be eval'd in the now-removed
824 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
825 * from what this function expects, it is better to bail out than to do
826 * something that the user does not expect.
828 int read_author_script(const char *path
, char **name
, char **email
, char **date
,
831 struct strbuf buf
= STRBUF_INIT
;
832 struct string_list kv
= STRING_LIST_INIT_DUP
;
833 int retval
= -1; /* assume failure */
834 int i
, name_i
= -2, email_i
= -2, date_i
= -2, err
= 0;
836 if (strbuf_read_file(&buf
, path
, 256) <= 0) {
837 strbuf_release(&buf
);
838 if (errno
== ENOENT
&& allow_missing
)
841 return error_errno(_("could not open '%s' for reading"),
845 if (parse_key_value_squoted(buf
.buf
, &kv
))
848 for (i
= 0; i
< kv
.nr
; i
++) {
849 if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_NAME")) {
851 name_i
= error(_("'GIT_AUTHOR_NAME' already given"));
854 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_EMAIL")) {
856 email_i
= error(_("'GIT_AUTHOR_EMAIL' already given"));
859 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_DATE")) {
861 date_i
= error(_("'GIT_AUTHOR_DATE' already given"));
865 err
= error(_("unknown variable '%s'"),
870 error(_("missing 'GIT_AUTHOR_NAME'"));
872 error(_("missing 'GIT_AUTHOR_EMAIL'"));
874 error(_("missing 'GIT_AUTHOR_DATE'"));
875 if (date_i
< 0 || email_i
< 0 || date_i
< 0 || err
)
877 *name
= kv
.items
[name_i
].util
;
878 *email
= kv
.items
[email_i
].util
;
879 *date
= kv
.items
[date_i
].util
;
882 string_list_clear(&kv
, !!retval
);
883 strbuf_release(&buf
);
888 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
889 * file with shell quoting into struct strvec. Returns -1 on
890 * error, 0 otherwise.
892 static int read_env_script(struct strvec
*env
)
894 char *name
, *email
, *date
;
896 if (read_author_script(rebase_path_author_script(),
897 &name
, &email
, &date
, 0))
900 strvec_pushf(env
, "GIT_AUTHOR_NAME=%s", name
);
901 strvec_pushf(env
, "GIT_AUTHOR_EMAIL=%s", email
);
902 strvec_pushf(env
, "GIT_AUTHOR_DATE=%s", date
);
910 static char *get_author(const char *message
)
915 a
= find_commit_header(message
, "author", &len
);
917 return xmemdupz(a
, len
);
922 static const char *author_date_from_env_array(const struct strvec
*env
)
927 for (i
= 0; i
< env
->nr
; i
++)
928 if (skip_prefix(env
->v
[i
],
929 "GIT_AUTHOR_DATE=", &date
))
932 * If GIT_AUTHOR_DATE is missing we should have already errored out when
935 BUG("GIT_AUTHOR_DATE missing from author script");
938 static const char staged_changes_advice
[] =
939 N_("you have staged changes in your working tree\n"
940 "If these changes are meant to be squashed into the previous commit, run:\n"
942 " git commit --amend %s\n"
944 "If they are meant to go into a new commit, run:\n"
948 "In both cases, once you're done, continue with:\n"
950 " git rebase --continue\n");
952 #define ALLOW_EMPTY (1<<0)
953 #define EDIT_MSG (1<<1)
954 #define AMEND_MSG (1<<2)
955 #define CLEANUP_MSG (1<<3)
956 #define VERIFY_MSG (1<<4)
957 #define CREATE_ROOT_COMMIT (1<<5)
958 #define VERBATIM_MSG (1<<6)
960 static int run_command_silent_on_success(struct child_process
*cmd
)
962 struct strbuf buf
= STRBUF_INIT
;
965 cmd
->stdout_to_stderr
= 1;
966 rc
= pipe_command(cmd
,
972 fputs(buf
.buf
, stderr
);
973 strbuf_release(&buf
);
978 * If we are cherry-pick, and if the merge did not result in
979 * hand-editing, we will hit this commit and inherit the original
980 * author date and name.
982 * If we are revert, or if our cherry-pick results in a hand merge,
983 * we had better say that the current user is responsible for that.
985 * An exception is when run_git_commit() is called during an
986 * interactive rebase: in that case, we will want to retain the
989 static int run_git_commit(const char *defmsg
,
990 struct replay_opts
*opts
,
993 struct child_process cmd
= CHILD_PROCESS_INIT
;
995 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
996 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1000 if (is_rebase_i(opts
) &&
1001 ((opts
->committer_date_is_author_date
&& !opts
->ignore_date
) ||
1002 !(!defmsg
&& (flags
& AMEND_MSG
))) &&
1003 read_env_script(&cmd
.env_array
)) {
1004 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
1006 return error(_(staged_changes_advice
),
1010 if (opts
->committer_date_is_author_date
)
1011 strvec_pushf(&cmd
.env_array
, "GIT_COMMITTER_DATE=%s",
1014 author_date_from_env_array(&cmd
.env_array
));
1015 if (opts
->ignore_date
)
1016 strvec_push(&cmd
.env_array
, "GIT_AUTHOR_DATE=");
1018 strvec_push(&cmd
.args
, "commit");
1020 if (!(flags
& VERIFY_MSG
))
1021 strvec_push(&cmd
.args
, "-n");
1022 if ((flags
& AMEND_MSG
))
1023 strvec_push(&cmd
.args
, "--amend");
1025 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
1027 strvec_push(&cmd
.args
, "--no-gpg-sign");
1029 strvec_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
1030 else if (!(flags
& EDIT_MSG
))
1031 strvec_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
1032 if ((flags
& CLEANUP_MSG
))
1033 strvec_push(&cmd
.args
, "--cleanup=strip");
1034 if ((flags
& VERBATIM_MSG
))
1035 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1036 if ((flags
& EDIT_MSG
))
1037 strvec_push(&cmd
.args
, "-e");
1038 else if (!(flags
& CLEANUP_MSG
) &&
1039 !opts
->signoff
&& !opts
->record_origin
&&
1040 !opts
->explicit_cleanup
)
1041 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1043 if ((flags
& ALLOW_EMPTY
))
1044 strvec_push(&cmd
.args
, "--allow-empty");
1046 if (!(flags
& EDIT_MSG
))
1047 strvec_push(&cmd
.args
, "--allow-empty-message");
1049 if (is_rebase_i(opts
) && !(flags
& EDIT_MSG
))
1050 return run_command_silent_on_success(&cmd
);
1052 return run_command(&cmd
);
1055 static int rest_is_empty(const struct strbuf
*sb
, int start
)
1060 /* Check if the rest is just whitespace and Signed-off-by's. */
1061 for (i
= start
; i
< sb
->len
; i
++) {
1062 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1068 if (strlen(sign_off_header
) <= eol
- i
&&
1069 starts_with(sb
->buf
+ i
, sign_off_header
)) {
1074 if (!isspace(sb
->buf
[i
++]))
1081 void cleanup_message(struct strbuf
*msgbuf
,
1082 enum commit_msg_cleanup_mode cleanup_mode
, int verbose
)
1084 if (verbose
|| /* Truncate the message just before the diff, if any. */
1085 cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
1086 strbuf_setlen(msgbuf
, wt_status_locate_end(msgbuf
->buf
, msgbuf
->len
));
1087 if (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
)
1088 strbuf_stripspace(msgbuf
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1092 * Find out if the message in the strbuf contains only whitespace and
1093 * Signed-off-by lines.
1095 int message_is_empty(const struct strbuf
*sb
,
1096 enum commit_msg_cleanup_mode cleanup_mode
)
1098 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1100 return rest_is_empty(sb
, 0);
1104 * See if the user edited the message in the editor or left what
1105 * was in the template intact
1107 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
1108 enum commit_msg_cleanup_mode cleanup_mode
)
1110 struct strbuf tmpl
= STRBUF_INIT
;
1113 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1116 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
1119 strbuf_stripspace(&tmpl
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1120 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
1122 strbuf_release(&tmpl
);
1123 return rest_is_empty(sb
, start
- sb
->buf
);
1126 int update_head_with_reflog(const struct commit
*old_head
,
1127 const struct object_id
*new_head
,
1128 const char *action
, const struct strbuf
*msg
,
1131 struct ref_transaction
*transaction
;
1132 struct strbuf sb
= STRBUF_INIT
;
1137 strbuf_addstr(&sb
, action
);
1138 strbuf_addstr(&sb
, ": ");
1141 nl
= strchr(msg
->buf
, '\n');
1143 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
1145 strbuf_addbuf(&sb
, msg
);
1146 strbuf_addch(&sb
, '\n');
1149 transaction
= ref_transaction_begin(err
);
1151 ref_transaction_update(transaction
, "HEAD", new_head
,
1152 old_head
? &old_head
->object
.oid
: null_oid(),
1154 ref_transaction_commit(transaction
, err
)) {
1157 ref_transaction_free(transaction
);
1158 strbuf_release(&sb
);
1163 static int run_rewrite_hook(const struct object_id
*oldoid
,
1164 const struct object_id
*newoid
)
1166 struct child_process proc
= CHILD_PROCESS_INIT
;
1168 struct strbuf sb
= STRBUF_INIT
;
1169 const char *hook_path
= find_hook("post-rewrite");
1174 strvec_pushl(&proc
.args
, hook_path
, "amend", NULL
);
1176 proc
.stdout_to_stderr
= 1;
1177 proc
.trace2_hook_name
= "post-rewrite";
1179 code
= start_command(&proc
);
1182 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
1183 sigchain_push(SIGPIPE
, SIG_IGN
);
1184 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
1186 strbuf_release(&sb
);
1187 sigchain_pop(SIGPIPE
);
1188 return finish_command(&proc
);
1191 void commit_post_rewrite(struct repository
*r
,
1192 const struct commit
*old_head
,
1193 const struct object_id
*new_head
)
1195 struct notes_rewrite_cfg
*cfg
;
1197 cfg
= init_copy_notes_for_rewrite("amend");
1199 /* we are amending, so old_head is not NULL */
1200 copy_note_for_rewrite(cfg
, &old_head
->object
.oid
, new_head
);
1201 finish_copy_notes_for_rewrite(r
, cfg
, "Notes added by 'git commit --amend'");
1203 run_rewrite_hook(&old_head
->object
.oid
, new_head
);
1206 static int run_prepare_commit_msg_hook(struct repository
*r
,
1211 const char *name
, *arg1
= NULL
, *arg2
= NULL
;
1213 name
= git_path_commit_editmsg();
1214 if (write_message(msg
->buf
, msg
->len
, name
, 0))
1223 if (run_commit_hook(0, r
->index_file
, "prepare-commit-msg", name
,
1225 ret
= error(_("'prepare-commit-msg' hook failed"));
1230 static const char implicit_ident_advice_noconfig
[] =
1231 N_("Your name and email address were configured automatically based\n"
1232 "on your username and hostname. Please check that they are accurate.\n"
1233 "You can suppress this message by setting them explicitly. Run the\n"
1234 "following command and follow the instructions in your editor to edit\n"
1235 "your configuration file:\n"
1237 " git config --global --edit\n"
1239 "After doing this, you may fix the identity used for this commit with:\n"
1241 " git commit --amend --reset-author\n");
1243 static const char implicit_ident_advice_config
[] =
1244 N_("Your name and email address were configured automatically based\n"
1245 "on your username and hostname. Please check that they are accurate.\n"
1246 "You can suppress this message by setting them explicitly:\n"
1248 " git config --global user.name \"Your Name\"\n"
1249 " git config --global user.email you@example.com\n"
1251 "After doing this, you may fix the identity used for this commit with:\n"
1253 " git commit --amend --reset-author\n");
1255 static const char *implicit_ident_advice(void)
1257 char *user_config
= interpolate_path("~/.gitconfig", 0);
1258 char *xdg_config
= xdg_config_home("config");
1259 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1265 return _(implicit_ident_advice_config
);
1267 return _(implicit_ident_advice_noconfig
);
1271 void print_commit_summary(struct repository
*r
,
1273 const struct object_id
*oid
,
1276 struct rev_info rev
;
1277 struct commit
*commit
;
1278 struct strbuf format
= STRBUF_INIT
;
1280 struct pretty_print_context pctx
= {0};
1281 struct strbuf author_ident
= STRBUF_INIT
;
1282 struct strbuf committer_ident
= STRBUF_INIT
;
1283 struct ref_store
*refs
;
1286 commit
= lookup_commit(r
, oid
);
1288 die(_("couldn't look up newly created commit"));
1289 if (parse_commit(commit
))
1290 die(_("could not parse newly created commit"));
1292 strbuf_addstr(&format
, "format:%h] %s");
1294 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1295 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1296 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1297 strbuf_addstr(&format
, "\n Author: ");
1298 strbuf_addbuf_percentquote(&format
, &author_ident
);
1300 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
1301 struct strbuf date
= STRBUF_INIT
;
1303 format_commit_message(commit
, "%ad", &date
, &pctx
);
1304 strbuf_addstr(&format
, "\n Date: ");
1305 strbuf_addbuf_percentquote(&format
, &date
);
1306 strbuf_release(&date
);
1308 if (!committer_ident_sufficiently_given()) {
1309 strbuf_addstr(&format
, "\n Committer: ");
1310 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1311 if (advice_enabled(ADVICE_IMPLICIT_IDENTITY
)) {
1312 strbuf_addch(&format
, '\n');
1313 strbuf_addstr(&format
, implicit_ident_advice());
1316 strbuf_release(&author_ident
);
1317 strbuf_release(&committer_ident
);
1319 repo_init_revisions(r
, &rev
, prefix
);
1320 setup_revisions(0, NULL
, &rev
, NULL
);
1323 rev
.diffopt
.output_format
=
1324 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1326 rev
.verbose_header
= 1;
1327 rev
.show_root_diff
= 1;
1328 get_commit_format(format
.buf
, &rev
);
1329 rev
.always_show_header
= 0;
1330 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1331 rev
.diffopt
.break_opt
= 0;
1332 diff_setup_done(&rev
.diffopt
);
1334 refs
= get_main_ref_store(the_repository
);
1335 head
= refs_resolve_ref_unsafe(refs
, "HEAD", 0, NULL
, NULL
,
1338 errno
= resolve_errno
;
1339 die_errno(_("unable to resolve HEAD after creating commit"));
1341 if (!strcmp(head
, "HEAD"))
1342 head
= _("detached HEAD");
1344 skip_prefix(head
, "refs/heads/", &head
);
1345 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1346 _(" (root-commit)") : "");
1348 if (!log_tree_commit(&rev
, commit
)) {
1349 rev
.always_show_header
= 1;
1350 rev
.use_terminator
= 1;
1351 log_tree_commit(&rev
, commit
);
1354 strbuf_release(&format
);
1357 static int parse_head(struct repository
*r
, struct commit
**head
)
1359 struct commit
*current_head
;
1360 struct object_id oid
;
1362 if (get_oid("HEAD", &oid
)) {
1363 current_head
= NULL
;
1365 current_head
= lookup_commit_reference(r
, &oid
);
1367 return error(_("could not parse HEAD"));
1368 if (!oideq(&oid
, ¤t_head
->object
.oid
)) {
1369 warning(_("HEAD %s is not a commit!"),
1372 if (parse_commit(current_head
))
1373 return error(_("could not parse HEAD commit"));
1375 *head
= current_head
;
1381 * Try to commit without forking 'git commit'. In some cases we need
1382 * to run 'git commit' to display an error message
1385 * -1 - error unable to commit
1387 * 1 - run 'git commit'
1389 static int try_to_commit(struct repository
*r
,
1390 struct strbuf
*msg
, const char *author
,
1391 struct replay_opts
*opts
, unsigned int flags
,
1392 struct object_id
*oid
)
1394 struct object_id tree
;
1395 struct commit
*current_head
= NULL
;
1396 struct commit_list
*parents
= NULL
;
1397 struct commit_extra_header
*extra
= NULL
;
1398 struct strbuf err
= STRBUF_INIT
;
1399 struct strbuf commit_msg
= STRBUF_INIT
;
1400 char *amend_author
= NULL
;
1401 const char *committer
= NULL
;
1402 const char *hook_commit
= NULL
;
1403 enum commit_msg_cleanup_mode cleanup
;
1406 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1407 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1409 if (parse_head(r
, ¤t_head
))
1412 if (flags
& AMEND_MSG
) {
1413 const char *exclude_gpgsig
[] = { "gpgsig", "gpgsig-sha256", NULL
};
1414 const char *out_enc
= get_commit_output_encoding();
1415 const char *message
= logmsg_reencode(current_head
, NULL
,
1419 const char *orig_message
= NULL
;
1421 find_commit_subject(message
, &orig_message
);
1423 strbuf_addstr(msg
, orig_message
);
1424 hook_commit
= "HEAD";
1426 author
= amend_author
= get_author(message
);
1427 unuse_commit_buffer(current_head
, message
);
1429 res
= error(_("unable to parse commit author"));
1432 parents
= copy_commit_list(current_head
->parents
);
1433 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1434 } else if (current_head
&&
1435 (!(flags
& CREATE_ROOT_COMMIT
) || (flags
& AMEND_MSG
))) {
1436 commit_list_insert(current_head
, &parents
);
1439 if (write_index_as_tree(&tree
, r
->index
, r
->index_file
, 0, NULL
)) {
1440 res
= error(_("git write-tree failed to write a tree"));
1444 if (!(flags
& ALLOW_EMPTY
)) {
1445 struct commit
*first_parent
= current_head
;
1447 if (flags
& AMEND_MSG
) {
1448 if (current_head
->parents
) {
1449 first_parent
= current_head
->parents
->item
;
1450 if (repo_parse_commit(r
, first_parent
)) {
1451 res
= error(_("could not parse HEAD commit"));
1455 first_parent
= NULL
;
1458 if (oideq(first_parent
1459 ? get_commit_tree_oid(first_parent
)
1460 : the_hash_algo
->empty_tree
,
1462 res
= 1; /* run 'git commit' to display error message */
1467 if (hook_exists("prepare-commit-msg")) {
1468 res
= run_prepare_commit_msg_hook(r
, msg
, hook_commit
);
1471 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1473 res
= error_errno(_("unable to read commit message "
1475 git_path_commit_editmsg());
1481 if (flags
& CLEANUP_MSG
)
1482 cleanup
= COMMIT_MSG_CLEANUP_ALL
;
1483 else if (flags
& VERBATIM_MSG
)
1484 cleanup
= COMMIT_MSG_CLEANUP_NONE
;
1485 else if ((opts
->signoff
|| opts
->record_origin
) &&
1486 !opts
->explicit_cleanup
)
1487 cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
1489 cleanup
= opts
->default_msg_cleanup
;
1491 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1492 strbuf_stripspace(msg
, cleanup
== COMMIT_MSG_CLEANUP_ALL
);
1493 if ((flags
& EDIT_MSG
) && message_is_empty(msg
, cleanup
)) {
1494 res
= 1; /* run 'git commit' to display error message */
1498 if (opts
->committer_date_is_author_date
) {
1499 struct ident_split id
;
1500 struct strbuf date
= STRBUF_INIT
;
1502 if (!opts
->ignore_date
) {
1503 if (split_ident_line(&id
, author
, (int)strlen(author
)) < 0) {
1504 res
= error(_("invalid author identity '%s'"),
1508 if (!id
.date_begin
) {
1510 "corrupt author: missing date information"));
1513 strbuf_addf(&date
, "@%.*s %.*s",
1514 (int)(id
.date_end
- id
.date_begin
),
1516 (int)(id
.tz_end
- id
.tz_begin
),
1521 committer
= fmt_ident(getenv("GIT_COMMITTER_NAME"),
1522 getenv("GIT_COMMITTER_EMAIL"),
1523 WANT_COMMITTER_IDENT
,
1524 opts
->ignore_date
? NULL
: date
.buf
,
1526 strbuf_release(&date
);
1531 if (opts
->ignore_date
) {
1532 struct ident_split id
;
1535 if (split_ident_line(&id
, author
, strlen(author
)) < 0) {
1536 error(_("invalid author identity '%s'"), author
);
1539 name
= xmemdupz(id
.name_begin
, id
.name_end
- id
.name_begin
);
1540 email
= xmemdupz(id
.mail_begin
, id
.mail_end
- id
.mail_begin
);
1541 author
= fmt_ident(name
, email
, WANT_AUTHOR_IDENT
, NULL
,
1547 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
, oid
,
1548 author
, committer
, opts
->gpg_sign
, extra
)) {
1549 res
= error(_("failed to write commit object"));
1553 if (update_head_with_reflog(current_head
, oid
,
1554 getenv("GIT_REFLOG_ACTION"), msg
, &err
)) {
1555 res
= error("%s", err
.buf
);
1559 run_commit_hook(0, r
->index_file
, "post-commit", NULL
);
1560 if (flags
& AMEND_MSG
)
1561 commit_post_rewrite(r
, current_head
, oid
);
1564 free_commit_extra_headers(extra
);
1565 strbuf_release(&err
);
1566 strbuf_release(&commit_msg
);
1572 static int write_rebase_head(struct object_id
*oid
)
1574 if (update_ref("rebase", "REBASE_HEAD", oid
,
1575 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1576 return error(_("could not update %s"), "REBASE_HEAD");
1581 static int do_commit(struct repository
*r
,
1582 const char *msg_file
, const char *author
,
1583 struct replay_opts
*opts
, unsigned int flags
,
1584 struct object_id
*oid
)
1588 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
)) {
1589 struct object_id oid
;
1590 struct strbuf sb
= STRBUF_INIT
;
1592 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1593 return error_errno(_("unable to read commit message "
1597 res
= try_to_commit(r
, msg_file
? &sb
: NULL
,
1598 author
, opts
, flags
, &oid
);
1599 strbuf_release(&sb
);
1601 refs_delete_ref(get_main_ref_store(r
), "",
1602 "CHERRY_PICK_HEAD", NULL
, 0);
1603 unlink(git_path_merge_msg(r
));
1604 if (!is_rebase_i(opts
))
1605 print_commit_summary(r
, NULL
, &oid
,
1606 SUMMARY_SHOW_AUTHOR_DATE
);
1611 if (is_rebase_i(opts
) && oid
)
1612 if (write_rebase_head(oid
))
1614 return run_git_commit(msg_file
, opts
, flags
);
1620 static int is_original_commit_empty(struct commit
*commit
)
1622 const struct object_id
*ptree_oid
;
1624 if (parse_commit(commit
))
1625 return error(_("could not parse commit %s"),
1626 oid_to_hex(&commit
->object
.oid
));
1627 if (commit
->parents
) {
1628 struct commit
*parent
= commit
->parents
->item
;
1629 if (parse_commit(parent
))
1630 return error(_("could not parse parent commit %s"),
1631 oid_to_hex(&parent
->object
.oid
));
1632 ptree_oid
= get_commit_tree_oid(parent
);
1634 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1637 return oideq(ptree_oid
, get_commit_tree_oid(commit
));
1641 * Should empty commits be allowed? Return status:
1642 * <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1643 * 0: Halt on empty commit
1644 * 1: Allow empty commit
1645 * 2: Drop empty commit
1647 static int allow_empty(struct repository
*r
,
1648 struct replay_opts
*opts
,
1649 struct commit
*commit
)
1651 int index_unchanged
, originally_empty
;
1656 * (1) we do not allow empty at all and error out.
1658 * (2) we allow ones that were initially empty, and
1659 * just drop the ones that become empty
1661 * (3) we allow ones that were initially empty, but
1662 * halt for the ones that become empty;
1664 * (4) we allow both.
1666 if (!opts
->allow_empty
)
1667 return 0; /* let "git commit" barf as necessary */
1669 index_unchanged
= is_index_unchanged(r
);
1670 if (index_unchanged
< 0)
1671 return index_unchanged
;
1672 if (!index_unchanged
)
1673 return 0; /* we do not have to say --allow-empty */
1675 if (opts
->keep_redundant_commits
)
1678 originally_empty
= is_original_commit_empty(commit
);
1679 if (originally_empty
< 0)
1680 return originally_empty
;
1681 if (originally_empty
)
1683 else if (opts
->drop_redundant_commits
)
1692 } todo_command_info
[] = {
1709 static const char *command_to_string(const enum todo_command command
)
1711 if (command
< TODO_COMMENT
)
1712 return todo_command_info
[command
].str
;
1713 die(_("unknown command: %d"), command
);
1716 static char command_to_char(const enum todo_command command
)
1718 if (command
< TODO_COMMENT
)
1719 return todo_command_info
[command
].c
;
1720 return comment_line_char
;
1723 static int is_noop(const enum todo_command command
)
1725 return TODO_NOOP
<= command
;
1728 static int is_fixup(enum todo_command command
)
1730 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1733 /* Does this command create a (non-merge) commit? */
1734 static int is_pick_or_similar(enum todo_command command
)
1749 enum todo_item_flags
{
1750 TODO_EDIT_MERGE_MSG
= (1 << 0),
1751 TODO_REPLACE_FIXUP_MSG
= (1 << 1),
1752 TODO_EDIT_FIXUP_MSG
= (1 << 2),
1755 static const char first_commit_msg_str
[] = N_("This is the 1st commit message:");
1756 static const char nth_commit_msg_fmt
[] = N_("This is the commit message #%d:");
1757 static const char skip_first_commit_msg_str
[] = N_("The 1st commit message will be skipped:");
1758 static const char skip_nth_commit_msg_fmt
[] = N_("The commit message #%d will be skipped:");
1759 static const char combined_commit_msg_fmt
[] = N_("This is a combination of %d commits.");
1761 static int is_fixup_flag(enum todo_command command
, unsigned flag
)
1763 return command
== TODO_FIXUP
&& ((flag
& TODO_REPLACE_FIXUP_MSG
) ||
1764 (flag
& TODO_EDIT_FIXUP_MSG
));
1768 * Wrapper around strbuf_add_commented_lines() which avoids double
1769 * commenting commit subjects.
1771 static void add_commented_lines(struct strbuf
*buf
, const void *str
, size_t len
)
1773 const char *s
= str
;
1774 while (len
> 0 && s
[0] == comment_line_char
) {
1776 const char *n
= memchr(s
, '\n', len
);
1781 strbuf_add(buf
, s
, count
);
1785 strbuf_add_commented_lines(buf
, s
, len
);
1788 /* Does the current fixup chain contain a squash command? */
1789 static int seen_squash(struct replay_opts
*opts
)
1791 return starts_with(opts
->current_fixups
.buf
, "squash") ||
1792 strstr(opts
->current_fixups
.buf
, "\nsquash");
1795 static void update_comment_bufs(struct strbuf
*buf1
, struct strbuf
*buf2
, int n
)
1797 strbuf_setlen(buf1
, 2);
1798 strbuf_addf(buf1
, _(nth_commit_msg_fmt
), n
);
1799 strbuf_addch(buf1
, '\n');
1800 strbuf_setlen(buf2
, 2);
1801 strbuf_addf(buf2
, _(skip_nth_commit_msg_fmt
), n
);
1802 strbuf_addch(buf2
, '\n');
1806 * Comment out any un-commented commit messages, updating the message comments
1807 * to say they will be skipped but do not comment out the empty lines that
1808 * surround commit messages and their comments.
1810 static void update_squash_message_for_fixup(struct strbuf
*msg
)
1812 void (*copy_lines
)(struct strbuf
*, const void *, size_t) = strbuf_add
;
1813 struct strbuf buf1
= STRBUF_INIT
, buf2
= STRBUF_INIT
;
1814 const char *s
, *start
;
1816 size_t orig_msg_len
;
1819 strbuf_addf(&buf1
, "# %s\n", _(first_commit_msg_str
));
1820 strbuf_addf(&buf2
, "# %s\n", _(skip_first_commit_msg_str
));
1821 s
= start
= orig_msg
= strbuf_detach(msg
, &orig_msg_len
);
1825 if (skip_prefix(s
, buf1
.buf
, &next
)) {
1827 * Copy the last message, preserving the blank line
1828 * preceding the current line
1830 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1831 copy_lines(msg
, start
, s
- start
- off
);
1833 strbuf_addch(msg
, '\n');
1835 * The next message needs to be commented out but the
1836 * message header is already commented out so just copy
1837 * it and the blank line that follows it.
1839 strbuf_addbuf(msg
, &buf2
);
1841 strbuf_addch(msg
, *next
++);
1843 copy_lines
= add_commented_lines
;
1844 update_comment_bufs(&buf1
, &buf2
, ++i
);
1845 } else if (skip_prefix(s
, buf2
.buf
, &next
)) {
1846 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1847 copy_lines(msg
, start
, s
- start
- off
);
1850 copy_lines
= strbuf_add
;
1851 update_comment_bufs(&buf1
, &buf2
, ++i
);
1853 s
= strchr(s
, '\n');
1858 copy_lines(msg
, start
, orig_msg_len
- (start
- orig_msg
));
1860 strbuf_release(&buf1
);
1861 strbuf_release(&buf2
);
1864 static int append_squash_message(struct strbuf
*buf
, const char *body
,
1865 enum todo_command command
, struct replay_opts
*opts
,
1868 const char *fixup_msg
;
1869 size_t commented_len
= 0, fixup_off
;
1871 * amend is non-interactive and not normally used with fixup!
1872 * or squash! commits, so only comment out those subjects when
1873 * squashing commit messages.
1875 if (starts_with(body
, "amend!") ||
1876 ((command
== TODO_SQUASH
|| seen_squash(opts
)) &&
1877 (starts_with(body
, "squash!") || starts_with(body
, "fixup!"))))
1878 commented_len
= commit_subject_length(body
);
1880 strbuf_addf(buf
, "\n%c ", comment_line_char
);
1881 strbuf_addf(buf
, _(nth_commit_msg_fmt
),
1882 ++opts
->current_fixup_count
+ 1);
1883 strbuf_addstr(buf
, "\n\n");
1884 strbuf_add_commented_lines(buf
, body
, commented_len
);
1885 /* buf->buf may be reallocated so store an offset into the buffer */
1886 fixup_off
= buf
->len
;
1887 strbuf_addstr(buf
, body
+ commented_len
);
1889 /* fixup -C after squash behaves like squash */
1890 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
)) {
1892 * We're replacing the commit message so we need to
1893 * append the Signed-off-by: trailer if the user
1894 * requested '--signoff'.
1897 append_signoff(buf
, 0, 0);
1899 if ((command
== TODO_FIXUP
) &&
1900 (flag
& TODO_REPLACE_FIXUP_MSG
) &&
1901 (file_exists(rebase_path_fixup_msg()) ||
1902 !file_exists(rebase_path_squash_msg()))) {
1903 fixup_msg
= skip_blank_lines(buf
->buf
+ fixup_off
);
1904 if (write_message(fixup_msg
, strlen(fixup_msg
),
1905 rebase_path_fixup_msg(), 0) < 0)
1906 return error(_("cannot write '%s'"),
1907 rebase_path_fixup_msg());
1909 unlink(rebase_path_fixup_msg());
1912 unlink(rebase_path_fixup_msg());
1918 static int update_squash_messages(struct repository
*r
,
1919 enum todo_command command
,
1920 struct commit
*commit
,
1921 struct replay_opts
*opts
,
1924 struct strbuf buf
= STRBUF_INIT
;
1926 const char *message
, *body
;
1927 const char *encoding
= get_commit_output_encoding();
1929 if (opts
->current_fixup_count
> 0) {
1930 struct strbuf header
= STRBUF_INIT
;
1933 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
1934 return error(_("could not read '%s'"),
1935 rebase_path_squash_msg());
1937 eol
= buf
.buf
[0] != comment_line_char
?
1938 buf
.buf
: strchrnul(buf
.buf
, '\n');
1940 strbuf_addf(&header
, "%c ", comment_line_char
);
1941 strbuf_addf(&header
, _(combined_commit_msg_fmt
),
1942 opts
->current_fixup_count
+ 2);
1943 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
1944 strbuf_release(&header
);
1945 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
))
1946 update_squash_message_for_fixup(&buf
);
1948 struct object_id head
;
1949 struct commit
*head_commit
;
1950 const char *head_message
, *body
;
1952 if (get_oid("HEAD", &head
))
1953 return error(_("need a HEAD to fixup"));
1954 if (!(head_commit
= lookup_commit_reference(r
, &head
)))
1955 return error(_("could not read HEAD"));
1956 if (!(head_message
= logmsg_reencode(head_commit
, NULL
, encoding
)))
1957 return error(_("could not read HEAD's commit message"));
1959 find_commit_subject(head_message
, &body
);
1960 if (command
== TODO_FIXUP
&& !flag
&& write_message(body
, strlen(body
),
1961 rebase_path_fixup_msg(), 0) < 0) {
1962 unuse_commit_buffer(head_commit
, head_message
);
1963 return error(_("cannot write '%s'"), rebase_path_fixup_msg());
1965 strbuf_addf(&buf
, "%c ", comment_line_char
);
1966 strbuf_addf(&buf
, _(combined_commit_msg_fmt
), 2);
1967 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1968 strbuf_addstr(&buf
, is_fixup_flag(command
, flag
) ?
1969 _(skip_first_commit_msg_str
) :
1970 _(first_commit_msg_str
));
1971 strbuf_addstr(&buf
, "\n\n");
1972 if (is_fixup_flag(command
, flag
))
1973 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
1975 strbuf_addstr(&buf
, body
);
1977 unuse_commit_buffer(head_commit
, head_message
);
1980 if (!(message
= logmsg_reencode(commit
, NULL
, encoding
)))
1981 return error(_("could not read commit message of %s"),
1982 oid_to_hex(&commit
->object
.oid
));
1983 find_commit_subject(message
, &body
);
1985 if (command
== TODO_SQUASH
|| is_fixup_flag(command
, flag
)) {
1986 res
= append_squash_message(&buf
, body
, command
, opts
, flag
);
1987 } else if (command
== TODO_FIXUP
) {
1988 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1989 strbuf_addf(&buf
, _(skip_nth_commit_msg_fmt
),
1990 ++opts
->current_fixup_count
+ 1);
1991 strbuf_addstr(&buf
, "\n\n");
1992 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
1994 return error(_("unknown command: %d"), command
);
1995 unuse_commit_buffer(commit
, message
);
1998 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(),
2000 strbuf_release(&buf
);
2003 strbuf_addf(&opts
->current_fixups
, "%s%s %s",
2004 opts
->current_fixups
.len
? "\n" : "",
2005 command_to_string(command
),
2006 oid_to_hex(&commit
->object
.oid
));
2007 res
= write_message(opts
->current_fixups
.buf
,
2008 opts
->current_fixups
.len
,
2009 rebase_path_current_fixups(), 0);
2015 static void flush_rewritten_pending(void)
2017 struct strbuf buf
= STRBUF_INIT
;
2018 struct object_id newoid
;
2021 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
2022 !get_oid("HEAD", &newoid
) &&
2023 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
2024 char *bol
= buf
.buf
, *eol
;
2027 eol
= strchrnul(bol
, '\n');
2028 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
2029 bol
, oid_to_hex(&newoid
));
2035 unlink(rebase_path_rewritten_pending());
2037 strbuf_release(&buf
);
2040 static void record_in_rewritten(struct object_id
*oid
,
2041 enum todo_command next_command
)
2043 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
2048 fprintf(out
, "%s\n", oid_to_hex(oid
));
2051 if (!is_fixup(next_command
))
2052 flush_rewritten_pending();
2055 static int should_edit(struct replay_opts
*opts
) {
2058 * Note that we only handle the case of non-conflicted
2059 * commits; continue_single_pick() handles the conflicted
2060 * commits itself instead of calling this function.
2062 return (opts
->action
== REPLAY_REVERT
&& isatty(0)) ? 1 : 0;
2066 static int do_pick_commit(struct repository
*r
,
2067 struct todo_item
*item
,
2068 struct replay_opts
*opts
,
2069 int final_fixup
, int *check_todo
)
2071 unsigned int flags
= should_edit(opts
) ? EDIT_MSG
: 0;
2072 const char *msg_file
= should_edit(opts
) ? NULL
: git_path_merge_msg(r
);
2073 struct object_id head
;
2074 struct commit
*base
, *next
, *parent
;
2075 const char *base_label
, *next_label
;
2076 char *author
= NULL
;
2077 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
2078 struct strbuf msgbuf
= STRBUF_INIT
;
2079 int res
, unborn
= 0, reword
= 0, allow
, drop_commit
;
2080 enum todo_command command
= item
->command
;
2081 struct commit
*commit
= item
->commit
;
2083 if (opts
->no_commit
) {
2085 * We do not intend to commit immediately. We just want to
2086 * merge the differences in, so let's compute the tree
2087 * that represents the "current" state for the merge machinery
2090 if (write_index_as_tree(&head
, r
->index
, r
->index_file
, 0, NULL
))
2091 return error(_("your index file is unmerged."));
2093 unborn
= get_oid("HEAD", &head
);
2094 /* Do we want to generate a root commit? */
2095 if (is_pick_or_similar(command
) && opts
->have_squash_onto
&&
2096 oideq(&head
, &opts
->squash_onto
)) {
2097 if (is_fixup(command
))
2098 return error(_("cannot fixup root commit"));
2099 flags
|= CREATE_ROOT_COMMIT
;
2102 oidcpy(&head
, the_hash_algo
->empty_tree
);
2103 if (index_differs_from(r
, unborn
? empty_tree_oid_hex() : "HEAD",
2105 return error_dirty_index(r
, opts
);
2107 discard_index(r
->index
);
2109 if (!commit
->parents
)
2111 else if (commit
->parents
->next
) {
2112 /* Reverting or cherry-picking a merge commit */
2114 struct commit_list
*p
;
2116 if (!opts
->mainline
)
2117 return error(_("commit %s is a merge but no -m option was given."),
2118 oid_to_hex(&commit
->object
.oid
));
2120 for (cnt
= 1, p
= commit
->parents
;
2121 cnt
!= opts
->mainline
&& p
;
2124 if (cnt
!= opts
->mainline
|| !p
)
2125 return error(_("commit %s does not have parent %d"),
2126 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2128 } else if (1 < opts
->mainline
)
2130 * Non-first parent explicitly specified as mainline for
2133 return error(_("commit %s does not have parent %d"),
2134 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2136 parent
= commit
->parents
->item
;
2138 if (get_message(commit
, &msg
) != 0)
2139 return error(_("cannot get commit message for %s"),
2140 oid_to_hex(&commit
->object
.oid
));
2142 if (opts
->allow_ff
&& !is_fixup(command
) &&
2143 ((parent
&& oideq(&parent
->object
.oid
, &head
)) ||
2144 (!parent
&& unborn
))) {
2145 if (is_rebase_i(opts
))
2146 write_author_script(msg
.message
);
2147 res
= fast_forward_to(r
, &commit
->object
.oid
, &head
, unborn
,
2149 if (res
|| command
!= TODO_REWORD
)
2153 goto fast_forward_edit
;
2155 if (parent
&& parse_commit(parent
) < 0)
2156 /* TRANSLATORS: The first %s will be a "todo" command like
2157 "revert" or "pick", the second %s a SHA1. */
2158 return error(_("%s: cannot parse parent commit %s"),
2159 command_to_string(command
),
2160 oid_to_hex(&parent
->object
.oid
));
2163 * "commit" is an existing commit. We would want to apply
2164 * the difference it introduces since its first parent "prev"
2165 * on top of the current HEAD if we are cherry-pick. Or the
2166 * reverse of it if we are revert.
2169 if (command
== TODO_REVERT
) {
2171 base_label
= msg
.label
;
2173 next_label
= msg
.parent_label
;
2174 strbuf_addstr(&msgbuf
, "Revert \"");
2175 strbuf_addstr(&msgbuf
, msg
.subject
);
2176 strbuf_addstr(&msgbuf
, "\"\n\nThis reverts commit ");
2177 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
2179 if (commit
->parents
&& commit
->parents
->next
) {
2180 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
2181 strbuf_addstr(&msgbuf
, oid_to_hex(&parent
->object
.oid
));
2183 strbuf_addstr(&msgbuf
, ".\n");
2188 base_label
= msg
.parent_label
;
2190 next_label
= msg
.label
;
2192 /* Append the commit log message to msgbuf. */
2193 if (find_commit_subject(msg
.message
, &p
))
2194 strbuf_addstr(&msgbuf
, p
);
2196 if (opts
->record_origin
) {
2197 strbuf_complete_line(&msgbuf
);
2198 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
2199 strbuf_addch(&msgbuf
, '\n');
2200 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
2201 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
2202 strbuf_addstr(&msgbuf
, ")\n");
2204 if (!is_fixup(command
))
2205 author
= get_author(msg
.message
);
2208 if (command
== TODO_REWORD
)
2210 else if (is_fixup(command
)) {
2211 if (update_squash_messages(r
, command
, commit
,
2216 msg_file
= rebase_path_squash_msg();
2217 else if (file_exists(rebase_path_fixup_msg())) {
2218 flags
|= VERBATIM_MSG
;
2219 msg_file
= rebase_path_fixup_msg();
2221 const char *dest
= git_path_squash_msg(r
);
2223 if (copy_file(dest
, rebase_path_squash_msg(), 0666))
2224 return error(_("could not rename '%s' to '%s'"),
2225 rebase_path_squash_msg(), dest
);
2226 unlink(git_path_merge_msg(r
));
2232 if (opts
->signoff
&& !is_fixup(command
))
2233 append_signoff(&msgbuf
, 0, 0);
2235 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
2237 else if (!opts
->strategy
||
2238 !strcmp(opts
->strategy
, "recursive") ||
2239 !strcmp(opts
->strategy
, "ort") ||
2240 command
== TODO_REVERT
) {
2241 res
= do_recursive_merge(r
, base
, next
, base_label
, next_label
,
2242 &head
, &msgbuf
, opts
);
2246 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
2247 git_path_merge_msg(r
), 0);
2249 struct commit_list
*common
= NULL
;
2250 struct commit_list
*remotes
= NULL
;
2252 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
2253 git_path_merge_msg(r
), 0);
2255 commit_list_insert(base
, &common
);
2256 commit_list_insert(next
, &remotes
);
2257 res
|= try_merge_command(r
, opts
->strategy
,
2258 opts
->xopts_nr
, (const char **)opts
->xopts
,
2259 common
, oid_to_hex(&head
), remotes
);
2260 free_commit_list(common
);
2261 free_commit_list(remotes
);
2263 strbuf_release(&msgbuf
);
2266 * If the merge was clean or if it failed due to conflict, we write
2267 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
2268 * However, if the merge did not even start, then we don't want to
2271 if ((command
== TODO_PICK
|| command
== TODO_REWORD
||
2272 command
== TODO_EDIT
) && !opts
->no_commit
&&
2273 (res
== 0 || res
== 1) &&
2274 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
2275 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2277 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
2278 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
2279 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2283 error(command
== TODO_REVERT
2284 ? _("could not revert %s... %s")
2285 : _("could not apply %s... %s"),
2286 short_commit_name(commit
), msg
.subject
);
2287 print_advice(r
, res
== 1, opts
);
2288 repo_rerere(r
, opts
->allow_rerere_auto
);
2293 allow
= allow_empty(r
, opts
, commit
);
2297 } else if (allow
== 1) {
2298 flags
|= ALLOW_EMPTY
;
2299 } else if (allow
== 2) {
2301 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
2303 unlink(git_path_merge_msg(r
));
2304 unlink(git_path_auto_merge(r
));
2306 _("dropping %s %s -- patch contents already upstream\n"),
2307 oid_to_hex(&commit
->object
.oid
), msg
.subject
);
2308 } /* else allow == 0 and there's nothing special to do */
2309 if (!opts
->no_commit
&& !drop_commit
) {
2310 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
2311 res
= do_commit(r
, msg_file
, author
, opts
, flags
,
2312 commit
? &commit
->object
.oid
: NULL
);
2314 res
= error(_("unable to parse commit author"));
2315 *check_todo
= !!(flags
& EDIT_MSG
);
2316 if (!res
&& reword
) {
2318 res
= run_git_commit(NULL
, opts
, EDIT_MSG
|
2319 VERIFY_MSG
| AMEND_MSG
|
2320 (flags
& ALLOW_EMPTY
));
2326 if (!res
&& final_fixup
) {
2327 unlink(rebase_path_fixup_msg());
2328 unlink(rebase_path_squash_msg());
2329 unlink(rebase_path_current_fixups());
2330 strbuf_reset(&opts
->current_fixups
);
2331 opts
->current_fixup_count
= 0;
2335 free_message(commit
, &msg
);
2337 update_abort_safety_file();
2342 static int prepare_revs(struct replay_opts
*opts
)
2345 * picking (but not reverting) ranges (but not individual revisions)
2346 * should be done in reverse
2348 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
2349 opts
->revs
->reverse
^= 1;
2351 if (prepare_revision_walk(opts
->revs
))
2352 return error(_("revision walk setup failed"));
2357 static int read_and_refresh_cache(struct repository
*r
,
2358 struct replay_opts
*opts
)
2360 struct lock_file index_lock
= LOCK_INIT
;
2361 int index_fd
= repo_hold_locked_index(r
, &index_lock
, 0);
2362 if (repo_read_index(r
) < 0) {
2363 rollback_lock_file(&index_lock
);
2364 return error(_("git %s: failed to read the index"),
2365 _(action_name(opts
)));
2367 refresh_index(r
->index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
2369 if (index_fd
>= 0) {
2370 if (write_locked_index(r
->index
, &index_lock
,
2371 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
2372 return error(_("git %s: failed to refresh the index"),
2373 _(action_name(opts
)));
2378 * If we are resolving merges in any way other than "ort", then
2379 * expand the sparse index.
2381 if (opts
->strategy
&& strcmp(opts
->strategy
, "ort"))
2382 ensure_full_index(r
->index
);
2386 void todo_list_release(struct todo_list
*todo_list
)
2388 strbuf_release(&todo_list
->buf
);
2389 FREE_AND_NULL(todo_list
->items
);
2390 todo_list
->nr
= todo_list
->alloc
= 0;
2393 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
2395 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
2396 todo_list
->total_nr
++;
2397 return todo_list
->items
+ todo_list
->nr
++;
2400 const char *todo_item_get_arg(struct todo_list
*todo_list
,
2401 struct todo_item
*item
)
2403 return todo_list
->buf
.buf
+ item
->arg_offset
;
2406 static int is_command(enum todo_command command
, const char **bol
)
2408 const char *str
= todo_command_info
[command
].str
;
2409 const char nick
= todo_command_info
[command
].c
;
2410 const char *p
= *bol
+ 1;
2412 return skip_prefix(*bol
, str
, bol
) ||
2413 ((nick
&& **bol
== nick
) &&
2414 (*p
== ' ' || *p
== '\t' || *p
== '\n' || *p
== '\r' || !*p
) &&
2418 static int parse_insn_line(struct repository
*r
, struct todo_item
*item
,
2419 const char *buf
, const char *bol
, char *eol
)
2421 struct object_id commit_oid
;
2422 char *end_of_object_name
;
2423 int i
, saved
, status
, padding
;
2428 bol
+= strspn(bol
, " \t");
2430 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
2431 item
->command
= TODO_COMMENT
;
2432 item
->commit
= NULL
;
2433 item
->arg_offset
= bol
- buf
;
2434 item
->arg_len
= eol
- bol
;
2438 for (i
= 0; i
< TODO_COMMENT
; i
++)
2439 if (is_command(i
, &bol
)) {
2443 if (i
>= TODO_COMMENT
)
2446 /* Eat up extra spaces/ tabs before object name */
2447 padding
= strspn(bol
, " \t");
2450 if (item
->command
== TODO_NOOP
|| item
->command
== TODO_BREAK
) {
2452 return error(_("%s does not accept arguments: '%s'"),
2453 command_to_string(item
->command
), bol
);
2454 item
->commit
= NULL
;
2455 item
->arg_offset
= bol
- buf
;
2456 item
->arg_len
= eol
- bol
;
2461 return error(_("missing arguments for %s"),
2462 command_to_string(item
->command
));
2464 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
2465 item
->command
== TODO_RESET
) {
2466 item
->commit
= NULL
;
2467 item
->arg_offset
= bol
- buf
;
2468 item
->arg_len
= (int)(eol
- bol
);
2472 if (item
->command
== TODO_FIXUP
) {
2473 if (skip_prefix(bol
, "-C", &bol
) &&
2474 (*bol
== ' ' || *bol
== '\t')) {
2475 bol
+= strspn(bol
, " \t");
2476 item
->flags
|= TODO_REPLACE_FIXUP_MSG
;
2477 } else if (skip_prefix(bol
, "-c", &bol
) &&
2478 (*bol
== ' ' || *bol
== '\t')) {
2479 bol
+= strspn(bol
, " \t");
2480 item
->flags
|= TODO_EDIT_FIXUP_MSG
;
2484 if (item
->command
== TODO_MERGE
) {
2485 if (skip_prefix(bol
, "-C", &bol
))
2486 bol
+= strspn(bol
, " \t");
2487 else if (skip_prefix(bol
, "-c", &bol
)) {
2488 bol
+= strspn(bol
, " \t");
2489 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2491 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2492 item
->commit
= NULL
;
2493 item
->arg_offset
= bol
- buf
;
2494 item
->arg_len
= (int)(eol
- bol
);
2499 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
2500 saved
= *end_of_object_name
;
2501 *end_of_object_name
= '\0';
2502 status
= get_oid(bol
, &commit_oid
);
2504 error(_("could not parse '%s'"), bol
); /* return later */
2505 *end_of_object_name
= saved
;
2507 bol
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2508 item
->arg_offset
= bol
- buf
;
2509 item
->arg_len
= (int)(eol
- bol
);
2514 item
->commit
= lookup_commit_reference(r
, &commit_oid
);
2515 return item
->commit
? 0 : -1;
2518 int sequencer_get_last_command(struct repository
*r
, enum replay_action
*action
)
2520 const char *todo_file
, *bol
;
2521 struct strbuf buf
= STRBUF_INIT
;
2524 todo_file
= git_path_todo_file();
2525 if (strbuf_read_file(&buf
, todo_file
, 0) < 0) {
2526 if (errno
== ENOENT
|| errno
== ENOTDIR
)
2529 return error_errno("unable to open '%s'", todo_file
);
2531 bol
= buf
.buf
+ strspn(buf
.buf
, " \t\r\n");
2532 if (is_command(TODO_PICK
, &bol
) && (*bol
== ' ' || *bol
== '\t'))
2533 *action
= REPLAY_PICK
;
2534 else if (is_command(TODO_REVERT
, &bol
) &&
2535 (*bol
== ' ' || *bol
== '\t'))
2536 *action
= REPLAY_REVERT
;
2540 strbuf_release(&buf
);
2545 int todo_list_parse_insn_buffer(struct repository
*r
, char *buf
,
2546 struct todo_list
*todo_list
)
2548 struct todo_item
*item
;
2549 char *p
= buf
, *next_p
;
2550 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2552 todo_list
->current
= todo_list
->nr
= 0;
2554 for (i
= 1; *p
; i
++, p
= next_p
) {
2555 char *eol
= strchrnul(p
, '\n');
2557 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2559 if (p
!= eol
&& eol
[-1] == '\r')
2560 eol
--; /* strip Carriage Return */
2562 item
= append_new_todo(todo_list
);
2563 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2564 if (parse_insn_line(r
, item
, buf
, p
, eol
)) {
2565 res
= error(_("invalid line %d: %.*s"),
2566 i
, (int)(eol
- p
), p
);
2567 item
->command
= TODO_COMMENT
+ 1;
2568 item
->arg_offset
= p
- buf
;
2569 item
->arg_len
= (int)(eol
- p
);
2570 item
->commit
= NULL
;
2575 else if (is_fixup(item
->command
))
2576 return error(_("cannot '%s' without a previous commit"),
2577 command_to_string(item
->command
));
2578 else if (!is_noop(item
->command
))
2585 static int count_commands(struct todo_list
*todo_list
)
2589 for (i
= 0; i
< todo_list
->nr
; i
++)
2590 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2596 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2598 return index
< todo_list
->nr
?
2599 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2602 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2604 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2607 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2609 return get_item_line_offset(todo_list
, index
+ 1)
2610 - get_item_line_offset(todo_list
, index
);
2613 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2618 fd
= open(path
, O_RDONLY
);
2620 return error_errno(_("could not open '%s'"), path
);
2621 len
= strbuf_read(sb
, fd
, 0);
2624 return error(_("could not read '%s'."), path
);
2628 static int have_finished_the_last_pick(void)
2630 struct strbuf buf
= STRBUF_INIT
;
2632 const char *todo_path
= git_path_todo_file();
2635 if (strbuf_read_file(&buf
, todo_path
, 0) < 0) {
2636 if (errno
== ENOENT
) {
2639 error_errno("unable to open '%s'", todo_path
);
2643 /* If there is only one line then we are done */
2644 eol
= strchr(buf
.buf
, '\n');
2645 if (!eol
|| !eol
[1])
2648 strbuf_release(&buf
);
2653 void sequencer_post_commit_cleanup(struct repository
*r
, int verbose
)
2655 struct replay_opts opts
= REPLAY_OPTS_INIT
;
2656 int need_cleanup
= 0;
2658 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
2659 if (!refs_delete_ref(get_main_ref_store(r
), "",
2660 "CHERRY_PICK_HEAD", NULL
, 0) &&
2662 warning(_("cancelling a cherry picking in progress"));
2663 opts
.action
= REPLAY_PICK
;
2667 if (refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
2668 if (!refs_delete_ref(get_main_ref_store(r
), "", "REVERT_HEAD",
2671 warning(_("cancelling a revert in progress"));
2672 opts
.action
= REPLAY_REVERT
;
2676 unlink(git_path_auto_merge(r
));
2681 if (!have_finished_the_last_pick())
2684 sequencer_remove_state(&opts
);
2687 static void todo_list_write_total_nr(struct todo_list
*todo_list
)
2689 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2692 fprintf(f
, "%d\n", todo_list
->total_nr
);
2697 static int read_populate_todo(struct repository
*r
,
2698 struct todo_list
*todo_list
,
2699 struct replay_opts
*opts
)
2701 const char *todo_file
= get_todo_path(opts
);
2704 strbuf_reset(&todo_list
->buf
);
2705 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2708 res
= todo_list_parse_insn_buffer(r
, todo_list
->buf
.buf
, todo_list
);
2710 if (is_rebase_i(opts
))
2711 return error(_("please fix this using "
2712 "'git rebase --edit-todo'."));
2713 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2716 if (!todo_list
->nr
&&
2717 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2718 return error(_("no commits parsed."));
2720 if (!is_rebase_i(opts
)) {
2721 enum todo_command valid
=
2722 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2725 for (i
= 0; i
< todo_list
->nr
; i
++)
2726 if (valid
== todo_list
->items
[i
].command
)
2728 else if (valid
== TODO_PICK
)
2729 return error(_("cannot cherry-pick during a revert."));
2731 return error(_("cannot revert during a cherry-pick."));
2734 if (is_rebase_i(opts
)) {
2735 struct todo_list done
= TODO_LIST_INIT
;
2737 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2738 !todo_list_parse_insn_buffer(r
, done
.buf
.buf
, &done
))
2739 todo_list
->done_nr
= count_commands(&done
);
2741 todo_list
->done_nr
= 0;
2743 todo_list
->total_nr
= todo_list
->done_nr
2744 + count_commands(todo_list
);
2745 todo_list_release(&done
);
2747 todo_list_write_total_nr(todo_list
);
2753 static int git_config_string_dup(char **dest
,
2754 const char *var
, const char *value
)
2757 return config_error_nonbool(var
);
2759 *dest
= xstrdup(value
);
2763 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
2765 struct replay_opts
*opts
= data
;
2770 else if (!strcmp(key
, "options.no-commit"))
2771 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
2772 else if (!strcmp(key
, "options.edit"))
2773 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
2774 else if (!strcmp(key
, "options.allow-empty"))
2776 git_config_bool_or_int(key
, value
, &error_flag
);
2777 else if (!strcmp(key
, "options.allow-empty-message"))
2778 opts
->allow_empty_message
=
2779 git_config_bool_or_int(key
, value
, &error_flag
);
2780 else if (!strcmp(key
, "options.keep-redundant-commits"))
2781 opts
->keep_redundant_commits
=
2782 git_config_bool_or_int(key
, value
, &error_flag
);
2783 else if (!strcmp(key
, "options.signoff"))
2784 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
2785 else if (!strcmp(key
, "options.record-origin"))
2786 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
2787 else if (!strcmp(key
, "options.allow-ff"))
2788 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
2789 else if (!strcmp(key
, "options.mainline"))
2790 opts
->mainline
= git_config_int(key
, value
);
2791 else if (!strcmp(key
, "options.strategy"))
2792 git_config_string_dup(&opts
->strategy
, key
, value
);
2793 else if (!strcmp(key
, "options.gpg-sign"))
2794 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
2795 else if (!strcmp(key
, "options.strategy-option")) {
2796 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
2797 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(value
);
2798 } else if (!strcmp(key
, "options.allow-rerere-auto"))
2799 opts
->allow_rerere_auto
=
2800 git_config_bool_or_int(key
, value
, &error_flag
) ?
2801 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
2802 else if (!strcmp(key
, "options.default-msg-cleanup")) {
2803 opts
->explicit_cleanup
= 1;
2804 opts
->default_msg_cleanup
= get_cleanup_mode(value
, 1);
2806 return error(_("invalid key: %s"), key
);
2809 return error(_("invalid value for %s: %s"), key
, value
);
2814 void parse_strategy_opts(struct replay_opts
*opts
, char *raw_opts
)
2817 char *strategy_opts_string
= raw_opts
;
2819 if (*strategy_opts_string
== ' ')
2820 strategy_opts_string
++;
2822 opts
->xopts_nr
= split_cmdline(strategy_opts_string
,
2823 (const char ***)&opts
->xopts
);
2824 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
2825 const char *arg
= opts
->xopts
[i
];
2827 skip_prefix(arg
, "--", &arg
);
2828 opts
->xopts
[i
] = xstrdup(arg
);
2832 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2835 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2837 opts
->strategy
= strbuf_detach(buf
, NULL
);
2838 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2841 parse_strategy_opts(opts
, buf
->buf
);
2844 static int read_populate_opts(struct replay_opts
*opts
)
2846 if (is_rebase_i(opts
)) {
2847 struct strbuf buf
= STRBUF_INIT
;
2850 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(),
2851 READ_ONELINER_SKIP_IF_EMPTY
)) {
2852 if (!starts_with(buf
.buf
, "-S"))
2855 free(opts
->gpg_sign
);
2856 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2861 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(),
2862 READ_ONELINER_SKIP_IF_EMPTY
)) {
2863 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2864 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2865 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2866 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2870 if (file_exists(rebase_path_verbose()))
2873 if (file_exists(rebase_path_quiet()))
2876 if (file_exists(rebase_path_signoff())) {
2881 if (file_exists(rebase_path_cdate_is_adate())) {
2883 opts
->committer_date_is_author_date
= 1;
2886 if (file_exists(rebase_path_ignore_date())) {
2888 opts
->ignore_date
= 1;
2891 if (file_exists(rebase_path_reschedule_failed_exec()))
2892 opts
->reschedule_failed_exec
= 1;
2893 else if (file_exists(rebase_path_no_reschedule_failed_exec()))
2894 opts
->reschedule_failed_exec
= 0;
2896 if (file_exists(rebase_path_drop_redundant_commits()))
2897 opts
->drop_redundant_commits
= 1;
2899 if (file_exists(rebase_path_keep_redundant_commits()))
2900 opts
->keep_redundant_commits
= 1;
2902 read_strategy_opts(opts
, &buf
);
2905 if (read_oneliner(&opts
->current_fixups
,
2906 rebase_path_current_fixups(),
2907 READ_ONELINER_SKIP_IF_EMPTY
)) {
2908 const char *p
= opts
->current_fixups
.buf
;
2909 opts
->current_fixup_count
= 1;
2910 while ((p
= strchr(p
, '\n'))) {
2911 opts
->current_fixup_count
++;
2916 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
2917 if (get_oid_committish(buf
.buf
, &opts
->squash_onto
) < 0) {
2918 ret
= error(_("unusable squash-onto"));
2921 opts
->have_squash_onto
= 1;
2925 strbuf_release(&buf
);
2929 if (!file_exists(git_path_opts_file()))
2932 * The function git_parse_source(), called from git_config_from_file(),
2933 * may die() in case of a syntactically incorrect file. We do not care
2934 * about this case, though, because we wrote that file ourselves, so we
2935 * are pretty certain that it is syntactically correct.
2937 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
2938 return error(_("malformed options sheet: '%s'"),
2939 git_path_opts_file());
2943 static void write_strategy_opts(struct replay_opts
*opts
)
2946 struct strbuf buf
= STRBUF_INIT
;
2948 for (i
= 0; i
< opts
->xopts_nr
; ++i
)
2949 strbuf_addf(&buf
, " --%s", opts
->xopts
[i
]);
2951 write_file(rebase_path_strategy_opts(), "%s\n", buf
.buf
);
2952 strbuf_release(&buf
);
2955 int write_basic_state(struct replay_opts
*opts
, const char *head_name
,
2956 struct commit
*onto
, const struct object_id
*orig_head
)
2959 write_file(rebase_path_head_name(), "%s\n", head_name
);
2961 write_file(rebase_path_onto(), "%s\n",
2962 oid_to_hex(&onto
->object
.oid
));
2964 write_file(rebase_path_orig_head(), "%s\n",
2965 oid_to_hex(orig_head
));
2968 write_file(rebase_path_quiet(), "%s", "");
2970 write_file(rebase_path_verbose(), "%s", "");
2972 write_file(rebase_path_strategy(), "%s\n", opts
->strategy
);
2973 if (opts
->xopts_nr
> 0)
2974 write_strategy_opts(opts
);
2976 if (opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
)
2977 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2978 else if (opts
->allow_rerere_auto
== RERERE_NOAUTOUPDATE
)
2979 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2982 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts
->gpg_sign
);
2984 write_file(rebase_path_signoff(), "--signoff\n");
2985 if (opts
->drop_redundant_commits
)
2986 write_file(rebase_path_drop_redundant_commits(), "%s", "");
2987 if (opts
->keep_redundant_commits
)
2988 write_file(rebase_path_keep_redundant_commits(), "%s", "");
2989 if (opts
->committer_date_is_author_date
)
2990 write_file(rebase_path_cdate_is_adate(), "%s", "");
2991 if (opts
->ignore_date
)
2992 write_file(rebase_path_ignore_date(), "%s", "");
2993 if (opts
->reschedule_failed_exec
)
2994 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
2996 write_file(rebase_path_no_reschedule_failed_exec(), "%s", "");
3001 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
3002 struct replay_opts
*opts
)
3004 enum todo_command command
= opts
->action
== REPLAY_PICK
?
3005 TODO_PICK
: TODO_REVERT
;
3006 const char *command_string
= todo_command_info
[command
].str
;
3007 const char *encoding
;
3008 struct commit
*commit
;
3010 if (prepare_revs(opts
))
3013 encoding
= get_log_output_encoding();
3015 while ((commit
= get_revision(opts
->revs
))) {
3016 struct todo_item
*item
= append_new_todo(todo_list
);
3017 const char *commit_buffer
= logmsg_reencode(commit
, NULL
, encoding
);
3018 const char *subject
;
3021 item
->command
= command
;
3022 item
->commit
= commit
;
3023 item
->arg_offset
= 0;
3025 item
->offset_in_buf
= todo_list
->buf
.len
;
3026 subject_len
= find_commit_subject(commit_buffer
, &subject
);
3027 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
3028 short_commit_name(commit
), subject_len
, subject
);
3029 unuse_commit_buffer(commit
, commit_buffer
);
3033 return error(_("empty commit set passed"));
3038 static int create_seq_dir(struct repository
*r
)
3040 enum replay_action action
;
3041 const char *in_progress_error
= NULL
;
3042 const char *in_progress_advice
= NULL
;
3043 unsigned int advise_skip
=
3044 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD") ||
3045 refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD");
3047 if (!sequencer_get_last_command(r
, &action
)) {
3050 in_progress_error
= _("revert is already in progress");
3051 in_progress_advice
=
3052 _("try \"git revert (--continue | %s--abort | --quit)\"");
3055 in_progress_error
= _("cherry-pick is already in progress");
3056 in_progress_advice
=
3057 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
3060 BUG("unexpected action in create_seq_dir");
3063 if (in_progress_error
) {
3064 error("%s", in_progress_error
);
3065 if (advice_enabled(ADVICE_SEQUENCER_IN_USE
))
3066 advise(in_progress_advice
,
3067 advise_skip
? "--skip | " : "");
3070 if (mkdir(git_path_seq_dir(), 0777) < 0)
3071 return error_errno(_("could not create sequencer directory '%s'"),
3072 git_path_seq_dir());
3077 static int save_head(const char *head
)
3079 struct lock_file head_lock
= LOCK_INIT
;
3080 struct strbuf buf
= STRBUF_INIT
;
3084 fd
= hold_lock_file_for_update(&head_lock
, git_path_head_file(), 0);
3086 return error_errno(_("could not lock HEAD"));
3087 strbuf_addf(&buf
, "%s\n", head
);
3088 written
= write_in_full(fd
, buf
.buf
, buf
.len
);
3089 strbuf_release(&buf
);
3091 error_errno(_("could not write to '%s'"), git_path_head_file());
3092 rollback_lock_file(&head_lock
);
3095 if (commit_lock_file(&head_lock
) < 0)
3096 return error(_("failed to finalize '%s'"), git_path_head_file());
3100 static int rollback_is_safe(void)
3102 struct strbuf sb
= STRBUF_INIT
;
3103 struct object_id expected_head
, actual_head
;
3105 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
3107 if (get_oid_hex(sb
.buf
, &expected_head
)) {
3108 strbuf_release(&sb
);
3109 die(_("could not parse %s"), git_path_abort_safety_file());
3111 strbuf_release(&sb
);
3113 else if (errno
== ENOENT
)
3114 oidclr(&expected_head
);
3116 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
3118 if (get_oid("HEAD", &actual_head
))
3119 oidclr(&actual_head
);
3121 return oideq(&actual_head
, &expected_head
);
3124 static int reset_merge(const struct object_id
*oid
)
3127 struct strvec argv
= STRVEC_INIT
;
3129 strvec_pushl(&argv
, "reset", "--merge", NULL
);
3131 if (!is_null_oid(oid
))
3132 strvec_push(&argv
, oid_to_hex(oid
));
3134 ret
= run_command_v_opt(argv
.v
, RUN_GIT_CMD
);
3135 strvec_clear(&argv
);
3140 static int rollback_single_pick(struct repository
*r
)
3142 struct object_id head_oid
;
3144 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
3145 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
3146 return error(_("no cherry-pick or revert in progress"));
3147 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
3148 return error(_("cannot resolve HEAD"));
3149 if (is_null_oid(&head_oid
))
3150 return error(_("cannot abort from a branch yet to be born"));
3151 return reset_merge(&head_oid
);
3154 static int skip_single_pick(void)
3156 struct object_id head
;
3158 if (read_ref_full("HEAD", 0, &head
, NULL
))
3159 return error(_("cannot resolve HEAD"));
3160 return reset_merge(&head
);
3163 int sequencer_rollback(struct repository
*r
, struct replay_opts
*opts
)
3166 struct object_id oid
;
3167 struct strbuf buf
= STRBUF_INIT
;
3170 f
= fopen(git_path_head_file(), "r");
3171 if (!f
&& errno
== ENOENT
) {
3173 * There is no multiple-cherry-pick in progress.
3174 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
3175 * a single-cherry-pick in progress, abort that.
3177 return rollback_single_pick(r
);
3180 return error_errno(_("cannot open '%s'"), git_path_head_file());
3181 if (strbuf_getline_lf(&buf
, f
)) {
3182 error(_("cannot read '%s': %s"), git_path_head_file(),
3183 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
3188 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
3189 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
3190 git_path_head_file());
3193 if (is_null_oid(&oid
)) {
3194 error(_("cannot abort from a branch yet to be born"));
3198 if (!rollback_is_safe()) {
3199 /* Do not error, just do not rollback */
3200 warning(_("You seem to have moved HEAD. "
3201 "Not rewinding, check your HEAD!"));
3203 if (reset_merge(&oid
))
3205 strbuf_release(&buf
);
3206 return sequencer_remove_state(opts
);
3208 strbuf_release(&buf
);
3212 int sequencer_skip(struct repository
*r
, struct replay_opts
*opts
)
3214 enum replay_action action
= -1;
3215 sequencer_get_last_command(r
, &action
);
3218 * Check whether the subcommand requested to skip the commit is actually
3219 * in progress and that it's safe to skip the commit.
3221 * opts->action tells us which subcommand requested to skip the commit.
3222 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
3223 * action is in progress and we can skip the commit.
3225 * Otherwise we check that the last instruction was related to the
3226 * particular subcommand we're trying to execute and barf if that's not
3229 * Finally we check that the rollback is "safe", i.e., has the HEAD
3230 * moved? In this case, it doesn't make sense to "reset the merge" and
3231 * "skip the commit" as the user already handled this by committing. But
3232 * we'd not want to barf here, instead give advice on how to proceed. We
3233 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
3234 * it gets removed when the user commits, so if it still exists we're
3235 * sure the user can't have committed before.
3237 switch (opts
->action
) {
3239 if (!refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
3240 if (action
!= REPLAY_REVERT
)
3241 return error(_("no revert in progress"));
3242 if (!rollback_is_safe())
3247 if (!refs_ref_exists(get_main_ref_store(r
),
3248 "CHERRY_PICK_HEAD")) {
3249 if (action
!= REPLAY_PICK
)
3250 return error(_("no cherry-pick in progress"));
3251 if (!rollback_is_safe())
3256 BUG("unexpected action in sequencer_skip");
3259 if (skip_single_pick())
3260 return error(_("failed to skip the commit"));
3261 if (!is_directory(git_path_seq_dir()))
3264 return sequencer_continue(r
, opts
);
3267 error(_("there is nothing to skip"));
3269 if (advice_enabled(ADVICE_RESOLVE_CONFLICT
)) {
3270 advise(_("have you committed already?\n"
3271 "try \"git %s --continue\""),
3272 action
== REPLAY_REVERT
? "revert" : "cherry-pick");
3277 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
3279 struct lock_file todo_lock
= LOCK_INIT
;
3280 const char *todo_path
= get_todo_path(opts
);
3281 int next
= todo_list
->current
, offset
, fd
;
3284 * rebase -i writes "git-rebase-todo" without the currently executing
3285 * command, appending it to "done" instead.
3287 if (is_rebase_i(opts
))
3290 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
3292 return error_errno(_("could not lock '%s'"), todo_path
);
3293 offset
= get_item_line_offset(todo_list
, next
);
3294 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
3295 todo_list
->buf
.len
- offset
) < 0)
3296 return error_errno(_("could not write to '%s'"), todo_path
);
3297 if (commit_lock_file(&todo_lock
) < 0)
3298 return error(_("failed to finalize '%s'"), todo_path
);
3300 if (is_rebase_i(opts
) && next
> 0) {
3301 const char *done
= rebase_path_done();
3302 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
3307 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
3308 get_item_line_length(todo_list
, next
- 1))
3310 ret
= error_errno(_("could not write to '%s'"), done
);
3312 ret
= error_errno(_("failed to finalize '%s'"), done
);
3318 static int save_opts(struct replay_opts
*opts
)
3320 const char *opts_file
= git_path_opts_file();
3323 if (opts
->no_commit
)
3324 res
|= git_config_set_in_file_gently(opts_file
,
3325 "options.no-commit", "true");
3326 if (opts
->edit
>= 0)
3327 res
|= git_config_set_in_file_gently(opts_file
, "options.edit",
3328 opts
->edit
? "true" : "false");
3329 if (opts
->allow_empty
)
3330 res
|= git_config_set_in_file_gently(opts_file
,
3331 "options.allow-empty", "true");
3332 if (opts
->allow_empty_message
)
3333 res
|= git_config_set_in_file_gently(opts_file
,
3334 "options.allow-empty-message", "true");
3335 if (opts
->keep_redundant_commits
)
3336 res
|= git_config_set_in_file_gently(opts_file
,
3337 "options.keep-redundant-commits", "true");
3339 res
|= git_config_set_in_file_gently(opts_file
,
3340 "options.signoff", "true");
3341 if (opts
->record_origin
)
3342 res
|= git_config_set_in_file_gently(opts_file
,
3343 "options.record-origin", "true");
3345 res
|= git_config_set_in_file_gently(opts_file
,
3346 "options.allow-ff", "true");
3347 if (opts
->mainline
) {
3348 struct strbuf buf
= STRBUF_INIT
;
3349 strbuf_addf(&buf
, "%d", opts
->mainline
);
3350 res
|= git_config_set_in_file_gently(opts_file
,
3351 "options.mainline", buf
.buf
);
3352 strbuf_release(&buf
);
3355 res
|= git_config_set_in_file_gently(opts_file
,
3356 "options.strategy", opts
->strategy
);
3358 res
|= git_config_set_in_file_gently(opts_file
,
3359 "options.gpg-sign", opts
->gpg_sign
);
3362 for (i
= 0; i
< opts
->xopts_nr
; i
++)
3363 res
|= git_config_set_multivar_in_file_gently(opts_file
,
3364 "options.strategy-option",
3365 opts
->xopts
[i
], "^$", 0);
3367 if (opts
->allow_rerere_auto
)
3368 res
|= git_config_set_in_file_gently(opts_file
,
3369 "options.allow-rerere-auto",
3370 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
3373 if (opts
->explicit_cleanup
)
3374 res
|= git_config_set_in_file_gently(opts_file
,
3375 "options.default-msg-cleanup",
3376 describe_cleanup_mode(opts
->default_msg_cleanup
));
3380 static int make_patch(struct repository
*r
,
3381 struct commit
*commit
,
3382 struct replay_opts
*opts
)
3384 struct strbuf buf
= STRBUF_INIT
;
3385 struct rev_info log_tree_opt
;
3386 const char *subject
;
3387 char hex
[GIT_MAX_HEXSZ
+ 1];
3390 oid_to_hex_r(hex
, &commit
->object
.oid
);
3391 if (write_message(hex
, strlen(hex
), rebase_path_stopped_sha(), 1) < 0)
3393 res
|= write_rebase_head(&commit
->object
.oid
);
3395 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
3396 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3397 repo_init_revisions(r
, &log_tree_opt
, NULL
);
3398 log_tree_opt
.abbrev
= 0;
3399 log_tree_opt
.diff
= 1;
3400 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
3401 log_tree_opt
.disable_stdin
= 1;
3402 log_tree_opt
.no_commit_id
= 1;
3403 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
3404 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
3405 if (!log_tree_opt
.diffopt
.file
)
3406 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
3408 res
|= log_tree_commit(&log_tree_opt
, commit
);
3409 fclose(log_tree_opt
.diffopt
.file
);
3413 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
3414 if (!file_exists(buf
.buf
)) {
3415 const char *encoding
= get_commit_output_encoding();
3416 const char *commit_buffer
= logmsg_reencode(commit
, NULL
, encoding
);
3417 find_commit_subject(commit_buffer
, &subject
);
3418 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
3419 unuse_commit_buffer(commit
, commit_buffer
);
3421 strbuf_release(&buf
);
3426 static int intend_to_amend(void)
3428 struct object_id head
;
3431 if (get_oid("HEAD", &head
))
3432 return error(_("cannot read HEAD"));
3434 p
= oid_to_hex(&head
);
3435 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
3438 static int error_with_patch(struct repository
*r
,
3439 struct commit
*commit
,
3440 const char *subject
, int subject_len
,
3441 struct replay_opts
*opts
,
3442 int exit_code
, int to_amend
)
3445 if (make_patch(r
, commit
, opts
))
3447 } else if (copy_file(rebase_path_message(),
3448 git_path_merge_msg(r
), 0666))
3449 return error(_("unable to copy '%s' to '%s'"),
3450 git_path_merge_msg(r
), rebase_path_message());
3453 if (intend_to_amend())
3457 _("You can amend the commit now, with\n"
3459 " git commit --amend %s\n"
3461 "Once you are satisfied with your changes, run\n"
3463 " git rebase --continue\n"),
3464 gpg_sign_opt_quoted(opts
));
3465 } else if (exit_code
) {
3467 fprintf_ln(stderr
, _("Could not apply %s... %.*s"),
3468 short_commit_name(commit
), subject_len
, subject
);
3471 * We don't have the hash of the parent so
3472 * just print the line from the todo file.
3474 fprintf_ln(stderr
, _("Could not merge %.*s"),
3475 subject_len
, subject
);
3481 static int error_failed_squash(struct repository
*r
,
3482 struct commit
*commit
,
3483 struct replay_opts
*opts
,
3485 const char *subject
)
3487 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3488 return error(_("could not copy '%s' to '%s'"),
3489 rebase_path_squash_msg(), rebase_path_message());
3490 unlink(git_path_merge_msg(r
));
3491 if (copy_file(git_path_merge_msg(r
), rebase_path_message(), 0666))
3492 return error(_("could not copy '%s' to '%s'"),
3493 rebase_path_message(),
3494 git_path_merge_msg(r
));
3495 return error_with_patch(r
, commit
, subject
, subject_len
, opts
, 1, 0);
3498 static int do_exec(struct repository
*r
, const char *command_line
)
3500 struct strvec child_env
= STRVEC_INIT
;
3501 const char *child_argv
[] = { NULL
, NULL
};
3504 fprintf(stderr
, _("Executing: %s\n"), command_line
);
3505 child_argv
[0] = command_line
;
3506 strvec_pushf(&child_env
, "GIT_DIR=%s", absolute_path(get_git_dir()));
3507 strvec_pushf(&child_env
, "GIT_WORK_TREE=%s",
3508 absolute_path(get_git_work_tree()));
3509 status
= run_command_v_opt_cd_env(child_argv
, RUN_USING_SHELL
, NULL
,
3512 /* force re-reading of the cache */
3513 if (discard_index(r
->index
) < 0 || repo_read_index(r
) < 0)
3514 return error(_("could not read index"));
3516 dirty
= require_clean_work_tree(r
, "rebase", NULL
, 1, 1);
3519 warning(_("execution failed: %s\n%s"
3520 "You can fix the problem, and then run\n"
3522 " git rebase --continue\n"
3525 dirty
? N_("and made changes to the index and/or the "
3526 "working tree\n") : "");
3528 /* command not found */
3531 warning(_("execution succeeded: %s\nbut "
3532 "left changes to the index and/or the working tree\n"
3533 "Commit or stash your changes, and then run\n"
3535 " git rebase --continue\n"
3536 "\n"), command_line
);
3540 strvec_clear(&child_env
);
3545 __attribute__((format (printf
, 2, 3)))
3546 static int safe_append(const char *filename
, const char *fmt
, ...)
3549 struct lock_file lock
= LOCK_INIT
;
3550 int fd
= hold_lock_file_for_update(&lock
, filename
,
3551 LOCK_REPORT_ON_ERROR
);
3552 struct strbuf buf
= STRBUF_INIT
;
3557 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
3558 error_errno(_("could not read '%s'"), filename
);
3559 rollback_lock_file(&lock
);
3562 strbuf_complete(&buf
, '\n');
3564 strbuf_vaddf(&buf
, fmt
, ap
);
3567 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
3568 error_errno(_("could not write to '%s'"), filename
);
3569 strbuf_release(&buf
);
3570 rollback_lock_file(&lock
);
3573 if (commit_lock_file(&lock
) < 0) {
3574 strbuf_release(&buf
);
3575 rollback_lock_file(&lock
);
3576 return error(_("failed to finalize '%s'"), filename
);
3579 strbuf_release(&buf
);
3583 static int do_label(struct repository
*r
, const char *name
, int len
)
3585 struct ref_store
*refs
= get_main_ref_store(r
);
3586 struct ref_transaction
*transaction
;
3587 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
3588 struct strbuf msg
= STRBUF_INIT
;
3590 struct object_id head_oid
;
3592 if (len
== 1 && *name
== '#')
3593 return error(_("illegal label name: '%.*s'"), len
, name
);
3595 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3596 strbuf_addf(&msg
, "rebase (label) '%.*s'", len
, name
);
3598 transaction
= ref_store_transaction_begin(refs
, &err
);
3600 error("%s", err
.buf
);
3602 } else if (get_oid("HEAD", &head_oid
)) {
3603 error(_("could not read HEAD"));
3605 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
3606 NULL
, 0, msg
.buf
, &err
) < 0 ||
3607 ref_transaction_commit(transaction
, &err
)) {
3608 error("%s", err
.buf
);
3611 ref_transaction_free(transaction
);
3612 strbuf_release(&err
);
3613 strbuf_release(&msg
);
3616 ret
= safe_append(rebase_path_refs_to_delete(),
3617 "%s\n", ref_name
.buf
);
3618 strbuf_release(&ref_name
);
3623 __attribute__((format (printf
, 3, 4)))
3624 static const char *reflog_message(struct replay_opts
*opts
,
3625 const char *sub_action
, const char *fmt
, ...)
3628 static struct strbuf buf
= STRBUF_INIT
;
3629 char *reflog_action
= getenv(GIT_REFLOG_ACTION
);
3633 strbuf_addstr(&buf
, reflog_action
? reflog_action
: action_name(opts
));
3635 strbuf_addf(&buf
, " (%s)", sub_action
);
3637 strbuf_addstr(&buf
, ": ");
3638 strbuf_vaddf(&buf
, fmt
, ap
);
3645 static int do_reset(struct repository
*r
,
3646 const char *name
, int len
,
3647 struct replay_opts
*opts
)
3649 struct strbuf ref_name
= STRBUF_INIT
;
3650 struct object_id oid
;
3651 struct lock_file lock
= LOCK_INIT
;
3652 struct tree_desc desc
= { 0 };
3654 struct unpack_trees_options unpack_tree_opts
= { 0 };
3657 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0)
3660 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
3661 if (!opts
->have_squash_onto
) {
3663 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
3664 NULL
, &opts
->squash_onto
,
3666 return error(_("writing fake root commit"));
3667 opts
->have_squash_onto
= 1;
3668 hex
= oid_to_hex(&opts
->squash_onto
);
3669 if (write_message(hex
, strlen(hex
),
3670 rebase_path_squash_onto(), 0))
3671 return error(_("writing squash-onto"));
3673 oidcpy(&oid
, &opts
->squash_onto
);
3677 /* Determine the length of the label */
3678 for (i
= 0; i
< len
; i
++)
3679 if (isspace(name
[i
]))
3683 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3684 if (get_oid(ref_name
.buf
, &oid
) &&
3685 get_oid(ref_name
.buf
+ strlen("refs/rewritten/"), &oid
)) {
3686 ret
= error(_("could not read '%s'"), ref_name
.buf
);
3691 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
3692 unpack_tree_opts
.head_idx
= 1;
3693 unpack_tree_opts
.src_index
= r
->index
;
3694 unpack_tree_opts
.dst_index
= r
->index
;
3695 unpack_tree_opts
.fn
= oneway_merge
;
3696 unpack_tree_opts
.merge
= 1;
3697 unpack_tree_opts
.update
= 1;
3698 unpack_tree_opts
.preserve_ignored
= 0; /* FIXME: !overwrite_ignore */
3699 init_checkout_metadata(&unpack_tree_opts
.meta
, name
, &oid
, NULL
);
3701 if (repo_read_index_unmerged(r
)) {
3702 ret
= error_resolve_conflict(_(action_name(opts
)));
3706 if (!fill_tree_descriptor(r
, &desc
, &oid
)) {
3707 ret
= error(_("failed to find tree of %s"), oid_to_hex(&oid
));
3711 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
3716 tree
= parse_tree_indirect(&oid
);
3717 prime_cache_tree(r
, r
->index
, tree
);
3719 if (write_locked_index(r
->index
, &lock
, COMMIT_LOCK
) < 0)
3720 ret
= error(_("could not write index"));
3723 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
3724 len
, name
), "HEAD", &oid
,
3725 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3727 free((void *)desc
.buffer
);
3729 rollback_lock_file(&lock
);
3730 strbuf_release(&ref_name
);
3731 clear_unpack_trees_porcelain(&unpack_tree_opts
);
3735 static struct commit
*lookup_label(const char *label
, int len
,
3738 struct commit
*commit
;
3741 strbuf_addf(buf
, "refs/rewritten/%.*s", len
, label
);
3742 commit
= lookup_commit_reference_by_name(buf
->buf
);
3744 /* fall back to non-rewritten ref or commit */
3745 strbuf_splice(buf
, 0, strlen("refs/rewritten/"), "", 0);
3746 commit
= lookup_commit_reference_by_name(buf
->buf
);
3750 error(_("could not resolve '%s'"), buf
->buf
);
3755 static int do_merge(struct repository
*r
,
3756 struct commit
*commit
,
3757 const char *arg
, int arg_len
,
3758 int flags
, int *check_todo
, struct replay_opts
*opts
)
3760 int run_commit_flags
= 0;
3761 struct strbuf ref_name
= STRBUF_INIT
;
3762 struct commit
*head_commit
, *merge_commit
, *i
;
3763 struct commit_list
*bases
, *j
, *reversed
= NULL
;
3764 struct commit_list
*to_merge
= NULL
, **tail
= &to_merge
;
3765 const char *strategy
= !opts
->xopts_nr
&&
3767 !strcmp(opts
->strategy
, "recursive") ||
3768 !strcmp(opts
->strategy
, "ort")) ?
3769 NULL
: opts
->strategy
;
3770 struct merge_options o
;
3771 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
, k
;
3772 static struct lock_file lock
;
3775 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0) {
3780 head_commit
= lookup_commit_reference_by_name("HEAD");
3782 ret
= error(_("cannot merge without a current revision"));
3787 * For octopus merges, the arg starts with the list of revisions to be
3788 * merged. The list is optionally followed by '#' and the oneline.
3790 merge_arg_len
= oneline_offset
= arg_len
;
3791 for (p
= arg
; p
- arg
< arg_len
; p
+= strspn(p
, " \t\n")) {
3794 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
3795 p
+= 1 + strspn(p
+ 1, " \t\n");
3796 oneline_offset
= p
- arg
;
3799 k
= strcspn(p
, " \t\n");
3802 merge_commit
= lookup_label(p
, k
, &ref_name
);
3803 if (!merge_commit
) {
3804 ret
= error(_("unable to parse '%.*s'"), k
, p
);
3807 tail
= &commit_list_insert(merge_commit
, tail
)->next
;
3809 merge_arg_len
= p
- arg
;
3813 ret
= error(_("nothing to merge: '%.*s'"), arg_len
, arg
);
3817 if (opts
->have_squash_onto
&&
3818 oideq(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
3820 * When the user tells us to "merge" something into a
3821 * "[new root]", let's simply fast-forward to the merge head.
3823 rollback_lock_file(&lock
);
3825 ret
= error(_("octopus merge cannot be executed on "
3826 "top of a [new root]"));
3828 ret
= fast_forward_to(r
, &to_merge
->item
->object
.oid
,
3829 &head_commit
->object
.oid
, 0,
3835 * If HEAD is not identical to the first parent of the original merge
3836 * commit, we cannot fast-forward.
3838 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
3839 oideq(&commit
->parents
->item
->object
.oid
,
3840 &head_commit
->object
.oid
);
3843 * If any merge head is different from the original one, we cannot
3846 if (can_fast_forward
) {
3847 struct commit_list
*p
= commit
->parents
->next
;
3849 for (j
= to_merge
; j
&& p
; j
= j
->next
, p
= p
->next
)
3850 if (!oideq(&j
->item
->object
.oid
,
3851 &p
->item
->object
.oid
)) {
3852 can_fast_forward
= 0;
3856 * If the number of merge heads differs from the original merge
3857 * commit, we cannot fast-forward.
3860 can_fast_forward
= 0;
3863 if (can_fast_forward
) {
3864 rollback_lock_file(&lock
);
3865 ret
= fast_forward_to(r
, &commit
->object
.oid
,
3866 &head_commit
->object
.oid
, 0, opts
);
3867 if (flags
& TODO_EDIT_MERGE_MSG
)
3868 goto fast_forward_edit
;
3874 const char *encoding
= get_commit_output_encoding();
3875 const char *message
= logmsg_reencode(commit
, NULL
, encoding
);
3880 ret
= error(_("could not get commit message of '%s'"),
3881 oid_to_hex(&commit
->object
.oid
));
3884 write_author_script(message
);
3885 find_commit_subject(message
, &body
);
3887 ret
= write_message(body
, len
, git_path_merge_msg(r
), 0);
3888 unuse_commit_buffer(commit
, message
);
3890 error_errno(_("could not write '%s'"),
3891 git_path_merge_msg(r
));
3895 struct strbuf buf
= STRBUF_INIT
;
3898 strbuf_addf(&buf
, "author %s", git_author_info(0));
3899 write_author_script(buf
.buf
);
3902 if (oneline_offset
< arg_len
) {
3903 p
= arg
+ oneline_offset
;
3904 len
= arg_len
- oneline_offset
;
3906 strbuf_addf(&buf
, "Merge %s '%.*s'",
3907 to_merge
->next
? "branches" : "branch",
3908 merge_arg_len
, arg
);
3913 ret
= write_message(p
, len
, git_path_merge_msg(r
), 0);
3914 strbuf_release(&buf
);
3916 error_errno(_("could not write '%s'"),
3917 git_path_merge_msg(r
));
3922 if (strategy
|| to_merge
->next
) {
3924 struct child_process cmd
= CHILD_PROCESS_INIT
;
3926 if (read_env_script(&cmd
.env_array
)) {
3927 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
3929 ret
= error(_(staged_changes_advice
), gpg_opt
, gpg_opt
);
3933 if (opts
->committer_date_is_author_date
)
3934 strvec_pushf(&cmd
.env_array
, "GIT_COMMITTER_DATE=%s",
3937 author_date_from_env_array(&cmd
.env_array
));
3938 if (opts
->ignore_date
)
3939 strvec_push(&cmd
.env_array
, "GIT_AUTHOR_DATE=");
3942 strvec_push(&cmd
.args
, "merge");
3943 strvec_push(&cmd
.args
, "-s");
3945 strvec_push(&cmd
.args
, "octopus");
3947 strvec_push(&cmd
.args
, strategy
);
3948 for (k
= 0; k
< opts
->xopts_nr
; k
++)
3949 strvec_pushf(&cmd
.args
,
3950 "-X%s", opts
->xopts
[k
]);
3952 if (!(flags
& TODO_EDIT_MERGE_MSG
))
3953 strvec_push(&cmd
.args
, "--no-edit");
3955 strvec_push(&cmd
.args
, "--edit");
3956 strvec_push(&cmd
.args
, "--no-ff");
3957 strvec_push(&cmd
.args
, "--no-log");
3958 strvec_push(&cmd
.args
, "--no-stat");
3959 strvec_push(&cmd
.args
, "-F");
3960 strvec_push(&cmd
.args
, git_path_merge_msg(r
));
3962 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
3964 strvec_push(&cmd
.args
, "--no-gpg-sign");
3966 /* Add the tips to be merged */
3967 for (j
= to_merge
; j
; j
= j
->next
)
3968 strvec_push(&cmd
.args
,
3969 oid_to_hex(&j
->item
->object
.oid
));
3971 strbuf_release(&ref_name
);
3972 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
3974 rollback_lock_file(&lock
);
3976 ret
= run_command(&cmd
);
3978 /* force re-reading of the cache */
3979 if (!ret
&& (discard_index(r
->index
) < 0 ||
3980 repo_read_index(r
) < 0))
3981 ret
= error(_("could not read index"));
3985 merge_commit
= to_merge
->item
;
3986 bases
= get_merge_bases(head_commit
, merge_commit
);
3987 if (bases
&& oideq(&merge_commit
->object
.oid
,
3988 &bases
->item
->object
.oid
)) {
3990 /* skip merging an ancestor of HEAD */
3994 write_message(oid_to_hex(&merge_commit
->object
.oid
), the_hash_algo
->hexsz
,
3995 git_path_merge_head(r
), 0);
3996 write_message("no-ff", 5, git_path_merge_mode(r
), 0);
3998 for (j
= bases
; j
; j
= j
->next
)
3999 commit_list_insert(j
->item
, &reversed
);
4000 free_commit_list(bases
);
4003 init_merge_options(&o
, r
);
4005 o
.branch2
= ref_name
.buf
;
4006 o
.buffer_output
= 2;
4008 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
4010 * TODO: Should use merge_incore_recursive() and
4011 * merge_switch_to_result(), skipping the call to
4012 * merge_switch_to_result() when we don't actually need to
4013 * update the index and working copy immediately.
4015 ret
= merge_ort_recursive(&o
,
4016 head_commit
, merge_commit
, reversed
,
4019 ret
= merge_recursive(&o
, head_commit
, merge_commit
, reversed
,
4023 fputs(o
.obuf
.buf
, stdout
);
4024 strbuf_release(&o
.obuf
);
4026 error(_("could not even attempt to merge '%.*s'"),
4027 merge_arg_len
, arg
);
4031 * The return value of merge_recursive() is 1 on clean, and 0 on
4034 * Let's reverse that, so that do_merge() returns 0 upon success and
4035 * 1 upon failed merge (keeping the return value -1 for the cases where
4036 * we will want to reschedule the `merge` command).
4040 if (r
->index
->cache_changed
&&
4041 write_locked_index(r
->index
, &lock
, COMMIT_LOCK
)) {
4042 ret
= error(_("merge: Unable to write new index file"));
4046 rollback_lock_file(&lock
);
4048 repo_rerere(r
, opts
->allow_rerere_auto
);
4051 * In case of problems, we now want to return a positive
4052 * value (a negative one would indicate that the `merge`
4053 * command needs to be rescheduled).
4055 ret
= !!run_git_commit(git_path_merge_msg(r
), opts
,
4058 if (!ret
&& flags
& TODO_EDIT_MERGE_MSG
) {
4061 run_commit_flags
|= AMEND_MSG
| EDIT_MSG
| VERIFY_MSG
;
4062 ret
= !!run_git_commit(NULL
, opts
, run_commit_flags
);
4067 strbuf_release(&ref_name
);
4068 rollback_lock_file(&lock
);
4069 free_commit_list(to_merge
);
4073 static int is_final_fixup(struct todo_list
*todo_list
)
4075 int i
= todo_list
->current
;
4077 if (!is_fixup(todo_list
->items
[i
].command
))
4080 while (++i
< todo_list
->nr
)
4081 if (is_fixup(todo_list
->items
[i
].command
))
4083 else if (!is_noop(todo_list
->items
[i
].command
))
4088 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
4092 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
4093 if (!is_noop(todo_list
->items
[i
].command
))
4094 return todo_list
->items
[i
].command
;
4099 void create_autostash(struct repository
*r
, const char *path
,
4100 const char *default_reflog_action
)
4102 struct strbuf buf
= STRBUF_INIT
;
4103 struct lock_file lock_file
= LOCK_INIT
;
4106 fd
= repo_hold_locked_index(r
, &lock_file
, 0);
4107 refresh_index(r
->index
, REFRESH_QUIET
, NULL
, NULL
, NULL
);
4109 repo_update_index_if_able(r
, &lock_file
);
4110 rollback_lock_file(&lock_file
);
4112 if (has_unstaged_changes(r
, 1) ||
4113 has_uncommitted_changes(r
, 1)) {
4114 struct child_process stash
= CHILD_PROCESS_INIT
;
4115 struct object_id oid
;
4117 strvec_pushl(&stash
.args
,
4118 "stash", "create", "autostash", NULL
);
4122 if (capture_command(&stash
, &buf
, GIT_MAX_HEXSZ
))
4123 die(_("Cannot autostash"));
4124 strbuf_trim_trailing_newline(&buf
);
4125 if (get_oid(buf
.buf
, &oid
))
4126 die(_("Unexpected stash response: '%s'"),
4129 strbuf_add_unique_abbrev(&buf
, &oid
, DEFAULT_ABBREV
);
4131 if (safe_create_leading_directories_const(path
))
4132 die(_("Could not create directory for '%s'"),
4134 write_file(path
, "%s", oid_to_hex(&oid
));
4135 printf(_("Created autostash: %s\n"), buf
.buf
);
4136 if (reset_head(r
, NULL
, "reset --hard",
4137 NULL
, RESET_HEAD_HARD
, NULL
, NULL
,
4138 default_reflog_action
) < 0)
4139 die(_("could not reset --hard"));
4141 if (discard_index(r
->index
) < 0 ||
4142 repo_read_index(r
) < 0)
4143 die(_("could not read index"));
4145 strbuf_release(&buf
);
4148 static int apply_save_autostash_oid(const char *stash_oid
, int attempt_apply
)
4150 struct child_process child
= CHILD_PROCESS_INIT
;
4153 if (attempt_apply
) {
4155 child
.no_stdout
= 1;
4156 child
.no_stderr
= 1;
4157 strvec_push(&child
.args
, "stash");
4158 strvec_push(&child
.args
, "apply");
4159 strvec_push(&child
.args
, stash_oid
);
4160 ret
= run_command(&child
);
4163 if (attempt_apply
&& !ret
)
4164 fprintf(stderr
, _("Applied autostash.\n"));
4166 struct child_process store
= CHILD_PROCESS_INIT
;
4169 strvec_push(&store
.args
, "stash");
4170 strvec_push(&store
.args
, "store");
4171 strvec_push(&store
.args
, "-m");
4172 strvec_push(&store
.args
, "autostash");
4173 strvec_push(&store
.args
, "-q");
4174 strvec_push(&store
.args
, stash_oid
);
4175 if (run_command(&store
))
4176 ret
= error(_("cannot store %s"), stash_oid
);
4180 "Your changes are safe in the stash.\n"
4181 "You can run \"git stash pop\" or"
4182 " \"git stash drop\" at any time.\n"),
4184 _("Applying autostash resulted in conflicts.") :
4185 _("Autostash exists; creating a new stash entry."));
4191 static int apply_save_autostash(const char *path
, int attempt_apply
)
4193 struct strbuf stash_oid
= STRBUF_INIT
;
4196 if (!read_oneliner(&stash_oid
, path
,
4197 READ_ONELINER_SKIP_IF_EMPTY
)) {
4198 strbuf_release(&stash_oid
);
4201 strbuf_trim(&stash_oid
);
4203 ret
= apply_save_autostash_oid(stash_oid
.buf
, attempt_apply
);
4206 strbuf_release(&stash_oid
);
4210 int save_autostash(const char *path
)
4212 return apply_save_autostash(path
, 0);
4215 int apply_autostash(const char *path
)
4217 return apply_save_autostash(path
, 1);
4220 int apply_autostash_oid(const char *stash_oid
)
4222 return apply_save_autostash_oid(stash_oid
, 1);
4225 static int run_git_checkout(struct repository
*r
, struct replay_opts
*opts
,
4226 const char *commit
, const char *action
)
4228 struct child_process cmd
= CHILD_PROCESS_INIT
;
4233 strvec_push(&cmd
.args
, "checkout");
4234 strvec_push(&cmd
.args
, commit
);
4235 strvec_pushf(&cmd
.env_array
, GIT_REFLOG_ACTION
"=%s", action
);
4238 ret
= run_command(&cmd
);
4240 ret
= run_command_silent_on_success(&cmd
);
4243 discard_index(r
->index
);
4248 static int checkout_onto(struct repository
*r
, struct replay_opts
*opts
,
4249 const char *onto_name
, const struct object_id
*onto
,
4250 const struct object_id
*orig_head
)
4252 const char *action
= reflog_message(opts
, "start", "checkout %s", onto_name
);
4254 if (run_git_checkout(r
, opts
, oid_to_hex(onto
), action
)) {
4255 apply_autostash(rebase_path_autostash());
4256 sequencer_remove_state(opts
);
4257 return error(_("could not detach HEAD"));
4260 return update_ref(NULL
, "ORIG_HEAD", orig_head
, NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
4263 static int stopped_at_head(struct repository
*r
)
4265 struct object_id head
;
4266 struct commit
*commit
;
4267 struct commit_message message
;
4269 if (get_oid("HEAD", &head
) ||
4270 !(commit
= lookup_commit(r
, &head
)) ||
4271 parse_commit(commit
) || get_message(commit
, &message
))
4272 fprintf(stderr
, _("Stopped at HEAD\n"));
4274 fprintf(stderr
, _("Stopped at %s\n"), message
.label
);
4275 free_message(commit
, &message
);
4281 static int reread_todo_if_changed(struct repository
*r
,
4282 struct todo_list
*todo_list
,
4283 struct replay_opts
*opts
)
4286 struct strbuf buf
= STRBUF_INIT
;
4288 if (strbuf_read_file_or_whine(&buf
, get_todo_path(opts
)) < 0)
4290 offset
= get_item_line_offset(todo_list
, todo_list
->current
+ 1);
4291 if (buf
.len
!= todo_list
->buf
.len
- offset
||
4292 memcmp(buf
.buf
, todo_list
->buf
.buf
+ offset
, buf
.len
)) {
4293 /* Reread the todo file if it has changed. */
4294 todo_list_release(todo_list
);
4295 if (read_populate_todo(r
, todo_list
, opts
))
4296 return -1; /* message was printed */
4297 /* `current` will be incremented on return */
4298 todo_list
->current
= -1;
4300 strbuf_release(&buf
);
4305 static const char rescheduled_advice
[] =
4306 N_("Could not execute the todo command\n"
4310 "It has been rescheduled; To edit the command before continuing, please\n"
4311 "edit the todo list first:\n"
4313 " git rebase --edit-todo\n"
4314 " git rebase --continue\n");
4316 static int pick_commits(struct repository
*r
,
4317 struct todo_list
*todo_list
,
4318 struct replay_opts
*opts
)
4320 int res
= 0, reschedule
= 0;
4321 char *prev_reflog_action
;
4323 /* Note that 0 for 3rd parameter of setenv means set only if not set */
4324 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
4325 prev_reflog_action
= xstrdup(getenv(GIT_REFLOG_ACTION
));
4327 assert(!(opts
->signoff
|| opts
->no_commit
||
4328 opts
->record_origin
|| should_edit(opts
) ||
4329 opts
->committer_date_is_author_date
||
4330 opts
->ignore_date
));
4331 if (read_and_refresh_cache(r
, opts
))
4334 while (todo_list
->current
< todo_list
->nr
) {
4335 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
4336 const char *arg
= todo_item_get_arg(todo_list
, item
);
4339 if (save_todo(todo_list
, opts
))
4341 if (is_rebase_i(opts
)) {
4342 if (item
->command
!= TODO_COMMENT
) {
4343 FILE *f
= fopen(rebase_path_msgnum(), "w");
4345 todo_list
->done_nr
++;
4348 fprintf(f
, "%d\n", todo_list
->done_nr
);
4352 fprintf(stderr
, _("Rebasing (%d/%d)%s"),
4354 todo_list
->total_nr
,
4355 opts
->verbose
? "\n" : "\r");
4357 unlink(rebase_path_message());
4358 unlink(rebase_path_author_script());
4359 unlink(rebase_path_stopped_sha());
4360 unlink(rebase_path_amend());
4361 unlink(git_path_merge_head(r
));
4362 unlink(git_path_auto_merge(r
));
4363 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
4365 if (item
->command
== TODO_BREAK
) {
4368 return stopped_at_head(r
);
4371 if (item
->command
<= TODO_SQUASH
) {
4372 if (is_rebase_i(opts
))
4373 setenv(GIT_REFLOG_ACTION
, reflog_message(opts
,
4374 command_to_string(item
->command
), NULL
),
4376 res
= do_pick_commit(r
, item
, opts
,
4377 is_final_fixup(todo_list
),
4379 if (is_rebase_i(opts
))
4380 setenv(GIT_REFLOG_ACTION
, prev_reflog_action
, 1);
4381 if (is_rebase_i(opts
) && res
< 0) {
4383 advise(_(rescheduled_advice
),
4384 get_item_line_length(todo_list
,
4385 todo_list
->current
),
4386 get_item_line(todo_list
,
4387 todo_list
->current
));
4388 todo_list
->current
--;
4389 if (save_todo(todo_list
, opts
))
4392 if (item
->command
== TODO_EDIT
) {
4393 struct commit
*commit
= item
->commit
;
4398 _("Stopped at %s... %.*s\n"),
4399 short_commit_name(commit
),
4400 item
->arg_len
, arg
);
4402 return error_with_patch(r
, commit
,
4403 arg
, item
->arg_len
, opts
, res
, !res
);
4405 if (is_rebase_i(opts
) && !res
)
4406 record_in_rewritten(&item
->commit
->object
.oid
,
4407 peek_command(todo_list
, 1));
4408 if (res
&& is_fixup(item
->command
)) {
4411 return error_failed_squash(r
, item
->commit
, opts
,
4412 item
->arg_len
, arg
);
4413 } else if (res
&& is_rebase_i(opts
) && item
->commit
) {
4415 struct object_id oid
;
4418 * If we are rewording and have either
4419 * fast-forwarded already, or are about to
4420 * create a new root commit, we want to amend,
4421 * otherwise we do not.
4423 if (item
->command
== TODO_REWORD
&&
4424 !get_oid("HEAD", &oid
) &&
4425 (oideq(&item
->commit
->object
.oid
, &oid
) ||
4426 (opts
->have_squash_onto
&&
4427 oideq(&opts
->squash_onto
, &oid
))))
4430 return res
| error_with_patch(r
, item
->commit
,
4431 arg
, item
->arg_len
, opts
,
4434 } else if (item
->command
== TODO_EXEC
) {
4435 char *end_of_arg
= (char *)(arg
+ item
->arg_len
);
4436 int saved
= *end_of_arg
;
4441 res
= do_exec(r
, arg
);
4442 *end_of_arg
= saved
;
4445 if (opts
->reschedule_failed_exec
)
4449 } else if (item
->command
== TODO_LABEL
) {
4450 if ((res
= do_label(r
, arg
, item
->arg_len
)))
4452 } else if (item
->command
== TODO_RESET
) {
4453 if ((res
= do_reset(r
, arg
, item
->arg_len
, opts
)))
4455 } else if (item
->command
== TODO_MERGE
) {
4456 if ((res
= do_merge(r
, item
->commit
, arg
, item
->arg_len
,
4457 item
->flags
, &check_todo
, opts
)) < 0)
4459 else if (item
->commit
)
4460 record_in_rewritten(&item
->commit
->object
.oid
,
4461 peek_command(todo_list
, 1));
4463 /* failed with merge conflicts */
4464 return error_with_patch(r
, item
->commit
,
4467 } else if (!is_noop(item
->command
))
4468 return error(_("unknown command %d"), item
->command
);
4471 advise(_(rescheduled_advice
),
4472 get_item_line_length(todo_list
,
4473 todo_list
->current
),
4474 get_item_line(todo_list
, todo_list
->current
));
4475 todo_list
->current
--;
4476 if (save_todo(todo_list
, opts
))
4479 return error_with_patch(r
,
4483 } else if (is_rebase_i(opts
) && check_todo
&& !res
&&
4484 reread_todo_if_changed(r
, todo_list
, opts
)) {
4488 todo_list
->current
++;
4493 if (is_rebase_i(opts
)) {
4494 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
4497 /* Stopped in the middle, as planned? */
4498 if (todo_list
->current
< todo_list
->nr
)
4501 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
4502 starts_with(head_ref
.buf
, "refs/")) {
4504 struct object_id head
, orig
;
4507 if (get_oid("HEAD", &head
)) {
4508 res
= error(_("cannot read HEAD"));
4510 strbuf_release(&head_ref
);
4511 strbuf_release(&buf
);
4514 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
4515 get_oid_hex(buf
.buf
, &orig
)) {
4516 res
= error(_("could not read orig-head"));
4517 goto cleanup_head_ref
;
4520 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
4521 res
= error(_("could not read 'onto'"));
4522 goto cleanup_head_ref
;
4524 msg
= reflog_message(opts
, "finish", "%s onto %s",
4525 head_ref
.buf
, buf
.buf
);
4526 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
4527 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
4528 res
= error(_("could not update %s"),
4530 goto cleanup_head_ref
;
4532 msg
= reflog_message(opts
, "finish", "returning to %s",
4534 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
4535 res
= error(_("could not update HEAD to %s"),
4537 goto cleanup_head_ref
;
4542 if (opts
->verbose
) {
4543 struct rev_info log_tree_opt
;
4544 struct object_id orig
, head
;
4546 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
4547 repo_init_revisions(r
, &log_tree_opt
, NULL
);
4548 log_tree_opt
.diff
= 1;
4549 log_tree_opt
.diffopt
.output_format
=
4550 DIFF_FORMAT_DIFFSTAT
;
4551 log_tree_opt
.disable_stdin
= 1;
4553 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
4554 !get_oid(buf
.buf
, &orig
) &&
4555 !get_oid("HEAD", &head
)) {
4556 diff_tree_oid(&orig
, &head
, "",
4557 &log_tree_opt
.diffopt
);
4558 log_tree_diff_flush(&log_tree_opt
);
4561 flush_rewritten_pending();
4562 if (!stat(rebase_path_rewritten_list(), &st
) &&
4564 struct child_process child
= CHILD_PROCESS_INIT
;
4565 const char *post_rewrite_hook
=
4566 find_hook("post-rewrite");
4568 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
4570 strvec_push(&child
.args
, "notes");
4571 strvec_push(&child
.args
, "copy");
4572 strvec_push(&child
.args
, "--for-rewrite=rebase");
4573 /* we don't care if this copying failed */
4574 run_command(&child
);
4576 if (post_rewrite_hook
) {
4577 struct child_process hook
= CHILD_PROCESS_INIT
;
4579 hook
.in
= open(rebase_path_rewritten_list(),
4581 hook
.stdout_to_stderr
= 1;
4582 hook
.trace2_hook_name
= "post-rewrite";
4583 strvec_push(&hook
.args
, post_rewrite_hook
);
4584 strvec_push(&hook
.args
, "rebase");
4585 /* we don't care if this hook failed */
4589 apply_autostash(rebase_path_autostash());
4595 _("Successfully rebased and updated %s.\n"),
4599 strbuf_release(&buf
);
4600 strbuf_release(&head_ref
);
4604 * Sequence of picks finished successfully; cleanup by
4605 * removing the .git/sequencer directory
4607 return sequencer_remove_state(opts
);
4610 static int continue_single_pick(struct repository
*r
, struct replay_opts
*opts
)
4612 struct strvec argv
= STRVEC_INIT
;
4615 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
4616 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
4617 return error(_("no cherry-pick or revert in progress"));
4619 strvec_push(&argv
, "commit");
4622 * continue_single_pick() handles the case of recovering from a
4623 * conflict. should_edit() doesn't handle that case; for a conflict,
4624 * we want to edit if the user asked for it, or if they didn't specify
4625 * and stdin is a tty.
4627 if (!opts
->edit
|| (opts
->edit
< 0 && !isatty(0)))
4629 * Include --cleanup=strip as well because we don't want the
4630 * "# Conflicts:" messages.
4632 strvec_pushl(&argv
, "--no-edit", "--cleanup=strip", NULL
);
4634 ret
= run_command_v_opt(argv
.v
, RUN_GIT_CMD
);
4635 strvec_clear(&argv
);
4639 static int commit_staged_changes(struct repository
*r
,
4640 struct replay_opts
*opts
,
4641 struct todo_list
*todo_list
)
4643 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
4644 unsigned int final_fixup
= 0, is_clean
;
4646 if (has_unstaged_changes(r
, 1))
4647 return error(_("cannot rebase: You have unstaged changes."));
4649 is_clean
= !has_uncommitted_changes(r
, 0);
4651 if (file_exists(rebase_path_amend())) {
4652 struct strbuf rev
= STRBUF_INIT
;
4653 struct object_id head
, to_amend
;
4655 if (get_oid("HEAD", &head
))
4656 return error(_("cannot amend non-existing commit"));
4657 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
4658 return error(_("invalid file: '%s'"), rebase_path_amend());
4659 if (get_oid_hex(rev
.buf
, &to_amend
))
4660 return error(_("invalid contents: '%s'"),
4661 rebase_path_amend());
4662 if (!is_clean
&& !oideq(&head
, &to_amend
))
4663 return error(_("\nYou have uncommitted changes in your "
4664 "working tree. Please, commit them\n"
4665 "first and then run 'git rebase "
4666 "--continue' again."));
4668 * When skipping a failed fixup/squash, we need to edit the
4669 * commit message, the current fixup list and count, and if it
4670 * was the last fixup/squash in the chain, we need to clean up
4671 * the commit message and if there was a squash, let the user
4674 if (!is_clean
|| !opts
->current_fixup_count
)
4675 ; /* this is not the final fixup */
4676 else if (!oideq(&head
, &to_amend
) ||
4677 !file_exists(rebase_path_stopped_sha())) {
4678 /* was a final fixup or squash done manually? */
4679 if (!is_fixup(peek_command(todo_list
, 0))) {
4680 unlink(rebase_path_fixup_msg());
4681 unlink(rebase_path_squash_msg());
4682 unlink(rebase_path_current_fixups());
4683 strbuf_reset(&opts
->current_fixups
);
4684 opts
->current_fixup_count
= 0;
4687 /* we are in a fixup/squash chain */
4688 const char *p
= opts
->current_fixups
.buf
;
4689 int len
= opts
->current_fixups
.len
;
4691 opts
->current_fixup_count
--;
4693 BUG("Incorrect current_fixups:\n%s", p
);
4694 while (len
&& p
[len
- 1] != '\n')
4696 strbuf_setlen(&opts
->current_fixups
, len
);
4697 if (write_message(p
, len
, rebase_path_current_fixups(),
4699 return error(_("could not write file: '%s'"),
4700 rebase_path_current_fixups());
4703 * If a fixup/squash in a fixup/squash chain failed, the
4704 * commit message is already correct, no need to commit
4707 * Only if it is the final command in the fixup/squash
4708 * chain, and only if the chain is longer than a single
4709 * fixup/squash command (which was just skipped), do we
4710 * actually need to re-commit with a cleaned up commit
4713 if (opts
->current_fixup_count
> 0 &&
4714 !is_fixup(peek_command(todo_list
, 0))) {
4717 * If there was not a single "squash" in the
4718 * chain, we only need to clean up the commit
4719 * message, no need to bother the user with
4720 * opening the commit message in the editor.
4722 if (!starts_with(p
, "squash ") &&
4723 !strstr(p
, "\nsquash "))
4724 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
4725 } else if (is_fixup(peek_command(todo_list
, 0))) {
4727 * We need to update the squash message to skip
4728 * the latest commit message.
4730 struct commit
*commit
;
4731 const char *path
= rebase_path_squash_msg();
4732 const char *encoding
= get_commit_output_encoding();
4734 if (parse_head(r
, &commit
) ||
4735 !(p
= logmsg_reencode(commit
, NULL
, encoding
)) ||
4736 write_message(p
, strlen(p
), path
, 0)) {
4737 unuse_commit_buffer(commit
, p
);
4738 return error(_("could not write file: "
4741 unuse_commit_buffer(commit
, p
);
4745 strbuf_release(&rev
);
4750 if (refs_ref_exists(get_main_ref_store(r
),
4751 "CHERRY_PICK_HEAD") &&
4752 refs_delete_ref(get_main_ref_store(r
), "",
4753 "CHERRY_PICK_HEAD", NULL
, 0))
4754 return error(_("could not remove CHERRY_PICK_HEAD"));
4755 if (unlink(git_path_merge_msg(r
)) && errno
!= ENOENT
)
4756 return error_errno(_("could not remove '%s'"),
4757 git_path_merge_msg(r
));
4762 if (run_git_commit(final_fixup
? NULL
: rebase_path_message(),
4764 return error(_("could not commit staged changes."));
4765 unlink(rebase_path_amend());
4766 unlink(git_path_merge_head(r
));
4767 unlink(git_path_auto_merge(r
));
4769 unlink(rebase_path_fixup_msg());
4770 unlink(rebase_path_squash_msg());
4772 if (opts
->current_fixup_count
> 0) {
4774 * Whether final fixup or not, we just cleaned up the commit
4777 unlink(rebase_path_current_fixups());
4778 strbuf_reset(&opts
->current_fixups
);
4779 opts
->current_fixup_count
= 0;
4784 int sequencer_continue(struct repository
*r
, struct replay_opts
*opts
)
4786 struct todo_list todo_list
= TODO_LIST_INIT
;
4789 if (read_and_refresh_cache(r
, opts
))
4792 if (read_populate_opts(opts
))
4794 if (is_rebase_i(opts
)) {
4795 if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
4796 goto release_todo_list
;
4798 if (file_exists(rebase_path_dropped())) {
4799 if ((res
= todo_list_check_against_backup(r
, &todo_list
)))
4800 goto release_todo_list
;
4802 unlink(rebase_path_dropped());
4805 if (commit_staged_changes(r
, opts
, &todo_list
)) {
4807 goto release_todo_list
;
4809 } else if (!file_exists(get_todo_path(opts
)))
4810 return continue_single_pick(r
, opts
);
4811 else if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
4812 goto release_todo_list
;
4814 if (!is_rebase_i(opts
)) {
4815 /* Verify that the conflict has been resolved */
4816 if (refs_ref_exists(get_main_ref_store(r
),
4817 "CHERRY_PICK_HEAD") ||
4818 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
4819 res
= continue_single_pick(r
, opts
);
4821 goto release_todo_list
;
4823 if (index_differs_from(r
, "HEAD", NULL
, 0)) {
4824 res
= error_dirty_index(r
, opts
);
4825 goto release_todo_list
;
4827 todo_list
.current
++;
4828 } else if (file_exists(rebase_path_stopped_sha())) {
4829 struct strbuf buf
= STRBUF_INIT
;
4830 struct object_id oid
;
4832 if (read_oneliner(&buf
, rebase_path_stopped_sha(),
4833 READ_ONELINER_SKIP_IF_EMPTY
) &&
4834 !get_oid_hex(buf
.buf
, &oid
))
4835 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
4836 strbuf_release(&buf
);
4839 res
= pick_commits(r
, &todo_list
, opts
);
4841 todo_list_release(&todo_list
);
4845 static int single_pick(struct repository
*r
,
4846 struct commit
*cmit
,
4847 struct replay_opts
*opts
)
4850 struct todo_item item
;
4852 item
.command
= opts
->action
== REPLAY_PICK
?
4853 TODO_PICK
: TODO_REVERT
;
4856 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
4857 return do_pick_commit(r
, &item
, opts
, 0, &check_todo
);
4860 int sequencer_pick_revisions(struct repository
*r
,
4861 struct replay_opts
*opts
)
4863 struct todo_list todo_list
= TODO_LIST_INIT
;
4864 struct object_id oid
;
4868 if (read_and_refresh_cache(r
, opts
))
4871 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
4872 struct object_id oid
;
4873 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
4875 /* This happens when using --stdin. */
4879 if (!get_oid(name
, &oid
)) {
4880 if (!lookup_commit_reference_gently(r
, &oid
, 1)) {
4881 enum object_type type
= oid_object_info(r
,
4884 return error(_("%s: can't cherry-pick a %s"),
4885 name
, type_name(type
));
4888 return error(_("%s: bad revision"), name
);
4892 * If we were called as "git cherry-pick <commit>", just
4893 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4894 * REVERT_HEAD, and don't touch the sequencer state.
4895 * This means it is possible to cherry-pick in the middle
4896 * of a cherry-pick sequence.
4898 if (opts
->revs
->cmdline
.nr
== 1 &&
4899 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
4900 opts
->revs
->no_walk
&&
4901 !opts
->revs
->cmdline
.rev
->flags
) {
4902 struct commit
*cmit
;
4903 if (prepare_revision_walk(opts
->revs
))
4904 return error(_("revision walk setup failed"));
4905 cmit
= get_revision(opts
->revs
);
4907 return error(_("empty commit set passed"));
4908 if (get_revision(opts
->revs
))
4909 BUG("unexpected extra commit from walk");
4910 return single_pick(r
, cmit
, opts
);
4914 * Start a new cherry-pick/ revert sequence; but
4915 * first, make sure that an existing one isn't in
4919 if (walk_revs_populate_todo(&todo_list
, opts
) ||
4920 create_seq_dir(r
) < 0)
4922 if (get_oid("HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
4923 return error(_("can't revert as initial commit"));
4924 if (save_head(oid_to_hex(&oid
)))
4926 if (save_opts(opts
))
4928 update_abort_safety_file();
4929 res
= pick_commits(r
, &todo_list
, opts
);
4930 todo_list_release(&todo_list
);
4934 void append_signoff(struct strbuf
*msgbuf
, size_t ignore_footer
, unsigned flag
)
4936 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
4937 struct strbuf sob
= STRBUF_INIT
;
4940 strbuf_addstr(&sob
, sign_off_header
);
4941 strbuf_addstr(&sob
, fmt_name(WANT_COMMITTER_IDENT
));
4942 strbuf_addch(&sob
, '\n');
4945 strbuf_complete_line(msgbuf
);
4948 * If the whole message buffer is equal to the sob, pretend that we
4949 * found a conforming footer with a matching sob
4951 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
4952 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
4955 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
4958 const char *append_newlines
= NULL
;
4959 size_t len
= msgbuf
->len
- ignore_footer
;
4963 * The buffer is completely empty. Leave foom for
4964 * the title and body to be filled in by the user.
4966 append_newlines
= "\n\n";
4967 } else if (len
== 1) {
4969 * Buffer contains a single newline. Add another
4970 * so that we leave room for the title and body.
4972 append_newlines
= "\n";
4973 } else if (msgbuf
->buf
[len
- 2] != '\n') {
4975 * Buffer ends with a single newline. Add another
4976 * so that there is an empty line between the message
4979 append_newlines
= "\n";
4980 } /* else, the buffer already ends with two newlines. */
4982 if (append_newlines
)
4983 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
4984 append_newlines
, strlen(append_newlines
));
4987 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
4988 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
4991 strbuf_release(&sob
);
4994 struct labels_entry
{
4995 struct hashmap_entry entry
;
4996 char label
[FLEX_ARRAY
];
4999 static int labels_cmp(const void *fndata
, const struct hashmap_entry
*eptr
,
5000 const struct hashmap_entry
*entry_or_key
, const void *key
)
5002 const struct labels_entry
*a
, *b
;
5004 a
= container_of(eptr
, const struct labels_entry
, entry
);
5005 b
= container_of(entry_or_key
, const struct labels_entry
, entry
);
5007 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
5010 struct string_entry
{
5011 struct oidmap_entry entry
;
5012 char string
[FLEX_ARRAY
];
5015 struct label_state
{
5016 struct oidmap commit2label
;
5017 struct hashmap labels
;
5021 static const char *label_oid(struct object_id
*oid
, const char *label
,
5022 struct label_state
*state
)
5024 struct labels_entry
*labels_entry
;
5025 struct string_entry
*string_entry
;
5026 struct object_id dummy
;
5029 string_entry
= oidmap_get(&state
->commit2label
, oid
);
5031 return string_entry
->string
;
5034 * For "uninteresting" commits, i.e. commits that are not to be
5035 * rebased, and which can therefore not be labeled, we use a unique
5036 * abbreviation of the commit name. This is slightly more complicated
5037 * than calling find_unique_abbrev() because we also need to make
5038 * sure that the abbreviation does not conflict with any other
5041 * We disallow "interesting" commits to be labeled by a string that
5042 * is a valid full-length hash, to ensure that we always can find an
5043 * abbreviation for any uninteresting commit's names that does not
5044 * clash with any other label.
5046 strbuf_reset(&state
->buf
);
5050 strbuf_grow(&state
->buf
, GIT_MAX_HEXSZ
);
5051 label
= p
= state
->buf
.buf
;
5053 find_unique_abbrev_r(p
, oid
, default_abbrev
);
5056 * We may need to extend the abbreviated hash so that there is
5057 * no conflicting label.
5059 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
5060 size_t i
= strlen(p
) + 1;
5062 oid_to_hex_r(p
, oid
);
5063 for (; i
< the_hash_algo
->hexsz
; i
++) {
5066 if (!hashmap_get_from_hash(&state
->labels
,
5073 struct strbuf
*buf
= &state
->buf
;
5076 * Sanitize labels by replacing non-alpha-numeric characters
5077 * (including white-space ones) by dashes, as they might be
5078 * illegal in file names (and hence in ref names).
5080 * Note that we retain non-ASCII UTF-8 characters (identified
5081 * via the most significant bit). They should be all acceptable
5082 * in file names. We do not validate the UTF-8 here, that's not
5083 * the job of this function.
5085 for (; *label
; label
++)
5086 if ((*label
& 0x80) || isalnum(*label
))
5087 strbuf_addch(buf
, *label
);
5088 /* avoid leading dash and double-dashes */
5089 else if (buf
->len
&& buf
->buf
[buf
->len
- 1] != '-')
5090 strbuf_addch(buf
, '-');
5092 strbuf_addstr(buf
, "rev-");
5093 strbuf_add_unique_abbrev(buf
, oid
, default_abbrev
);
5097 if ((buf
->len
== the_hash_algo
->hexsz
&&
5098 !get_oid_hex(label
, &dummy
)) ||
5099 (buf
->len
== 1 && *label
== '#') ||
5100 hashmap_get_from_hash(&state
->labels
,
5101 strihash(label
), label
)) {
5103 * If the label already exists, or if the label is a
5104 * valid full OID, or the label is a '#' (which we use
5105 * as a separator between merge heads and oneline), we
5106 * append a dash and a number to make it unique.
5108 size_t len
= buf
->len
;
5110 for (i
= 2; ; i
++) {
5111 strbuf_setlen(buf
, len
);
5112 strbuf_addf(buf
, "-%d", i
);
5113 if (!hashmap_get_from_hash(&state
->labels
,
5123 FLEX_ALLOC_STR(labels_entry
, label
, label
);
5124 hashmap_entry_init(&labels_entry
->entry
, strihash(label
));
5125 hashmap_add(&state
->labels
, &labels_entry
->entry
);
5127 FLEX_ALLOC_STR(string_entry
, string
, label
);
5128 oidcpy(&string_entry
->entry
.oid
, oid
);
5129 oidmap_put(&state
->commit2label
, string_entry
);
5131 return string_entry
->string
;
5134 static int make_script_with_merges(struct pretty_print_context
*pp
,
5135 struct rev_info
*revs
, struct strbuf
*out
,
5138 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5139 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
5140 int root_with_onto
= flags
& TODO_LIST_ROOT_WITH_ONTO
;
5141 int skipped_commit
= 0;
5142 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
5143 struct strbuf label
= STRBUF_INIT
;
5144 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
5145 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
5146 struct commit
*commit
;
5147 struct oidmap commit2todo
= OIDMAP_INIT
;
5148 struct string_entry
*entry
;
5149 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
5150 shown
= OIDSET_INIT
;
5151 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
5153 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
5154 const char *cmd_pick
= abbr
? "p" : "pick",
5155 *cmd_label
= abbr
? "l" : "label",
5156 *cmd_reset
= abbr
? "t" : "reset",
5157 *cmd_merge
= abbr
? "m" : "merge";
5159 oidmap_init(&commit2todo
, 0);
5160 oidmap_init(&state
.commit2label
, 0);
5161 hashmap_init(&state
.labels
, labels_cmp
, NULL
, 0);
5162 strbuf_init(&state
.buf
, 32);
5164 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
5165 struct labels_entry
*onto_label_entry
;
5166 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
5167 FLEX_ALLOC_STR(entry
, string
, "onto");
5168 oidcpy(&entry
->entry
.oid
, oid
);
5169 oidmap_put(&state
.commit2label
, entry
);
5171 FLEX_ALLOC_STR(onto_label_entry
, label
, "onto");
5172 hashmap_entry_init(&onto_label_entry
->entry
, strihash("onto"));
5173 hashmap_add(&state
.labels
, &onto_label_entry
->entry
);
5178 * - get onelines for all commits
5179 * - gather all branch tips (i.e. 2nd or later parents of merges)
5180 * - label all branch tips
5182 while ((commit
= get_revision(revs
))) {
5183 struct commit_list
*to_merge
;
5184 const char *p1
, *p2
;
5185 struct object_id
*oid
;
5188 tail
= &commit_list_insert(commit
, tail
)->next
;
5189 oidset_insert(&interesting
, &commit
->object
.oid
);
5191 is_empty
= is_original_commit_empty(commit
);
5192 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5193 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5194 warning(_("skipped previously applied commit %s"),
5195 short_commit_name(commit
));
5199 if (is_empty
&& !keep_empty
)
5202 strbuf_reset(&oneline
);
5203 pretty_print_commit(pp
, commit
, &oneline
);
5205 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
5207 /* non-merge commit: easy case */
5209 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
5210 oid_to_hex(&commit
->object
.oid
),
5213 strbuf_addf(&buf
, " %c empty",
5216 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5217 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5218 oidmap_put(&commit2todo
, entry
);
5223 /* Create a label */
5224 strbuf_reset(&label
);
5225 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
5226 (p1
= strchr(p1
, '\'')) &&
5227 (p2
= strchr(++p1
, '\'')))
5228 strbuf_add(&label
, p1
, p2
- p1
);
5229 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
5231 (p1
= strstr(p1
, " from ")))
5232 strbuf_addstr(&label
, p1
+ strlen(" from "));
5234 strbuf_addbuf(&label
, &oneline
);
5237 strbuf_addf(&buf
, "%s -C %s",
5238 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
5240 /* label the tips of merged branches */
5241 for (; to_merge
; to_merge
= to_merge
->next
) {
5242 oid
= &to_merge
->item
->object
.oid
;
5243 strbuf_addch(&buf
, ' ');
5245 if (!oidset_contains(&interesting
, oid
)) {
5246 strbuf_addstr(&buf
, label_oid(oid
, NULL
,
5251 tips_tail
= &commit_list_insert(to_merge
->item
,
5254 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
5256 strbuf_addf(&buf
, " # %s", oneline
.buf
);
5258 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5259 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5260 oidmap_put(&commit2todo
, entry
);
5263 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5264 _("use --reapply-cherry-picks to include skipped commits"));
5268 * - label branch points
5269 * - add HEAD to the branch tips
5271 for (iter
= commits
; iter
; iter
= iter
->next
) {
5272 struct commit_list
*parent
= iter
->item
->parents
;
5273 for (; parent
; parent
= parent
->next
) {
5274 struct object_id
*oid
= &parent
->item
->object
.oid
;
5275 if (!oidset_contains(&interesting
, oid
))
5277 if (oidset_insert(&child_seen
, oid
))
5278 label_oid(oid
, "branch-point", &state
);
5281 /* Add HEAD as implicit "tip of branch" */
5283 tips_tail
= &commit_list_insert(iter
->item
,
5288 * Third phase: output the todo list. This is a bit tricky, as we
5289 * want to avoid jumping back and forth between revisions. To
5290 * accomplish that goal, we walk backwards from the branch tips,
5291 * gathering commits not yet shown, reversing the list on the fly,
5292 * then outputting that list (labeling revisions as needed).
5294 strbuf_addf(out
, "%s onto\n", cmd_label
);
5295 for (iter
= tips
; iter
; iter
= iter
->next
) {
5296 struct commit_list
*list
= NULL
, *iter2
;
5298 commit
= iter
->item
;
5299 if (oidset_contains(&shown
, &commit
->object
.oid
))
5301 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
5304 strbuf_addf(out
, "\n%c Branch %s\n", comment_line_char
, entry
->string
);
5306 strbuf_addch(out
, '\n');
5308 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
5309 !oidset_contains(&shown
, &commit
->object
.oid
)) {
5310 commit_list_insert(commit
, &list
);
5311 if (!commit
->parents
) {
5315 commit
= commit
->parents
->item
;
5319 strbuf_addf(out
, "%s %s\n", cmd_reset
,
5320 rebase_cousins
|| root_with_onto
?
5321 "onto" : "[new root]");
5323 const char *to
= NULL
;
5325 entry
= oidmap_get(&state
.commit2label
,
5326 &commit
->object
.oid
);
5329 else if (!rebase_cousins
)
5330 to
= label_oid(&commit
->object
.oid
, NULL
,
5333 if (!to
|| !strcmp(to
, "onto"))
5334 strbuf_addf(out
, "%s onto\n", cmd_reset
);
5336 strbuf_reset(&oneline
);
5337 pretty_print_commit(pp
, commit
, &oneline
);
5338 strbuf_addf(out
, "%s %s # %s\n",
5339 cmd_reset
, to
, oneline
.buf
);
5343 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
5344 struct object_id
*oid
= &iter2
->item
->object
.oid
;
5345 entry
= oidmap_get(&commit2todo
, oid
);
5346 /* only show if not already upstream */
5348 strbuf_addf(out
, "%s\n", entry
->string
);
5349 entry
= oidmap_get(&state
.commit2label
, oid
);
5351 strbuf_addf(out
, "%s %s\n",
5352 cmd_label
, entry
->string
);
5353 oidset_insert(&shown
, oid
);
5356 free_commit_list(list
);
5359 free_commit_list(commits
);
5360 free_commit_list(tips
);
5362 strbuf_release(&label
);
5363 strbuf_release(&oneline
);
5364 strbuf_release(&buf
);
5366 oidmap_free(&commit2todo
, 1);
5367 oidmap_free(&state
.commit2label
, 1);
5368 hashmap_clear_and_free(&state
.labels
, struct labels_entry
, entry
);
5369 strbuf_release(&state
.buf
);
5374 int sequencer_make_script(struct repository
*r
, struct strbuf
*out
, int argc
,
5375 const char **argv
, unsigned flags
)
5377 char *format
= NULL
;
5378 struct pretty_print_context pp
= {0};
5379 struct rev_info revs
;
5380 struct commit
*commit
;
5381 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5382 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
5383 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
5384 int reapply_cherry_picks
= flags
& TODO_LIST_REAPPLY_CHERRY_PICKS
;
5385 int skipped_commit
= 0;
5387 repo_init_revisions(r
, &revs
, NULL
);
5388 revs
.verbose_header
= 1;
5390 revs
.max_parents
= 1;
5391 revs
.cherry_mark
= !reapply_cherry_picks
;
5394 revs
.right_only
= 1;
5395 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
5396 revs
.topo_order
= 1;
5398 revs
.pretty_given
= 1;
5399 git_config_get_string("rebase.instructionFormat", &format
);
5400 if (!format
|| !*format
) {
5402 format
= xstrdup("%s");
5404 get_commit_format(format
, &revs
);
5406 pp
.fmt
= revs
.commit_format
;
5407 pp
.output_encoding
= get_log_output_encoding();
5409 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1)
5410 return error(_("make_script: unhandled options"));
5412 if (prepare_revision_walk(&revs
) < 0)
5413 return error(_("make_script: error preparing revisions"));
5416 return make_script_with_merges(&pp
, &revs
, out
, flags
);
5418 while ((commit
= get_revision(&revs
))) {
5419 int is_empty
= is_original_commit_empty(commit
);
5421 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5422 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5423 warning(_("skipped previously applied commit %s"),
5424 short_commit_name(commit
));
5428 if (is_empty
&& !keep_empty
)
5430 strbuf_addf(out
, "%s %s ", insn
,
5431 oid_to_hex(&commit
->object
.oid
));
5432 pretty_print_commit(&pp
, commit
, out
);
5434 strbuf_addf(out
, " %c empty", comment_line_char
);
5435 strbuf_addch(out
, '\n');
5438 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5439 _("use --reapply-cherry-picks to include skipped commits"));
5444 * Add commands after pick and (series of) squash/fixup commands
5447 static void todo_list_add_exec_commands(struct todo_list
*todo_list
,
5448 struct string_list
*commands
)
5450 struct strbuf
*buf
= &todo_list
->buf
;
5451 size_t base_offset
= buf
->len
;
5452 int i
, insert
, nr
= 0, alloc
= 0;
5453 struct todo_item
*items
= NULL
, *base_items
= NULL
;
5455 CALLOC_ARRAY(base_items
, commands
->nr
);
5456 for (i
= 0; i
< commands
->nr
; i
++) {
5457 size_t command_len
= strlen(commands
->items
[i
].string
);
5459 strbuf_addstr(buf
, commands
->items
[i
].string
);
5460 strbuf_addch(buf
, '\n');
5462 base_items
[i
].command
= TODO_EXEC
;
5463 base_items
[i
].offset_in_buf
= base_offset
;
5464 base_items
[i
].arg_offset
= base_offset
+ strlen("exec ");
5465 base_items
[i
].arg_len
= command_len
- strlen("exec ");
5467 base_offset
+= command_len
+ 1;
5471 * Insert <commands> after every pick. Here, fixup/squash chains
5472 * are considered part of the pick, so we insert the commands *after*
5473 * those chains if there are any.
5475 * As we insert the exec commands immediately after rearranging
5476 * any fixups and before the user edits the list, a fixup chain
5477 * can never contain comments (any comments are empty picks that
5478 * have been commented out because the user did not specify
5479 * --keep-empty). So, it is safe to insert an exec command
5480 * without looking at the command following a comment.
5483 for (i
= 0; i
< todo_list
->nr
; i
++) {
5484 enum todo_command command
= todo_list
->items
[i
].command
;
5485 if (insert
&& !is_fixup(command
)) {
5486 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5487 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5493 ALLOC_GROW(items
, nr
+ 1, alloc
);
5494 items
[nr
++] = todo_list
->items
[i
];
5496 if (command
== TODO_PICK
|| command
== TODO_MERGE
)
5500 /* insert or append final <commands> */
5502 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5503 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5508 FREE_AND_NULL(todo_list
->items
);
5509 todo_list
->items
= items
;
5511 todo_list
->alloc
= alloc
;
5514 static void todo_list_to_strbuf(struct repository
*r
, struct todo_list
*todo_list
,
5515 struct strbuf
*buf
, int num
, unsigned flags
)
5517 struct todo_item
*item
;
5518 int i
, max
= todo_list
->nr
;
5520 if (num
> 0 && num
< max
)
5523 for (item
= todo_list
->items
, i
= 0; i
< max
; i
++, item
++) {
5526 /* if the item is not a command write it and continue */
5527 if (item
->command
>= TODO_COMMENT
) {
5528 strbuf_addf(buf
, "%.*s\n", item
->arg_len
,
5529 todo_item_get_arg(todo_list
, item
));
5533 /* add command to the buffer */
5534 cmd
= command_to_char(item
->command
);
5535 if ((flags
& TODO_LIST_ABBREVIATE_CMDS
) && cmd
)
5536 strbuf_addch(buf
, cmd
);
5538 strbuf_addstr(buf
, command_to_string(item
->command
));
5542 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
5543 short_commit_name(item
->commit
) :
5544 oid_to_hex(&item
->commit
->object
.oid
);
5546 if (item
->command
== TODO_FIXUP
) {
5547 if (item
->flags
& TODO_EDIT_FIXUP_MSG
)
5548 strbuf_addstr(buf
, " -c");
5549 else if (item
->flags
& TODO_REPLACE_FIXUP_MSG
) {
5550 strbuf_addstr(buf
, " -C");
5554 if (item
->command
== TODO_MERGE
) {
5555 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
5556 strbuf_addstr(buf
, " -c");
5558 strbuf_addstr(buf
, " -C");
5561 strbuf_addf(buf
, " %s", oid
);
5564 /* add all the rest */
5566 strbuf_addch(buf
, '\n');
5568 strbuf_addf(buf
, " %.*s\n", item
->arg_len
,
5569 todo_item_get_arg(todo_list
, item
));
5573 int todo_list_write_to_file(struct repository
*r
, struct todo_list
*todo_list
,
5574 const char *file
, const char *shortrevisions
,
5575 const char *shortonto
, int num
, unsigned flags
)
5578 struct strbuf buf
= STRBUF_INIT
;
5580 todo_list_to_strbuf(r
, todo_list
, &buf
, num
, flags
);
5581 if (flags
& TODO_LIST_APPEND_TODO_HELP
)
5582 append_todo_help(count_commands(todo_list
),
5583 shortrevisions
, shortonto
, &buf
);
5585 res
= write_message(buf
.buf
, buf
.len
, file
, 0);
5586 strbuf_release(&buf
);
5591 /* skip picking commits whose parents are unchanged */
5592 static int skip_unnecessary_picks(struct repository
*r
,
5593 struct todo_list
*todo_list
,
5594 struct object_id
*base_oid
)
5596 struct object_id
*parent_oid
;
5599 for (i
= 0; i
< todo_list
->nr
; i
++) {
5600 struct todo_item
*item
= todo_list
->items
+ i
;
5602 if (item
->command
>= TODO_NOOP
)
5604 if (item
->command
!= TODO_PICK
)
5606 if (parse_commit(item
->commit
)) {
5607 return error(_("could not parse commit '%s'"),
5608 oid_to_hex(&item
->commit
->object
.oid
));
5610 if (!item
->commit
->parents
)
5611 break; /* root commit */
5612 if (item
->commit
->parents
->next
)
5613 break; /* merge commit */
5614 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
5615 if (!oideq(parent_oid
, base_oid
))
5617 oidcpy(base_oid
, &item
->commit
->object
.oid
);
5620 const char *done_path
= rebase_path_done();
5622 if (todo_list_write_to_file(r
, todo_list
, done_path
, NULL
, NULL
, i
, 0)) {
5623 error_errno(_("could not write to '%s'"), done_path
);
5627 MOVE_ARRAY(todo_list
->items
, todo_list
->items
+ i
, todo_list
->nr
- i
);
5629 todo_list
->current
= 0;
5630 todo_list
->done_nr
+= i
;
5632 if (is_fixup(peek_command(todo_list
, 0)))
5633 record_in_rewritten(base_oid
, peek_command(todo_list
, 0));
5639 int complete_action(struct repository
*r
, struct replay_opts
*opts
, unsigned flags
,
5640 const char *shortrevisions
, const char *onto_name
,
5641 struct commit
*onto
, const struct object_id
*orig_head
,
5642 struct string_list
*commands
, unsigned autosquash
,
5643 struct todo_list
*todo_list
)
5645 char shortonto
[GIT_MAX_HEXSZ
+ 1];
5646 const char *todo_file
= rebase_path_todo();
5647 struct todo_list new_todo
= TODO_LIST_INIT
;
5648 struct strbuf
*buf
= &todo_list
->buf
, buf2
= STRBUF_INIT
;
5649 struct object_id oid
= onto
->object
.oid
;
5652 find_unique_abbrev_r(shortonto
, &oid
, DEFAULT_ABBREV
);
5654 if (buf
->len
== 0) {
5655 struct todo_item
*item
= append_new_todo(todo_list
);
5656 item
->command
= TODO_NOOP
;
5657 item
->commit
= NULL
;
5658 item
->arg_len
= item
->arg_offset
= item
->flags
= item
->offset_in_buf
= 0;
5661 if (autosquash
&& todo_list_rearrange_squash(todo_list
))
5665 todo_list_add_exec_commands(todo_list
, commands
);
5667 if (count_commands(todo_list
) == 0) {
5668 apply_autostash(rebase_path_autostash());
5669 sequencer_remove_state(opts
);
5671 return error(_("nothing to do"));
5674 res
= edit_todo_list(r
, todo_list
, &new_todo
, shortrevisions
,
5678 else if (res
== -2) {
5679 apply_autostash(rebase_path_autostash());
5680 sequencer_remove_state(opts
);
5683 } else if (res
== -3) {
5684 apply_autostash(rebase_path_autostash());
5685 sequencer_remove_state(opts
);
5686 todo_list_release(&new_todo
);
5688 return error(_("nothing to do"));
5689 } else if (res
== -4) {
5690 checkout_onto(r
, opts
, onto_name
, &onto
->object
.oid
, orig_head
);
5691 todo_list_release(&new_todo
);
5696 /* Expand the commit IDs */
5697 todo_list_to_strbuf(r
, &new_todo
, &buf2
, -1, 0);
5698 strbuf_swap(&new_todo
.buf
, &buf2
);
5699 strbuf_release(&buf2
);
5700 new_todo
.total_nr
-= new_todo
.nr
;
5701 if (todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
) < 0)
5702 BUG("invalid todo list after expanding IDs:\n%s",
5705 if (opts
->allow_ff
&& skip_unnecessary_picks(r
, &new_todo
, &oid
)) {
5706 todo_list_release(&new_todo
);
5707 return error(_("could not skip unnecessary pick commands"));
5710 if (todo_list_write_to_file(r
, &new_todo
, todo_file
, NULL
, NULL
, -1,
5711 flags
& ~(TODO_LIST_SHORTEN_IDS
))) {
5712 todo_list_release(&new_todo
);
5713 return error_errno(_("could not write '%s'"), todo_file
);
5718 if (checkout_onto(r
, opts
, onto_name
, &oid
, orig_head
))
5721 if (require_clean_work_tree(r
, "rebase", "", 1, 1))
5724 todo_list_write_total_nr(&new_todo
);
5725 res
= pick_commits(r
, &new_todo
, opts
);
5728 todo_list_release(&new_todo
);
5733 struct subject2item_entry
{
5734 struct hashmap_entry entry
;
5736 char subject
[FLEX_ARRAY
];
5739 static int subject2item_cmp(const void *fndata
,
5740 const struct hashmap_entry
*eptr
,
5741 const struct hashmap_entry
*entry_or_key
,
5744 const struct subject2item_entry
*a
, *b
;
5746 a
= container_of(eptr
, const struct subject2item_entry
, entry
);
5747 b
= container_of(entry_or_key
, const struct subject2item_entry
, entry
);
5749 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
5752 define_commit_slab(commit_todo_item
, struct todo_item
*);
5754 static int skip_fixupish(const char *subject
, const char **p
) {
5755 return skip_prefix(subject
, "fixup! ", p
) ||
5756 skip_prefix(subject
, "amend! ", p
) ||
5757 skip_prefix(subject
, "squash! ", p
);
5761 * Rearrange the todo list that has both "pick commit-id msg" and "pick
5762 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
5763 * after the former, and change "pick" to "fixup"/"squash".
5765 * Note that if the config has specified a custom instruction format, each log
5766 * message will have to be retrieved from the commit (as the oneline in the
5767 * script cannot be trusted) in order to normalize the autosquash arrangement.
5769 int todo_list_rearrange_squash(struct todo_list
*todo_list
)
5771 struct hashmap subject2item
;
5772 int rearranged
= 0, *next
, *tail
, i
, nr
= 0, alloc
= 0;
5774 struct commit_todo_item commit_todo
;
5775 struct todo_item
*items
= NULL
;
5777 init_commit_todo_item(&commit_todo
);
5779 * The hashmap maps onelines to the respective todo list index.
5781 * If any items need to be rearranged, the next[i] value will indicate
5782 * which item was moved directly after the i'th.
5784 * In that case, last[i] will indicate the index of the latest item to
5785 * be moved to appear after the i'th.
5787 hashmap_init(&subject2item
, subject2item_cmp
, NULL
, todo_list
->nr
);
5788 ALLOC_ARRAY(next
, todo_list
->nr
);
5789 ALLOC_ARRAY(tail
, todo_list
->nr
);
5790 ALLOC_ARRAY(subjects
, todo_list
->nr
);
5791 for (i
= 0; i
< todo_list
->nr
; i
++) {
5792 struct strbuf buf
= STRBUF_INIT
;
5793 struct todo_item
*item
= todo_list
->items
+ i
;
5794 const char *commit_buffer
, *subject
, *p
;
5797 struct subject2item_entry
*entry
;
5799 next
[i
] = tail
[i
] = -1;
5800 if (!item
->commit
|| item
->command
== TODO_DROP
) {
5805 if (is_fixup(item
->command
)) {
5806 clear_commit_todo_item(&commit_todo
);
5807 return error(_("the script was already rearranged."));
5810 *commit_todo_item_at(&commit_todo
, item
->commit
) = item
;
5812 parse_commit(item
->commit
);
5813 commit_buffer
= logmsg_reencode(item
->commit
, NULL
, "UTF-8");
5814 find_commit_subject(commit_buffer
, &subject
);
5815 format_subject(&buf
, subject
, " ");
5816 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
5817 unuse_commit_buffer(item
->commit
, commit_buffer
);
5818 if (skip_fixupish(subject
, &p
)) {
5819 struct commit
*commit2
;
5824 if (!skip_fixupish(p
, &p
))
5828 entry
= hashmap_get_entry_from_hash(&subject2item
,
5830 struct subject2item_entry
,
5833 /* found by title */
5835 else if (!strchr(p
, ' ') &&
5837 lookup_commit_reference_by_name(p
)) &&
5838 *commit_todo_item_at(&commit_todo
, commit2
))
5839 /* found by commit name */
5840 i2
= *commit_todo_item_at(&commit_todo
, commit2
)
5843 /* copy can be a prefix of the commit subject */
5844 for (i2
= 0; i2
< i
; i2
++)
5846 starts_with(subjects
[i2
], p
))
5854 if (starts_with(subject
, "fixup!")) {
5855 todo_list
->items
[i
].command
= TODO_FIXUP
;
5856 } else if (starts_with(subject
, "amend!")) {
5857 todo_list
->items
[i
].command
= TODO_FIXUP
;
5858 todo_list
->items
[i
].flags
= TODO_REPLACE_FIXUP_MSG
;
5860 todo_list
->items
[i
].command
= TODO_SQUASH
;
5866 next
[i
] = next
[tail
[i2
]];
5870 } else if (!hashmap_get_from_hash(&subject2item
,
5871 strhash(subject
), subject
)) {
5872 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
5874 hashmap_entry_init(&entry
->entry
,
5875 strhash(entry
->subject
));
5876 hashmap_put(&subject2item
, &entry
->entry
);
5881 for (i
= 0; i
< todo_list
->nr
; i
++) {
5882 enum todo_command command
= todo_list
->items
[i
].command
;
5886 * Initially, all commands are 'pick's. If it is a
5887 * fixup or a squash now, we have rearranged it.
5889 if (is_fixup(command
))
5893 ALLOC_GROW(items
, nr
+ 1, alloc
);
5894 items
[nr
++] = todo_list
->items
[cur
];
5899 FREE_AND_NULL(todo_list
->items
);
5900 todo_list
->items
= items
;
5902 todo_list
->alloc
= alloc
;
5907 for (i
= 0; i
< todo_list
->nr
; i
++)
5910 hashmap_clear_and_free(&subject2item
, struct subject2item_entry
, entry
);
5912 clear_commit_todo_item(&commit_todo
);
5917 int sequencer_determine_whence(struct repository
*r
, enum commit_whence
*whence
)
5919 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
5920 struct object_id cherry_pick_head
, rebase_head
;
5922 if (file_exists(git_path_seq_dir()))
5923 *whence
= FROM_CHERRY_PICK_MULTI
;
5924 if (file_exists(rebase_path()) &&
5925 !get_oid("REBASE_HEAD", &rebase_head
) &&
5926 !get_oid("CHERRY_PICK_HEAD", &cherry_pick_head
) &&
5927 oideq(&rebase_head
, &cherry_pick_head
))
5928 *whence
= FROM_REBASE_PICK
;
5930 *whence
= FROM_CHERRY_PICK_SINGLE
;