5 #include "object-store.h"
10 #include "run-command.h"
13 #include "cache-tree.h"
17 #include "merge-ort.h"
18 #include "merge-ort-wrappers.h"
24 #include "wt-status.h"
26 #include "notes-utils.h"
28 #include "unpack-trees.h"
32 #include "commit-slab.h"
34 #include "commit-reach.h"
35 #include "rebase-interactive.h"
38 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
40 static const char sign_off_header
[] = "Signed-off-by: ";
41 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
43 GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
45 static GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
47 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
48 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
49 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
50 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
52 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
54 * The file containing rebase commands, comments, and empty lines.
55 * This file is created by "git rebase -i" then edited by the user. As
56 * the lines are processed, they are removed from the front of this
57 * file and written to the tail of 'done'.
59 GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
60 GIT_PATH_FUNC(rebase_path_todo_backup
, "rebase-merge/git-rebase-todo.backup")
62 GIT_PATH_FUNC(rebase_path_dropped
, "rebase-merge/dropped")
65 * The rebase command lines that have already been processed. A line
66 * is moved here when it is first handled, before any associated user
69 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
71 * The file to keep track of how many commands were already processed (e.g.
74 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum")
76 * The file to keep track of how many commands are to be processed in total
77 * (e.g. for the prompt).
79 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end")
81 * The commit message that is planned to be used for any changes that
82 * need to be committed following a user interaction.
84 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
86 * The file into which is accumulated the suggested commit message for
87 * squash/fixup commands. When the first of a series of squash/fixups
88 * is seen, the file is created and the commit message from the
89 * previous commit and from the first squash/fixup commit are written
90 * to it. The commit message for each subsequent squash/fixup commit
91 * is appended to the file as it is processed.
93 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
95 * If the current series of squash/fixups has not yet included a squash
96 * command, then this file exists and holds the commit message of the
97 * original "pick" commit. (If the series ends without a "squash"
98 * command, then this can be used as the commit message of the combined
99 * commit without opening the editor.)
101 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
103 * This file contains the list fixup/squash commands that have been
104 * accumulated into message-fixup or message-squash so far.
106 static GIT_PATH_FUNC(rebase_path_current_fixups
, "rebase-merge/current-fixups")
108 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
109 * GIT_AUTHOR_DATE that will be used for the commit that is currently
112 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
114 * When an "edit" rebase command is being processed, the SHA1 of the
115 * commit to be edited is recorded in this file. When "git rebase
116 * --continue" is executed, if there are any staged changes then they
117 * will be amended to the HEAD commit, but only provided the HEAD
118 * commit is still the commit to be edited. When any other rebase
119 * command is processed, this file is deleted.
121 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
123 * When we stop at a given patch via the "edit" command, this file contains
124 * the commit object name of the corresponding patch.
126 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
128 * For the post-rewrite hook, we make a list of rewritten commits and
129 * their new sha1s. The rewritten-pending list keeps the sha1s of
130 * commits that have been processed, but not committed yet,
131 * e.g. because they are waiting for a 'squash' command.
133 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
134 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
135 "rebase-merge/rewritten-pending")
138 * The path of the file containing the OID of the "squash onto" commit, i.e.
139 * the dummy commit used for `reset [new root]`.
141 static GIT_PATH_FUNC(rebase_path_squash_onto
, "rebase-merge/squash-onto")
144 * The path of the file listing refs that need to be deleted after the rebase
145 * finishes. This is used by the `label` command to record the need for cleanup.
147 static GIT_PATH_FUNC(rebase_path_refs_to_delete
, "rebase-merge/refs-to-delete")
150 * The following files are written by git-rebase just after parsing the
153 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
154 static GIT_PATH_FUNC(rebase_path_cdate_is_adate
, "rebase-merge/cdate_is_adate")
155 static GIT_PATH_FUNC(rebase_path_ignore_date
, "rebase-merge/ignore_date")
156 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
157 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
158 static GIT_PATH_FUNC(rebase_path_quiet
, "rebase-merge/quiet")
159 static GIT_PATH_FUNC(rebase_path_signoff
, "rebase-merge/signoff")
160 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
161 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
162 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
163 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
164 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
165 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
166 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec
, "rebase-merge/reschedule-failed-exec")
167 static GIT_PATH_FUNC(rebase_path_no_reschedule_failed_exec
, "rebase-merge/no-reschedule-failed-exec")
168 static GIT_PATH_FUNC(rebase_path_drop_redundant_commits
, "rebase-merge/drop_redundant_commits")
169 static GIT_PATH_FUNC(rebase_path_keep_redundant_commits
, "rebase-merge/keep_redundant_commits")
171 static int git_sequencer_config(const char *k
, const char *v
, void *cb
)
173 struct replay_opts
*opts
= cb
;
176 if (!strcmp(k
, "commit.cleanup")) {
179 status
= git_config_string(&s
, k
, v
);
183 if (!strcmp(s
, "verbatim")) {
184 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
185 opts
->explicit_cleanup
= 1;
186 } else if (!strcmp(s
, "whitespace")) {
187 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
188 opts
->explicit_cleanup
= 1;
189 } else if (!strcmp(s
, "strip")) {
190 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_ALL
;
191 opts
->explicit_cleanup
= 1;
192 } else if (!strcmp(s
, "scissors")) {
193 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SCISSORS
;
194 opts
->explicit_cleanup
= 1;
196 warning(_("invalid commit message cleanup mode '%s'"),
204 if (!strcmp(k
, "commit.gpgsign")) {
205 opts
->gpg_sign
= git_config_bool(k
, v
) ? xstrdup("") : NULL
;
209 if (!opts
->default_strategy
&& !strcmp(k
, "pull.twohead")) {
210 int ret
= git_config_string((const char**)&opts
->default_strategy
, k
, v
);
213 * pull.twohead is allowed to be multi-valued; we only
214 * care about the first value.
216 char *tmp
= strchr(opts
->default_strategy
, ' ');
223 status
= git_gpg_config(k
, v
, NULL
);
227 return git_diff_basic_config(k
, v
, NULL
);
230 void sequencer_init_config(struct replay_opts
*opts
)
232 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
233 git_config(git_sequencer_config
, opts
);
236 static inline int is_rebase_i(const struct replay_opts
*opts
)
238 return opts
->action
== REPLAY_INTERACTIVE_REBASE
;
241 static const char *get_dir(const struct replay_opts
*opts
)
243 if (is_rebase_i(opts
))
244 return rebase_path();
245 return git_path_seq_dir();
248 static const char *get_todo_path(const struct replay_opts
*opts
)
250 if (is_rebase_i(opts
))
251 return rebase_path_todo();
252 return git_path_todo_file();
256 * Returns 0 for non-conforming footer
257 * Returns 1 for conforming footer
258 * Returns 2 when sob exists within conforming footer
259 * Returns 3 when sob exists within conforming footer as last entry
261 static int has_conforming_footer(struct strbuf
*sb
, struct strbuf
*sob
,
262 size_t ignore_footer
)
264 struct process_trailer_options opts
= PROCESS_TRAILER_OPTIONS_INIT
;
265 struct trailer_info info
;
267 int found_sob
= 0, found_sob_last
= 0;
273 saved_char
= sb
->buf
[sb
->len
- ignore_footer
];
274 sb
->buf
[sb
->len
- ignore_footer
] = '\0';
277 trailer_info_get(&info
, sb
->buf
, &opts
);
280 sb
->buf
[sb
->len
- ignore_footer
] = saved_char
;
282 if (info
.trailer_start
== info
.trailer_end
)
285 for (i
= 0; i
< info
.trailer_nr
; i
++)
286 if (sob
&& !strncmp(info
.trailers
[i
], sob
->buf
, sob
->len
)) {
288 if (i
== info
.trailer_nr
- 1)
292 trailer_info_release(&info
);
301 static const char *gpg_sign_opt_quoted(struct replay_opts
*opts
)
303 static struct strbuf buf
= STRBUF_INIT
;
307 sq_quotef(&buf
, "-S%s", opts
->gpg_sign
);
311 int sequencer_remove_state(struct replay_opts
*opts
)
313 struct strbuf buf
= STRBUF_INIT
;
316 if (is_rebase_i(opts
) &&
317 strbuf_read_file(&buf
, rebase_path_refs_to_delete(), 0) > 0) {
320 char *eol
= strchr(p
, '\n');
323 if (delete_ref("(rebase) cleanup", p
, NULL
, 0) < 0) {
324 warning(_("could not delete '%s'"), p
);
333 free(opts
->gpg_sign
);
334 free(opts
->default_strategy
);
335 free(opts
->strategy
);
336 for (i
= 0; i
< opts
->xopts_nr
; i
++)
337 free(opts
->xopts
[i
]);
339 strbuf_release(&opts
->current_fixups
);
342 strbuf_addstr(&buf
, get_dir(opts
));
343 if (remove_dir_recursively(&buf
, 0))
344 ret
= error(_("could not remove '%s'"), buf
.buf
);
345 strbuf_release(&buf
);
350 static const char *action_name(const struct replay_opts
*opts
)
352 switch (opts
->action
) {
356 return N_("cherry-pick");
357 case REPLAY_INTERACTIVE_REBASE
:
360 die(_("unknown action: %d"), opts
->action
);
363 struct commit_message
{
370 static const char *short_commit_name(struct commit
*commit
)
372 return find_unique_abbrev(&commit
->object
.oid
, DEFAULT_ABBREV
);
375 static int get_message(struct commit
*commit
, struct commit_message
*out
)
377 const char *abbrev
, *subject
;
380 out
->message
= logmsg_reencode(commit
, NULL
, get_commit_output_encoding());
381 abbrev
= short_commit_name(commit
);
383 subject_len
= find_commit_subject(out
->message
, &subject
);
385 out
->subject
= xmemdupz(subject
, subject_len
);
386 out
->label
= xstrfmt("%s (%s)", abbrev
, out
->subject
);
387 out
->parent_label
= xstrfmt("parent of %s", out
->label
);
392 static void free_message(struct commit
*commit
, struct commit_message
*msg
)
394 free(msg
->parent_label
);
397 unuse_commit_buffer(commit
, msg
->message
);
400 static void print_advice(struct repository
*r
, int show_hint
,
401 struct replay_opts
*opts
)
403 char *msg
= getenv("GIT_CHERRY_PICK_HELP");
408 * A conflict has occurred but the porcelain
409 * (typically rebase --interactive) wants to take care
410 * of the commit itself so remove CHERRY_PICK_HEAD
412 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
419 advise(_("after resolving the conflicts, mark the corrected paths\n"
420 "with 'git add <paths>' or 'git rm <paths>'"));
421 else if (opts
->action
== REPLAY_PICK
)
422 advise(_("After resolving the conflicts, mark them with\n"
423 "\"git add/rm <pathspec>\", then run\n"
424 "\"git cherry-pick --continue\".\n"
425 "You can instead skip this commit with \"git cherry-pick --skip\".\n"
426 "To abort and get back to the state before \"git cherry-pick\",\n"
427 "run \"git cherry-pick --abort\"."));
428 else if (opts
->action
== REPLAY_REVERT
)
429 advise(_("After resolving the conflicts, mark them with\n"
430 "\"git add/rm <pathspec>\", then run\n"
431 "\"git revert --continue\".\n"
432 "You can instead skip this commit with \"git revert --skip\".\n"
433 "To abort and get back to the state before \"git revert\",\n"
434 "run \"git revert --abort\"."));
436 BUG("unexpected pick action in print_advice()");
440 static int write_message(const void *buf
, size_t len
, const char *filename
,
443 struct lock_file msg_file
= LOCK_INIT
;
445 int msg_fd
= hold_lock_file_for_update(&msg_file
, filename
, 0);
447 return error_errno(_("could not lock '%s'"), filename
);
448 if (write_in_full(msg_fd
, buf
, len
) < 0) {
449 error_errno(_("could not write to '%s'"), filename
);
450 rollback_lock_file(&msg_file
);
453 if (append_eol
&& write(msg_fd
, "\n", 1) < 0) {
454 error_errno(_("could not write eol to '%s'"), filename
);
455 rollback_lock_file(&msg_file
);
458 if (commit_lock_file(&msg_file
) < 0)
459 return error(_("failed to finalize '%s'"), filename
);
464 int read_oneliner(struct strbuf
*buf
,
465 const char *path
, unsigned flags
)
467 int orig_len
= buf
->len
;
469 if (strbuf_read_file(buf
, path
, 0) < 0) {
470 if ((flags
& READ_ONELINER_WARN_MISSING
) ||
471 (errno
!= ENOENT
&& errno
!= ENOTDIR
))
472 warning_errno(_("could not read '%s'"), path
);
476 if (buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\n') {
477 if (--buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\r')
479 buf
->buf
[buf
->len
] = '\0';
482 if ((flags
& READ_ONELINER_SKIP_IF_EMPTY
) && buf
->len
== orig_len
)
488 static struct tree
*empty_tree(struct repository
*r
)
490 return lookup_tree(r
, the_hash_algo
->empty_tree
);
493 static int error_dirty_index(struct repository
*repo
, struct replay_opts
*opts
)
495 if (repo_read_index_unmerged(repo
))
496 return error_resolve_conflict(_(action_name(opts
)));
498 error(_("your local changes would be overwritten by %s."),
499 _(action_name(opts
)));
501 if (advice_enabled(ADVICE_COMMIT_BEFORE_MERGE
))
502 advise(_("commit your changes or stash them to proceed."));
506 static void update_abort_safety_file(void)
508 struct object_id head
;
510 /* Do nothing on a single-pick */
511 if (!file_exists(git_path_seq_dir()))
514 if (!get_oid("HEAD", &head
))
515 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head
));
517 write_file(git_path_abort_safety_file(), "%s", "");
520 static int fast_forward_to(struct repository
*r
,
521 const struct object_id
*to
,
522 const struct object_id
*from
,
524 struct replay_opts
*opts
)
526 struct ref_transaction
*transaction
;
527 struct strbuf sb
= STRBUF_INIT
;
528 struct strbuf err
= STRBUF_INIT
;
531 if (checkout_fast_forward(r
, from
, to
, 1))
532 return -1; /* the callee should have complained already */
534 strbuf_addf(&sb
, _("%s: fast-forward"), _(action_name(opts
)));
536 transaction
= ref_transaction_begin(&err
);
538 ref_transaction_update(transaction
, "HEAD",
539 to
, unborn
&& !is_rebase_i(opts
) ?
542 ref_transaction_commit(transaction
, &err
)) {
543 ref_transaction_free(transaction
);
544 error("%s", err
.buf
);
546 strbuf_release(&err
);
551 strbuf_release(&err
);
552 ref_transaction_free(transaction
);
553 update_abort_safety_file();
557 enum commit_msg_cleanup_mode
get_cleanup_mode(const char *cleanup_arg
,
560 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
561 return use_editor
? COMMIT_MSG_CLEANUP_ALL
:
562 COMMIT_MSG_CLEANUP_SPACE
;
563 else if (!strcmp(cleanup_arg
, "verbatim"))
564 return COMMIT_MSG_CLEANUP_NONE
;
565 else if (!strcmp(cleanup_arg
, "whitespace"))
566 return COMMIT_MSG_CLEANUP_SPACE
;
567 else if (!strcmp(cleanup_arg
, "strip"))
568 return COMMIT_MSG_CLEANUP_ALL
;
569 else if (!strcmp(cleanup_arg
, "scissors"))
570 return use_editor
? COMMIT_MSG_CLEANUP_SCISSORS
:
571 COMMIT_MSG_CLEANUP_SPACE
;
573 die(_("Invalid cleanup mode %s"), cleanup_arg
);
577 * NB using int rather than enum cleanup_mode to stop clang's
578 * -Wtautological-constant-out-of-range-compare complaining that the comparison
581 static const char *describe_cleanup_mode(int cleanup_mode
)
583 static const char *modes
[] = { "whitespace",
588 if (cleanup_mode
< ARRAY_SIZE(modes
))
589 return modes
[cleanup_mode
];
591 BUG("invalid cleanup_mode provided (%d)", cleanup_mode
);
594 void append_conflicts_hint(struct index_state
*istate
,
595 struct strbuf
*msgbuf
, enum commit_msg_cleanup_mode cleanup_mode
)
599 if (cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
) {
600 strbuf_addch(msgbuf
, '\n');
601 wt_status_append_cut_line(msgbuf
);
602 strbuf_addch(msgbuf
, comment_line_char
);
605 strbuf_addch(msgbuf
, '\n');
606 strbuf_commented_addf(msgbuf
, "Conflicts:\n");
607 for (i
= 0; i
< istate
->cache_nr
;) {
608 const struct cache_entry
*ce
= istate
->cache
[i
++];
610 strbuf_commented_addf(msgbuf
, "\t%s\n", ce
->name
);
611 while (i
< istate
->cache_nr
&&
612 !strcmp(ce
->name
, istate
->cache
[i
]->name
))
618 static int do_recursive_merge(struct repository
*r
,
619 struct commit
*base
, struct commit
*next
,
620 const char *base_label
, const char *next_label
,
621 struct object_id
*head
, struct strbuf
*msgbuf
,
622 struct replay_opts
*opts
)
624 struct merge_options o
;
625 struct merge_result result
;
626 struct tree
*next_tree
, *base_tree
, *head_tree
;
627 int clean
, show_output
;
629 struct lock_file index_lock
= LOCK_INIT
;
631 if (repo_hold_locked_index(r
, &index_lock
, LOCK_REPORT_ON_ERROR
) < 0)
636 init_merge_options(&o
, r
);
637 o
.ancestor
= base
? base_label
: "(empty tree)";
639 o
.branch2
= next
? next_label
: "(empty tree)";
640 if (is_rebase_i(opts
))
642 o
.show_rename_progress
= 1;
644 head_tree
= parse_tree_indirect(head
);
645 next_tree
= next
? get_commit_tree(next
) : empty_tree(r
);
646 base_tree
= base
? get_commit_tree(base
) : empty_tree(r
);
648 for (i
= 0; i
< opts
->xopts_nr
; i
++)
649 parse_merge_opt(&o
, opts
->xopts
[i
]);
651 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
652 memset(&result
, 0, sizeof(result
));
653 merge_incore_nonrecursive(&o
, base_tree
, head_tree
, next_tree
,
655 show_output
= !is_rebase_i(opts
) || !result
.clean
;
657 * TODO: merge_switch_to_result will update index/working tree;
658 * we only really want to do that if !result.clean || this is
659 * the final patch to be picked. But determining this is the
660 * final patch would take some work, and "head_tree" would need
661 * to be replace with the tree the index matched before we
662 * started doing any picks.
664 merge_switch_to_result(&o
, head_tree
, &result
, 1, show_output
);
665 clean
= result
.clean
;
667 clean
= merge_trees(&o
, head_tree
, next_tree
, base_tree
);
668 if (is_rebase_i(opts
) && clean
<= 0)
669 fputs(o
.obuf
.buf
, stdout
);
670 strbuf_release(&o
.obuf
);
673 rollback_lock_file(&index_lock
);
677 if (write_locked_index(r
->index
, &index_lock
,
678 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
680 * TRANSLATORS: %s will be "revert", "cherry-pick" or
683 return error(_("%s: Unable to write new index file"),
684 _(action_name(opts
)));
687 append_conflicts_hint(r
->index
, msgbuf
,
688 opts
->default_msg_cleanup
);
693 static struct object_id
*get_cache_tree_oid(struct index_state
*istate
)
695 if (!cache_tree_fully_valid(istate
->cache_tree
))
696 if (cache_tree_update(istate
, 0)) {
697 error(_("unable to update cache tree"));
701 return &istate
->cache_tree
->oid
;
704 static int is_index_unchanged(struct repository
*r
)
706 struct object_id head_oid
, *cache_tree_oid
;
707 struct commit
*head_commit
;
708 struct index_state
*istate
= r
->index
;
710 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
711 return error(_("could not resolve HEAD commit"));
713 head_commit
= lookup_commit(r
, &head_oid
);
716 * If head_commit is NULL, check_commit, called from
717 * lookup_commit, would have indicated that head_commit is not
718 * a commit object already. parse_commit() will return failure
719 * without further complaints in such a case. Otherwise, if
720 * the commit is invalid, parse_commit() will complain. So
721 * there is nothing for us to say here. Just return failure.
723 if (parse_commit(head_commit
))
726 if (!(cache_tree_oid
= get_cache_tree_oid(istate
)))
729 return oideq(cache_tree_oid
, get_commit_tree_oid(head_commit
));
732 static int write_author_script(const char *message
)
734 struct strbuf buf
= STRBUF_INIT
;
739 if (!*message
|| starts_with(message
, "\n")) {
741 /* Missing 'author' line? */
742 unlink(rebase_path_author_script());
744 } else if (skip_prefix(message
, "author ", &message
))
746 else if ((eol
= strchr(message
, '\n')))
751 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
752 while (*message
&& *message
!= '\n' && *message
!= '\r')
753 if (skip_prefix(message
, " <", &message
))
755 else if (*message
!= '\'')
756 strbuf_addch(&buf
, *(message
++));
758 strbuf_addf(&buf
, "'\\%c'", *(message
++));
759 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
760 while (*message
&& *message
!= '\n' && *message
!= '\r')
761 if (skip_prefix(message
, "> ", &message
))
763 else if (*message
!= '\'')
764 strbuf_addch(&buf
, *(message
++));
766 strbuf_addf(&buf
, "'\\%c'", *(message
++));
767 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
768 while (*message
&& *message
!= '\n' && *message
!= '\r')
769 if (*message
!= '\'')
770 strbuf_addch(&buf
, *(message
++));
772 strbuf_addf(&buf
, "'\\%c'", *(message
++));
773 strbuf_addch(&buf
, '\'');
774 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
775 strbuf_release(&buf
);
780 * Take a series of KEY='VALUE' lines where VALUE part is
781 * sq-quoted, and append <KEY, VALUE> at the end of the string list
783 static int parse_key_value_squoted(char *buf
, struct string_list
*list
)
786 struct string_list_item
*item
;
788 char *cp
= strchr(buf
, '=');
790 np
= strchrnul(buf
, '\n');
791 return error(_("no key present in '%.*s'"),
792 (int) (np
- buf
), buf
);
794 np
= strchrnul(cp
, '\n');
796 item
= string_list_append(list
, buf
);
798 buf
= np
+ (*np
== '\n');
802 return error(_("unable to dequote value of '%s'"),
804 item
->util
= xstrdup(cp
);
810 * Reads and parses the state directory's "author-script" file, and sets name,
811 * email and date accordingly.
812 * Returns 0 on success, -1 if the file could not be parsed.
814 * The author script is of the format:
816 * GIT_AUTHOR_NAME='$author_name'
817 * GIT_AUTHOR_EMAIL='$author_email'
818 * GIT_AUTHOR_DATE='$author_date'
820 * where $author_name, $author_email and $author_date are quoted. We are strict
821 * with our parsing, as the file was meant to be eval'd in the now-removed
822 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
823 * from what this function expects, it is better to bail out than to do
824 * something that the user does not expect.
826 int read_author_script(const char *path
, char **name
, char **email
, char **date
,
829 struct strbuf buf
= STRBUF_INIT
;
830 struct string_list kv
= STRING_LIST_INIT_DUP
;
831 int retval
= -1; /* assume failure */
832 int i
, name_i
= -2, email_i
= -2, date_i
= -2, err
= 0;
834 if (strbuf_read_file(&buf
, path
, 256) <= 0) {
835 strbuf_release(&buf
);
836 if (errno
== ENOENT
&& allow_missing
)
839 return error_errno(_("could not open '%s' for reading"),
843 if (parse_key_value_squoted(buf
.buf
, &kv
))
846 for (i
= 0; i
< kv
.nr
; i
++) {
847 if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_NAME")) {
849 name_i
= error(_("'GIT_AUTHOR_NAME' already given"));
852 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_EMAIL")) {
854 email_i
= error(_("'GIT_AUTHOR_EMAIL' already given"));
857 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_DATE")) {
859 date_i
= error(_("'GIT_AUTHOR_DATE' already given"));
863 err
= error(_("unknown variable '%s'"),
868 error(_("missing 'GIT_AUTHOR_NAME'"));
870 error(_("missing 'GIT_AUTHOR_EMAIL'"));
872 error(_("missing 'GIT_AUTHOR_DATE'"));
873 if (date_i
< 0 || email_i
< 0 || date_i
< 0 || err
)
875 *name
= kv
.items
[name_i
].util
;
876 *email
= kv
.items
[email_i
].util
;
877 *date
= kv
.items
[date_i
].util
;
880 string_list_clear(&kv
, !!retval
);
881 strbuf_release(&buf
);
886 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
887 * file with shell quoting into struct strvec. Returns -1 on
888 * error, 0 otherwise.
890 static int read_env_script(struct strvec
*env
)
892 char *name
, *email
, *date
;
894 if (read_author_script(rebase_path_author_script(),
895 &name
, &email
, &date
, 0))
898 strvec_pushf(env
, "GIT_AUTHOR_NAME=%s", name
);
899 strvec_pushf(env
, "GIT_AUTHOR_EMAIL=%s", email
);
900 strvec_pushf(env
, "GIT_AUTHOR_DATE=%s", date
);
908 static char *get_author(const char *message
)
913 a
= find_commit_header(message
, "author", &len
);
915 return xmemdupz(a
, len
);
920 static const char *author_date_from_env_array(const struct strvec
*env
)
925 for (i
= 0; i
< env
->nr
; i
++)
926 if (skip_prefix(env
->v
[i
],
927 "GIT_AUTHOR_DATE=", &date
))
930 * If GIT_AUTHOR_DATE is missing we should have already errored out when
933 BUG("GIT_AUTHOR_DATE missing from author script");
936 static const char staged_changes_advice
[] =
937 N_("you have staged changes in your working tree\n"
938 "If these changes are meant to be squashed into the previous commit, run:\n"
940 " git commit --amend %s\n"
942 "If they are meant to go into a new commit, run:\n"
946 "In both cases, once you're done, continue with:\n"
948 " git rebase --continue\n");
950 #define ALLOW_EMPTY (1<<0)
951 #define EDIT_MSG (1<<1)
952 #define AMEND_MSG (1<<2)
953 #define CLEANUP_MSG (1<<3)
954 #define VERIFY_MSG (1<<4)
955 #define CREATE_ROOT_COMMIT (1<<5)
956 #define VERBATIM_MSG (1<<6)
958 static int run_command_silent_on_success(struct child_process
*cmd
)
960 struct strbuf buf
= STRBUF_INIT
;
963 cmd
->stdout_to_stderr
= 1;
964 rc
= pipe_command(cmd
,
970 fputs(buf
.buf
, stderr
);
971 strbuf_release(&buf
);
976 * If we are cherry-pick, and if the merge did not result in
977 * hand-editing, we will hit this commit and inherit the original
978 * author date and name.
980 * If we are revert, or if our cherry-pick results in a hand merge,
981 * we had better say that the current user is responsible for that.
983 * An exception is when run_git_commit() is called during an
984 * interactive rebase: in that case, we will want to retain the
987 static int run_git_commit(const char *defmsg
,
988 struct replay_opts
*opts
,
991 struct child_process cmd
= CHILD_PROCESS_INIT
;
993 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
994 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
998 if (is_rebase_i(opts
) && !(!defmsg
&& (flags
& AMEND_MSG
)) &&
999 read_env_script(&cmd
.env_array
)) {
1000 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
1002 return error(_(staged_changes_advice
),
1006 if (opts
->committer_date_is_author_date
)
1007 strvec_pushf(&cmd
.env_array
, "GIT_COMMITTER_DATE=%s",
1010 author_date_from_env_array(&cmd
.env_array
));
1011 if (opts
->ignore_date
)
1012 strvec_push(&cmd
.env_array
, "GIT_AUTHOR_DATE=");
1014 strvec_push(&cmd
.args
, "commit");
1016 if (!(flags
& VERIFY_MSG
))
1017 strvec_push(&cmd
.args
, "-n");
1018 if ((flags
& AMEND_MSG
))
1019 strvec_push(&cmd
.args
, "--amend");
1021 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
1023 strvec_push(&cmd
.args
, "--no-gpg-sign");
1025 strvec_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
1026 else if (!(flags
& EDIT_MSG
))
1027 strvec_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
1028 if ((flags
& CLEANUP_MSG
))
1029 strvec_push(&cmd
.args
, "--cleanup=strip");
1030 if ((flags
& VERBATIM_MSG
))
1031 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1032 if ((flags
& EDIT_MSG
))
1033 strvec_push(&cmd
.args
, "-e");
1034 else if (!(flags
& CLEANUP_MSG
) &&
1035 !opts
->signoff
&& !opts
->record_origin
&&
1036 !opts
->explicit_cleanup
)
1037 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1039 if ((flags
& ALLOW_EMPTY
))
1040 strvec_push(&cmd
.args
, "--allow-empty");
1042 if (!(flags
& EDIT_MSG
))
1043 strvec_push(&cmd
.args
, "--allow-empty-message");
1045 if (is_rebase_i(opts
) && !(flags
& EDIT_MSG
))
1046 return run_command_silent_on_success(&cmd
);
1048 return run_command(&cmd
);
1051 static int rest_is_empty(const struct strbuf
*sb
, int start
)
1056 /* Check if the rest is just whitespace and Signed-off-by's. */
1057 for (i
= start
; i
< sb
->len
; i
++) {
1058 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1064 if (strlen(sign_off_header
) <= eol
- i
&&
1065 starts_with(sb
->buf
+ i
, sign_off_header
)) {
1070 if (!isspace(sb
->buf
[i
++]))
1077 void cleanup_message(struct strbuf
*msgbuf
,
1078 enum commit_msg_cleanup_mode cleanup_mode
, int verbose
)
1080 if (verbose
|| /* Truncate the message just before the diff, if any. */
1081 cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
1082 strbuf_setlen(msgbuf
, wt_status_locate_end(msgbuf
->buf
, msgbuf
->len
));
1083 if (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
)
1084 strbuf_stripspace(msgbuf
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1088 * Find out if the message in the strbuf contains only whitespace and
1089 * Signed-off-by lines.
1091 int message_is_empty(const struct strbuf
*sb
,
1092 enum commit_msg_cleanup_mode cleanup_mode
)
1094 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1096 return rest_is_empty(sb
, 0);
1100 * See if the user edited the message in the editor or left what
1101 * was in the template intact
1103 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
1104 enum commit_msg_cleanup_mode cleanup_mode
)
1106 struct strbuf tmpl
= STRBUF_INIT
;
1109 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1112 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
1115 strbuf_stripspace(&tmpl
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1116 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
1118 strbuf_release(&tmpl
);
1119 return rest_is_empty(sb
, start
- sb
->buf
);
1122 int update_head_with_reflog(const struct commit
*old_head
,
1123 const struct object_id
*new_head
,
1124 const char *action
, const struct strbuf
*msg
,
1127 struct ref_transaction
*transaction
;
1128 struct strbuf sb
= STRBUF_INIT
;
1133 strbuf_addstr(&sb
, action
);
1134 strbuf_addstr(&sb
, ": ");
1137 nl
= strchr(msg
->buf
, '\n');
1139 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
1141 strbuf_addbuf(&sb
, msg
);
1142 strbuf_addch(&sb
, '\n');
1145 transaction
= ref_transaction_begin(err
);
1147 ref_transaction_update(transaction
, "HEAD", new_head
,
1148 old_head
? &old_head
->object
.oid
: null_oid(),
1150 ref_transaction_commit(transaction
, err
)) {
1153 ref_transaction_free(transaction
);
1154 strbuf_release(&sb
);
1159 static int run_rewrite_hook(const struct object_id
*oldoid
,
1160 const struct object_id
*newoid
)
1162 struct child_process proc
= CHILD_PROCESS_INIT
;
1163 const char *argv
[3];
1165 struct strbuf sb
= STRBUF_INIT
;
1167 argv
[0] = find_hook("post-rewrite");
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
;
1284 commit
= lookup_commit(r
, oid
);
1286 die(_("couldn't look up newly created commit"));
1287 if (parse_commit(commit
))
1288 die(_("could not parse newly created commit"));
1290 strbuf_addstr(&format
, "format:%h] %s");
1292 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1293 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1294 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1295 strbuf_addstr(&format
, "\n Author: ");
1296 strbuf_addbuf_percentquote(&format
, &author_ident
);
1298 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
1299 struct strbuf date
= STRBUF_INIT
;
1301 format_commit_message(commit
, "%ad", &date
, &pctx
);
1302 strbuf_addstr(&format
, "\n Date: ");
1303 strbuf_addbuf_percentquote(&format
, &date
);
1304 strbuf_release(&date
);
1306 if (!committer_ident_sufficiently_given()) {
1307 strbuf_addstr(&format
, "\n Committer: ");
1308 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1309 if (advice_enabled(ADVICE_IMPLICIT_IDENTITY
)) {
1310 strbuf_addch(&format
, '\n');
1311 strbuf_addstr(&format
, implicit_ident_advice());
1314 strbuf_release(&author_ident
);
1315 strbuf_release(&committer_ident
);
1317 repo_init_revisions(r
, &rev
, prefix
);
1318 setup_revisions(0, NULL
, &rev
, NULL
);
1321 rev
.diffopt
.output_format
=
1322 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1324 rev
.verbose_header
= 1;
1325 rev
.show_root_diff
= 1;
1326 get_commit_format(format
.buf
, &rev
);
1327 rev
.always_show_header
= 0;
1328 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1329 rev
.diffopt
.break_opt
= 0;
1330 diff_setup_done(&rev
.diffopt
);
1332 head
= resolve_ref_unsafe("HEAD", 0, NULL
, NULL
);
1334 die_errno(_("unable to resolve HEAD after creating commit"));
1335 if (!strcmp(head
, "HEAD"))
1336 head
= _("detached HEAD");
1338 skip_prefix(head
, "refs/heads/", &head
);
1339 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1340 _(" (root-commit)") : "");
1342 if (!log_tree_commit(&rev
, commit
)) {
1343 rev
.always_show_header
= 1;
1344 rev
.use_terminator
= 1;
1345 log_tree_commit(&rev
, commit
);
1348 strbuf_release(&format
);
1351 static int parse_head(struct repository
*r
, struct commit
**head
)
1353 struct commit
*current_head
;
1354 struct object_id oid
;
1356 if (get_oid("HEAD", &oid
)) {
1357 current_head
= NULL
;
1359 current_head
= lookup_commit_reference(r
, &oid
);
1361 return error(_("could not parse HEAD"));
1362 if (!oideq(&oid
, ¤t_head
->object
.oid
)) {
1363 warning(_("HEAD %s is not a commit!"),
1366 if (parse_commit(current_head
))
1367 return error(_("could not parse HEAD commit"));
1369 *head
= current_head
;
1375 * Try to commit without forking 'git commit'. In some cases we need
1376 * to run 'git commit' to display an error message
1379 * -1 - error unable to commit
1381 * 1 - run 'git commit'
1383 static int try_to_commit(struct repository
*r
,
1384 struct strbuf
*msg
, const char *author
,
1385 struct replay_opts
*opts
, unsigned int flags
,
1386 struct object_id
*oid
)
1388 struct object_id tree
;
1389 struct commit
*current_head
= NULL
;
1390 struct commit_list
*parents
= NULL
;
1391 struct commit_extra_header
*extra
= NULL
;
1392 struct strbuf err
= STRBUF_INIT
;
1393 struct strbuf commit_msg
= STRBUF_INIT
;
1394 char *amend_author
= NULL
;
1395 const char *committer
= NULL
;
1396 const char *hook_commit
= NULL
;
1397 enum commit_msg_cleanup_mode cleanup
;
1400 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1401 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1403 if (parse_head(r
, ¤t_head
))
1406 if (flags
& AMEND_MSG
) {
1407 const char *exclude_gpgsig
[] = { "gpgsig", "gpgsig-sha256", NULL
};
1408 const char *out_enc
= get_commit_output_encoding();
1409 const char *message
= logmsg_reencode(current_head
, NULL
,
1413 const char *orig_message
= NULL
;
1415 find_commit_subject(message
, &orig_message
);
1417 strbuf_addstr(msg
, orig_message
);
1418 hook_commit
= "HEAD";
1420 author
= amend_author
= get_author(message
);
1421 unuse_commit_buffer(current_head
, message
);
1423 res
= error(_("unable to parse commit author"));
1426 parents
= copy_commit_list(current_head
->parents
);
1427 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1428 } else if (current_head
&&
1429 (!(flags
& CREATE_ROOT_COMMIT
) || (flags
& AMEND_MSG
))) {
1430 commit_list_insert(current_head
, &parents
);
1433 if (write_index_as_tree(&tree
, r
->index
, r
->index_file
, 0, NULL
)) {
1434 res
= error(_("git write-tree failed to write a tree"));
1438 if (!(flags
& ALLOW_EMPTY
)) {
1439 struct commit
*first_parent
= current_head
;
1441 if (flags
& AMEND_MSG
) {
1442 if (current_head
->parents
) {
1443 first_parent
= current_head
->parents
->item
;
1444 if (repo_parse_commit(r
, first_parent
)) {
1445 res
= error(_("could not parse HEAD commit"));
1449 first_parent
= NULL
;
1452 if (oideq(first_parent
1453 ? get_commit_tree_oid(first_parent
)
1454 : the_hash_algo
->empty_tree
,
1456 res
= 1; /* run 'git commit' to display error message */
1461 if (find_hook("prepare-commit-msg")) {
1462 res
= run_prepare_commit_msg_hook(r
, msg
, hook_commit
);
1465 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1467 res
= error_errno(_("unable to read commit message "
1469 git_path_commit_editmsg());
1475 if (flags
& CLEANUP_MSG
)
1476 cleanup
= COMMIT_MSG_CLEANUP_ALL
;
1477 else if (flags
& VERBATIM_MSG
)
1478 cleanup
= COMMIT_MSG_CLEANUP_NONE
;
1479 else if ((opts
->signoff
|| opts
->record_origin
) &&
1480 !opts
->explicit_cleanup
)
1481 cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
1483 cleanup
= opts
->default_msg_cleanup
;
1485 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1486 strbuf_stripspace(msg
, cleanup
== COMMIT_MSG_CLEANUP_ALL
);
1487 if ((flags
& EDIT_MSG
) && message_is_empty(msg
, cleanup
)) {
1488 res
= 1; /* run 'git commit' to display error message */
1492 if (opts
->committer_date_is_author_date
) {
1493 struct ident_split id
;
1494 struct strbuf date
= STRBUF_INIT
;
1496 if (!opts
->ignore_date
) {
1497 if (split_ident_line(&id
, author
, (int)strlen(author
)) < 0) {
1498 res
= error(_("invalid author identity '%s'"),
1502 if (!id
.date_begin
) {
1504 "corrupt author: missing date information"));
1507 strbuf_addf(&date
, "@%.*s %.*s",
1508 (int)(id
.date_end
- id
.date_begin
),
1510 (int)(id
.tz_end
- id
.tz_begin
),
1515 committer
= fmt_ident(getenv("GIT_COMMITTER_NAME"),
1516 getenv("GIT_COMMITTER_EMAIL"),
1517 WANT_COMMITTER_IDENT
,
1518 opts
->ignore_date
? NULL
: date
.buf
,
1520 strbuf_release(&date
);
1525 if (opts
->ignore_date
) {
1526 struct ident_split id
;
1529 if (split_ident_line(&id
, author
, strlen(author
)) < 0) {
1530 error(_("invalid author identity '%s'"), author
);
1533 name
= xmemdupz(id
.name_begin
, id
.name_end
- id
.name_begin
);
1534 email
= xmemdupz(id
.mail_begin
, id
.mail_end
- id
.mail_begin
);
1535 author
= fmt_ident(name
, email
, WANT_AUTHOR_IDENT
, NULL
,
1541 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
, oid
,
1542 author
, committer
, opts
->gpg_sign
, extra
)) {
1543 res
= error(_("failed to write commit object"));
1547 if (update_head_with_reflog(current_head
, oid
,
1548 getenv("GIT_REFLOG_ACTION"), msg
, &err
)) {
1549 res
= error("%s", err
.buf
);
1553 run_commit_hook(0, r
->index_file
, "post-commit", NULL
);
1554 if (flags
& AMEND_MSG
)
1555 commit_post_rewrite(r
, current_head
, oid
);
1558 free_commit_extra_headers(extra
);
1559 strbuf_release(&err
);
1560 strbuf_release(&commit_msg
);
1566 static int write_rebase_head(struct object_id
*oid
)
1568 if (update_ref("rebase", "REBASE_HEAD", oid
,
1569 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1570 return error(_("could not update %s"), "REBASE_HEAD");
1575 static int do_commit(struct repository
*r
,
1576 const char *msg_file
, const char *author
,
1577 struct replay_opts
*opts
, unsigned int flags
,
1578 struct object_id
*oid
)
1582 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
)) {
1583 struct object_id oid
;
1584 struct strbuf sb
= STRBUF_INIT
;
1586 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1587 return error_errno(_("unable to read commit message "
1591 res
= try_to_commit(r
, msg_file
? &sb
: NULL
,
1592 author
, opts
, flags
, &oid
);
1593 strbuf_release(&sb
);
1595 refs_delete_ref(get_main_ref_store(r
), "",
1596 "CHERRY_PICK_HEAD", NULL
, 0);
1597 unlink(git_path_merge_msg(r
));
1598 if (!is_rebase_i(opts
))
1599 print_commit_summary(r
, NULL
, &oid
,
1600 SUMMARY_SHOW_AUTHOR_DATE
);
1605 if (is_rebase_i(opts
) && oid
)
1606 if (write_rebase_head(oid
))
1608 return run_git_commit(msg_file
, opts
, flags
);
1614 static int is_original_commit_empty(struct commit
*commit
)
1616 const struct object_id
*ptree_oid
;
1618 if (parse_commit(commit
))
1619 return error(_("could not parse commit %s"),
1620 oid_to_hex(&commit
->object
.oid
));
1621 if (commit
->parents
) {
1622 struct commit
*parent
= commit
->parents
->item
;
1623 if (parse_commit(parent
))
1624 return error(_("could not parse parent commit %s"),
1625 oid_to_hex(&parent
->object
.oid
));
1626 ptree_oid
= get_commit_tree_oid(parent
);
1628 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1631 return oideq(ptree_oid
, get_commit_tree_oid(commit
));
1635 * Should empty commits be allowed? Return status:
1636 * <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1637 * 0: Halt on empty commit
1638 * 1: Allow empty commit
1639 * 2: Drop empty commit
1641 static int allow_empty(struct repository
*r
,
1642 struct replay_opts
*opts
,
1643 struct commit
*commit
)
1645 int index_unchanged
, originally_empty
;
1650 * (1) we do not allow empty at all and error out.
1652 * (2) we allow ones that were initially empty, and
1653 * just drop the ones that become empty
1655 * (3) we allow ones that were initially empty, but
1656 * halt for the ones that become empty;
1658 * (4) we allow both.
1660 if (!opts
->allow_empty
)
1661 return 0; /* let "git commit" barf as necessary */
1663 index_unchanged
= is_index_unchanged(r
);
1664 if (index_unchanged
< 0)
1665 return index_unchanged
;
1666 if (!index_unchanged
)
1667 return 0; /* we do not have to say --allow-empty */
1669 if (opts
->keep_redundant_commits
)
1672 originally_empty
= is_original_commit_empty(commit
);
1673 if (originally_empty
< 0)
1674 return originally_empty
;
1675 if (originally_empty
)
1677 else if (opts
->drop_redundant_commits
)
1686 } todo_command_info
[] = {
1703 static const char *command_to_string(const enum todo_command command
)
1705 if (command
< TODO_COMMENT
)
1706 return todo_command_info
[command
].str
;
1707 die(_("unknown command: %d"), command
);
1710 static char command_to_char(const enum todo_command command
)
1712 if (command
< TODO_COMMENT
)
1713 return todo_command_info
[command
].c
;
1714 return comment_line_char
;
1717 static int is_noop(const enum todo_command command
)
1719 return TODO_NOOP
<= command
;
1722 static int is_fixup(enum todo_command command
)
1724 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1727 /* Does this command create a (non-merge) commit? */
1728 static int is_pick_or_similar(enum todo_command command
)
1743 enum todo_item_flags
{
1744 TODO_EDIT_MERGE_MSG
= (1 << 0),
1745 TODO_REPLACE_FIXUP_MSG
= (1 << 1),
1746 TODO_EDIT_FIXUP_MSG
= (1 << 2),
1749 static const char first_commit_msg_str
[] = N_("This is the 1st commit message:");
1750 static const char nth_commit_msg_fmt
[] = N_("This is the commit message #%d:");
1751 static const char skip_first_commit_msg_str
[] = N_("The 1st commit message will be skipped:");
1752 static const char skip_nth_commit_msg_fmt
[] = N_("The commit message #%d will be skipped:");
1753 static const char combined_commit_msg_fmt
[] = N_("This is a combination of %d commits.");
1755 static int is_fixup_flag(enum todo_command command
, unsigned flag
)
1757 return command
== TODO_FIXUP
&& ((flag
& TODO_REPLACE_FIXUP_MSG
) ||
1758 (flag
& TODO_EDIT_FIXUP_MSG
));
1762 * Wrapper around strbuf_add_commented_lines() which avoids double
1763 * commenting commit subjects.
1765 static void add_commented_lines(struct strbuf
*buf
, const void *str
, size_t len
)
1767 const char *s
= str
;
1768 while (len
> 0 && s
[0] == comment_line_char
) {
1770 const char *n
= memchr(s
, '\n', len
);
1775 strbuf_add(buf
, s
, count
);
1779 strbuf_add_commented_lines(buf
, s
, len
);
1782 /* Does the current fixup chain contain a squash command? */
1783 static int seen_squash(struct replay_opts
*opts
)
1785 return starts_with(opts
->current_fixups
.buf
, "squash") ||
1786 strstr(opts
->current_fixups
.buf
, "\nsquash");
1789 static void update_comment_bufs(struct strbuf
*buf1
, struct strbuf
*buf2
, int n
)
1791 strbuf_setlen(buf1
, 2);
1792 strbuf_addf(buf1
, _(nth_commit_msg_fmt
), n
);
1793 strbuf_addch(buf1
, '\n');
1794 strbuf_setlen(buf2
, 2);
1795 strbuf_addf(buf2
, _(skip_nth_commit_msg_fmt
), n
);
1796 strbuf_addch(buf2
, '\n');
1800 * Comment out any un-commented commit messages, updating the message comments
1801 * to say they will be skipped but do not comment out the empty lines that
1802 * surround commit messages and their comments.
1804 static void update_squash_message_for_fixup(struct strbuf
*msg
)
1806 void (*copy_lines
)(struct strbuf
*, const void *, size_t) = strbuf_add
;
1807 struct strbuf buf1
= STRBUF_INIT
, buf2
= STRBUF_INIT
;
1808 const char *s
, *start
;
1810 size_t orig_msg_len
;
1813 strbuf_addf(&buf1
, "# %s\n", _(first_commit_msg_str
));
1814 strbuf_addf(&buf2
, "# %s\n", _(skip_first_commit_msg_str
));
1815 s
= start
= orig_msg
= strbuf_detach(msg
, &orig_msg_len
);
1819 if (skip_prefix(s
, buf1
.buf
, &next
)) {
1821 * Copy the last message, preserving the blank line
1822 * preceding the current line
1824 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1825 copy_lines(msg
, start
, s
- start
- off
);
1827 strbuf_addch(msg
, '\n');
1829 * The next message needs to be commented out but the
1830 * message header is already commented out so just copy
1831 * it and the blank line that follows it.
1833 strbuf_addbuf(msg
, &buf2
);
1835 strbuf_addch(msg
, *next
++);
1837 copy_lines
= add_commented_lines
;
1838 update_comment_bufs(&buf1
, &buf2
, ++i
);
1839 } else if (skip_prefix(s
, buf2
.buf
, &next
)) {
1840 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1841 copy_lines(msg
, start
, s
- start
- off
);
1844 copy_lines
= strbuf_add
;
1845 update_comment_bufs(&buf1
, &buf2
, ++i
);
1847 s
= strchr(s
, '\n');
1852 copy_lines(msg
, start
, orig_msg_len
- (start
- orig_msg
));
1854 strbuf_release(&buf1
);
1855 strbuf_release(&buf2
);
1858 static int append_squash_message(struct strbuf
*buf
, const char *body
,
1859 enum todo_command command
, struct replay_opts
*opts
,
1862 const char *fixup_msg
;
1863 size_t commented_len
= 0, fixup_off
;
1865 * amend is non-interactive and not normally used with fixup!
1866 * or squash! commits, so only comment out those subjects when
1867 * squashing commit messages.
1869 if (starts_with(body
, "amend!") ||
1870 ((command
== TODO_SQUASH
|| seen_squash(opts
)) &&
1871 (starts_with(body
, "squash!") || starts_with(body
, "fixup!"))))
1872 commented_len
= commit_subject_length(body
);
1874 strbuf_addf(buf
, "\n%c ", comment_line_char
);
1875 strbuf_addf(buf
, _(nth_commit_msg_fmt
),
1876 ++opts
->current_fixup_count
+ 1);
1877 strbuf_addstr(buf
, "\n\n");
1878 strbuf_add_commented_lines(buf
, body
, commented_len
);
1879 /* buf->buf may be reallocated so store an offset into the buffer */
1880 fixup_off
= buf
->len
;
1881 strbuf_addstr(buf
, body
+ commented_len
);
1883 /* fixup -C after squash behaves like squash */
1884 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
)) {
1886 * We're replacing the commit message so we need to
1887 * append the Signed-off-by: trailer if the user
1888 * requested '--signoff'.
1891 append_signoff(buf
, 0, 0);
1893 if ((command
== TODO_FIXUP
) &&
1894 (flag
& TODO_REPLACE_FIXUP_MSG
) &&
1895 (file_exists(rebase_path_fixup_msg()) ||
1896 !file_exists(rebase_path_squash_msg()))) {
1897 fixup_msg
= skip_blank_lines(buf
->buf
+ fixup_off
);
1898 if (write_message(fixup_msg
, strlen(fixup_msg
),
1899 rebase_path_fixup_msg(), 0) < 0)
1900 return error(_("cannot write '%s'"),
1901 rebase_path_fixup_msg());
1903 unlink(rebase_path_fixup_msg());
1906 unlink(rebase_path_fixup_msg());
1912 static int update_squash_messages(struct repository
*r
,
1913 enum todo_command command
,
1914 struct commit
*commit
,
1915 struct replay_opts
*opts
,
1918 struct strbuf buf
= STRBUF_INIT
;
1920 const char *message
, *body
;
1921 const char *encoding
= get_commit_output_encoding();
1923 if (opts
->current_fixup_count
> 0) {
1924 struct strbuf header
= STRBUF_INIT
;
1927 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
1928 return error(_("could not read '%s'"),
1929 rebase_path_squash_msg());
1931 eol
= buf
.buf
[0] != comment_line_char
?
1932 buf
.buf
: strchrnul(buf
.buf
, '\n');
1934 strbuf_addf(&header
, "%c ", comment_line_char
);
1935 strbuf_addf(&header
, _(combined_commit_msg_fmt
),
1936 opts
->current_fixup_count
+ 2);
1937 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
1938 strbuf_release(&header
);
1939 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
))
1940 update_squash_message_for_fixup(&buf
);
1942 struct object_id head
;
1943 struct commit
*head_commit
;
1944 const char *head_message
, *body
;
1946 if (get_oid("HEAD", &head
))
1947 return error(_("need a HEAD to fixup"));
1948 if (!(head_commit
= lookup_commit_reference(r
, &head
)))
1949 return error(_("could not read HEAD"));
1950 if (!(head_message
= logmsg_reencode(head_commit
, NULL
, encoding
)))
1951 return error(_("could not read HEAD's commit message"));
1953 find_commit_subject(head_message
, &body
);
1954 if (command
== TODO_FIXUP
&& !flag
&& write_message(body
, strlen(body
),
1955 rebase_path_fixup_msg(), 0) < 0) {
1956 unuse_commit_buffer(head_commit
, head_message
);
1957 return error(_("cannot write '%s'"), rebase_path_fixup_msg());
1959 strbuf_addf(&buf
, "%c ", comment_line_char
);
1960 strbuf_addf(&buf
, _(combined_commit_msg_fmt
), 2);
1961 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1962 strbuf_addstr(&buf
, is_fixup_flag(command
, flag
) ?
1963 _(skip_first_commit_msg_str
) :
1964 _(first_commit_msg_str
));
1965 strbuf_addstr(&buf
, "\n\n");
1966 if (is_fixup_flag(command
, flag
))
1967 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
1969 strbuf_addstr(&buf
, body
);
1971 unuse_commit_buffer(head_commit
, head_message
);
1974 if (!(message
= logmsg_reencode(commit
, NULL
, encoding
)))
1975 return error(_("could not read commit message of %s"),
1976 oid_to_hex(&commit
->object
.oid
));
1977 find_commit_subject(message
, &body
);
1979 if (command
== TODO_SQUASH
|| is_fixup_flag(command
, flag
)) {
1980 res
= append_squash_message(&buf
, body
, command
, opts
, flag
);
1981 } else if (command
== TODO_FIXUP
) {
1982 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1983 strbuf_addf(&buf
, _(skip_nth_commit_msg_fmt
),
1984 ++opts
->current_fixup_count
+ 1);
1985 strbuf_addstr(&buf
, "\n\n");
1986 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
1988 return error(_("unknown command: %d"), command
);
1989 unuse_commit_buffer(commit
, message
);
1992 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(),
1994 strbuf_release(&buf
);
1997 strbuf_addf(&opts
->current_fixups
, "%s%s %s",
1998 opts
->current_fixups
.len
? "\n" : "",
1999 command_to_string(command
),
2000 oid_to_hex(&commit
->object
.oid
));
2001 res
= write_message(opts
->current_fixups
.buf
,
2002 opts
->current_fixups
.len
,
2003 rebase_path_current_fixups(), 0);
2009 static void flush_rewritten_pending(void)
2011 struct strbuf buf
= STRBUF_INIT
;
2012 struct object_id newoid
;
2015 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
2016 !get_oid("HEAD", &newoid
) &&
2017 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
2018 char *bol
= buf
.buf
, *eol
;
2021 eol
= strchrnul(bol
, '\n');
2022 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
2023 bol
, oid_to_hex(&newoid
));
2029 unlink(rebase_path_rewritten_pending());
2031 strbuf_release(&buf
);
2034 static void record_in_rewritten(struct object_id
*oid
,
2035 enum todo_command next_command
)
2037 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
2042 fprintf(out
, "%s\n", oid_to_hex(oid
));
2045 if (!is_fixup(next_command
))
2046 flush_rewritten_pending();
2049 static int should_edit(struct replay_opts
*opts
) {
2052 * Note that we only handle the case of non-conflicted
2053 * commits; continue_single_pick() handles the conflicted
2054 * commits itself instead of calling this function.
2056 return (opts
->action
== REPLAY_REVERT
&& isatty(0)) ? 1 : 0;
2060 static int do_pick_commit(struct repository
*r
,
2061 struct todo_item
*item
,
2062 struct replay_opts
*opts
,
2063 int final_fixup
, int *check_todo
)
2065 unsigned int flags
= should_edit(opts
) ? EDIT_MSG
: 0;
2066 const char *msg_file
= should_edit(opts
) ? NULL
: git_path_merge_msg(r
);
2067 struct object_id head
;
2068 struct commit
*base
, *next
, *parent
;
2069 const char *base_label
, *next_label
;
2070 char *author
= NULL
;
2071 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
2072 struct strbuf msgbuf
= STRBUF_INIT
;
2073 int res
, unborn
= 0, reword
= 0, allow
, drop_commit
;
2074 enum todo_command command
= item
->command
;
2075 struct commit
*commit
= item
->commit
;
2077 if (opts
->no_commit
) {
2079 * We do not intend to commit immediately. We just want to
2080 * merge the differences in, so let's compute the tree
2081 * that represents the "current" state for the merge machinery
2084 if (write_index_as_tree(&head
, r
->index
, r
->index_file
, 0, NULL
))
2085 return error(_("your index file is unmerged."));
2087 unborn
= get_oid("HEAD", &head
);
2088 /* Do we want to generate a root commit? */
2089 if (is_pick_or_similar(command
) && opts
->have_squash_onto
&&
2090 oideq(&head
, &opts
->squash_onto
)) {
2091 if (is_fixup(command
))
2092 return error(_("cannot fixup root commit"));
2093 flags
|= CREATE_ROOT_COMMIT
;
2096 oidcpy(&head
, the_hash_algo
->empty_tree
);
2097 if (index_differs_from(r
, unborn
? empty_tree_oid_hex() : "HEAD",
2099 return error_dirty_index(r
, opts
);
2101 discard_index(r
->index
);
2103 if (!commit
->parents
)
2105 else if (commit
->parents
->next
) {
2106 /* Reverting or cherry-picking a merge commit */
2108 struct commit_list
*p
;
2110 if (!opts
->mainline
)
2111 return error(_("commit %s is a merge but no -m option was given."),
2112 oid_to_hex(&commit
->object
.oid
));
2114 for (cnt
= 1, p
= commit
->parents
;
2115 cnt
!= opts
->mainline
&& p
;
2118 if (cnt
!= opts
->mainline
|| !p
)
2119 return error(_("commit %s does not have parent %d"),
2120 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2122 } else if (1 < opts
->mainline
)
2124 * Non-first parent explicitly specified as mainline for
2127 return error(_("commit %s does not have parent %d"),
2128 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2130 parent
= commit
->parents
->item
;
2132 if (get_message(commit
, &msg
) != 0)
2133 return error(_("cannot get commit message for %s"),
2134 oid_to_hex(&commit
->object
.oid
));
2136 if (opts
->allow_ff
&& !is_fixup(command
) &&
2137 ((parent
&& oideq(&parent
->object
.oid
, &head
)) ||
2138 (!parent
&& unborn
))) {
2139 if (is_rebase_i(opts
))
2140 write_author_script(msg
.message
);
2141 res
= fast_forward_to(r
, &commit
->object
.oid
, &head
, unborn
,
2143 if (res
|| command
!= TODO_REWORD
)
2147 goto fast_forward_edit
;
2149 if (parent
&& parse_commit(parent
) < 0)
2150 /* TRANSLATORS: The first %s will be a "todo" command like
2151 "revert" or "pick", the second %s a SHA1. */
2152 return error(_("%s: cannot parse parent commit %s"),
2153 command_to_string(command
),
2154 oid_to_hex(&parent
->object
.oid
));
2157 * "commit" is an existing commit. We would want to apply
2158 * the difference it introduces since its first parent "prev"
2159 * on top of the current HEAD if we are cherry-pick. Or the
2160 * reverse of it if we are revert.
2163 if (command
== TODO_REVERT
) {
2165 base_label
= msg
.label
;
2167 next_label
= msg
.parent_label
;
2168 strbuf_addstr(&msgbuf
, "Revert \"");
2169 strbuf_addstr(&msgbuf
, msg
.subject
);
2170 strbuf_addstr(&msgbuf
, "\"\n\nThis reverts commit ");
2171 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
2173 if (commit
->parents
&& commit
->parents
->next
) {
2174 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
2175 strbuf_addstr(&msgbuf
, oid_to_hex(&parent
->object
.oid
));
2177 strbuf_addstr(&msgbuf
, ".\n");
2182 base_label
= msg
.parent_label
;
2184 next_label
= msg
.label
;
2186 /* Append the commit log message to msgbuf. */
2187 if (find_commit_subject(msg
.message
, &p
))
2188 strbuf_addstr(&msgbuf
, p
);
2190 if (opts
->record_origin
) {
2191 strbuf_complete_line(&msgbuf
);
2192 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
2193 strbuf_addch(&msgbuf
, '\n');
2194 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
2195 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
2196 strbuf_addstr(&msgbuf
, ")\n");
2198 if (!is_fixup(command
))
2199 author
= get_author(msg
.message
);
2202 if (command
== TODO_REWORD
)
2204 else if (is_fixup(command
)) {
2205 if (update_squash_messages(r
, command
, commit
,
2210 msg_file
= rebase_path_squash_msg();
2211 else if (file_exists(rebase_path_fixup_msg())) {
2212 flags
|= VERBATIM_MSG
;
2213 msg_file
= rebase_path_fixup_msg();
2215 const char *dest
= git_path_squash_msg(r
);
2217 if (copy_file(dest
, rebase_path_squash_msg(), 0666))
2218 return error(_("could not rename '%s' to '%s'"),
2219 rebase_path_squash_msg(), dest
);
2220 unlink(git_path_merge_msg(r
));
2226 if (opts
->signoff
&& !is_fixup(command
))
2227 append_signoff(&msgbuf
, 0, 0);
2229 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
2231 else if (!opts
->strategy
||
2232 !strcmp(opts
->strategy
, "recursive") ||
2233 !strcmp(opts
->strategy
, "ort") ||
2234 command
== TODO_REVERT
) {
2235 res
= do_recursive_merge(r
, base
, next
, base_label
, next_label
,
2236 &head
, &msgbuf
, opts
);
2240 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
2241 git_path_merge_msg(r
), 0);
2243 struct commit_list
*common
= NULL
;
2244 struct commit_list
*remotes
= NULL
;
2246 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
2247 git_path_merge_msg(r
), 0);
2249 commit_list_insert(base
, &common
);
2250 commit_list_insert(next
, &remotes
);
2251 res
|= try_merge_command(r
, opts
->strategy
,
2252 opts
->xopts_nr
, (const char **)opts
->xopts
,
2253 common
, oid_to_hex(&head
), remotes
);
2254 free_commit_list(common
);
2255 free_commit_list(remotes
);
2257 strbuf_release(&msgbuf
);
2260 * If the merge was clean or if it failed due to conflict, we write
2261 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
2262 * However, if the merge did not even start, then we don't want to
2265 if ((command
== TODO_PICK
|| command
== TODO_REWORD
||
2266 command
== TODO_EDIT
) && !opts
->no_commit
&&
2267 (res
== 0 || res
== 1) &&
2268 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
2269 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2271 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
2272 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
2273 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2277 error(command
== TODO_REVERT
2278 ? _("could not revert %s... %s")
2279 : _("could not apply %s... %s"),
2280 short_commit_name(commit
), msg
.subject
);
2281 print_advice(r
, res
== 1, opts
);
2282 repo_rerere(r
, opts
->allow_rerere_auto
);
2287 allow
= allow_empty(r
, opts
, commit
);
2291 } else if (allow
== 1) {
2292 flags
|= ALLOW_EMPTY
;
2293 } else if (allow
== 2) {
2295 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
2297 unlink(git_path_merge_msg(r
));
2298 unlink(git_path_auto_merge(r
));
2300 _("dropping %s %s -- patch contents already upstream\n"),
2301 oid_to_hex(&commit
->object
.oid
), msg
.subject
);
2302 } /* else allow == 0 and there's nothing special to do */
2303 if (!opts
->no_commit
&& !drop_commit
) {
2304 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
2305 res
= do_commit(r
, msg_file
, author
, opts
, flags
,
2306 commit
? &commit
->object
.oid
: NULL
);
2308 res
= error(_("unable to parse commit author"));
2309 *check_todo
= !!(flags
& EDIT_MSG
);
2310 if (!res
&& reword
) {
2312 res
= run_git_commit(NULL
, opts
, EDIT_MSG
|
2313 VERIFY_MSG
| AMEND_MSG
|
2314 (flags
& ALLOW_EMPTY
));
2320 if (!res
&& final_fixup
) {
2321 unlink(rebase_path_fixup_msg());
2322 unlink(rebase_path_squash_msg());
2323 unlink(rebase_path_current_fixups());
2324 strbuf_reset(&opts
->current_fixups
);
2325 opts
->current_fixup_count
= 0;
2329 free_message(commit
, &msg
);
2331 update_abort_safety_file();
2336 static int prepare_revs(struct replay_opts
*opts
)
2339 * picking (but not reverting) ranges (but not individual revisions)
2340 * should be done in reverse
2342 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
2343 opts
->revs
->reverse
^= 1;
2345 if (prepare_revision_walk(opts
->revs
))
2346 return error(_("revision walk setup failed"));
2351 static int read_and_refresh_cache(struct repository
*r
,
2352 struct replay_opts
*opts
)
2354 struct lock_file index_lock
= LOCK_INIT
;
2355 int index_fd
= repo_hold_locked_index(r
, &index_lock
, 0);
2356 if (repo_read_index(r
) < 0) {
2357 rollback_lock_file(&index_lock
);
2358 return error(_("git %s: failed to read the index"),
2359 _(action_name(opts
)));
2361 refresh_index(r
->index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
2362 if (index_fd
>= 0) {
2363 if (write_locked_index(r
->index
, &index_lock
,
2364 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
2365 return error(_("git %s: failed to refresh the index"),
2366 _(action_name(opts
)));
2372 void todo_list_release(struct todo_list
*todo_list
)
2374 strbuf_release(&todo_list
->buf
);
2375 FREE_AND_NULL(todo_list
->items
);
2376 todo_list
->nr
= todo_list
->alloc
= 0;
2379 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
2381 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
2382 todo_list
->total_nr
++;
2383 return todo_list
->items
+ todo_list
->nr
++;
2386 const char *todo_item_get_arg(struct todo_list
*todo_list
,
2387 struct todo_item
*item
)
2389 return todo_list
->buf
.buf
+ item
->arg_offset
;
2392 static int is_command(enum todo_command command
, const char **bol
)
2394 const char *str
= todo_command_info
[command
].str
;
2395 const char nick
= todo_command_info
[command
].c
;
2396 const char *p
= *bol
+ 1;
2398 return skip_prefix(*bol
, str
, bol
) ||
2399 ((nick
&& **bol
== nick
) &&
2400 (*p
== ' ' || *p
== '\t' || *p
== '\n' || *p
== '\r' || !*p
) &&
2404 static int parse_insn_line(struct repository
*r
, struct todo_item
*item
,
2405 const char *buf
, const char *bol
, char *eol
)
2407 struct object_id commit_oid
;
2408 char *end_of_object_name
;
2409 int i
, saved
, status
, padding
;
2414 bol
+= strspn(bol
, " \t");
2416 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
2417 item
->command
= TODO_COMMENT
;
2418 item
->commit
= NULL
;
2419 item
->arg_offset
= bol
- buf
;
2420 item
->arg_len
= eol
- bol
;
2424 for (i
= 0; i
< TODO_COMMENT
; i
++)
2425 if (is_command(i
, &bol
)) {
2429 if (i
>= TODO_COMMENT
)
2432 /* Eat up extra spaces/ tabs before object name */
2433 padding
= strspn(bol
, " \t");
2436 if (item
->command
== TODO_NOOP
|| item
->command
== TODO_BREAK
) {
2438 return error(_("%s does not accept arguments: '%s'"),
2439 command_to_string(item
->command
), bol
);
2440 item
->commit
= NULL
;
2441 item
->arg_offset
= bol
- buf
;
2442 item
->arg_len
= eol
- bol
;
2447 return error(_("missing arguments for %s"),
2448 command_to_string(item
->command
));
2450 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
2451 item
->command
== TODO_RESET
) {
2452 item
->commit
= NULL
;
2453 item
->arg_offset
= bol
- buf
;
2454 item
->arg_len
= (int)(eol
- bol
);
2458 if (item
->command
== TODO_FIXUP
) {
2459 if (skip_prefix(bol
, "-C", &bol
) &&
2460 (*bol
== ' ' || *bol
== '\t')) {
2461 bol
+= strspn(bol
, " \t");
2462 item
->flags
|= TODO_REPLACE_FIXUP_MSG
;
2463 } else if (skip_prefix(bol
, "-c", &bol
) &&
2464 (*bol
== ' ' || *bol
== '\t')) {
2465 bol
+= strspn(bol
, " \t");
2466 item
->flags
|= TODO_EDIT_FIXUP_MSG
;
2470 if (item
->command
== TODO_MERGE
) {
2471 if (skip_prefix(bol
, "-C", &bol
))
2472 bol
+= strspn(bol
, " \t");
2473 else if (skip_prefix(bol
, "-c", &bol
)) {
2474 bol
+= strspn(bol
, " \t");
2475 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2477 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2478 item
->commit
= NULL
;
2479 item
->arg_offset
= bol
- buf
;
2480 item
->arg_len
= (int)(eol
- bol
);
2485 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
2486 saved
= *end_of_object_name
;
2487 *end_of_object_name
= '\0';
2488 status
= get_oid(bol
, &commit_oid
);
2490 error(_("could not parse '%s'"), bol
); /* return later */
2491 *end_of_object_name
= saved
;
2493 bol
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2494 item
->arg_offset
= bol
- buf
;
2495 item
->arg_len
= (int)(eol
- bol
);
2500 item
->commit
= lookup_commit_reference(r
, &commit_oid
);
2501 return item
->commit
? 0 : -1;
2504 int sequencer_get_last_command(struct repository
*r
, enum replay_action
*action
)
2506 const char *todo_file
, *bol
;
2507 struct strbuf buf
= STRBUF_INIT
;
2510 todo_file
= git_path_todo_file();
2511 if (strbuf_read_file(&buf
, todo_file
, 0) < 0) {
2512 if (errno
== ENOENT
|| errno
== ENOTDIR
)
2515 return error_errno("unable to open '%s'", todo_file
);
2517 bol
= buf
.buf
+ strspn(buf
.buf
, " \t\r\n");
2518 if (is_command(TODO_PICK
, &bol
) && (*bol
== ' ' || *bol
== '\t'))
2519 *action
= REPLAY_PICK
;
2520 else if (is_command(TODO_REVERT
, &bol
) &&
2521 (*bol
== ' ' || *bol
== '\t'))
2522 *action
= REPLAY_REVERT
;
2526 strbuf_release(&buf
);
2531 int todo_list_parse_insn_buffer(struct repository
*r
, char *buf
,
2532 struct todo_list
*todo_list
)
2534 struct todo_item
*item
;
2535 char *p
= buf
, *next_p
;
2536 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2538 todo_list
->current
= todo_list
->nr
= 0;
2540 for (i
= 1; *p
; i
++, p
= next_p
) {
2541 char *eol
= strchrnul(p
, '\n');
2543 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2545 if (p
!= eol
&& eol
[-1] == '\r')
2546 eol
--; /* strip Carriage Return */
2548 item
= append_new_todo(todo_list
);
2549 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2550 if (parse_insn_line(r
, item
, buf
, p
, eol
)) {
2551 res
= error(_("invalid line %d: %.*s"),
2552 i
, (int)(eol
- p
), p
);
2553 item
->command
= TODO_COMMENT
+ 1;
2554 item
->arg_offset
= p
- buf
;
2555 item
->arg_len
= (int)(eol
- p
);
2556 item
->commit
= NULL
;
2561 else if (is_fixup(item
->command
))
2562 return error(_("cannot '%s' without a previous commit"),
2563 command_to_string(item
->command
));
2564 else if (!is_noop(item
->command
))
2571 static int count_commands(struct todo_list
*todo_list
)
2575 for (i
= 0; i
< todo_list
->nr
; i
++)
2576 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2582 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2584 return index
< todo_list
->nr
?
2585 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2588 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2590 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2593 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2595 return get_item_line_offset(todo_list
, index
+ 1)
2596 - get_item_line_offset(todo_list
, index
);
2599 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2604 fd
= open(path
, O_RDONLY
);
2606 return error_errno(_("could not open '%s'"), path
);
2607 len
= strbuf_read(sb
, fd
, 0);
2610 return error(_("could not read '%s'."), path
);
2614 static int have_finished_the_last_pick(void)
2616 struct strbuf buf
= STRBUF_INIT
;
2618 const char *todo_path
= git_path_todo_file();
2621 if (strbuf_read_file(&buf
, todo_path
, 0) < 0) {
2622 if (errno
== ENOENT
) {
2625 error_errno("unable to open '%s'", todo_path
);
2629 /* If there is only one line then we are done */
2630 eol
= strchr(buf
.buf
, '\n');
2631 if (!eol
|| !eol
[1])
2634 strbuf_release(&buf
);
2639 void sequencer_post_commit_cleanup(struct repository
*r
, int verbose
)
2641 struct replay_opts opts
= REPLAY_OPTS_INIT
;
2642 int need_cleanup
= 0;
2644 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
2645 if (!refs_delete_ref(get_main_ref_store(r
), "",
2646 "CHERRY_PICK_HEAD", NULL
, 0) &&
2648 warning(_("cancelling a cherry picking in progress"));
2649 opts
.action
= REPLAY_PICK
;
2653 if (refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
2654 if (!refs_delete_ref(get_main_ref_store(r
), "", "REVERT_HEAD",
2657 warning(_("cancelling a revert in progress"));
2658 opts
.action
= REPLAY_REVERT
;
2662 unlink(git_path_auto_merge(r
));
2667 if (!have_finished_the_last_pick())
2670 sequencer_remove_state(&opts
);
2673 static void todo_list_write_total_nr(struct todo_list
*todo_list
)
2675 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2678 fprintf(f
, "%d\n", todo_list
->total_nr
);
2683 static int read_populate_todo(struct repository
*r
,
2684 struct todo_list
*todo_list
,
2685 struct replay_opts
*opts
)
2688 const char *todo_file
= get_todo_path(opts
);
2691 strbuf_reset(&todo_list
->buf
);
2692 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2695 res
= stat(todo_file
, &st
);
2697 return error(_("could not stat '%s'"), todo_file
);
2698 fill_stat_data(&todo_list
->stat
, &st
);
2700 res
= todo_list_parse_insn_buffer(r
, todo_list
->buf
.buf
, todo_list
);
2702 if (is_rebase_i(opts
))
2703 return error(_("please fix this using "
2704 "'git rebase --edit-todo'."));
2705 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2708 if (!todo_list
->nr
&&
2709 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2710 return error(_("no commits parsed."));
2712 if (!is_rebase_i(opts
)) {
2713 enum todo_command valid
=
2714 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2717 for (i
= 0; i
< todo_list
->nr
; i
++)
2718 if (valid
== todo_list
->items
[i
].command
)
2720 else if (valid
== TODO_PICK
)
2721 return error(_("cannot cherry-pick during a revert."));
2723 return error(_("cannot revert during a cherry-pick."));
2726 if (is_rebase_i(opts
)) {
2727 struct todo_list done
= TODO_LIST_INIT
;
2729 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2730 !todo_list_parse_insn_buffer(r
, done
.buf
.buf
, &done
))
2731 todo_list
->done_nr
= count_commands(&done
);
2733 todo_list
->done_nr
= 0;
2735 todo_list
->total_nr
= todo_list
->done_nr
2736 + count_commands(todo_list
);
2737 todo_list_release(&done
);
2739 todo_list_write_total_nr(todo_list
);
2745 static int git_config_string_dup(char **dest
,
2746 const char *var
, const char *value
)
2749 return config_error_nonbool(var
);
2751 *dest
= xstrdup(value
);
2755 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
2757 struct replay_opts
*opts
= data
;
2762 else if (!strcmp(key
, "options.no-commit"))
2763 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
2764 else if (!strcmp(key
, "options.edit"))
2765 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
2766 else if (!strcmp(key
, "options.allow-empty"))
2768 git_config_bool_or_int(key
, value
, &error_flag
);
2769 else if (!strcmp(key
, "options.allow-empty-message"))
2770 opts
->allow_empty_message
=
2771 git_config_bool_or_int(key
, value
, &error_flag
);
2772 else if (!strcmp(key
, "options.keep-redundant-commits"))
2773 opts
->keep_redundant_commits
=
2774 git_config_bool_or_int(key
, value
, &error_flag
);
2775 else if (!strcmp(key
, "options.signoff"))
2776 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
2777 else if (!strcmp(key
, "options.record-origin"))
2778 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
2779 else if (!strcmp(key
, "options.allow-ff"))
2780 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
2781 else if (!strcmp(key
, "options.mainline"))
2782 opts
->mainline
= git_config_int(key
, value
);
2783 else if (!strcmp(key
, "options.strategy"))
2784 git_config_string_dup(&opts
->strategy
, key
, value
);
2785 else if (!strcmp(key
, "options.gpg-sign"))
2786 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
2787 else if (!strcmp(key
, "options.strategy-option")) {
2788 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
2789 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(value
);
2790 } else if (!strcmp(key
, "options.allow-rerere-auto"))
2791 opts
->allow_rerere_auto
=
2792 git_config_bool_or_int(key
, value
, &error_flag
) ?
2793 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
2794 else if (!strcmp(key
, "options.default-msg-cleanup")) {
2795 opts
->explicit_cleanup
= 1;
2796 opts
->default_msg_cleanup
= get_cleanup_mode(value
, 1);
2798 return error(_("invalid key: %s"), key
);
2801 return error(_("invalid value for %s: %s"), key
, value
);
2806 void parse_strategy_opts(struct replay_opts
*opts
, char *raw_opts
)
2809 char *strategy_opts_string
= raw_opts
;
2811 if (*strategy_opts_string
== ' ')
2812 strategy_opts_string
++;
2814 opts
->xopts_nr
= split_cmdline(strategy_opts_string
,
2815 (const char ***)&opts
->xopts
);
2816 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
2817 const char *arg
= opts
->xopts
[i
];
2819 skip_prefix(arg
, "--", &arg
);
2820 opts
->xopts
[i
] = xstrdup(arg
);
2824 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2827 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2829 opts
->strategy
= strbuf_detach(buf
, NULL
);
2830 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2833 parse_strategy_opts(opts
, buf
->buf
);
2836 static int read_populate_opts(struct replay_opts
*opts
)
2838 if (is_rebase_i(opts
)) {
2839 struct strbuf buf
= STRBUF_INIT
;
2842 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(),
2843 READ_ONELINER_SKIP_IF_EMPTY
)) {
2844 if (!starts_with(buf
.buf
, "-S"))
2847 free(opts
->gpg_sign
);
2848 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2853 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(),
2854 READ_ONELINER_SKIP_IF_EMPTY
)) {
2855 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2856 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2857 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2858 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2862 if (file_exists(rebase_path_verbose()))
2865 if (file_exists(rebase_path_quiet()))
2868 if (file_exists(rebase_path_signoff())) {
2873 if (file_exists(rebase_path_cdate_is_adate())) {
2875 opts
->committer_date_is_author_date
= 1;
2878 if (file_exists(rebase_path_ignore_date())) {
2880 opts
->ignore_date
= 1;
2883 if (file_exists(rebase_path_reschedule_failed_exec()))
2884 opts
->reschedule_failed_exec
= 1;
2885 else if (file_exists(rebase_path_no_reschedule_failed_exec()))
2886 opts
->reschedule_failed_exec
= 0;
2888 if (file_exists(rebase_path_drop_redundant_commits()))
2889 opts
->drop_redundant_commits
= 1;
2891 if (file_exists(rebase_path_keep_redundant_commits()))
2892 opts
->keep_redundant_commits
= 1;
2894 read_strategy_opts(opts
, &buf
);
2897 if (read_oneliner(&opts
->current_fixups
,
2898 rebase_path_current_fixups(),
2899 READ_ONELINER_SKIP_IF_EMPTY
)) {
2900 const char *p
= opts
->current_fixups
.buf
;
2901 opts
->current_fixup_count
= 1;
2902 while ((p
= strchr(p
, '\n'))) {
2903 opts
->current_fixup_count
++;
2908 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
2909 if (get_oid_committish(buf
.buf
, &opts
->squash_onto
) < 0) {
2910 ret
= error(_("unusable squash-onto"));
2913 opts
->have_squash_onto
= 1;
2917 strbuf_release(&buf
);
2921 if (!file_exists(git_path_opts_file()))
2924 * The function git_parse_source(), called from git_config_from_file(),
2925 * may die() in case of a syntactically incorrect file. We do not care
2926 * about this case, though, because we wrote that file ourselves, so we
2927 * are pretty certain that it is syntactically correct.
2929 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
2930 return error(_("malformed options sheet: '%s'"),
2931 git_path_opts_file());
2935 static void write_strategy_opts(struct replay_opts
*opts
)
2938 struct strbuf buf
= STRBUF_INIT
;
2940 for (i
= 0; i
< opts
->xopts_nr
; ++i
)
2941 strbuf_addf(&buf
, " --%s", opts
->xopts
[i
]);
2943 write_file(rebase_path_strategy_opts(), "%s\n", buf
.buf
);
2944 strbuf_release(&buf
);
2947 int write_basic_state(struct replay_opts
*opts
, const char *head_name
,
2948 struct commit
*onto
, const struct object_id
*orig_head
)
2951 write_file(rebase_path_head_name(), "%s\n", head_name
);
2953 write_file(rebase_path_onto(), "%s\n",
2954 oid_to_hex(&onto
->object
.oid
));
2956 write_file(rebase_path_orig_head(), "%s\n",
2957 oid_to_hex(orig_head
));
2960 write_file(rebase_path_quiet(), "%s", "");
2962 write_file(rebase_path_verbose(), "%s", "");
2964 write_file(rebase_path_strategy(), "%s\n", opts
->strategy
);
2965 if (opts
->xopts_nr
> 0)
2966 write_strategy_opts(opts
);
2968 if (opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
)
2969 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2970 else if (opts
->allow_rerere_auto
== RERERE_NOAUTOUPDATE
)
2971 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2974 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts
->gpg_sign
);
2976 write_file(rebase_path_signoff(), "--signoff\n");
2977 if (opts
->drop_redundant_commits
)
2978 write_file(rebase_path_drop_redundant_commits(), "%s", "");
2979 if (opts
->keep_redundant_commits
)
2980 write_file(rebase_path_keep_redundant_commits(), "%s", "");
2981 if (opts
->committer_date_is_author_date
)
2982 write_file(rebase_path_cdate_is_adate(), "%s", "");
2983 if (opts
->ignore_date
)
2984 write_file(rebase_path_ignore_date(), "%s", "");
2985 if (opts
->reschedule_failed_exec
)
2986 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
2988 write_file(rebase_path_no_reschedule_failed_exec(), "%s", "");
2993 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
2994 struct replay_opts
*opts
)
2996 enum todo_command command
= opts
->action
== REPLAY_PICK
?
2997 TODO_PICK
: TODO_REVERT
;
2998 const char *command_string
= todo_command_info
[command
].str
;
2999 const char *encoding
;
3000 struct commit
*commit
;
3002 if (prepare_revs(opts
))
3005 encoding
= get_log_output_encoding();
3007 while ((commit
= get_revision(opts
->revs
))) {
3008 struct todo_item
*item
= append_new_todo(todo_list
);
3009 const char *commit_buffer
= logmsg_reencode(commit
, NULL
, encoding
);
3010 const char *subject
;
3013 item
->command
= command
;
3014 item
->commit
= commit
;
3015 item
->arg_offset
= 0;
3017 item
->offset_in_buf
= todo_list
->buf
.len
;
3018 subject_len
= find_commit_subject(commit_buffer
, &subject
);
3019 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
3020 short_commit_name(commit
), subject_len
, subject
);
3021 unuse_commit_buffer(commit
, commit_buffer
);
3025 return error(_("empty commit set passed"));
3030 static int create_seq_dir(struct repository
*r
)
3032 enum replay_action action
;
3033 const char *in_progress_error
= NULL
;
3034 const char *in_progress_advice
= NULL
;
3035 unsigned int advise_skip
=
3036 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD") ||
3037 refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD");
3039 if (!sequencer_get_last_command(r
, &action
)) {
3042 in_progress_error
= _("revert is already in progress");
3043 in_progress_advice
=
3044 _("try \"git revert (--continue | %s--abort | --quit)\"");
3047 in_progress_error
= _("cherry-pick is already in progress");
3048 in_progress_advice
=
3049 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
3052 BUG("unexpected action in create_seq_dir");
3055 if (in_progress_error
) {
3056 error("%s", in_progress_error
);
3057 if (advice_enabled(ADVICE_SEQUENCER_IN_USE
))
3058 advise(in_progress_advice
,
3059 advise_skip
? "--skip | " : "");
3062 if (mkdir(git_path_seq_dir(), 0777) < 0)
3063 return error_errno(_("could not create sequencer directory '%s'"),
3064 git_path_seq_dir());
3069 static int save_head(const char *head
)
3071 struct lock_file head_lock
= LOCK_INIT
;
3072 struct strbuf buf
= STRBUF_INIT
;
3076 fd
= hold_lock_file_for_update(&head_lock
, git_path_head_file(), 0);
3078 return error_errno(_("could not lock HEAD"));
3079 strbuf_addf(&buf
, "%s\n", head
);
3080 written
= write_in_full(fd
, buf
.buf
, buf
.len
);
3081 strbuf_release(&buf
);
3083 error_errno(_("could not write to '%s'"), git_path_head_file());
3084 rollback_lock_file(&head_lock
);
3087 if (commit_lock_file(&head_lock
) < 0)
3088 return error(_("failed to finalize '%s'"), git_path_head_file());
3092 static int rollback_is_safe(void)
3094 struct strbuf sb
= STRBUF_INIT
;
3095 struct object_id expected_head
, actual_head
;
3097 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
3099 if (get_oid_hex(sb
.buf
, &expected_head
)) {
3100 strbuf_release(&sb
);
3101 die(_("could not parse %s"), git_path_abort_safety_file());
3103 strbuf_release(&sb
);
3105 else if (errno
== ENOENT
)
3106 oidclr(&expected_head
);
3108 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
3110 if (get_oid("HEAD", &actual_head
))
3111 oidclr(&actual_head
);
3113 return oideq(&actual_head
, &expected_head
);
3116 static int reset_merge(const struct object_id
*oid
)
3119 struct strvec argv
= STRVEC_INIT
;
3121 strvec_pushl(&argv
, "reset", "--merge", NULL
);
3123 if (!is_null_oid(oid
))
3124 strvec_push(&argv
, oid_to_hex(oid
));
3126 ret
= run_command_v_opt(argv
.v
, RUN_GIT_CMD
);
3127 strvec_clear(&argv
);
3132 static int rollback_single_pick(struct repository
*r
)
3134 struct object_id head_oid
;
3136 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
3137 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
3138 return error(_("no cherry-pick or revert in progress"));
3139 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
3140 return error(_("cannot resolve HEAD"));
3141 if (is_null_oid(&head_oid
))
3142 return error(_("cannot abort from a branch yet to be born"));
3143 return reset_merge(&head_oid
);
3146 static int skip_single_pick(void)
3148 struct object_id head
;
3150 if (read_ref_full("HEAD", 0, &head
, NULL
))
3151 return error(_("cannot resolve HEAD"));
3152 return reset_merge(&head
);
3155 int sequencer_rollback(struct repository
*r
, struct replay_opts
*opts
)
3158 struct object_id oid
;
3159 struct strbuf buf
= STRBUF_INIT
;
3162 f
= fopen(git_path_head_file(), "r");
3163 if (!f
&& errno
== ENOENT
) {
3165 * There is no multiple-cherry-pick in progress.
3166 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
3167 * a single-cherry-pick in progress, abort that.
3169 return rollback_single_pick(r
);
3172 return error_errno(_("cannot open '%s'"), git_path_head_file());
3173 if (strbuf_getline_lf(&buf
, f
)) {
3174 error(_("cannot read '%s': %s"), git_path_head_file(),
3175 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
3180 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
3181 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
3182 git_path_head_file());
3185 if (is_null_oid(&oid
)) {
3186 error(_("cannot abort from a branch yet to be born"));
3190 if (!rollback_is_safe()) {
3191 /* Do not error, just do not rollback */
3192 warning(_("You seem to have moved HEAD. "
3193 "Not rewinding, check your HEAD!"));
3195 if (reset_merge(&oid
))
3197 strbuf_release(&buf
);
3198 return sequencer_remove_state(opts
);
3200 strbuf_release(&buf
);
3204 int sequencer_skip(struct repository
*r
, struct replay_opts
*opts
)
3206 enum replay_action action
= -1;
3207 sequencer_get_last_command(r
, &action
);
3210 * Check whether the subcommand requested to skip the commit is actually
3211 * in progress and that it's safe to skip the commit.
3213 * opts->action tells us which subcommand requested to skip the commit.
3214 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
3215 * action is in progress and we can skip the commit.
3217 * Otherwise we check that the last instruction was related to the
3218 * particular subcommand we're trying to execute and barf if that's not
3221 * Finally we check that the rollback is "safe", i.e., has the HEAD
3222 * moved? In this case, it doesn't make sense to "reset the merge" and
3223 * "skip the commit" as the user already handled this by committing. But
3224 * we'd not want to barf here, instead give advice on how to proceed. We
3225 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
3226 * it gets removed when the user commits, so if it still exists we're
3227 * sure the user can't have committed before.
3229 switch (opts
->action
) {
3231 if (!refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
3232 if (action
!= REPLAY_REVERT
)
3233 return error(_("no revert in progress"));
3234 if (!rollback_is_safe())
3239 if (!refs_ref_exists(get_main_ref_store(r
),
3240 "CHERRY_PICK_HEAD")) {
3241 if (action
!= REPLAY_PICK
)
3242 return error(_("no cherry-pick in progress"));
3243 if (!rollback_is_safe())
3248 BUG("unexpected action in sequencer_skip");
3251 if (skip_single_pick())
3252 return error(_("failed to skip the commit"));
3253 if (!is_directory(git_path_seq_dir()))
3256 return sequencer_continue(r
, opts
);
3259 error(_("there is nothing to skip"));
3261 if (advice_enabled(ADVICE_RESOLVE_CONFLICT
)) {
3262 advise(_("have you committed already?\n"
3263 "try \"git %s --continue\""),
3264 action
== REPLAY_REVERT
? "revert" : "cherry-pick");
3269 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
3271 struct lock_file todo_lock
= LOCK_INIT
;
3272 const char *todo_path
= get_todo_path(opts
);
3273 int next
= todo_list
->current
, offset
, fd
;
3276 * rebase -i writes "git-rebase-todo" without the currently executing
3277 * command, appending it to "done" instead.
3279 if (is_rebase_i(opts
))
3282 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
3284 return error_errno(_("could not lock '%s'"), todo_path
);
3285 offset
= get_item_line_offset(todo_list
, next
);
3286 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
3287 todo_list
->buf
.len
- offset
) < 0)
3288 return error_errno(_("could not write to '%s'"), todo_path
);
3289 if (commit_lock_file(&todo_lock
) < 0)
3290 return error(_("failed to finalize '%s'"), todo_path
);
3292 if (is_rebase_i(opts
) && next
> 0) {
3293 const char *done
= rebase_path_done();
3294 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
3299 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
3300 get_item_line_length(todo_list
, next
- 1))
3302 ret
= error_errno(_("could not write to '%s'"), done
);
3304 ret
= error_errno(_("failed to finalize '%s'"), done
);
3310 static int save_opts(struct replay_opts
*opts
)
3312 const char *opts_file
= git_path_opts_file();
3315 if (opts
->no_commit
)
3316 res
|= git_config_set_in_file_gently(opts_file
,
3317 "options.no-commit", "true");
3318 if (opts
->edit
>= 0)
3319 res
|= git_config_set_in_file_gently(opts_file
, "options.edit",
3320 opts
->edit
? "true" : "false");
3321 if (opts
->allow_empty
)
3322 res
|= git_config_set_in_file_gently(opts_file
,
3323 "options.allow-empty", "true");
3324 if (opts
->allow_empty_message
)
3325 res
|= git_config_set_in_file_gently(opts_file
,
3326 "options.allow-empty-message", "true");
3327 if (opts
->keep_redundant_commits
)
3328 res
|= git_config_set_in_file_gently(opts_file
,
3329 "options.keep-redundant-commits", "true");
3331 res
|= git_config_set_in_file_gently(opts_file
,
3332 "options.signoff", "true");
3333 if (opts
->record_origin
)
3334 res
|= git_config_set_in_file_gently(opts_file
,
3335 "options.record-origin", "true");
3337 res
|= git_config_set_in_file_gently(opts_file
,
3338 "options.allow-ff", "true");
3339 if (opts
->mainline
) {
3340 struct strbuf buf
= STRBUF_INIT
;
3341 strbuf_addf(&buf
, "%d", opts
->mainline
);
3342 res
|= git_config_set_in_file_gently(opts_file
,
3343 "options.mainline", buf
.buf
);
3344 strbuf_release(&buf
);
3347 res
|= git_config_set_in_file_gently(opts_file
,
3348 "options.strategy", opts
->strategy
);
3350 res
|= git_config_set_in_file_gently(opts_file
,
3351 "options.gpg-sign", opts
->gpg_sign
);
3354 for (i
= 0; i
< opts
->xopts_nr
; i
++)
3355 res
|= git_config_set_multivar_in_file_gently(opts_file
,
3356 "options.strategy-option",
3357 opts
->xopts
[i
], "^$", 0);
3359 if (opts
->allow_rerere_auto
)
3360 res
|= git_config_set_in_file_gently(opts_file
,
3361 "options.allow-rerere-auto",
3362 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
3365 if (opts
->explicit_cleanup
)
3366 res
|= git_config_set_in_file_gently(opts_file
,
3367 "options.default-msg-cleanup",
3368 describe_cleanup_mode(opts
->default_msg_cleanup
));
3372 static int make_patch(struct repository
*r
,
3373 struct commit
*commit
,
3374 struct replay_opts
*opts
)
3376 struct strbuf buf
= STRBUF_INIT
;
3377 struct rev_info log_tree_opt
;
3378 const char *subject
;
3379 char hex
[GIT_MAX_HEXSZ
+ 1];
3382 oid_to_hex_r(hex
, &commit
->object
.oid
);
3383 if (write_message(hex
, strlen(hex
), rebase_path_stopped_sha(), 1) < 0)
3385 res
|= write_rebase_head(&commit
->object
.oid
);
3387 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
3388 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3389 repo_init_revisions(r
, &log_tree_opt
, NULL
);
3390 log_tree_opt
.abbrev
= 0;
3391 log_tree_opt
.diff
= 1;
3392 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
3393 log_tree_opt
.disable_stdin
= 1;
3394 log_tree_opt
.no_commit_id
= 1;
3395 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
3396 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
3397 if (!log_tree_opt
.diffopt
.file
)
3398 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
3400 res
|= log_tree_commit(&log_tree_opt
, commit
);
3401 fclose(log_tree_opt
.diffopt
.file
);
3405 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
3406 if (!file_exists(buf
.buf
)) {
3407 const char *encoding
= get_commit_output_encoding();
3408 const char *commit_buffer
= logmsg_reencode(commit
, NULL
, encoding
);
3409 find_commit_subject(commit_buffer
, &subject
);
3410 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
3411 unuse_commit_buffer(commit
, commit_buffer
);
3413 strbuf_release(&buf
);
3418 static int intend_to_amend(void)
3420 struct object_id head
;
3423 if (get_oid("HEAD", &head
))
3424 return error(_("cannot read HEAD"));
3426 p
= oid_to_hex(&head
);
3427 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
3430 static int error_with_patch(struct repository
*r
,
3431 struct commit
*commit
,
3432 const char *subject
, int subject_len
,
3433 struct replay_opts
*opts
,
3434 int exit_code
, int to_amend
)
3437 if (make_patch(r
, commit
, opts
))
3439 } else if (copy_file(rebase_path_message(),
3440 git_path_merge_msg(r
), 0666))
3441 return error(_("unable to copy '%s' to '%s'"),
3442 git_path_merge_msg(r
), rebase_path_message());
3445 if (intend_to_amend())
3449 _("You can amend the commit now, with\n"
3451 " git commit --amend %s\n"
3453 "Once you are satisfied with your changes, run\n"
3455 " git rebase --continue\n"),
3456 gpg_sign_opt_quoted(opts
));
3457 } else if (exit_code
) {
3459 fprintf_ln(stderr
, _("Could not apply %s... %.*s"),
3460 short_commit_name(commit
), subject_len
, subject
);
3463 * We don't have the hash of the parent so
3464 * just print the line from the todo file.
3466 fprintf_ln(stderr
, _("Could not merge %.*s"),
3467 subject_len
, subject
);
3473 static int error_failed_squash(struct repository
*r
,
3474 struct commit
*commit
,
3475 struct replay_opts
*opts
,
3477 const char *subject
)
3479 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3480 return error(_("could not copy '%s' to '%s'"),
3481 rebase_path_squash_msg(), rebase_path_message());
3482 unlink(git_path_merge_msg(r
));
3483 if (copy_file(git_path_merge_msg(r
), rebase_path_message(), 0666))
3484 return error(_("could not copy '%s' to '%s'"),
3485 rebase_path_message(),
3486 git_path_merge_msg(r
));
3487 return error_with_patch(r
, commit
, subject
, subject_len
, opts
, 1, 0);
3490 static int do_exec(struct repository
*r
, const char *command_line
)
3492 struct strvec child_env
= STRVEC_INIT
;
3493 const char *child_argv
[] = { NULL
, NULL
};
3496 fprintf(stderr
, _("Executing: %s\n"), command_line
);
3497 child_argv
[0] = command_line
;
3498 strvec_pushf(&child_env
, "GIT_DIR=%s", absolute_path(get_git_dir()));
3499 strvec_pushf(&child_env
, "GIT_WORK_TREE=%s",
3500 absolute_path(get_git_work_tree()));
3501 status
= run_command_v_opt_cd_env(child_argv
, RUN_USING_SHELL
, NULL
,
3504 /* force re-reading of the cache */
3505 if (discard_index(r
->index
) < 0 || repo_read_index(r
) < 0)
3506 return error(_("could not read index"));
3508 dirty
= require_clean_work_tree(r
, "rebase", NULL
, 1, 1);
3511 warning(_("execution failed: %s\n%s"
3512 "You can fix the problem, and then run\n"
3514 " git rebase --continue\n"
3517 dirty
? N_("and made changes to the index and/or the "
3518 "working tree\n") : "");
3520 /* command not found */
3523 warning(_("execution succeeded: %s\nbut "
3524 "left changes to the index and/or the working tree\n"
3525 "Commit or stash your changes, and then run\n"
3527 " git rebase --continue\n"
3528 "\n"), command_line
);
3532 strvec_clear(&child_env
);
3537 __attribute__((format (printf
, 2, 3)))
3538 static int safe_append(const char *filename
, const char *fmt
, ...)
3541 struct lock_file lock
= LOCK_INIT
;
3542 int fd
= hold_lock_file_for_update(&lock
, filename
,
3543 LOCK_REPORT_ON_ERROR
);
3544 struct strbuf buf
= STRBUF_INIT
;
3549 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
3550 error_errno(_("could not read '%s'"), filename
);
3551 rollback_lock_file(&lock
);
3554 strbuf_complete(&buf
, '\n');
3556 strbuf_vaddf(&buf
, fmt
, ap
);
3559 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
3560 error_errno(_("could not write to '%s'"), filename
);
3561 strbuf_release(&buf
);
3562 rollback_lock_file(&lock
);
3565 if (commit_lock_file(&lock
) < 0) {
3566 strbuf_release(&buf
);
3567 rollback_lock_file(&lock
);
3568 return error(_("failed to finalize '%s'"), filename
);
3571 strbuf_release(&buf
);
3575 static int do_label(struct repository
*r
, const char *name
, int len
)
3577 struct ref_store
*refs
= get_main_ref_store(r
);
3578 struct ref_transaction
*transaction
;
3579 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
3580 struct strbuf msg
= STRBUF_INIT
;
3582 struct object_id head_oid
;
3584 if (len
== 1 && *name
== '#')
3585 return error(_("illegal label name: '%.*s'"), len
, name
);
3587 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3588 strbuf_addf(&msg
, "rebase (label) '%.*s'", len
, name
);
3590 transaction
= ref_store_transaction_begin(refs
, &err
);
3592 error("%s", err
.buf
);
3594 } else if (get_oid("HEAD", &head_oid
)) {
3595 error(_("could not read HEAD"));
3597 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
3598 NULL
, 0, msg
.buf
, &err
) < 0 ||
3599 ref_transaction_commit(transaction
, &err
)) {
3600 error("%s", err
.buf
);
3603 ref_transaction_free(transaction
);
3604 strbuf_release(&err
);
3605 strbuf_release(&msg
);
3608 ret
= safe_append(rebase_path_refs_to_delete(),
3609 "%s\n", ref_name
.buf
);
3610 strbuf_release(&ref_name
);
3615 __attribute__((format (printf
, 3, 4)))
3616 static const char *reflog_message(struct replay_opts
*opts
,
3617 const char *sub_action
, const char *fmt
, ...)
3620 static struct strbuf buf
= STRBUF_INIT
;
3621 char *reflog_action
= getenv(GIT_REFLOG_ACTION
);
3625 strbuf_addstr(&buf
, reflog_action
? reflog_action
: action_name(opts
));
3627 strbuf_addf(&buf
, " (%s)", sub_action
);
3629 strbuf_addstr(&buf
, ": ");
3630 strbuf_vaddf(&buf
, fmt
, ap
);
3637 static int do_reset(struct repository
*r
,
3638 const char *name
, int len
,
3639 struct replay_opts
*opts
)
3641 struct strbuf ref_name
= STRBUF_INIT
;
3642 struct object_id oid
;
3643 struct lock_file lock
= LOCK_INIT
;
3644 struct tree_desc desc
;
3646 struct unpack_trees_options unpack_tree_opts
;
3649 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0)
3652 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
3653 if (!opts
->have_squash_onto
) {
3655 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
3656 NULL
, &opts
->squash_onto
,
3658 return error(_("writing fake root commit"));
3659 opts
->have_squash_onto
= 1;
3660 hex
= oid_to_hex(&opts
->squash_onto
);
3661 if (write_message(hex
, strlen(hex
),
3662 rebase_path_squash_onto(), 0))
3663 return error(_("writing squash-onto"));
3665 oidcpy(&oid
, &opts
->squash_onto
);
3669 /* Determine the length of the label */
3670 for (i
= 0; i
< len
; i
++)
3671 if (isspace(name
[i
]))
3675 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3676 if (get_oid(ref_name
.buf
, &oid
) &&
3677 get_oid(ref_name
.buf
+ strlen("refs/rewritten/"), &oid
)) {
3678 error(_("could not read '%s'"), ref_name
.buf
);
3679 rollback_lock_file(&lock
);
3680 strbuf_release(&ref_name
);
3685 memset(&unpack_tree_opts
, 0, sizeof(unpack_tree_opts
));
3686 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
3687 unpack_tree_opts
.head_idx
= 1;
3688 unpack_tree_opts
.src_index
= r
->index
;
3689 unpack_tree_opts
.dst_index
= r
->index
;
3690 unpack_tree_opts
.fn
= oneway_merge
;
3691 unpack_tree_opts
.merge
= 1;
3692 unpack_tree_opts
.update
= 1;
3693 /* FIXME: Default should be to remove ignored files */
3694 unpack_tree_opts
.preserve_ignored
= 1;
3695 init_checkout_metadata(&unpack_tree_opts
.meta
, name
, &oid
, NULL
);
3697 if (repo_read_index_unmerged(r
)) {
3698 rollback_lock_file(&lock
);
3699 strbuf_release(&ref_name
);
3700 return error_resolve_conflict(_(action_name(opts
)));
3703 if (!fill_tree_descriptor(r
, &desc
, &oid
)) {
3704 error(_("failed to find tree of %s"), oid_to_hex(&oid
));
3705 rollback_lock_file(&lock
);
3706 free((void *)desc
.buffer
);
3707 strbuf_release(&ref_name
);
3711 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
3712 rollback_lock_file(&lock
);
3713 free((void *)desc
.buffer
);
3714 strbuf_release(&ref_name
);
3718 tree
= parse_tree_indirect(&oid
);
3719 prime_cache_tree(r
, r
->index
, tree
);
3721 if (write_locked_index(r
->index
, &lock
, COMMIT_LOCK
) < 0)
3722 ret
= error(_("could not write index"));
3723 free((void *)desc
.buffer
);
3726 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
3727 len
, name
), "HEAD", &oid
,
3728 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3730 strbuf_release(&ref_name
);
3734 static struct commit
*lookup_label(const char *label
, int len
,
3737 struct commit
*commit
;
3740 strbuf_addf(buf
, "refs/rewritten/%.*s", len
, label
);
3741 commit
= lookup_commit_reference_by_name(buf
->buf
);
3743 /* fall back to non-rewritten ref or commit */
3744 strbuf_splice(buf
, 0, strlen("refs/rewritten/"), "", 0);
3745 commit
= lookup_commit_reference_by_name(buf
->buf
);
3749 error(_("could not resolve '%s'"), buf
->buf
);
3754 static int do_merge(struct repository
*r
,
3755 struct commit
*commit
,
3756 const char *arg
, int arg_len
,
3757 int flags
, int *check_todo
, struct replay_opts
*opts
)
3759 int run_commit_flags
= 0;
3760 struct strbuf ref_name
= STRBUF_INIT
;
3761 struct commit
*head_commit
, *merge_commit
, *i
;
3762 struct commit_list
*bases
, *j
, *reversed
= NULL
;
3763 struct commit_list
*to_merge
= NULL
, **tail
= &to_merge
;
3764 const char *strategy
= !opts
->xopts_nr
&&
3766 !strcmp(opts
->strategy
, "recursive") ||
3767 !strcmp(opts
->strategy
, "ort")) ?
3768 NULL
: opts
->strategy
;
3769 struct merge_options o
;
3770 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
, k
;
3771 static struct lock_file lock
;
3774 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0) {
3779 head_commit
= lookup_commit_reference_by_name("HEAD");
3781 ret
= error(_("cannot merge without a current revision"));
3786 * For octopus merges, the arg starts with the list of revisions to be
3787 * merged. The list is optionally followed by '#' and the oneline.
3789 merge_arg_len
= oneline_offset
= arg_len
;
3790 for (p
= arg
; p
- arg
< arg_len
; p
+= strspn(p
, " \t\n")) {
3793 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
3794 p
+= 1 + strspn(p
+ 1, " \t\n");
3795 oneline_offset
= p
- arg
;
3798 k
= strcspn(p
, " \t\n");
3801 merge_commit
= lookup_label(p
, k
, &ref_name
);
3802 if (!merge_commit
) {
3803 ret
= error(_("unable to parse '%.*s'"), k
, p
);
3806 tail
= &commit_list_insert(merge_commit
, tail
)->next
;
3808 merge_arg_len
= p
- arg
;
3812 ret
= error(_("nothing to merge: '%.*s'"), arg_len
, arg
);
3816 if (opts
->have_squash_onto
&&
3817 oideq(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
3819 * When the user tells us to "merge" something into a
3820 * "[new root]", let's simply fast-forward to the merge head.
3822 rollback_lock_file(&lock
);
3824 ret
= error(_("octopus merge cannot be executed on "
3825 "top of a [new root]"));
3827 ret
= fast_forward_to(r
, &to_merge
->item
->object
.oid
,
3828 &head_commit
->object
.oid
, 0,
3834 * If HEAD is not identical to the first parent of the original merge
3835 * commit, we cannot fast-forward.
3837 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
3838 oideq(&commit
->parents
->item
->object
.oid
,
3839 &head_commit
->object
.oid
);
3842 * If any merge head is different from the original one, we cannot
3845 if (can_fast_forward
) {
3846 struct commit_list
*p
= commit
->parents
->next
;
3848 for (j
= to_merge
; j
&& p
; j
= j
->next
, p
= p
->next
)
3849 if (!oideq(&j
->item
->object
.oid
,
3850 &p
->item
->object
.oid
)) {
3851 can_fast_forward
= 0;
3855 * If the number of merge heads differs from the original merge
3856 * commit, we cannot fast-forward.
3859 can_fast_forward
= 0;
3862 if (can_fast_forward
) {
3863 rollback_lock_file(&lock
);
3864 ret
= fast_forward_to(r
, &commit
->object
.oid
,
3865 &head_commit
->object
.oid
, 0, opts
);
3866 if (flags
& TODO_EDIT_MERGE_MSG
)
3867 goto fast_forward_edit
;
3873 const char *encoding
= get_commit_output_encoding();
3874 const char *message
= logmsg_reencode(commit
, NULL
, encoding
);
3879 ret
= error(_("could not get commit message of '%s'"),
3880 oid_to_hex(&commit
->object
.oid
));
3883 write_author_script(message
);
3884 find_commit_subject(message
, &body
);
3886 ret
= write_message(body
, len
, git_path_merge_msg(r
), 0);
3887 unuse_commit_buffer(commit
, message
);
3889 error_errno(_("could not write '%s'"),
3890 git_path_merge_msg(r
));
3894 struct strbuf buf
= STRBUF_INIT
;
3897 strbuf_addf(&buf
, "author %s", git_author_info(0));
3898 write_author_script(buf
.buf
);
3901 if (oneline_offset
< arg_len
) {
3902 p
= arg
+ oneline_offset
;
3903 len
= arg_len
- oneline_offset
;
3905 strbuf_addf(&buf
, "Merge %s '%.*s'",
3906 to_merge
->next
? "branches" : "branch",
3907 merge_arg_len
, arg
);
3912 ret
= write_message(p
, len
, git_path_merge_msg(r
), 0);
3913 strbuf_release(&buf
);
3915 error_errno(_("could not write '%s'"),
3916 git_path_merge_msg(r
));
3921 if (strategy
|| to_merge
->next
) {
3923 struct child_process cmd
= CHILD_PROCESS_INIT
;
3925 if (read_env_script(&cmd
.env_array
)) {
3926 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
3928 ret
= error(_(staged_changes_advice
), gpg_opt
, gpg_opt
);
3932 if (opts
->committer_date_is_author_date
)
3933 strvec_pushf(&cmd
.env_array
, "GIT_COMMITTER_DATE=%s",
3936 author_date_from_env_array(&cmd
.env_array
));
3937 if (opts
->ignore_date
)
3938 strvec_push(&cmd
.env_array
, "GIT_AUTHOR_DATE=");
3941 strvec_push(&cmd
.args
, "merge");
3942 strvec_push(&cmd
.args
, "-s");
3944 strvec_push(&cmd
.args
, "octopus");
3946 strvec_push(&cmd
.args
, strategy
);
3947 for (k
= 0; k
< opts
->xopts_nr
; k
++)
3948 strvec_pushf(&cmd
.args
,
3949 "-X%s", opts
->xopts
[k
]);
3951 if (!(flags
& TODO_EDIT_MERGE_MSG
))
3952 strvec_push(&cmd
.args
, "--no-edit");
3954 strvec_push(&cmd
.args
, "--edit");
3955 strvec_push(&cmd
.args
, "--no-ff");
3956 strvec_push(&cmd
.args
, "--no-log");
3957 strvec_push(&cmd
.args
, "--no-stat");
3958 strvec_push(&cmd
.args
, "-F");
3959 strvec_push(&cmd
.args
, git_path_merge_msg(r
));
3961 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
3963 strvec_push(&cmd
.args
, "--no-gpg-sign");
3965 /* Add the tips to be merged */
3966 for (j
= to_merge
; j
; j
= j
->next
)
3967 strvec_push(&cmd
.args
,
3968 oid_to_hex(&j
->item
->object
.oid
));
3970 strbuf_release(&ref_name
);
3971 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
3973 rollback_lock_file(&lock
);
3975 ret
= run_command(&cmd
);
3977 /* force re-reading of the cache */
3978 if (!ret
&& (discard_index(r
->index
) < 0 ||
3979 repo_read_index(r
) < 0))
3980 ret
= error(_("could not read index"));
3984 merge_commit
= to_merge
->item
;
3985 bases
= get_merge_bases(head_commit
, merge_commit
);
3986 if (bases
&& oideq(&merge_commit
->object
.oid
,
3987 &bases
->item
->object
.oid
)) {
3989 /* skip merging an ancestor of HEAD */
3993 write_message(oid_to_hex(&merge_commit
->object
.oid
), the_hash_algo
->hexsz
,
3994 git_path_merge_head(r
), 0);
3995 write_message("no-ff", 5, git_path_merge_mode(r
), 0);
3997 for (j
= bases
; j
; j
= j
->next
)
3998 commit_list_insert(j
->item
, &reversed
);
3999 free_commit_list(bases
);
4002 init_merge_options(&o
, r
);
4004 o
.branch2
= ref_name
.buf
;
4005 o
.buffer_output
= 2;
4007 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
4009 * TODO: Should use merge_incore_recursive() and
4010 * merge_switch_to_result(), skipping the call to
4011 * merge_switch_to_result() when we don't actually need to
4012 * update the index and working copy immediately.
4014 ret
= merge_ort_recursive(&o
,
4015 head_commit
, merge_commit
, reversed
,
4018 ret
= merge_recursive(&o
, head_commit
, merge_commit
, reversed
,
4022 fputs(o
.obuf
.buf
, stdout
);
4023 strbuf_release(&o
.obuf
);
4025 error(_("could not even attempt to merge '%.*s'"),
4026 merge_arg_len
, arg
);
4030 * The return value of merge_recursive() is 1 on clean, and 0 on
4033 * Let's reverse that, so that do_merge() returns 0 upon success and
4034 * 1 upon failed merge (keeping the return value -1 for the cases where
4035 * we will want to reschedule the `merge` command).
4039 if (r
->index
->cache_changed
&&
4040 write_locked_index(r
->index
, &lock
, COMMIT_LOCK
)) {
4041 ret
= error(_("merge: Unable to write new index file"));
4045 rollback_lock_file(&lock
);
4047 repo_rerere(r
, opts
->allow_rerere_auto
);
4050 * In case of problems, we now want to return a positive
4051 * value (a negative one would indicate that the `merge`
4052 * command needs to be rescheduled).
4054 ret
= !!run_git_commit(git_path_merge_msg(r
), opts
,
4057 if (!ret
&& flags
& TODO_EDIT_MERGE_MSG
) {
4060 run_commit_flags
|= AMEND_MSG
| EDIT_MSG
| VERIFY_MSG
;
4061 ret
= !!run_git_commit(NULL
, opts
, run_commit_flags
);
4066 strbuf_release(&ref_name
);
4067 rollback_lock_file(&lock
);
4068 free_commit_list(to_merge
);
4072 static int is_final_fixup(struct todo_list
*todo_list
)
4074 int i
= todo_list
->current
;
4076 if (!is_fixup(todo_list
->items
[i
].command
))
4079 while (++i
< todo_list
->nr
)
4080 if (is_fixup(todo_list
->items
[i
].command
))
4082 else if (!is_noop(todo_list
->items
[i
].command
))
4087 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
4091 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
4092 if (!is_noop(todo_list
->items
[i
].command
))
4093 return todo_list
->items
[i
].command
;
4098 void create_autostash(struct repository
*r
, const char *path
,
4099 const char *default_reflog_action
)
4101 struct strbuf buf
= STRBUF_INIT
;
4102 struct lock_file lock_file
= LOCK_INIT
;
4105 fd
= repo_hold_locked_index(r
, &lock_file
, 0);
4106 refresh_index(r
->index
, REFRESH_QUIET
, NULL
, NULL
, NULL
);
4108 repo_update_index_if_able(r
, &lock_file
);
4109 rollback_lock_file(&lock_file
);
4111 if (has_unstaged_changes(r
, 1) ||
4112 has_uncommitted_changes(r
, 1)) {
4113 struct child_process stash
= CHILD_PROCESS_INIT
;
4114 struct object_id oid
;
4116 strvec_pushl(&stash
.args
,
4117 "stash", "create", "autostash", NULL
);
4121 if (capture_command(&stash
, &buf
, GIT_MAX_HEXSZ
))
4122 die(_("Cannot autostash"));
4123 strbuf_trim_trailing_newline(&buf
);
4124 if (get_oid(buf
.buf
, &oid
))
4125 die(_("Unexpected stash response: '%s'"),
4128 strbuf_add_unique_abbrev(&buf
, &oid
, DEFAULT_ABBREV
);
4130 if (safe_create_leading_directories_const(path
))
4131 die(_("Could not create directory for '%s'"),
4133 write_file(path
, "%s", oid_to_hex(&oid
));
4134 printf(_("Created autostash: %s\n"), buf
.buf
);
4135 if (reset_head(r
, NULL
, "reset --hard",
4136 NULL
, RESET_HEAD_HARD
, NULL
, NULL
,
4137 default_reflog_action
) < 0)
4138 die(_("could not reset --hard"));
4140 if (discard_index(r
->index
) < 0 ||
4141 repo_read_index(r
) < 0)
4142 die(_("could not read index"));
4144 strbuf_release(&buf
);
4147 static int apply_save_autostash_oid(const char *stash_oid
, int attempt_apply
)
4149 struct child_process child
= CHILD_PROCESS_INIT
;
4152 if (attempt_apply
) {
4154 child
.no_stdout
= 1;
4155 child
.no_stderr
= 1;
4156 strvec_push(&child
.args
, "stash");
4157 strvec_push(&child
.args
, "apply");
4158 strvec_push(&child
.args
, stash_oid
);
4159 ret
= run_command(&child
);
4162 if (attempt_apply
&& !ret
)
4163 fprintf(stderr
, _("Applied autostash.\n"));
4165 struct child_process store
= CHILD_PROCESS_INIT
;
4168 strvec_push(&store
.args
, "stash");
4169 strvec_push(&store
.args
, "store");
4170 strvec_push(&store
.args
, "-m");
4171 strvec_push(&store
.args
, "autostash");
4172 strvec_push(&store
.args
, "-q");
4173 strvec_push(&store
.args
, stash_oid
);
4174 if (run_command(&store
))
4175 ret
= error(_("cannot store %s"), stash_oid
);
4179 "Your changes are safe in the stash.\n"
4180 "You can run \"git stash pop\" or"
4181 " \"git stash drop\" at any time.\n"),
4183 _("Applying autostash resulted in conflicts.") :
4184 _("Autostash exists; creating a new stash entry."));
4190 static int apply_save_autostash(const char *path
, int attempt_apply
)
4192 struct strbuf stash_oid
= STRBUF_INIT
;
4195 if (!read_oneliner(&stash_oid
, path
,
4196 READ_ONELINER_SKIP_IF_EMPTY
)) {
4197 strbuf_release(&stash_oid
);
4200 strbuf_trim(&stash_oid
);
4202 ret
= apply_save_autostash_oid(stash_oid
.buf
, attempt_apply
);
4205 strbuf_release(&stash_oid
);
4209 int save_autostash(const char *path
)
4211 return apply_save_autostash(path
, 0);
4214 int apply_autostash(const char *path
)
4216 return apply_save_autostash(path
, 1);
4219 int apply_autostash_oid(const char *stash_oid
)
4221 return apply_save_autostash_oid(stash_oid
, 1);
4224 static int run_git_checkout(struct repository
*r
, struct replay_opts
*opts
,
4225 const char *commit
, const char *action
)
4227 struct child_process cmd
= CHILD_PROCESS_INIT
;
4232 strvec_push(&cmd
.args
, "checkout");
4233 strvec_push(&cmd
.args
, commit
);
4234 strvec_pushf(&cmd
.env_array
, GIT_REFLOG_ACTION
"=%s", action
);
4237 ret
= run_command(&cmd
);
4239 ret
= run_command_silent_on_success(&cmd
);
4242 discard_index(r
->index
);
4247 static int checkout_onto(struct repository
*r
, struct replay_opts
*opts
,
4248 const char *onto_name
, const struct object_id
*onto
,
4249 const struct object_id
*orig_head
)
4251 const char *action
= reflog_message(opts
, "start", "checkout %s", onto_name
);
4253 if (run_git_checkout(r
, opts
, oid_to_hex(onto
), action
)) {
4254 apply_autostash(rebase_path_autostash());
4255 sequencer_remove_state(opts
);
4256 return error(_("could not detach HEAD"));
4259 return update_ref(NULL
, "ORIG_HEAD", orig_head
, NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
4262 static int stopped_at_head(struct repository
*r
)
4264 struct object_id head
;
4265 struct commit
*commit
;
4266 struct commit_message message
;
4268 if (get_oid("HEAD", &head
) ||
4269 !(commit
= lookup_commit(r
, &head
)) ||
4270 parse_commit(commit
) || get_message(commit
, &message
))
4271 fprintf(stderr
, _("Stopped at HEAD\n"));
4273 fprintf(stderr
, _("Stopped at %s\n"), message
.label
);
4274 free_message(commit
, &message
);
4280 static const char rescheduled_advice
[] =
4281 N_("Could not execute the todo command\n"
4285 "It has been rescheduled; To edit the command before continuing, please\n"
4286 "edit the todo list first:\n"
4288 " git rebase --edit-todo\n"
4289 " git rebase --continue\n");
4291 static int pick_commits(struct repository
*r
,
4292 struct todo_list
*todo_list
,
4293 struct replay_opts
*opts
)
4295 int res
= 0, reschedule
= 0;
4296 char *prev_reflog_action
;
4298 /* Note that 0 for 3rd parameter of setenv means set only if not set */
4299 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
4300 prev_reflog_action
= xstrdup(getenv(GIT_REFLOG_ACTION
));
4302 assert(!(opts
->signoff
|| opts
->no_commit
||
4303 opts
->record_origin
|| should_edit(opts
) ||
4304 opts
->committer_date_is_author_date
||
4305 opts
->ignore_date
));
4306 if (read_and_refresh_cache(r
, opts
))
4309 while (todo_list
->current
< todo_list
->nr
) {
4310 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
4311 const char *arg
= todo_item_get_arg(todo_list
, item
);
4314 if (save_todo(todo_list
, opts
))
4316 if (is_rebase_i(opts
)) {
4317 if (item
->command
!= TODO_COMMENT
) {
4318 FILE *f
= fopen(rebase_path_msgnum(), "w");
4320 todo_list
->done_nr
++;
4323 fprintf(f
, "%d\n", todo_list
->done_nr
);
4327 fprintf(stderr
, _("Rebasing (%d/%d)%s"),
4329 todo_list
->total_nr
,
4330 opts
->verbose
? "\n" : "\r");
4332 unlink(rebase_path_message());
4333 unlink(rebase_path_author_script());
4334 unlink(rebase_path_stopped_sha());
4335 unlink(rebase_path_amend());
4336 unlink(git_path_merge_head(r
));
4337 unlink(git_path_auto_merge(r
));
4338 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
4340 if (item
->command
== TODO_BREAK
) {
4343 return stopped_at_head(r
);
4346 if (item
->command
<= TODO_SQUASH
) {
4347 if (is_rebase_i(opts
))
4348 setenv(GIT_REFLOG_ACTION
, reflog_message(opts
,
4349 command_to_string(item
->command
), NULL
),
4351 res
= do_pick_commit(r
, item
, opts
,
4352 is_final_fixup(todo_list
),
4354 if (is_rebase_i(opts
))
4355 setenv(GIT_REFLOG_ACTION
, prev_reflog_action
, 1);
4356 if (is_rebase_i(opts
) && res
< 0) {
4358 advise(_(rescheduled_advice
),
4359 get_item_line_length(todo_list
,
4360 todo_list
->current
),
4361 get_item_line(todo_list
,
4362 todo_list
->current
));
4363 todo_list
->current
--;
4364 if (save_todo(todo_list
, opts
))
4367 if (item
->command
== TODO_EDIT
) {
4368 struct commit
*commit
= item
->commit
;
4373 _("Stopped at %s... %.*s\n"),
4374 short_commit_name(commit
),
4375 item
->arg_len
, arg
);
4377 return error_with_patch(r
, commit
,
4378 arg
, item
->arg_len
, opts
, res
, !res
);
4380 if (is_rebase_i(opts
) && !res
)
4381 record_in_rewritten(&item
->commit
->object
.oid
,
4382 peek_command(todo_list
, 1));
4383 if (res
&& is_fixup(item
->command
)) {
4386 return error_failed_squash(r
, item
->commit
, opts
,
4387 item
->arg_len
, arg
);
4388 } else if (res
&& is_rebase_i(opts
) && item
->commit
) {
4390 struct object_id oid
;
4393 * If we are rewording and have either
4394 * fast-forwarded already, or are about to
4395 * create a new root commit, we want to amend,
4396 * otherwise we do not.
4398 if (item
->command
== TODO_REWORD
&&
4399 !get_oid("HEAD", &oid
) &&
4400 (oideq(&item
->commit
->object
.oid
, &oid
) ||
4401 (opts
->have_squash_onto
&&
4402 oideq(&opts
->squash_onto
, &oid
))))
4405 return res
| error_with_patch(r
, item
->commit
,
4406 arg
, item
->arg_len
, opts
,
4409 } else if (item
->command
== TODO_EXEC
) {
4410 char *end_of_arg
= (char *)(arg
+ item
->arg_len
);
4411 int saved
= *end_of_arg
;
4416 res
= do_exec(r
, arg
);
4417 *end_of_arg
= saved
;
4420 if (opts
->reschedule_failed_exec
)
4424 } else if (item
->command
== TODO_LABEL
) {
4425 if ((res
= do_label(r
, arg
, item
->arg_len
)))
4427 } else if (item
->command
== TODO_RESET
) {
4428 if ((res
= do_reset(r
, arg
, item
->arg_len
, opts
)))
4430 } else if (item
->command
== TODO_MERGE
) {
4431 if ((res
= do_merge(r
, item
->commit
, arg
, item
->arg_len
,
4432 item
->flags
, &check_todo
, opts
)) < 0)
4434 else if (item
->commit
)
4435 record_in_rewritten(&item
->commit
->object
.oid
,
4436 peek_command(todo_list
, 1));
4438 /* failed with merge conflicts */
4439 return error_with_patch(r
, item
->commit
,
4442 } else if (!is_noop(item
->command
))
4443 return error(_("unknown command %d"), item
->command
);
4446 advise(_(rescheduled_advice
),
4447 get_item_line_length(todo_list
,
4448 todo_list
->current
),
4449 get_item_line(todo_list
, todo_list
->current
));
4450 todo_list
->current
--;
4451 if (save_todo(todo_list
, opts
))
4454 return error_with_patch(r
,
4458 } else if (is_rebase_i(opts
) && check_todo
&& !res
) {
4461 if (stat(get_todo_path(opts
), &st
)) {
4462 res
= error_errno(_("could not stat '%s'"),
4463 get_todo_path(opts
));
4464 } else if (match_stat_data(&todo_list
->stat
, &st
)) {
4465 /* Reread the todo file if it has changed. */
4466 todo_list_release(todo_list
);
4467 if (read_populate_todo(r
, todo_list
, opts
))
4468 res
= -1; /* message was printed */
4469 /* `current` will be incremented below */
4470 todo_list
->current
= -1;
4474 todo_list
->current
++;
4479 if (is_rebase_i(opts
)) {
4480 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
4483 /* Stopped in the middle, as planned? */
4484 if (todo_list
->current
< todo_list
->nr
)
4487 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
4488 starts_with(head_ref
.buf
, "refs/")) {
4490 struct object_id head
, orig
;
4493 if (get_oid("HEAD", &head
)) {
4494 res
= error(_("cannot read HEAD"));
4496 strbuf_release(&head_ref
);
4497 strbuf_release(&buf
);
4500 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
4501 get_oid_hex(buf
.buf
, &orig
)) {
4502 res
= error(_("could not read orig-head"));
4503 goto cleanup_head_ref
;
4506 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
4507 res
= error(_("could not read 'onto'"));
4508 goto cleanup_head_ref
;
4510 msg
= reflog_message(opts
, "finish", "%s onto %s",
4511 head_ref
.buf
, buf
.buf
);
4512 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
4513 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
4514 res
= error(_("could not update %s"),
4516 goto cleanup_head_ref
;
4518 msg
= reflog_message(opts
, "finish", "returning to %s",
4520 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
4521 res
= error(_("could not update HEAD to %s"),
4523 goto cleanup_head_ref
;
4528 if (opts
->verbose
) {
4529 struct rev_info log_tree_opt
;
4530 struct object_id orig
, head
;
4532 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
4533 repo_init_revisions(r
, &log_tree_opt
, NULL
);
4534 log_tree_opt
.diff
= 1;
4535 log_tree_opt
.diffopt
.output_format
=
4536 DIFF_FORMAT_DIFFSTAT
;
4537 log_tree_opt
.disable_stdin
= 1;
4539 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
4540 !get_oid(buf
.buf
, &orig
) &&
4541 !get_oid("HEAD", &head
)) {
4542 diff_tree_oid(&orig
, &head
, "",
4543 &log_tree_opt
.diffopt
);
4544 log_tree_diff_flush(&log_tree_opt
);
4547 flush_rewritten_pending();
4548 if (!stat(rebase_path_rewritten_list(), &st
) &&
4550 struct child_process child
= CHILD_PROCESS_INIT
;
4551 const char *post_rewrite_hook
=
4552 find_hook("post-rewrite");
4554 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
4556 strvec_push(&child
.args
, "notes");
4557 strvec_push(&child
.args
, "copy");
4558 strvec_push(&child
.args
, "--for-rewrite=rebase");
4559 /* we don't care if this copying failed */
4560 run_command(&child
);
4562 if (post_rewrite_hook
) {
4563 struct child_process hook
= CHILD_PROCESS_INIT
;
4565 hook
.in
= open(rebase_path_rewritten_list(),
4567 hook
.stdout_to_stderr
= 1;
4568 hook
.trace2_hook_name
= "post-rewrite";
4569 strvec_push(&hook
.args
, post_rewrite_hook
);
4570 strvec_push(&hook
.args
, "rebase");
4571 /* we don't care if this hook failed */
4575 apply_autostash(rebase_path_autostash());
4581 _("Successfully rebased and updated %s.\n"),
4585 strbuf_release(&buf
);
4586 strbuf_release(&head_ref
);
4590 * Sequence of picks finished successfully; cleanup by
4591 * removing the .git/sequencer directory
4593 return sequencer_remove_state(opts
);
4596 static int continue_single_pick(struct repository
*r
, struct replay_opts
*opts
)
4598 struct strvec argv
= STRVEC_INIT
;
4601 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
4602 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
4603 return error(_("no cherry-pick or revert in progress"));
4605 strvec_push(&argv
, "commit");
4608 * continue_single_pick() handles the case of recovering from a
4609 * conflict. should_edit() doesn't handle that case; for a conflict,
4610 * we want to edit if the user asked for it, or if they didn't specify
4611 * and stdin is a tty.
4613 if (!opts
->edit
|| (opts
->edit
< 0 && !isatty(0)))
4615 * Include --cleanup=strip as well because we don't want the
4616 * "# Conflicts:" messages.
4618 strvec_pushl(&argv
, "--no-edit", "--cleanup=strip", NULL
);
4620 ret
= run_command_v_opt(argv
.v
, RUN_GIT_CMD
);
4621 strvec_clear(&argv
);
4625 static int commit_staged_changes(struct repository
*r
,
4626 struct replay_opts
*opts
,
4627 struct todo_list
*todo_list
)
4629 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
4630 unsigned int final_fixup
= 0, is_clean
;
4632 if (has_unstaged_changes(r
, 1))
4633 return error(_("cannot rebase: You have unstaged changes."));
4635 is_clean
= !has_uncommitted_changes(r
, 0);
4637 if (file_exists(rebase_path_amend())) {
4638 struct strbuf rev
= STRBUF_INIT
;
4639 struct object_id head
, to_amend
;
4641 if (get_oid("HEAD", &head
))
4642 return error(_("cannot amend non-existing commit"));
4643 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
4644 return error(_("invalid file: '%s'"), rebase_path_amend());
4645 if (get_oid_hex(rev
.buf
, &to_amend
))
4646 return error(_("invalid contents: '%s'"),
4647 rebase_path_amend());
4648 if (!is_clean
&& !oideq(&head
, &to_amend
))
4649 return error(_("\nYou have uncommitted changes in your "
4650 "working tree. Please, commit them\n"
4651 "first and then run 'git rebase "
4652 "--continue' again."));
4654 * When skipping a failed fixup/squash, we need to edit the
4655 * commit message, the current fixup list and count, and if it
4656 * was the last fixup/squash in the chain, we need to clean up
4657 * the commit message and if there was a squash, let the user
4660 if (!is_clean
|| !opts
->current_fixup_count
)
4661 ; /* this is not the final fixup */
4662 else if (!oideq(&head
, &to_amend
) ||
4663 !file_exists(rebase_path_stopped_sha())) {
4664 /* was a final fixup or squash done manually? */
4665 if (!is_fixup(peek_command(todo_list
, 0))) {
4666 unlink(rebase_path_fixup_msg());
4667 unlink(rebase_path_squash_msg());
4668 unlink(rebase_path_current_fixups());
4669 strbuf_reset(&opts
->current_fixups
);
4670 opts
->current_fixup_count
= 0;
4673 /* we are in a fixup/squash chain */
4674 const char *p
= opts
->current_fixups
.buf
;
4675 int len
= opts
->current_fixups
.len
;
4677 opts
->current_fixup_count
--;
4679 BUG("Incorrect current_fixups:\n%s", p
);
4680 while (len
&& p
[len
- 1] != '\n')
4682 strbuf_setlen(&opts
->current_fixups
, len
);
4683 if (write_message(p
, len
, rebase_path_current_fixups(),
4685 return error(_("could not write file: '%s'"),
4686 rebase_path_current_fixups());
4689 * If a fixup/squash in a fixup/squash chain failed, the
4690 * commit message is already correct, no need to commit
4693 * Only if it is the final command in the fixup/squash
4694 * chain, and only if the chain is longer than a single
4695 * fixup/squash command (which was just skipped), do we
4696 * actually need to re-commit with a cleaned up commit
4699 if (opts
->current_fixup_count
> 0 &&
4700 !is_fixup(peek_command(todo_list
, 0))) {
4703 * If there was not a single "squash" in the
4704 * chain, we only need to clean up the commit
4705 * message, no need to bother the user with
4706 * opening the commit message in the editor.
4708 if (!starts_with(p
, "squash ") &&
4709 !strstr(p
, "\nsquash "))
4710 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
4711 } else if (is_fixup(peek_command(todo_list
, 0))) {
4713 * We need to update the squash message to skip
4714 * the latest commit message.
4716 struct commit
*commit
;
4717 const char *path
= rebase_path_squash_msg();
4718 const char *encoding
= get_commit_output_encoding();
4720 if (parse_head(r
, &commit
) ||
4721 !(p
= logmsg_reencode(commit
, NULL
, encoding
)) ||
4722 write_message(p
, strlen(p
), path
, 0)) {
4723 unuse_commit_buffer(commit
, p
);
4724 return error(_("could not write file: "
4727 unuse_commit_buffer(commit
, p
);
4731 strbuf_release(&rev
);
4736 if (refs_ref_exists(get_main_ref_store(r
),
4737 "CHERRY_PICK_HEAD") &&
4738 refs_delete_ref(get_main_ref_store(r
), "",
4739 "CHERRY_PICK_HEAD", NULL
, 0))
4740 return error(_("could not remove CHERRY_PICK_HEAD"));
4741 if (unlink(git_path_merge_msg(r
)) && errno
!= ENOENT
)
4742 return error_errno(_("could not remove '%s'"),
4743 git_path_merge_msg(r
));
4748 if (run_git_commit(final_fixup
? NULL
: rebase_path_message(),
4750 return error(_("could not commit staged changes."));
4751 unlink(rebase_path_amend());
4752 unlink(git_path_merge_head(r
));
4753 unlink(git_path_auto_merge(r
));
4755 unlink(rebase_path_fixup_msg());
4756 unlink(rebase_path_squash_msg());
4758 if (opts
->current_fixup_count
> 0) {
4760 * Whether final fixup or not, we just cleaned up the commit
4763 unlink(rebase_path_current_fixups());
4764 strbuf_reset(&opts
->current_fixups
);
4765 opts
->current_fixup_count
= 0;
4770 int sequencer_continue(struct repository
*r
, struct replay_opts
*opts
)
4772 struct todo_list todo_list
= TODO_LIST_INIT
;
4775 if (read_and_refresh_cache(r
, opts
))
4778 if (read_populate_opts(opts
))
4780 if (is_rebase_i(opts
)) {
4781 if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
4782 goto release_todo_list
;
4784 if (file_exists(rebase_path_dropped())) {
4785 if ((res
= todo_list_check_against_backup(r
, &todo_list
)))
4786 goto release_todo_list
;
4788 unlink(rebase_path_dropped());
4791 if (commit_staged_changes(r
, opts
, &todo_list
)) {
4793 goto release_todo_list
;
4795 } else if (!file_exists(get_todo_path(opts
)))
4796 return continue_single_pick(r
, opts
);
4797 else if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
4798 goto release_todo_list
;
4800 if (!is_rebase_i(opts
)) {
4801 /* Verify that the conflict has been resolved */
4802 if (refs_ref_exists(get_main_ref_store(r
),
4803 "CHERRY_PICK_HEAD") ||
4804 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
4805 res
= continue_single_pick(r
, opts
);
4807 goto release_todo_list
;
4809 if (index_differs_from(r
, "HEAD", NULL
, 0)) {
4810 res
= error_dirty_index(r
, opts
);
4811 goto release_todo_list
;
4813 todo_list
.current
++;
4814 } else if (file_exists(rebase_path_stopped_sha())) {
4815 struct strbuf buf
= STRBUF_INIT
;
4816 struct object_id oid
;
4818 if (read_oneliner(&buf
, rebase_path_stopped_sha(),
4819 READ_ONELINER_SKIP_IF_EMPTY
) &&
4820 !get_oid_hex(buf
.buf
, &oid
))
4821 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
4822 strbuf_release(&buf
);
4825 res
= pick_commits(r
, &todo_list
, opts
);
4827 todo_list_release(&todo_list
);
4831 static int single_pick(struct repository
*r
,
4832 struct commit
*cmit
,
4833 struct replay_opts
*opts
)
4836 struct todo_item item
;
4838 item
.command
= opts
->action
== REPLAY_PICK
?
4839 TODO_PICK
: TODO_REVERT
;
4842 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
4843 return do_pick_commit(r
, &item
, opts
, 0, &check_todo
);
4846 int sequencer_pick_revisions(struct repository
*r
,
4847 struct replay_opts
*opts
)
4849 struct todo_list todo_list
= TODO_LIST_INIT
;
4850 struct object_id oid
;
4854 if (read_and_refresh_cache(r
, opts
))
4857 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
4858 struct object_id oid
;
4859 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
4861 /* This happens when using --stdin. */
4865 if (!get_oid(name
, &oid
)) {
4866 if (!lookup_commit_reference_gently(r
, &oid
, 1)) {
4867 enum object_type type
= oid_object_info(r
,
4870 return error(_("%s: can't cherry-pick a %s"),
4871 name
, type_name(type
));
4874 return error(_("%s: bad revision"), name
);
4878 * If we were called as "git cherry-pick <commit>", just
4879 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4880 * REVERT_HEAD, and don't touch the sequencer state.
4881 * This means it is possible to cherry-pick in the middle
4882 * of a cherry-pick sequence.
4884 if (opts
->revs
->cmdline
.nr
== 1 &&
4885 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
4886 opts
->revs
->no_walk
&&
4887 !opts
->revs
->cmdline
.rev
->flags
) {
4888 struct commit
*cmit
;
4889 if (prepare_revision_walk(opts
->revs
))
4890 return error(_("revision walk setup failed"));
4891 cmit
= get_revision(opts
->revs
);
4893 return error(_("empty commit set passed"));
4894 if (get_revision(opts
->revs
))
4895 BUG("unexpected extra commit from walk");
4896 return single_pick(r
, cmit
, opts
);
4900 * Start a new cherry-pick/ revert sequence; but
4901 * first, make sure that an existing one isn't in
4905 if (walk_revs_populate_todo(&todo_list
, opts
) ||
4906 create_seq_dir(r
) < 0)
4908 if (get_oid("HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
4909 return error(_("can't revert as initial commit"));
4910 if (save_head(oid_to_hex(&oid
)))
4912 if (save_opts(opts
))
4914 update_abort_safety_file();
4915 res
= pick_commits(r
, &todo_list
, opts
);
4916 todo_list_release(&todo_list
);
4920 void append_signoff(struct strbuf
*msgbuf
, size_t ignore_footer
, unsigned flag
)
4922 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
4923 struct strbuf sob
= STRBUF_INIT
;
4926 strbuf_addstr(&sob
, sign_off_header
);
4927 strbuf_addstr(&sob
, fmt_name(WANT_COMMITTER_IDENT
));
4928 strbuf_addch(&sob
, '\n');
4931 strbuf_complete_line(msgbuf
);
4934 * If the whole message buffer is equal to the sob, pretend that we
4935 * found a conforming footer with a matching sob
4937 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
4938 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
4941 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
4944 const char *append_newlines
= NULL
;
4945 size_t len
= msgbuf
->len
- ignore_footer
;
4949 * The buffer is completely empty. Leave foom for
4950 * the title and body to be filled in by the user.
4952 append_newlines
= "\n\n";
4953 } else if (len
== 1) {
4955 * Buffer contains a single newline. Add another
4956 * so that we leave room for the title and body.
4958 append_newlines
= "\n";
4959 } else if (msgbuf
->buf
[len
- 2] != '\n') {
4961 * Buffer ends with a single newline. Add another
4962 * so that there is an empty line between the message
4965 append_newlines
= "\n";
4966 } /* else, the buffer already ends with two newlines. */
4968 if (append_newlines
)
4969 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
4970 append_newlines
, strlen(append_newlines
));
4973 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
4974 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
4977 strbuf_release(&sob
);
4980 struct labels_entry
{
4981 struct hashmap_entry entry
;
4982 char label
[FLEX_ARRAY
];
4985 static int labels_cmp(const void *fndata
, const struct hashmap_entry
*eptr
,
4986 const struct hashmap_entry
*entry_or_key
, const void *key
)
4988 const struct labels_entry
*a
, *b
;
4990 a
= container_of(eptr
, const struct labels_entry
, entry
);
4991 b
= container_of(entry_or_key
, const struct labels_entry
, entry
);
4993 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
4996 struct string_entry
{
4997 struct oidmap_entry entry
;
4998 char string
[FLEX_ARRAY
];
5001 struct label_state
{
5002 struct oidmap commit2label
;
5003 struct hashmap labels
;
5007 static const char *label_oid(struct object_id
*oid
, const char *label
,
5008 struct label_state
*state
)
5010 struct labels_entry
*labels_entry
;
5011 struct string_entry
*string_entry
;
5012 struct object_id dummy
;
5015 string_entry
= oidmap_get(&state
->commit2label
, oid
);
5017 return string_entry
->string
;
5020 * For "uninteresting" commits, i.e. commits that are not to be
5021 * rebased, and which can therefore not be labeled, we use a unique
5022 * abbreviation of the commit name. This is slightly more complicated
5023 * than calling find_unique_abbrev() because we also need to make
5024 * sure that the abbreviation does not conflict with any other
5027 * We disallow "interesting" commits to be labeled by a string that
5028 * is a valid full-length hash, to ensure that we always can find an
5029 * abbreviation for any uninteresting commit's names that does not
5030 * clash with any other label.
5032 strbuf_reset(&state
->buf
);
5036 strbuf_grow(&state
->buf
, GIT_MAX_HEXSZ
);
5037 label
= p
= state
->buf
.buf
;
5039 find_unique_abbrev_r(p
, oid
, default_abbrev
);
5042 * We may need to extend the abbreviated hash so that there is
5043 * no conflicting label.
5045 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
5046 size_t i
= strlen(p
) + 1;
5048 oid_to_hex_r(p
, oid
);
5049 for (; i
< the_hash_algo
->hexsz
; i
++) {
5052 if (!hashmap_get_from_hash(&state
->labels
,
5059 struct strbuf
*buf
= &state
->buf
;
5062 * Sanitize labels by replacing non-alpha-numeric characters
5063 * (including white-space ones) by dashes, as they might be
5064 * illegal in file names (and hence in ref names).
5066 * Note that we retain non-ASCII UTF-8 characters (identified
5067 * via the most significant bit). They should be all acceptable
5068 * in file names. We do not validate the UTF-8 here, that's not
5069 * the job of this function.
5071 for (; *label
; label
++)
5072 if ((*label
& 0x80) || isalnum(*label
))
5073 strbuf_addch(buf
, *label
);
5074 /* avoid leading dash and double-dashes */
5075 else if (buf
->len
&& buf
->buf
[buf
->len
- 1] != '-')
5076 strbuf_addch(buf
, '-');
5078 strbuf_addstr(buf
, "rev-");
5079 strbuf_add_unique_abbrev(buf
, oid
, default_abbrev
);
5083 if ((buf
->len
== the_hash_algo
->hexsz
&&
5084 !get_oid_hex(label
, &dummy
)) ||
5085 (buf
->len
== 1 && *label
== '#') ||
5086 hashmap_get_from_hash(&state
->labels
,
5087 strihash(label
), label
)) {
5089 * If the label already exists, or if the label is a
5090 * valid full OID, or the label is a '#' (which we use
5091 * as a separator between merge heads and oneline), we
5092 * append a dash and a number to make it unique.
5094 size_t len
= buf
->len
;
5096 for (i
= 2; ; i
++) {
5097 strbuf_setlen(buf
, len
);
5098 strbuf_addf(buf
, "-%d", i
);
5099 if (!hashmap_get_from_hash(&state
->labels
,
5109 FLEX_ALLOC_STR(labels_entry
, label
, label
);
5110 hashmap_entry_init(&labels_entry
->entry
, strihash(label
));
5111 hashmap_add(&state
->labels
, &labels_entry
->entry
);
5113 FLEX_ALLOC_STR(string_entry
, string
, label
);
5114 oidcpy(&string_entry
->entry
.oid
, oid
);
5115 oidmap_put(&state
->commit2label
, string_entry
);
5117 return string_entry
->string
;
5120 static int make_script_with_merges(struct pretty_print_context
*pp
,
5121 struct rev_info
*revs
, struct strbuf
*out
,
5124 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5125 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
5126 int root_with_onto
= flags
& TODO_LIST_ROOT_WITH_ONTO
;
5127 int skipped_commit
= 0;
5128 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
5129 struct strbuf label
= STRBUF_INIT
;
5130 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
5131 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
5132 struct commit
*commit
;
5133 struct oidmap commit2todo
= OIDMAP_INIT
;
5134 struct string_entry
*entry
;
5135 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
5136 shown
= OIDSET_INIT
;
5137 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
5139 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
5140 const char *cmd_pick
= abbr
? "p" : "pick",
5141 *cmd_label
= abbr
? "l" : "label",
5142 *cmd_reset
= abbr
? "t" : "reset",
5143 *cmd_merge
= abbr
? "m" : "merge";
5145 oidmap_init(&commit2todo
, 0);
5146 oidmap_init(&state
.commit2label
, 0);
5147 hashmap_init(&state
.labels
, labels_cmp
, NULL
, 0);
5148 strbuf_init(&state
.buf
, 32);
5150 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
5151 struct labels_entry
*onto_label_entry
;
5152 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
5153 FLEX_ALLOC_STR(entry
, string
, "onto");
5154 oidcpy(&entry
->entry
.oid
, oid
);
5155 oidmap_put(&state
.commit2label
, entry
);
5157 FLEX_ALLOC_STR(onto_label_entry
, label
, "onto");
5158 hashmap_entry_init(&onto_label_entry
->entry
, strihash("onto"));
5159 hashmap_add(&state
.labels
, &onto_label_entry
->entry
);
5164 * - get onelines for all commits
5165 * - gather all branch tips (i.e. 2nd or later parents of merges)
5166 * - label all branch tips
5168 while ((commit
= get_revision(revs
))) {
5169 struct commit_list
*to_merge
;
5170 const char *p1
, *p2
;
5171 struct object_id
*oid
;
5174 tail
= &commit_list_insert(commit
, tail
)->next
;
5175 oidset_insert(&interesting
, &commit
->object
.oid
);
5177 is_empty
= is_original_commit_empty(commit
);
5178 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5179 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5180 warning(_("skipped previously applied commit %s"),
5181 short_commit_name(commit
));
5185 if (is_empty
&& !keep_empty
)
5188 strbuf_reset(&oneline
);
5189 pretty_print_commit(pp
, commit
, &oneline
);
5191 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
5193 /* non-merge commit: easy case */
5195 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
5196 oid_to_hex(&commit
->object
.oid
),
5199 strbuf_addf(&buf
, " %c empty",
5202 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5203 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5204 oidmap_put(&commit2todo
, entry
);
5209 /* Create a label */
5210 strbuf_reset(&label
);
5211 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
5212 (p1
= strchr(p1
, '\'')) &&
5213 (p2
= strchr(++p1
, '\'')))
5214 strbuf_add(&label
, p1
, p2
- p1
);
5215 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
5217 (p1
= strstr(p1
, " from ")))
5218 strbuf_addstr(&label
, p1
+ strlen(" from "));
5220 strbuf_addbuf(&label
, &oneline
);
5223 strbuf_addf(&buf
, "%s -C %s",
5224 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
5226 /* label the tips of merged branches */
5227 for (; to_merge
; to_merge
= to_merge
->next
) {
5228 oid
= &to_merge
->item
->object
.oid
;
5229 strbuf_addch(&buf
, ' ');
5231 if (!oidset_contains(&interesting
, oid
)) {
5232 strbuf_addstr(&buf
, label_oid(oid
, NULL
,
5237 tips_tail
= &commit_list_insert(to_merge
->item
,
5240 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
5242 strbuf_addf(&buf
, " # %s", oneline
.buf
);
5244 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5245 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5246 oidmap_put(&commit2todo
, entry
);
5249 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5250 _("use --reapply-cherry-picks to include skipped commits"));
5254 * - label branch points
5255 * - add HEAD to the branch tips
5257 for (iter
= commits
; iter
; iter
= iter
->next
) {
5258 struct commit_list
*parent
= iter
->item
->parents
;
5259 for (; parent
; parent
= parent
->next
) {
5260 struct object_id
*oid
= &parent
->item
->object
.oid
;
5261 if (!oidset_contains(&interesting
, oid
))
5263 if (oidset_insert(&child_seen
, oid
))
5264 label_oid(oid
, "branch-point", &state
);
5267 /* Add HEAD as implicit "tip of branch" */
5269 tips_tail
= &commit_list_insert(iter
->item
,
5274 * Third phase: output the todo list. This is a bit tricky, as we
5275 * want to avoid jumping back and forth between revisions. To
5276 * accomplish that goal, we walk backwards from the branch tips,
5277 * gathering commits not yet shown, reversing the list on the fly,
5278 * then outputting that list (labeling revisions as needed).
5280 strbuf_addf(out
, "%s onto\n", cmd_label
);
5281 for (iter
= tips
; iter
; iter
= iter
->next
) {
5282 struct commit_list
*list
= NULL
, *iter2
;
5284 commit
= iter
->item
;
5285 if (oidset_contains(&shown
, &commit
->object
.oid
))
5287 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
5290 strbuf_addf(out
, "\n%c Branch %s\n", comment_line_char
, entry
->string
);
5292 strbuf_addch(out
, '\n');
5294 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
5295 !oidset_contains(&shown
, &commit
->object
.oid
)) {
5296 commit_list_insert(commit
, &list
);
5297 if (!commit
->parents
) {
5301 commit
= commit
->parents
->item
;
5305 strbuf_addf(out
, "%s %s\n", cmd_reset
,
5306 rebase_cousins
|| root_with_onto
?
5307 "onto" : "[new root]");
5309 const char *to
= NULL
;
5311 entry
= oidmap_get(&state
.commit2label
,
5312 &commit
->object
.oid
);
5315 else if (!rebase_cousins
)
5316 to
= label_oid(&commit
->object
.oid
, NULL
,
5319 if (!to
|| !strcmp(to
, "onto"))
5320 strbuf_addf(out
, "%s onto\n", cmd_reset
);
5322 strbuf_reset(&oneline
);
5323 pretty_print_commit(pp
, commit
, &oneline
);
5324 strbuf_addf(out
, "%s %s # %s\n",
5325 cmd_reset
, to
, oneline
.buf
);
5329 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
5330 struct object_id
*oid
= &iter2
->item
->object
.oid
;
5331 entry
= oidmap_get(&commit2todo
, oid
);
5332 /* only show if not already upstream */
5334 strbuf_addf(out
, "%s\n", entry
->string
);
5335 entry
= oidmap_get(&state
.commit2label
, oid
);
5337 strbuf_addf(out
, "%s %s\n",
5338 cmd_label
, entry
->string
);
5339 oidset_insert(&shown
, oid
);
5342 free_commit_list(list
);
5345 free_commit_list(commits
);
5346 free_commit_list(tips
);
5348 strbuf_release(&label
);
5349 strbuf_release(&oneline
);
5350 strbuf_release(&buf
);
5352 oidmap_free(&commit2todo
, 1);
5353 oidmap_free(&state
.commit2label
, 1);
5354 hashmap_clear_and_free(&state
.labels
, struct labels_entry
, entry
);
5355 strbuf_release(&state
.buf
);
5360 int sequencer_make_script(struct repository
*r
, struct strbuf
*out
, int argc
,
5361 const char **argv
, unsigned flags
)
5363 char *format
= NULL
;
5364 struct pretty_print_context pp
= {0};
5365 struct rev_info revs
;
5366 struct commit
*commit
;
5367 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5368 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
5369 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
5370 int reapply_cherry_picks
= flags
& TODO_LIST_REAPPLY_CHERRY_PICKS
;
5371 int skipped_commit
= 0;
5373 repo_init_revisions(r
, &revs
, NULL
);
5374 revs
.verbose_header
= 1;
5376 revs
.max_parents
= 1;
5377 revs
.cherry_mark
= !reapply_cherry_picks
;
5380 revs
.right_only
= 1;
5381 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
5382 revs
.topo_order
= 1;
5384 revs
.pretty_given
= 1;
5385 git_config_get_string("rebase.instructionFormat", &format
);
5386 if (!format
|| !*format
) {
5388 format
= xstrdup("%s");
5390 get_commit_format(format
, &revs
);
5392 pp
.fmt
= revs
.commit_format
;
5393 pp
.output_encoding
= get_log_output_encoding();
5395 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1)
5396 return error(_("make_script: unhandled options"));
5398 if (prepare_revision_walk(&revs
) < 0)
5399 return error(_("make_script: error preparing revisions"));
5402 return make_script_with_merges(&pp
, &revs
, out
, flags
);
5404 while ((commit
= get_revision(&revs
))) {
5405 int is_empty
= is_original_commit_empty(commit
);
5407 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5408 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5409 warning(_("skipped previously applied commit %s"),
5410 short_commit_name(commit
));
5414 if (is_empty
&& !keep_empty
)
5416 strbuf_addf(out
, "%s %s ", insn
,
5417 oid_to_hex(&commit
->object
.oid
));
5418 pretty_print_commit(&pp
, commit
, out
);
5420 strbuf_addf(out
, " %c empty", comment_line_char
);
5421 strbuf_addch(out
, '\n');
5424 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5425 _("use --reapply-cherry-picks to include skipped commits"));
5430 * Add commands after pick and (series of) squash/fixup commands
5433 void todo_list_add_exec_commands(struct todo_list
*todo_list
,
5434 struct string_list
*commands
)
5436 struct strbuf
*buf
= &todo_list
->buf
;
5437 size_t base_offset
= buf
->len
;
5438 int i
, insert
, nr
= 0, alloc
= 0;
5439 struct todo_item
*items
= NULL
, *base_items
= NULL
;
5441 CALLOC_ARRAY(base_items
, commands
->nr
);
5442 for (i
= 0; i
< commands
->nr
; i
++) {
5443 size_t command_len
= strlen(commands
->items
[i
].string
);
5445 strbuf_addstr(buf
, commands
->items
[i
].string
);
5446 strbuf_addch(buf
, '\n');
5448 base_items
[i
].command
= TODO_EXEC
;
5449 base_items
[i
].offset_in_buf
= base_offset
;
5450 base_items
[i
].arg_offset
= base_offset
+ strlen("exec ");
5451 base_items
[i
].arg_len
= command_len
- strlen("exec ");
5453 base_offset
+= command_len
+ 1;
5457 * Insert <commands> after every pick. Here, fixup/squash chains
5458 * are considered part of the pick, so we insert the commands *after*
5459 * those chains if there are any.
5461 * As we insert the exec commands immediately after rearranging
5462 * any fixups and before the user edits the list, a fixup chain
5463 * can never contain comments (any comments are empty picks that
5464 * have been commented out because the user did not specify
5465 * --keep-empty). So, it is safe to insert an exec command
5466 * without looking at the command following a comment.
5469 for (i
= 0; i
< todo_list
->nr
; i
++) {
5470 enum todo_command command
= todo_list
->items
[i
].command
;
5471 if (insert
&& !is_fixup(command
)) {
5472 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5473 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5479 ALLOC_GROW(items
, nr
+ 1, alloc
);
5480 items
[nr
++] = todo_list
->items
[i
];
5482 if (command
== TODO_PICK
|| command
== TODO_MERGE
)
5486 /* insert or append final <commands> */
5487 if (insert
|| nr
== todo_list
->nr
) {
5488 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5489 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5494 FREE_AND_NULL(todo_list
->items
);
5495 todo_list
->items
= items
;
5497 todo_list
->alloc
= alloc
;
5500 static void todo_list_to_strbuf(struct repository
*r
, struct todo_list
*todo_list
,
5501 struct strbuf
*buf
, int num
, unsigned flags
)
5503 struct todo_item
*item
;
5504 int i
, max
= todo_list
->nr
;
5506 if (num
> 0 && num
< max
)
5509 for (item
= todo_list
->items
, i
= 0; i
< max
; i
++, item
++) {
5512 /* if the item is not a command write it and continue */
5513 if (item
->command
>= TODO_COMMENT
) {
5514 strbuf_addf(buf
, "%.*s\n", item
->arg_len
,
5515 todo_item_get_arg(todo_list
, item
));
5519 /* add command to the buffer */
5520 cmd
= command_to_char(item
->command
);
5521 if ((flags
& TODO_LIST_ABBREVIATE_CMDS
) && cmd
)
5522 strbuf_addch(buf
, cmd
);
5524 strbuf_addstr(buf
, command_to_string(item
->command
));
5528 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
5529 short_commit_name(item
->commit
) :
5530 oid_to_hex(&item
->commit
->object
.oid
);
5532 if (item
->command
== TODO_FIXUP
) {
5533 if (item
->flags
& TODO_EDIT_FIXUP_MSG
)
5534 strbuf_addstr(buf
, " -c");
5535 else if (item
->flags
& TODO_REPLACE_FIXUP_MSG
) {
5536 strbuf_addstr(buf
, " -C");
5540 if (item
->command
== TODO_MERGE
) {
5541 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
5542 strbuf_addstr(buf
, " -c");
5544 strbuf_addstr(buf
, " -C");
5547 strbuf_addf(buf
, " %s", oid
);
5550 /* add all the rest */
5552 strbuf_addch(buf
, '\n');
5554 strbuf_addf(buf
, " %.*s\n", item
->arg_len
,
5555 todo_item_get_arg(todo_list
, item
));
5559 int todo_list_write_to_file(struct repository
*r
, struct todo_list
*todo_list
,
5560 const char *file
, const char *shortrevisions
,
5561 const char *shortonto
, int num
, unsigned flags
)
5564 struct strbuf buf
= STRBUF_INIT
;
5566 todo_list_to_strbuf(r
, todo_list
, &buf
, num
, flags
);
5567 if (flags
& TODO_LIST_APPEND_TODO_HELP
)
5568 append_todo_help(count_commands(todo_list
),
5569 shortrevisions
, shortonto
, &buf
);
5571 res
= write_message(buf
.buf
, buf
.len
, file
, 0);
5572 strbuf_release(&buf
);
5577 /* skip picking commits whose parents are unchanged */
5578 static int skip_unnecessary_picks(struct repository
*r
,
5579 struct todo_list
*todo_list
,
5580 struct object_id
*base_oid
)
5582 struct object_id
*parent_oid
;
5585 for (i
= 0; i
< todo_list
->nr
; i
++) {
5586 struct todo_item
*item
= todo_list
->items
+ i
;
5588 if (item
->command
>= TODO_NOOP
)
5590 if (item
->command
!= TODO_PICK
)
5592 if (parse_commit(item
->commit
)) {
5593 return error(_("could not parse commit '%s'"),
5594 oid_to_hex(&item
->commit
->object
.oid
));
5596 if (!item
->commit
->parents
)
5597 break; /* root commit */
5598 if (item
->commit
->parents
->next
)
5599 break; /* merge commit */
5600 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
5601 if (!oideq(parent_oid
, base_oid
))
5603 oidcpy(base_oid
, &item
->commit
->object
.oid
);
5606 const char *done_path
= rebase_path_done();
5608 if (todo_list_write_to_file(r
, todo_list
, done_path
, NULL
, NULL
, i
, 0)) {
5609 error_errno(_("could not write to '%s'"), done_path
);
5613 MOVE_ARRAY(todo_list
->items
, todo_list
->items
+ i
, todo_list
->nr
- i
);
5615 todo_list
->current
= 0;
5616 todo_list
->done_nr
+= i
;
5618 if (is_fixup(peek_command(todo_list
, 0)))
5619 record_in_rewritten(base_oid
, peek_command(todo_list
, 0));
5625 int complete_action(struct repository
*r
, struct replay_opts
*opts
, unsigned flags
,
5626 const char *shortrevisions
, const char *onto_name
,
5627 struct commit
*onto
, const struct object_id
*orig_head
,
5628 struct string_list
*commands
, unsigned autosquash
,
5629 struct todo_list
*todo_list
)
5631 char shortonto
[GIT_MAX_HEXSZ
+ 1];
5632 const char *todo_file
= rebase_path_todo();
5633 struct todo_list new_todo
= TODO_LIST_INIT
;
5634 struct strbuf
*buf
= &todo_list
->buf
, buf2
= STRBUF_INIT
;
5635 struct object_id oid
= onto
->object
.oid
;
5638 find_unique_abbrev_r(shortonto
, &oid
, DEFAULT_ABBREV
);
5640 if (buf
->len
== 0) {
5641 struct todo_item
*item
= append_new_todo(todo_list
);
5642 item
->command
= TODO_NOOP
;
5643 item
->commit
= NULL
;
5644 item
->arg_len
= item
->arg_offset
= item
->flags
= item
->offset_in_buf
= 0;
5647 if (autosquash
&& todo_list_rearrange_squash(todo_list
))
5651 todo_list_add_exec_commands(todo_list
, commands
);
5653 if (count_commands(todo_list
) == 0) {
5654 apply_autostash(rebase_path_autostash());
5655 sequencer_remove_state(opts
);
5657 return error(_("nothing to do"));
5660 res
= edit_todo_list(r
, todo_list
, &new_todo
, shortrevisions
,
5664 else if (res
== -2) {
5665 apply_autostash(rebase_path_autostash());
5666 sequencer_remove_state(opts
);
5669 } else if (res
== -3) {
5670 apply_autostash(rebase_path_autostash());
5671 sequencer_remove_state(opts
);
5672 todo_list_release(&new_todo
);
5674 return error(_("nothing to do"));
5675 } else if (res
== -4) {
5676 checkout_onto(r
, opts
, onto_name
, &onto
->object
.oid
, orig_head
);
5677 todo_list_release(&new_todo
);
5682 /* Expand the commit IDs */
5683 todo_list_to_strbuf(r
, &new_todo
, &buf2
, -1, 0);
5684 strbuf_swap(&new_todo
.buf
, &buf2
);
5685 strbuf_release(&buf2
);
5686 new_todo
.total_nr
-= new_todo
.nr
;
5687 if (todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
) < 0)
5688 BUG("invalid todo list after expanding IDs:\n%s",
5691 if (opts
->allow_ff
&& skip_unnecessary_picks(r
, &new_todo
, &oid
)) {
5692 todo_list_release(&new_todo
);
5693 return error(_("could not skip unnecessary pick commands"));
5696 if (todo_list_write_to_file(r
, &new_todo
, todo_file
, NULL
, NULL
, -1,
5697 flags
& ~(TODO_LIST_SHORTEN_IDS
))) {
5698 todo_list_release(&new_todo
);
5699 return error_errno(_("could not write '%s'"), todo_file
);
5704 if (checkout_onto(r
, opts
, onto_name
, &oid
, orig_head
))
5707 if (require_clean_work_tree(r
, "rebase", "", 1, 1))
5710 todo_list_write_total_nr(&new_todo
);
5711 res
= pick_commits(r
, &new_todo
, opts
);
5714 todo_list_release(&new_todo
);
5719 struct subject2item_entry
{
5720 struct hashmap_entry entry
;
5722 char subject
[FLEX_ARRAY
];
5725 static int subject2item_cmp(const void *fndata
,
5726 const struct hashmap_entry
*eptr
,
5727 const struct hashmap_entry
*entry_or_key
,
5730 const struct subject2item_entry
*a
, *b
;
5732 a
= container_of(eptr
, const struct subject2item_entry
, entry
);
5733 b
= container_of(entry_or_key
, const struct subject2item_entry
, entry
);
5735 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
5738 define_commit_slab(commit_todo_item
, struct todo_item
*);
5740 static int skip_fixupish(const char *subject
, const char **p
) {
5741 return skip_prefix(subject
, "fixup! ", p
) ||
5742 skip_prefix(subject
, "amend! ", p
) ||
5743 skip_prefix(subject
, "squash! ", p
);
5747 * Rearrange the todo list that has both "pick commit-id msg" and "pick
5748 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
5749 * after the former, and change "pick" to "fixup"/"squash".
5751 * Note that if the config has specified a custom instruction format, each log
5752 * message will have to be retrieved from the commit (as the oneline in the
5753 * script cannot be trusted) in order to normalize the autosquash arrangement.
5755 int todo_list_rearrange_squash(struct todo_list
*todo_list
)
5757 struct hashmap subject2item
;
5758 int rearranged
= 0, *next
, *tail
, i
, nr
= 0, alloc
= 0;
5760 struct commit_todo_item commit_todo
;
5761 struct todo_item
*items
= NULL
;
5763 init_commit_todo_item(&commit_todo
);
5765 * The hashmap maps onelines to the respective todo list index.
5767 * If any items need to be rearranged, the next[i] value will indicate
5768 * which item was moved directly after the i'th.
5770 * In that case, last[i] will indicate the index of the latest item to
5771 * be moved to appear after the i'th.
5773 hashmap_init(&subject2item
, subject2item_cmp
, NULL
, todo_list
->nr
);
5774 ALLOC_ARRAY(next
, todo_list
->nr
);
5775 ALLOC_ARRAY(tail
, todo_list
->nr
);
5776 ALLOC_ARRAY(subjects
, todo_list
->nr
);
5777 for (i
= 0; i
< todo_list
->nr
; i
++) {
5778 struct strbuf buf
= STRBUF_INIT
;
5779 struct todo_item
*item
= todo_list
->items
+ i
;
5780 const char *commit_buffer
, *subject
, *p
;
5783 struct subject2item_entry
*entry
;
5785 next
[i
] = tail
[i
] = -1;
5786 if (!item
->commit
|| item
->command
== TODO_DROP
) {
5791 if (is_fixup(item
->command
)) {
5792 clear_commit_todo_item(&commit_todo
);
5793 return error(_("the script was already rearranged."));
5796 *commit_todo_item_at(&commit_todo
, item
->commit
) = item
;
5798 parse_commit(item
->commit
);
5799 commit_buffer
= logmsg_reencode(item
->commit
, NULL
, "UTF-8");
5800 find_commit_subject(commit_buffer
, &subject
);
5801 format_subject(&buf
, subject
, " ");
5802 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
5803 unuse_commit_buffer(item
->commit
, commit_buffer
);
5804 if (skip_fixupish(subject
, &p
)) {
5805 struct commit
*commit2
;
5810 if (!skip_fixupish(p
, &p
))
5814 entry
= hashmap_get_entry_from_hash(&subject2item
,
5816 struct subject2item_entry
,
5819 /* found by title */
5821 else if (!strchr(p
, ' ') &&
5823 lookup_commit_reference_by_name(p
)) &&
5824 *commit_todo_item_at(&commit_todo
, commit2
))
5825 /* found by commit name */
5826 i2
= *commit_todo_item_at(&commit_todo
, commit2
)
5829 /* copy can be a prefix of the commit subject */
5830 for (i2
= 0; i2
< i
; i2
++)
5832 starts_with(subjects
[i2
], p
))
5840 if (starts_with(subject
, "fixup!")) {
5841 todo_list
->items
[i
].command
= TODO_FIXUP
;
5842 } else if (starts_with(subject
, "amend!")) {
5843 todo_list
->items
[i
].command
= TODO_FIXUP
;
5844 todo_list
->items
[i
].flags
= TODO_REPLACE_FIXUP_MSG
;
5846 todo_list
->items
[i
].command
= TODO_SQUASH
;
5852 next
[i
] = next
[tail
[i2
]];
5856 } else if (!hashmap_get_from_hash(&subject2item
,
5857 strhash(subject
), subject
)) {
5858 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
5860 hashmap_entry_init(&entry
->entry
,
5861 strhash(entry
->subject
));
5862 hashmap_put(&subject2item
, &entry
->entry
);
5867 for (i
= 0; i
< todo_list
->nr
; i
++) {
5868 enum todo_command command
= todo_list
->items
[i
].command
;
5872 * Initially, all commands are 'pick's. If it is a
5873 * fixup or a squash now, we have rearranged it.
5875 if (is_fixup(command
))
5879 ALLOC_GROW(items
, nr
+ 1, alloc
);
5880 items
[nr
++] = todo_list
->items
[cur
];
5885 FREE_AND_NULL(todo_list
->items
);
5886 todo_list
->items
= items
;
5888 todo_list
->alloc
= alloc
;
5893 for (i
= 0; i
< todo_list
->nr
; i
++)
5896 hashmap_clear_and_free(&subject2item
, struct subject2item_entry
, entry
);
5898 clear_commit_todo_item(&commit_todo
);
5903 int sequencer_determine_whence(struct repository
*r
, enum commit_whence
*whence
)
5905 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
5906 struct object_id cherry_pick_head
, rebase_head
;
5908 if (file_exists(git_path_seq_dir()))
5909 *whence
= FROM_CHERRY_PICK_MULTI
;
5910 if (file_exists(rebase_path()) &&
5911 !get_oid("REBASE_HEAD", &rebase_head
) &&
5912 !get_oid("CHERRY_PICK_HEAD", &cherry_pick_head
) &&
5913 oideq(&rebase_head
, &cherry_pick_head
))
5914 *whence
= FROM_REBASE_PICK
;
5916 *whence
= FROM_CHERRY_PICK_SINGLE
;