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 ensure_full_index(r
->index
);
668 clean
= merge_trees(&o
, head_tree
, next_tree
, base_tree
);
669 if (is_rebase_i(opts
) && clean
<= 0)
670 fputs(o
.obuf
.buf
, stdout
);
671 strbuf_release(&o
.obuf
);
674 rollback_lock_file(&index_lock
);
678 if (write_locked_index(r
->index
, &index_lock
,
679 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
681 * TRANSLATORS: %s will be "revert", "cherry-pick" or
684 return error(_("%s: Unable to write new index file"),
685 _(action_name(opts
)));
688 append_conflicts_hint(r
->index
, msgbuf
,
689 opts
->default_msg_cleanup
);
694 static struct object_id
*get_cache_tree_oid(struct index_state
*istate
)
696 if (!cache_tree_fully_valid(istate
->cache_tree
))
697 if (cache_tree_update(istate
, 0)) {
698 error(_("unable to update cache tree"));
702 return &istate
->cache_tree
->oid
;
705 static int is_index_unchanged(struct repository
*r
)
707 struct object_id head_oid
, *cache_tree_oid
;
708 struct commit
*head_commit
;
709 struct index_state
*istate
= r
->index
;
711 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
712 return error(_("could not resolve HEAD commit"));
714 head_commit
= lookup_commit(r
, &head_oid
);
717 * If head_commit is NULL, check_commit, called from
718 * lookup_commit, would have indicated that head_commit is not
719 * a commit object already. parse_commit() will return failure
720 * without further complaints in such a case. Otherwise, if
721 * the commit is invalid, parse_commit() will complain. So
722 * there is nothing for us to say here. Just return failure.
724 if (parse_commit(head_commit
))
727 if (!(cache_tree_oid
= get_cache_tree_oid(istate
)))
730 return oideq(cache_tree_oid
, get_commit_tree_oid(head_commit
));
733 static int write_author_script(const char *message
)
735 struct strbuf buf
= STRBUF_INIT
;
740 if (!*message
|| starts_with(message
, "\n")) {
742 /* Missing 'author' line? */
743 unlink(rebase_path_author_script());
745 } else if (skip_prefix(message
, "author ", &message
))
747 else if ((eol
= strchr(message
, '\n')))
752 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
753 while (*message
&& *message
!= '\n' && *message
!= '\r')
754 if (skip_prefix(message
, " <", &message
))
756 else if (*message
!= '\'')
757 strbuf_addch(&buf
, *(message
++));
759 strbuf_addf(&buf
, "'\\%c'", *(message
++));
760 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
761 while (*message
&& *message
!= '\n' && *message
!= '\r')
762 if (skip_prefix(message
, "> ", &message
))
764 else if (*message
!= '\'')
765 strbuf_addch(&buf
, *(message
++));
767 strbuf_addf(&buf
, "'\\%c'", *(message
++));
768 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
769 while (*message
&& *message
!= '\n' && *message
!= '\r')
770 if (*message
!= '\'')
771 strbuf_addch(&buf
, *(message
++));
773 strbuf_addf(&buf
, "'\\%c'", *(message
++));
774 strbuf_addch(&buf
, '\'');
775 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
776 strbuf_release(&buf
);
781 * Take a series of KEY='VALUE' lines where VALUE part is
782 * sq-quoted, and append <KEY, VALUE> at the end of the string list
784 static int parse_key_value_squoted(char *buf
, struct string_list
*list
)
787 struct string_list_item
*item
;
789 char *cp
= strchr(buf
, '=');
791 np
= strchrnul(buf
, '\n');
792 return error(_("no key present in '%.*s'"),
793 (int) (np
- buf
), buf
);
795 np
= strchrnul(cp
, '\n');
797 item
= string_list_append(list
, buf
);
799 buf
= np
+ (*np
== '\n');
803 return error(_("unable to dequote value of '%s'"),
805 item
->util
= xstrdup(cp
);
811 * Reads and parses the state directory's "author-script" file, and sets name,
812 * email and date accordingly.
813 * Returns 0 on success, -1 if the file could not be parsed.
815 * The author script is of the format:
817 * GIT_AUTHOR_NAME='$author_name'
818 * GIT_AUTHOR_EMAIL='$author_email'
819 * GIT_AUTHOR_DATE='$author_date'
821 * where $author_name, $author_email and $author_date are quoted. We are strict
822 * with our parsing, as the file was meant to be eval'd in the now-removed
823 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
824 * from what this function expects, it is better to bail out than to do
825 * something that the user does not expect.
827 int read_author_script(const char *path
, char **name
, char **email
, char **date
,
830 struct strbuf buf
= STRBUF_INIT
;
831 struct string_list kv
= STRING_LIST_INIT_DUP
;
832 int retval
= -1; /* assume failure */
833 int i
, name_i
= -2, email_i
= -2, date_i
= -2, err
= 0;
835 if (strbuf_read_file(&buf
, path
, 256) <= 0) {
836 strbuf_release(&buf
);
837 if (errno
== ENOENT
&& allow_missing
)
840 return error_errno(_("could not open '%s' for reading"),
844 if (parse_key_value_squoted(buf
.buf
, &kv
))
847 for (i
= 0; i
< kv
.nr
; i
++) {
848 if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_NAME")) {
850 name_i
= error(_("'GIT_AUTHOR_NAME' already given"));
853 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_EMAIL")) {
855 email_i
= error(_("'GIT_AUTHOR_EMAIL' already given"));
858 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_DATE")) {
860 date_i
= error(_("'GIT_AUTHOR_DATE' already given"));
864 err
= error(_("unknown variable '%s'"),
869 error(_("missing 'GIT_AUTHOR_NAME'"));
871 error(_("missing 'GIT_AUTHOR_EMAIL'"));
873 error(_("missing 'GIT_AUTHOR_DATE'"));
874 if (date_i
< 0 || email_i
< 0 || date_i
< 0 || err
)
876 *name
= kv
.items
[name_i
].util
;
877 *email
= kv
.items
[email_i
].util
;
878 *date
= kv
.items
[date_i
].util
;
881 string_list_clear(&kv
, !!retval
);
882 strbuf_release(&buf
);
887 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
888 * file with shell quoting into struct strvec. Returns -1 on
889 * error, 0 otherwise.
891 static int read_env_script(struct strvec
*env
)
893 char *name
, *email
, *date
;
895 if (read_author_script(rebase_path_author_script(),
896 &name
, &email
, &date
, 0))
899 strvec_pushf(env
, "GIT_AUTHOR_NAME=%s", name
);
900 strvec_pushf(env
, "GIT_AUTHOR_EMAIL=%s", email
);
901 strvec_pushf(env
, "GIT_AUTHOR_DATE=%s", date
);
909 static char *get_author(const char *message
)
914 a
= find_commit_header(message
, "author", &len
);
916 return xmemdupz(a
, len
);
921 static const char *author_date_from_env_array(const struct strvec
*env
)
926 for (i
= 0; i
< env
->nr
; i
++)
927 if (skip_prefix(env
->v
[i
],
928 "GIT_AUTHOR_DATE=", &date
))
931 * If GIT_AUTHOR_DATE is missing we should have already errored out when
934 BUG("GIT_AUTHOR_DATE missing from author script");
937 static const char staged_changes_advice
[] =
938 N_("you have staged changes in your working tree\n"
939 "If these changes are meant to be squashed into the previous commit, run:\n"
941 " git commit --amend %s\n"
943 "If they are meant to go into a new commit, run:\n"
947 "In both cases, once you're done, continue with:\n"
949 " git rebase --continue\n");
951 #define ALLOW_EMPTY (1<<0)
952 #define EDIT_MSG (1<<1)
953 #define AMEND_MSG (1<<2)
954 #define CLEANUP_MSG (1<<3)
955 #define VERIFY_MSG (1<<4)
956 #define CREATE_ROOT_COMMIT (1<<5)
957 #define VERBATIM_MSG (1<<6)
959 static int run_command_silent_on_success(struct child_process
*cmd
)
961 struct strbuf buf
= STRBUF_INIT
;
964 cmd
->stdout_to_stderr
= 1;
965 rc
= pipe_command(cmd
,
971 fputs(buf
.buf
, stderr
);
972 strbuf_release(&buf
);
977 * If we are cherry-pick, and if the merge did not result in
978 * hand-editing, we will hit this commit and inherit the original
979 * author date and name.
981 * If we are revert, or if our cherry-pick results in a hand merge,
982 * we had better say that the current user is responsible for that.
984 * An exception is when run_git_commit() is called during an
985 * interactive rebase: in that case, we will want to retain the
988 static int run_git_commit(const char *defmsg
,
989 struct replay_opts
*opts
,
992 struct child_process cmd
= CHILD_PROCESS_INIT
;
994 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
995 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
999 if (is_rebase_i(opts
) && !(!defmsg
&& (flags
& AMEND_MSG
)) &&
1000 read_env_script(&cmd
.env_array
)) {
1001 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
1003 return error(_(staged_changes_advice
),
1007 if (opts
->committer_date_is_author_date
)
1008 strvec_pushf(&cmd
.env_array
, "GIT_COMMITTER_DATE=%s",
1011 author_date_from_env_array(&cmd
.env_array
));
1012 if (opts
->ignore_date
)
1013 strvec_push(&cmd
.env_array
, "GIT_AUTHOR_DATE=");
1015 strvec_push(&cmd
.args
, "commit");
1017 if (!(flags
& VERIFY_MSG
))
1018 strvec_push(&cmd
.args
, "-n");
1019 if ((flags
& AMEND_MSG
))
1020 strvec_push(&cmd
.args
, "--amend");
1022 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
1024 strvec_push(&cmd
.args
, "--no-gpg-sign");
1026 strvec_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
1027 else if (!(flags
& EDIT_MSG
))
1028 strvec_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
1029 if ((flags
& CLEANUP_MSG
))
1030 strvec_push(&cmd
.args
, "--cleanup=strip");
1031 if ((flags
& VERBATIM_MSG
))
1032 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1033 if ((flags
& EDIT_MSG
))
1034 strvec_push(&cmd
.args
, "-e");
1035 else if (!(flags
& CLEANUP_MSG
) &&
1036 !opts
->signoff
&& !opts
->record_origin
&&
1037 !opts
->explicit_cleanup
)
1038 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1040 if ((flags
& ALLOW_EMPTY
))
1041 strvec_push(&cmd
.args
, "--allow-empty");
1043 if (!(flags
& EDIT_MSG
))
1044 strvec_push(&cmd
.args
, "--allow-empty-message");
1046 if (is_rebase_i(opts
) && !(flags
& EDIT_MSG
))
1047 return run_command_silent_on_success(&cmd
);
1049 return run_command(&cmd
);
1052 static int rest_is_empty(const struct strbuf
*sb
, int start
)
1057 /* Check if the rest is just whitespace and Signed-off-by's. */
1058 for (i
= start
; i
< sb
->len
; i
++) {
1059 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1065 if (strlen(sign_off_header
) <= eol
- i
&&
1066 starts_with(sb
->buf
+ i
, sign_off_header
)) {
1071 if (!isspace(sb
->buf
[i
++]))
1078 void cleanup_message(struct strbuf
*msgbuf
,
1079 enum commit_msg_cleanup_mode cleanup_mode
, int verbose
)
1081 if (verbose
|| /* Truncate the message just before the diff, if any. */
1082 cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
1083 strbuf_setlen(msgbuf
, wt_status_locate_end(msgbuf
->buf
, msgbuf
->len
));
1084 if (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
)
1085 strbuf_stripspace(msgbuf
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1089 * Find out if the message in the strbuf contains only whitespace and
1090 * Signed-off-by lines.
1092 int message_is_empty(const struct strbuf
*sb
,
1093 enum commit_msg_cleanup_mode cleanup_mode
)
1095 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1097 return rest_is_empty(sb
, 0);
1101 * See if the user edited the message in the editor or left what
1102 * was in the template intact
1104 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
1105 enum commit_msg_cleanup_mode cleanup_mode
)
1107 struct strbuf tmpl
= STRBUF_INIT
;
1110 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1113 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
1116 strbuf_stripspace(&tmpl
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1117 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
1119 strbuf_release(&tmpl
);
1120 return rest_is_empty(sb
, start
- sb
->buf
);
1123 int update_head_with_reflog(const struct commit
*old_head
,
1124 const struct object_id
*new_head
,
1125 const char *action
, const struct strbuf
*msg
,
1128 struct ref_transaction
*transaction
;
1129 struct strbuf sb
= STRBUF_INIT
;
1134 strbuf_addstr(&sb
, action
);
1135 strbuf_addstr(&sb
, ": ");
1138 nl
= strchr(msg
->buf
, '\n');
1140 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
1142 strbuf_addbuf(&sb
, msg
);
1143 strbuf_addch(&sb
, '\n');
1146 transaction
= ref_transaction_begin(err
);
1148 ref_transaction_update(transaction
, "HEAD", new_head
,
1149 old_head
? &old_head
->object
.oid
: null_oid(),
1151 ref_transaction_commit(transaction
, err
)) {
1154 ref_transaction_free(transaction
);
1155 strbuf_release(&sb
);
1160 static int run_rewrite_hook(const struct object_id
*oldoid
,
1161 const struct object_id
*newoid
)
1163 struct child_process proc
= CHILD_PROCESS_INIT
;
1164 const char *argv
[3];
1166 struct strbuf sb
= STRBUF_INIT
;
1168 argv
[0] = find_hook("post-rewrite");
1177 proc
.stdout_to_stderr
= 1;
1178 proc
.trace2_hook_name
= "post-rewrite";
1180 code
= start_command(&proc
);
1183 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
1184 sigchain_push(SIGPIPE
, SIG_IGN
);
1185 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
1187 strbuf_release(&sb
);
1188 sigchain_pop(SIGPIPE
);
1189 return finish_command(&proc
);
1192 void commit_post_rewrite(struct repository
*r
,
1193 const struct commit
*old_head
,
1194 const struct object_id
*new_head
)
1196 struct notes_rewrite_cfg
*cfg
;
1198 cfg
= init_copy_notes_for_rewrite("amend");
1200 /* we are amending, so old_head is not NULL */
1201 copy_note_for_rewrite(cfg
, &old_head
->object
.oid
, new_head
);
1202 finish_copy_notes_for_rewrite(r
, cfg
, "Notes added by 'git commit --amend'");
1204 run_rewrite_hook(&old_head
->object
.oid
, new_head
);
1207 static int run_prepare_commit_msg_hook(struct repository
*r
,
1212 const char *name
, *arg1
= NULL
, *arg2
= NULL
;
1214 name
= git_path_commit_editmsg();
1215 if (write_message(msg
->buf
, msg
->len
, name
, 0))
1224 if (run_commit_hook(0, r
->index_file
, "prepare-commit-msg", name
,
1226 ret
= error(_("'prepare-commit-msg' hook failed"));
1231 static const char implicit_ident_advice_noconfig
[] =
1232 N_("Your name and email address were configured automatically based\n"
1233 "on your username and hostname. Please check that they are accurate.\n"
1234 "You can suppress this message by setting them explicitly. Run the\n"
1235 "following command and follow the instructions in your editor to edit\n"
1236 "your configuration file:\n"
1238 " git config --global --edit\n"
1240 "After doing this, you may fix the identity used for this commit with:\n"
1242 " git commit --amend --reset-author\n");
1244 static const char implicit_ident_advice_config
[] =
1245 N_("Your name and email address were configured automatically based\n"
1246 "on your username and hostname. Please check that they are accurate.\n"
1247 "You can suppress this message by setting them explicitly:\n"
1249 " git config --global user.name \"Your Name\"\n"
1250 " git config --global user.email you@example.com\n"
1252 "After doing this, you may fix the identity used for this commit with:\n"
1254 " git commit --amend --reset-author\n");
1256 static const char *implicit_ident_advice(void)
1258 char *user_config
= interpolate_path("~/.gitconfig", 0);
1259 char *xdg_config
= xdg_config_home("config");
1260 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1266 return _(implicit_ident_advice_config
);
1268 return _(implicit_ident_advice_noconfig
);
1272 void print_commit_summary(struct repository
*r
,
1274 const struct object_id
*oid
,
1277 struct rev_info rev
;
1278 struct commit
*commit
;
1279 struct strbuf format
= STRBUF_INIT
;
1281 struct pretty_print_context pctx
= {0};
1282 struct strbuf author_ident
= STRBUF_INIT
;
1283 struct strbuf committer_ident
= STRBUF_INIT
;
1285 commit
= lookup_commit(r
, oid
);
1287 die(_("couldn't look up newly created commit"));
1288 if (parse_commit(commit
))
1289 die(_("could not parse newly created commit"));
1291 strbuf_addstr(&format
, "format:%h] %s");
1293 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1294 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1295 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1296 strbuf_addstr(&format
, "\n Author: ");
1297 strbuf_addbuf_percentquote(&format
, &author_ident
);
1299 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
1300 struct strbuf date
= STRBUF_INIT
;
1302 format_commit_message(commit
, "%ad", &date
, &pctx
);
1303 strbuf_addstr(&format
, "\n Date: ");
1304 strbuf_addbuf_percentquote(&format
, &date
);
1305 strbuf_release(&date
);
1307 if (!committer_ident_sufficiently_given()) {
1308 strbuf_addstr(&format
, "\n Committer: ");
1309 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1310 if (advice_enabled(ADVICE_IMPLICIT_IDENTITY
)) {
1311 strbuf_addch(&format
, '\n');
1312 strbuf_addstr(&format
, implicit_ident_advice());
1315 strbuf_release(&author_ident
);
1316 strbuf_release(&committer_ident
);
1318 repo_init_revisions(r
, &rev
, prefix
);
1319 setup_revisions(0, NULL
, &rev
, NULL
);
1322 rev
.diffopt
.output_format
=
1323 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1325 rev
.verbose_header
= 1;
1326 rev
.show_root_diff
= 1;
1327 get_commit_format(format
.buf
, &rev
);
1328 rev
.always_show_header
= 0;
1329 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1330 rev
.diffopt
.break_opt
= 0;
1331 diff_setup_done(&rev
.diffopt
);
1333 head
= resolve_ref_unsafe("HEAD", 0, NULL
, NULL
);
1335 die_errno(_("unable to resolve HEAD after creating commit"));
1336 if (!strcmp(head
, "HEAD"))
1337 head
= _("detached HEAD");
1339 skip_prefix(head
, "refs/heads/", &head
);
1340 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1341 _(" (root-commit)") : "");
1343 if (!log_tree_commit(&rev
, commit
)) {
1344 rev
.always_show_header
= 1;
1345 rev
.use_terminator
= 1;
1346 log_tree_commit(&rev
, commit
);
1349 strbuf_release(&format
);
1352 static int parse_head(struct repository
*r
, struct commit
**head
)
1354 struct commit
*current_head
;
1355 struct object_id oid
;
1357 if (get_oid("HEAD", &oid
)) {
1358 current_head
= NULL
;
1360 current_head
= lookup_commit_reference(r
, &oid
);
1362 return error(_("could not parse HEAD"));
1363 if (!oideq(&oid
, ¤t_head
->object
.oid
)) {
1364 warning(_("HEAD %s is not a commit!"),
1367 if (parse_commit(current_head
))
1368 return error(_("could not parse HEAD commit"));
1370 *head
= current_head
;
1376 * Try to commit without forking 'git commit'. In some cases we need
1377 * to run 'git commit' to display an error message
1380 * -1 - error unable to commit
1382 * 1 - run 'git commit'
1384 static int try_to_commit(struct repository
*r
,
1385 struct strbuf
*msg
, const char *author
,
1386 struct replay_opts
*opts
, unsigned int flags
,
1387 struct object_id
*oid
)
1389 struct object_id tree
;
1390 struct commit
*current_head
= NULL
;
1391 struct commit_list
*parents
= NULL
;
1392 struct commit_extra_header
*extra
= NULL
;
1393 struct strbuf err
= STRBUF_INIT
;
1394 struct strbuf commit_msg
= STRBUF_INIT
;
1395 char *amend_author
= NULL
;
1396 const char *committer
= NULL
;
1397 const char *hook_commit
= NULL
;
1398 enum commit_msg_cleanup_mode cleanup
;
1401 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1402 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1404 if (parse_head(r
, ¤t_head
))
1407 if (flags
& AMEND_MSG
) {
1408 const char *exclude_gpgsig
[] = { "gpgsig", "gpgsig-sha256", NULL
};
1409 const char *out_enc
= get_commit_output_encoding();
1410 const char *message
= logmsg_reencode(current_head
, NULL
,
1414 const char *orig_message
= NULL
;
1416 find_commit_subject(message
, &orig_message
);
1418 strbuf_addstr(msg
, orig_message
);
1419 hook_commit
= "HEAD";
1421 author
= amend_author
= get_author(message
);
1422 unuse_commit_buffer(current_head
, message
);
1424 res
= error(_("unable to parse commit author"));
1427 parents
= copy_commit_list(current_head
->parents
);
1428 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1429 } else if (current_head
&&
1430 (!(flags
& CREATE_ROOT_COMMIT
) || (flags
& AMEND_MSG
))) {
1431 commit_list_insert(current_head
, &parents
);
1434 if (write_index_as_tree(&tree
, r
->index
, r
->index_file
, 0, NULL
)) {
1435 res
= error(_("git write-tree failed to write a tree"));
1439 if (!(flags
& ALLOW_EMPTY
)) {
1440 struct commit
*first_parent
= current_head
;
1442 if (flags
& AMEND_MSG
) {
1443 if (current_head
->parents
) {
1444 first_parent
= current_head
->parents
->item
;
1445 if (repo_parse_commit(r
, first_parent
)) {
1446 res
= error(_("could not parse HEAD commit"));
1450 first_parent
= NULL
;
1453 if (oideq(first_parent
1454 ? get_commit_tree_oid(first_parent
)
1455 : the_hash_algo
->empty_tree
,
1457 res
= 1; /* run 'git commit' to display error message */
1462 if (find_hook("prepare-commit-msg")) {
1463 res
= run_prepare_commit_msg_hook(r
, msg
, hook_commit
);
1466 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1468 res
= error_errno(_("unable to read commit message "
1470 git_path_commit_editmsg());
1476 if (flags
& CLEANUP_MSG
)
1477 cleanup
= COMMIT_MSG_CLEANUP_ALL
;
1478 else if (flags
& VERBATIM_MSG
)
1479 cleanup
= COMMIT_MSG_CLEANUP_NONE
;
1480 else if ((opts
->signoff
|| opts
->record_origin
) &&
1481 !opts
->explicit_cleanup
)
1482 cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
1484 cleanup
= opts
->default_msg_cleanup
;
1486 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1487 strbuf_stripspace(msg
, cleanup
== COMMIT_MSG_CLEANUP_ALL
);
1488 if ((flags
& EDIT_MSG
) && message_is_empty(msg
, cleanup
)) {
1489 res
= 1; /* run 'git commit' to display error message */
1493 if (opts
->committer_date_is_author_date
) {
1494 struct ident_split id
;
1495 struct strbuf date
= STRBUF_INIT
;
1497 if (!opts
->ignore_date
) {
1498 if (split_ident_line(&id
, author
, (int)strlen(author
)) < 0) {
1499 res
= error(_("invalid author identity '%s'"),
1503 if (!id
.date_begin
) {
1505 "corrupt author: missing date information"));
1508 strbuf_addf(&date
, "@%.*s %.*s",
1509 (int)(id
.date_end
- id
.date_begin
),
1511 (int)(id
.tz_end
- id
.tz_begin
),
1516 committer
= fmt_ident(getenv("GIT_COMMITTER_NAME"),
1517 getenv("GIT_COMMITTER_EMAIL"),
1518 WANT_COMMITTER_IDENT
,
1519 opts
->ignore_date
? NULL
: date
.buf
,
1521 strbuf_release(&date
);
1526 if (opts
->ignore_date
) {
1527 struct ident_split id
;
1530 if (split_ident_line(&id
, author
, strlen(author
)) < 0) {
1531 error(_("invalid author identity '%s'"), author
);
1534 name
= xmemdupz(id
.name_begin
, id
.name_end
- id
.name_begin
);
1535 email
= xmemdupz(id
.mail_begin
, id
.mail_end
- id
.mail_begin
);
1536 author
= fmt_ident(name
, email
, WANT_AUTHOR_IDENT
, NULL
,
1542 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
, oid
,
1543 author
, committer
, opts
->gpg_sign
, extra
)) {
1544 res
= error(_("failed to write commit object"));
1548 if (update_head_with_reflog(current_head
, oid
,
1549 getenv("GIT_REFLOG_ACTION"), msg
, &err
)) {
1550 res
= error("%s", err
.buf
);
1554 run_commit_hook(0, r
->index_file
, "post-commit", NULL
);
1555 if (flags
& AMEND_MSG
)
1556 commit_post_rewrite(r
, current_head
, oid
);
1559 free_commit_extra_headers(extra
);
1560 strbuf_release(&err
);
1561 strbuf_release(&commit_msg
);
1567 static int write_rebase_head(struct object_id
*oid
)
1569 if (update_ref("rebase", "REBASE_HEAD", oid
,
1570 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1571 return error(_("could not update %s"), "REBASE_HEAD");
1576 static int do_commit(struct repository
*r
,
1577 const char *msg_file
, const char *author
,
1578 struct replay_opts
*opts
, unsigned int flags
,
1579 struct object_id
*oid
)
1583 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
)) {
1584 struct object_id oid
;
1585 struct strbuf sb
= STRBUF_INIT
;
1587 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1588 return error_errno(_("unable to read commit message "
1592 res
= try_to_commit(r
, msg_file
? &sb
: NULL
,
1593 author
, opts
, flags
, &oid
);
1594 strbuf_release(&sb
);
1596 refs_delete_ref(get_main_ref_store(r
), "",
1597 "CHERRY_PICK_HEAD", NULL
, 0);
1598 unlink(git_path_merge_msg(r
));
1599 if (!is_rebase_i(opts
))
1600 print_commit_summary(r
, NULL
, &oid
,
1601 SUMMARY_SHOW_AUTHOR_DATE
);
1606 if (is_rebase_i(opts
) && oid
)
1607 if (write_rebase_head(oid
))
1609 return run_git_commit(msg_file
, opts
, flags
);
1615 static int is_original_commit_empty(struct commit
*commit
)
1617 const struct object_id
*ptree_oid
;
1619 if (parse_commit(commit
))
1620 return error(_("could not parse commit %s"),
1621 oid_to_hex(&commit
->object
.oid
));
1622 if (commit
->parents
) {
1623 struct commit
*parent
= commit
->parents
->item
;
1624 if (parse_commit(parent
))
1625 return error(_("could not parse parent commit %s"),
1626 oid_to_hex(&parent
->object
.oid
));
1627 ptree_oid
= get_commit_tree_oid(parent
);
1629 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1632 return oideq(ptree_oid
, get_commit_tree_oid(commit
));
1636 * Should empty commits be allowed? Return status:
1637 * <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1638 * 0: Halt on empty commit
1639 * 1: Allow empty commit
1640 * 2: Drop empty commit
1642 static int allow_empty(struct repository
*r
,
1643 struct replay_opts
*opts
,
1644 struct commit
*commit
)
1646 int index_unchanged
, originally_empty
;
1651 * (1) we do not allow empty at all and error out.
1653 * (2) we allow ones that were initially empty, and
1654 * just drop the ones that become empty
1656 * (3) we allow ones that were initially empty, but
1657 * halt for the ones that become empty;
1659 * (4) we allow both.
1661 if (!opts
->allow_empty
)
1662 return 0; /* let "git commit" barf as necessary */
1664 index_unchanged
= is_index_unchanged(r
);
1665 if (index_unchanged
< 0)
1666 return index_unchanged
;
1667 if (!index_unchanged
)
1668 return 0; /* we do not have to say --allow-empty */
1670 if (opts
->keep_redundant_commits
)
1673 originally_empty
= is_original_commit_empty(commit
);
1674 if (originally_empty
< 0)
1675 return originally_empty
;
1676 if (originally_empty
)
1678 else if (opts
->drop_redundant_commits
)
1687 } todo_command_info
[] = {
1704 static const char *command_to_string(const enum todo_command command
)
1706 if (command
< TODO_COMMENT
)
1707 return todo_command_info
[command
].str
;
1708 die(_("unknown command: %d"), command
);
1711 static char command_to_char(const enum todo_command command
)
1713 if (command
< TODO_COMMENT
)
1714 return todo_command_info
[command
].c
;
1715 return comment_line_char
;
1718 static int is_noop(const enum todo_command command
)
1720 return TODO_NOOP
<= command
;
1723 static int is_fixup(enum todo_command command
)
1725 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1728 /* Does this command create a (non-merge) commit? */
1729 static int is_pick_or_similar(enum todo_command command
)
1744 enum todo_item_flags
{
1745 TODO_EDIT_MERGE_MSG
= (1 << 0),
1746 TODO_REPLACE_FIXUP_MSG
= (1 << 1),
1747 TODO_EDIT_FIXUP_MSG
= (1 << 2),
1750 static const char first_commit_msg_str
[] = N_("This is the 1st commit message:");
1751 static const char nth_commit_msg_fmt
[] = N_("This is the commit message #%d:");
1752 static const char skip_first_commit_msg_str
[] = N_("The 1st commit message will be skipped:");
1753 static const char skip_nth_commit_msg_fmt
[] = N_("The commit message #%d will be skipped:");
1754 static const char combined_commit_msg_fmt
[] = N_("This is a combination of %d commits.");
1756 static int is_fixup_flag(enum todo_command command
, unsigned flag
)
1758 return command
== TODO_FIXUP
&& ((flag
& TODO_REPLACE_FIXUP_MSG
) ||
1759 (flag
& TODO_EDIT_FIXUP_MSG
));
1763 * Wrapper around strbuf_add_commented_lines() which avoids double
1764 * commenting commit subjects.
1766 static void add_commented_lines(struct strbuf
*buf
, const void *str
, size_t len
)
1768 const char *s
= str
;
1769 while (len
> 0 && s
[0] == comment_line_char
) {
1771 const char *n
= memchr(s
, '\n', len
);
1776 strbuf_add(buf
, s
, count
);
1780 strbuf_add_commented_lines(buf
, s
, len
);
1783 /* Does the current fixup chain contain a squash command? */
1784 static int seen_squash(struct replay_opts
*opts
)
1786 return starts_with(opts
->current_fixups
.buf
, "squash") ||
1787 strstr(opts
->current_fixups
.buf
, "\nsquash");
1790 static void update_comment_bufs(struct strbuf
*buf1
, struct strbuf
*buf2
, int n
)
1792 strbuf_setlen(buf1
, 2);
1793 strbuf_addf(buf1
, _(nth_commit_msg_fmt
), n
);
1794 strbuf_addch(buf1
, '\n');
1795 strbuf_setlen(buf2
, 2);
1796 strbuf_addf(buf2
, _(skip_nth_commit_msg_fmt
), n
);
1797 strbuf_addch(buf2
, '\n');
1801 * Comment out any un-commented commit messages, updating the message comments
1802 * to say they will be skipped but do not comment out the empty lines that
1803 * surround commit messages and their comments.
1805 static void update_squash_message_for_fixup(struct strbuf
*msg
)
1807 void (*copy_lines
)(struct strbuf
*, const void *, size_t) = strbuf_add
;
1808 struct strbuf buf1
= STRBUF_INIT
, buf2
= STRBUF_INIT
;
1809 const char *s
, *start
;
1811 size_t orig_msg_len
;
1814 strbuf_addf(&buf1
, "# %s\n", _(first_commit_msg_str
));
1815 strbuf_addf(&buf2
, "# %s\n", _(skip_first_commit_msg_str
));
1816 s
= start
= orig_msg
= strbuf_detach(msg
, &orig_msg_len
);
1820 if (skip_prefix(s
, buf1
.buf
, &next
)) {
1822 * Copy the last message, preserving the blank line
1823 * preceding the current line
1825 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1826 copy_lines(msg
, start
, s
- start
- off
);
1828 strbuf_addch(msg
, '\n');
1830 * The next message needs to be commented out but the
1831 * message header is already commented out so just copy
1832 * it and the blank line that follows it.
1834 strbuf_addbuf(msg
, &buf2
);
1836 strbuf_addch(msg
, *next
++);
1838 copy_lines
= add_commented_lines
;
1839 update_comment_bufs(&buf1
, &buf2
, ++i
);
1840 } else if (skip_prefix(s
, buf2
.buf
, &next
)) {
1841 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1842 copy_lines(msg
, start
, s
- start
- off
);
1845 copy_lines
= strbuf_add
;
1846 update_comment_bufs(&buf1
, &buf2
, ++i
);
1848 s
= strchr(s
, '\n');
1853 copy_lines(msg
, start
, orig_msg_len
- (start
- orig_msg
));
1855 strbuf_release(&buf1
);
1856 strbuf_release(&buf2
);
1859 static int append_squash_message(struct strbuf
*buf
, const char *body
,
1860 enum todo_command command
, struct replay_opts
*opts
,
1863 const char *fixup_msg
;
1864 size_t commented_len
= 0, fixup_off
;
1866 * amend is non-interactive and not normally used with fixup!
1867 * or squash! commits, so only comment out those subjects when
1868 * squashing commit messages.
1870 if (starts_with(body
, "amend!") ||
1871 ((command
== TODO_SQUASH
|| seen_squash(opts
)) &&
1872 (starts_with(body
, "squash!") || starts_with(body
, "fixup!"))))
1873 commented_len
= commit_subject_length(body
);
1875 strbuf_addf(buf
, "\n%c ", comment_line_char
);
1876 strbuf_addf(buf
, _(nth_commit_msg_fmt
),
1877 ++opts
->current_fixup_count
+ 1);
1878 strbuf_addstr(buf
, "\n\n");
1879 strbuf_add_commented_lines(buf
, body
, commented_len
);
1880 /* buf->buf may be reallocated so store an offset into the buffer */
1881 fixup_off
= buf
->len
;
1882 strbuf_addstr(buf
, body
+ commented_len
);
1884 /* fixup -C after squash behaves like squash */
1885 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
)) {
1887 * We're replacing the commit message so we need to
1888 * append the Signed-off-by: trailer if the user
1889 * requested '--signoff'.
1892 append_signoff(buf
, 0, 0);
1894 if ((command
== TODO_FIXUP
) &&
1895 (flag
& TODO_REPLACE_FIXUP_MSG
) &&
1896 (file_exists(rebase_path_fixup_msg()) ||
1897 !file_exists(rebase_path_squash_msg()))) {
1898 fixup_msg
= skip_blank_lines(buf
->buf
+ fixup_off
);
1899 if (write_message(fixup_msg
, strlen(fixup_msg
),
1900 rebase_path_fixup_msg(), 0) < 0)
1901 return error(_("cannot write '%s'"),
1902 rebase_path_fixup_msg());
1904 unlink(rebase_path_fixup_msg());
1907 unlink(rebase_path_fixup_msg());
1913 static int update_squash_messages(struct repository
*r
,
1914 enum todo_command command
,
1915 struct commit
*commit
,
1916 struct replay_opts
*opts
,
1919 struct strbuf buf
= STRBUF_INIT
;
1921 const char *message
, *body
;
1922 const char *encoding
= get_commit_output_encoding();
1924 if (opts
->current_fixup_count
> 0) {
1925 struct strbuf header
= STRBUF_INIT
;
1928 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
1929 return error(_("could not read '%s'"),
1930 rebase_path_squash_msg());
1932 eol
= buf
.buf
[0] != comment_line_char
?
1933 buf
.buf
: strchrnul(buf
.buf
, '\n');
1935 strbuf_addf(&header
, "%c ", comment_line_char
);
1936 strbuf_addf(&header
, _(combined_commit_msg_fmt
),
1937 opts
->current_fixup_count
+ 2);
1938 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
1939 strbuf_release(&header
);
1940 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
))
1941 update_squash_message_for_fixup(&buf
);
1943 struct object_id head
;
1944 struct commit
*head_commit
;
1945 const char *head_message
, *body
;
1947 if (get_oid("HEAD", &head
))
1948 return error(_("need a HEAD to fixup"));
1949 if (!(head_commit
= lookup_commit_reference(r
, &head
)))
1950 return error(_("could not read HEAD"));
1951 if (!(head_message
= logmsg_reencode(head_commit
, NULL
, encoding
)))
1952 return error(_("could not read HEAD's commit message"));
1954 find_commit_subject(head_message
, &body
);
1955 if (command
== TODO_FIXUP
&& !flag
&& write_message(body
, strlen(body
),
1956 rebase_path_fixup_msg(), 0) < 0) {
1957 unuse_commit_buffer(head_commit
, head_message
);
1958 return error(_("cannot write '%s'"), rebase_path_fixup_msg());
1960 strbuf_addf(&buf
, "%c ", comment_line_char
);
1961 strbuf_addf(&buf
, _(combined_commit_msg_fmt
), 2);
1962 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1963 strbuf_addstr(&buf
, is_fixup_flag(command
, flag
) ?
1964 _(skip_first_commit_msg_str
) :
1965 _(first_commit_msg_str
));
1966 strbuf_addstr(&buf
, "\n\n");
1967 if (is_fixup_flag(command
, flag
))
1968 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
1970 strbuf_addstr(&buf
, body
);
1972 unuse_commit_buffer(head_commit
, head_message
);
1975 if (!(message
= logmsg_reencode(commit
, NULL
, encoding
)))
1976 return error(_("could not read commit message of %s"),
1977 oid_to_hex(&commit
->object
.oid
));
1978 find_commit_subject(message
, &body
);
1980 if (command
== TODO_SQUASH
|| is_fixup_flag(command
, flag
)) {
1981 res
= append_squash_message(&buf
, body
, command
, opts
, flag
);
1982 } else if (command
== TODO_FIXUP
) {
1983 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1984 strbuf_addf(&buf
, _(skip_nth_commit_msg_fmt
),
1985 ++opts
->current_fixup_count
+ 1);
1986 strbuf_addstr(&buf
, "\n\n");
1987 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
1989 return error(_("unknown command: %d"), command
);
1990 unuse_commit_buffer(commit
, message
);
1993 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(),
1995 strbuf_release(&buf
);
1998 strbuf_addf(&opts
->current_fixups
, "%s%s %s",
1999 opts
->current_fixups
.len
? "\n" : "",
2000 command_to_string(command
),
2001 oid_to_hex(&commit
->object
.oid
));
2002 res
= write_message(opts
->current_fixups
.buf
,
2003 opts
->current_fixups
.len
,
2004 rebase_path_current_fixups(), 0);
2010 static void flush_rewritten_pending(void)
2012 struct strbuf buf
= STRBUF_INIT
;
2013 struct object_id newoid
;
2016 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
2017 !get_oid("HEAD", &newoid
) &&
2018 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
2019 char *bol
= buf
.buf
, *eol
;
2022 eol
= strchrnul(bol
, '\n');
2023 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
2024 bol
, oid_to_hex(&newoid
));
2030 unlink(rebase_path_rewritten_pending());
2032 strbuf_release(&buf
);
2035 static void record_in_rewritten(struct object_id
*oid
,
2036 enum todo_command next_command
)
2038 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
2043 fprintf(out
, "%s\n", oid_to_hex(oid
));
2046 if (!is_fixup(next_command
))
2047 flush_rewritten_pending();
2050 static int should_edit(struct replay_opts
*opts
) {
2053 * Note that we only handle the case of non-conflicted
2054 * commits; continue_single_pick() handles the conflicted
2055 * commits itself instead of calling this function.
2057 return (opts
->action
== REPLAY_REVERT
&& isatty(0)) ? 1 : 0;
2061 static int do_pick_commit(struct repository
*r
,
2062 struct todo_item
*item
,
2063 struct replay_opts
*opts
,
2064 int final_fixup
, int *check_todo
)
2066 unsigned int flags
= should_edit(opts
) ? EDIT_MSG
: 0;
2067 const char *msg_file
= should_edit(opts
) ? NULL
: git_path_merge_msg(r
);
2068 struct object_id head
;
2069 struct commit
*base
, *next
, *parent
;
2070 const char *base_label
, *next_label
;
2071 char *author
= NULL
;
2072 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
2073 struct strbuf msgbuf
= STRBUF_INIT
;
2074 int res
, unborn
= 0, reword
= 0, allow
, drop_commit
;
2075 enum todo_command command
= item
->command
;
2076 struct commit
*commit
= item
->commit
;
2078 if (opts
->no_commit
) {
2080 * We do not intend to commit immediately. We just want to
2081 * merge the differences in, so let's compute the tree
2082 * that represents the "current" state for the merge machinery
2085 if (write_index_as_tree(&head
, r
->index
, r
->index_file
, 0, NULL
))
2086 return error(_("your index file is unmerged."));
2088 unborn
= get_oid("HEAD", &head
);
2089 /* Do we want to generate a root commit? */
2090 if (is_pick_or_similar(command
) && opts
->have_squash_onto
&&
2091 oideq(&head
, &opts
->squash_onto
)) {
2092 if (is_fixup(command
))
2093 return error(_("cannot fixup root commit"));
2094 flags
|= CREATE_ROOT_COMMIT
;
2097 oidcpy(&head
, the_hash_algo
->empty_tree
);
2098 if (index_differs_from(r
, unborn
? empty_tree_oid_hex() : "HEAD",
2100 return error_dirty_index(r
, opts
);
2102 discard_index(r
->index
);
2104 if (!commit
->parents
)
2106 else if (commit
->parents
->next
) {
2107 /* Reverting or cherry-picking a merge commit */
2109 struct commit_list
*p
;
2111 if (!opts
->mainline
)
2112 return error(_("commit %s is a merge but no -m option was given."),
2113 oid_to_hex(&commit
->object
.oid
));
2115 for (cnt
= 1, p
= commit
->parents
;
2116 cnt
!= opts
->mainline
&& p
;
2119 if (cnt
!= opts
->mainline
|| !p
)
2120 return error(_("commit %s does not have parent %d"),
2121 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2123 } else if (1 < opts
->mainline
)
2125 * Non-first parent explicitly specified as mainline for
2128 return error(_("commit %s does not have parent %d"),
2129 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2131 parent
= commit
->parents
->item
;
2133 if (get_message(commit
, &msg
) != 0)
2134 return error(_("cannot get commit message for %s"),
2135 oid_to_hex(&commit
->object
.oid
));
2137 if (opts
->allow_ff
&& !is_fixup(command
) &&
2138 ((parent
&& oideq(&parent
->object
.oid
, &head
)) ||
2139 (!parent
&& unborn
))) {
2140 if (is_rebase_i(opts
))
2141 write_author_script(msg
.message
);
2142 res
= fast_forward_to(r
, &commit
->object
.oid
, &head
, unborn
,
2144 if (res
|| command
!= TODO_REWORD
)
2148 goto fast_forward_edit
;
2150 if (parent
&& parse_commit(parent
) < 0)
2151 /* TRANSLATORS: The first %s will be a "todo" command like
2152 "revert" or "pick", the second %s a SHA1. */
2153 return error(_("%s: cannot parse parent commit %s"),
2154 command_to_string(command
),
2155 oid_to_hex(&parent
->object
.oid
));
2158 * "commit" is an existing commit. We would want to apply
2159 * the difference it introduces since its first parent "prev"
2160 * on top of the current HEAD if we are cherry-pick. Or the
2161 * reverse of it if we are revert.
2164 if (command
== TODO_REVERT
) {
2166 base_label
= msg
.label
;
2168 next_label
= msg
.parent_label
;
2169 strbuf_addstr(&msgbuf
, "Revert \"");
2170 strbuf_addstr(&msgbuf
, msg
.subject
);
2171 strbuf_addstr(&msgbuf
, "\"\n\nThis reverts commit ");
2172 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
2174 if (commit
->parents
&& commit
->parents
->next
) {
2175 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
2176 strbuf_addstr(&msgbuf
, oid_to_hex(&parent
->object
.oid
));
2178 strbuf_addstr(&msgbuf
, ".\n");
2183 base_label
= msg
.parent_label
;
2185 next_label
= msg
.label
;
2187 /* Append the commit log message to msgbuf. */
2188 if (find_commit_subject(msg
.message
, &p
))
2189 strbuf_addstr(&msgbuf
, p
);
2191 if (opts
->record_origin
) {
2192 strbuf_complete_line(&msgbuf
);
2193 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
2194 strbuf_addch(&msgbuf
, '\n');
2195 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
2196 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
2197 strbuf_addstr(&msgbuf
, ")\n");
2199 if (!is_fixup(command
))
2200 author
= get_author(msg
.message
);
2203 if (command
== TODO_REWORD
)
2205 else if (is_fixup(command
)) {
2206 if (update_squash_messages(r
, command
, commit
,
2211 msg_file
= rebase_path_squash_msg();
2212 else if (file_exists(rebase_path_fixup_msg())) {
2213 flags
|= VERBATIM_MSG
;
2214 msg_file
= rebase_path_fixup_msg();
2216 const char *dest
= git_path_squash_msg(r
);
2218 if (copy_file(dest
, rebase_path_squash_msg(), 0666))
2219 return error(_("could not rename '%s' to '%s'"),
2220 rebase_path_squash_msg(), dest
);
2221 unlink(git_path_merge_msg(r
));
2227 if (opts
->signoff
&& !is_fixup(command
))
2228 append_signoff(&msgbuf
, 0, 0);
2230 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
2232 else if (!opts
->strategy
||
2233 !strcmp(opts
->strategy
, "recursive") ||
2234 !strcmp(opts
->strategy
, "ort") ||
2235 command
== TODO_REVERT
) {
2236 res
= do_recursive_merge(r
, base
, next
, base_label
, next_label
,
2237 &head
, &msgbuf
, opts
);
2241 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
2242 git_path_merge_msg(r
), 0);
2244 struct commit_list
*common
= NULL
;
2245 struct commit_list
*remotes
= NULL
;
2247 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
2248 git_path_merge_msg(r
), 0);
2250 commit_list_insert(base
, &common
);
2251 commit_list_insert(next
, &remotes
);
2252 res
|= try_merge_command(r
, opts
->strategy
,
2253 opts
->xopts_nr
, (const char **)opts
->xopts
,
2254 common
, oid_to_hex(&head
), remotes
);
2255 free_commit_list(common
);
2256 free_commit_list(remotes
);
2258 strbuf_release(&msgbuf
);
2261 * If the merge was clean or if it failed due to conflict, we write
2262 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
2263 * However, if the merge did not even start, then we don't want to
2266 if ((command
== TODO_PICK
|| command
== TODO_REWORD
||
2267 command
== TODO_EDIT
) && !opts
->no_commit
&&
2268 (res
== 0 || res
== 1) &&
2269 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
2270 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2272 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
2273 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
2274 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2278 error(command
== TODO_REVERT
2279 ? _("could not revert %s... %s")
2280 : _("could not apply %s... %s"),
2281 short_commit_name(commit
), msg
.subject
);
2282 print_advice(r
, res
== 1, opts
);
2283 repo_rerere(r
, opts
->allow_rerere_auto
);
2288 allow
= allow_empty(r
, opts
, commit
);
2292 } else if (allow
== 1) {
2293 flags
|= ALLOW_EMPTY
;
2294 } else if (allow
== 2) {
2296 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
2298 unlink(git_path_merge_msg(r
));
2299 unlink(git_path_auto_merge(r
));
2301 _("dropping %s %s -- patch contents already upstream\n"),
2302 oid_to_hex(&commit
->object
.oid
), msg
.subject
);
2303 } /* else allow == 0 and there's nothing special to do */
2304 if (!opts
->no_commit
&& !drop_commit
) {
2305 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
2306 res
= do_commit(r
, msg_file
, author
, opts
, flags
,
2307 commit
? &commit
->object
.oid
: NULL
);
2309 res
= error(_("unable to parse commit author"));
2310 *check_todo
= !!(flags
& EDIT_MSG
);
2311 if (!res
&& reword
) {
2313 res
= run_git_commit(NULL
, opts
, EDIT_MSG
|
2314 VERIFY_MSG
| AMEND_MSG
|
2315 (flags
& ALLOW_EMPTY
));
2321 if (!res
&& final_fixup
) {
2322 unlink(rebase_path_fixup_msg());
2323 unlink(rebase_path_squash_msg());
2324 unlink(rebase_path_current_fixups());
2325 strbuf_reset(&opts
->current_fixups
);
2326 opts
->current_fixup_count
= 0;
2330 free_message(commit
, &msg
);
2332 update_abort_safety_file();
2337 static int prepare_revs(struct replay_opts
*opts
)
2340 * picking (but not reverting) ranges (but not individual revisions)
2341 * should be done in reverse
2343 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
2344 opts
->revs
->reverse
^= 1;
2346 if (prepare_revision_walk(opts
->revs
))
2347 return error(_("revision walk setup failed"));
2352 static int read_and_refresh_cache(struct repository
*r
,
2353 struct replay_opts
*opts
)
2355 struct lock_file index_lock
= LOCK_INIT
;
2356 int index_fd
= repo_hold_locked_index(r
, &index_lock
, 0);
2357 if (repo_read_index(r
) < 0) {
2358 rollback_lock_file(&index_lock
);
2359 return error(_("git %s: failed to read the index"),
2360 _(action_name(opts
)));
2362 refresh_index(r
->index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
2364 if (index_fd
>= 0) {
2365 if (write_locked_index(r
->index
, &index_lock
,
2366 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
2367 return error(_("git %s: failed to refresh the index"),
2368 _(action_name(opts
)));
2373 * If we are resolving merges in any way other than "ort", then
2374 * expand the sparse index.
2376 if (opts
->strategy
&& strcmp(opts
->strategy
, "ort"))
2377 ensure_full_index(r
->index
);
2381 void todo_list_release(struct todo_list
*todo_list
)
2383 strbuf_release(&todo_list
->buf
);
2384 FREE_AND_NULL(todo_list
->items
);
2385 todo_list
->nr
= todo_list
->alloc
= 0;
2388 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
2390 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
2391 todo_list
->total_nr
++;
2392 return todo_list
->items
+ todo_list
->nr
++;
2395 const char *todo_item_get_arg(struct todo_list
*todo_list
,
2396 struct todo_item
*item
)
2398 return todo_list
->buf
.buf
+ item
->arg_offset
;
2401 static int is_command(enum todo_command command
, const char **bol
)
2403 const char *str
= todo_command_info
[command
].str
;
2404 const char nick
= todo_command_info
[command
].c
;
2405 const char *p
= *bol
+ 1;
2407 return skip_prefix(*bol
, str
, bol
) ||
2408 ((nick
&& **bol
== nick
) &&
2409 (*p
== ' ' || *p
== '\t' || *p
== '\n' || *p
== '\r' || !*p
) &&
2413 static int parse_insn_line(struct repository
*r
, struct todo_item
*item
,
2414 const char *buf
, const char *bol
, char *eol
)
2416 struct object_id commit_oid
;
2417 char *end_of_object_name
;
2418 int i
, saved
, status
, padding
;
2423 bol
+= strspn(bol
, " \t");
2425 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
2426 item
->command
= TODO_COMMENT
;
2427 item
->commit
= NULL
;
2428 item
->arg_offset
= bol
- buf
;
2429 item
->arg_len
= eol
- bol
;
2433 for (i
= 0; i
< TODO_COMMENT
; i
++)
2434 if (is_command(i
, &bol
)) {
2438 if (i
>= TODO_COMMENT
)
2441 /* Eat up extra spaces/ tabs before object name */
2442 padding
= strspn(bol
, " \t");
2445 if (item
->command
== TODO_NOOP
|| item
->command
== TODO_BREAK
) {
2447 return error(_("%s does not accept arguments: '%s'"),
2448 command_to_string(item
->command
), bol
);
2449 item
->commit
= NULL
;
2450 item
->arg_offset
= bol
- buf
;
2451 item
->arg_len
= eol
- bol
;
2456 return error(_("missing arguments for %s"),
2457 command_to_string(item
->command
));
2459 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
2460 item
->command
== TODO_RESET
) {
2461 item
->commit
= NULL
;
2462 item
->arg_offset
= bol
- buf
;
2463 item
->arg_len
= (int)(eol
- bol
);
2467 if (item
->command
== TODO_FIXUP
) {
2468 if (skip_prefix(bol
, "-C", &bol
) &&
2469 (*bol
== ' ' || *bol
== '\t')) {
2470 bol
+= strspn(bol
, " \t");
2471 item
->flags
|= TODO_REPLACE_FIXUP_MSG
;
2472 } else if (skip_prefix(bol
, "-c", &bol
) &&
2473 (*bol
== ' ' || *bol
== '\t')) {
2474 bol
+= strspn(bol
, " \t");
2475 item
->flags
|= TODO_EDIT_FIXUP_MSG
;
2479 if (item
->command
== TODO_MERGE
) {
2480 if (skip_prefix(bol
, "-C", &bol
))
2481 bol
+= strspn(bol
, " \t");
2482 else if (skip_prefix(bol
, "-c", &bol
)) {
2483 bol
+= strspn(bol
, " \t");
2484 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2486 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2487 item
->commit
= NULL
;
2488 item
->arg_offset
= bol
- buf
;
2489 item
->arg_len
= (int)(eol
- bol
);
2494 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
2495 saved
= *end_of_object_name
;
2496 *end_of_object_name
= '\0';
2497 status
= get_oid(bol
, &commit_oid
);
2499 error(_("could not parse '%s'"), bol
); /* return later */
2500 *end_of_object_name
= saved
;
2502 bol
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2503 item
->arg_offset
= bol
- buf
;
2504 item
->arg_len
= (int)(eol
- bol
);
2509 item
->commit
= lookup_commit_reference(r
, &commit_oid
);
2510 return item
->commit
? 0 : -1;
2513 int sequencer_get_last_command(struct repository
*r
, enum replay_action
*action
)
2515 const char *todo_file
, *bol
;
2516 struct strbuf buf
= STRBUF_INIT
;
2519 todo_file
= git_path_todo_file();
2520 if (strbuf_read_file(&buf
, todo_file
, 0) < 0) {
2521 if (errno
== ENOENT
|| errno
== ENOTDIR
)
2524 return error_errno("unable to open '%s'", todo_file
);
2526 bol
= buf
.buf
+ strspn(buf
.buf
, " \t\r\n");
2527 if (is_command(TODO_PICK
, &bol
) && (*bol
== ' ' || *bol
== '\t'))
2528 *action
= REPLAY_PICK
;
2529 else if (is_command(TODO_REVERT
, &bol
) &&
2530 (*bol
== ' ' || *bol
== '\t'))
2531 *action
= REPLAY_REVERT
;
2535 strbuf_release(&buf
);
2540 int todo_list_parse_insn_buffer(struct repository
*r
, char *buf
,
2541 struct todo_list
*todo_list
)
2543 struct todo_item
*item
;
2544 char *p
= buf
, *next_p
;
2545 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2547 todo_list
->current
= todo_list
->nr
= 0;
2549 for (i
= 1; *p
; i
++, p
= next_p
) {
2550 char *eol
= strchrnul(p
, '\n');
2552 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2554 if (p
!= eol
&& eol
[-1] == '\r')
2555 eol
--; /* strip Carriage Return */
2557 item
= append_new_todo(todo_list
);
2558 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2559 if (parse_insn_line(r
, item
, buf
, p
, eol
)) {
2560 res
= error(_("invalid line %d: %.*s"),
2561 i
, (int)(eol
- p
), p
);
2562 item
->command
= TODO_COMMENT
+ 1;
2563 item
->arg_offset
= p
- buf
;
2564 item
->arg_len
= (int)(eol
- p
);
2565 item
->commit
= NULL
;
2570 else if (is_fixup(item
->command
))
2571 return error(_("cannot '%s' without a previous commit"),
2572 command_to_string(item
->command
));
2573 else if (!is_noop(item
->command
))
2580 static int count_commands(struct todo_list
*todo_list
)
2584 for (i
= 0; i
< todo_list
->nr
; i
++)
2585 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2591 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2593 return index
< todo_list
->nr
?
2594 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2597 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2599 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2602 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2604 return get_item_line_offset(todo_list
, index
+ 1)
2605 - get_item_line_offset(todo_list
, index
);
2608 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2613 fd
= open(path
, O_RDONLY
);
2615 return error_errno(_("could not open '%s'"), path
);
2616 len
= strbuf_read(sb
, fd
, 0);
2619 return error(_("could not read '%s'."), path
);
2623 static int have_finished_the_last_pick(void)
2625 struct strbuf buf
= STRBUF_INIT
;
2627 const char *todo_path
= git_path_todo_file();
2630 if (strbuf_read_file(&buf
, todo_path
, 0) < 0) {
2631 if (errno
== ENOENT
) {
2634 error_errno("unable to open '%s'", todo_path
);
2638 /* If there is only one line then we are done */
2639 eol
= strchr(buf
.buf
, '\n');
2640 if (!eol
|| !eol
[1])
2643 strbuf_release(&buf
);
2648 void sequencer_post_commit_cleanup(struct repository
*r
, int verbose
)
2650 struct replay_opts opts
= REPLAY_OPTS_INIT
;
2651 int need_cleanup
= 0;
2653 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
2654 if (!refs_delete_ref(get_main_ref_store(r
), "",
2655 "CHERRY_PICK_HEAD", NULL
, 0) &&
2657 warning(_("cancelling a cherry picking in progress"));
2658 opts
.action
= REPLAY_PICK
;
2662 if (refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
2663 if (!refs_delete_ref(get_main_ref_store(r
), "", "REVERT_HEAD",
2666 warning(_("cancelling a revert in progress"));
2667 opts
.action
= REPLAY_REVERT
;
2671 unlink(git_path_auto_merge(r
));
2676 if (!have_finished_the_last_pick())
2679 sequencer_remove_state(&opts
);
2682 static void todo_list_write_total_nr(struct todo_list
*todo_list
)
2684 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2687 fprintf(f
, "%d\n", todo_list
->total_nr
);
2692 static int read_populate_todo(struct repository
*r
,
2693 struct todo_list
*todo_list
,
2694 struct replay_opts
*opts
)
2696 const char *todo_file
= get_todo_path(opts
);
2699 strbuf_reset(&todo_list
->buf
);
2700 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2703 res
= todo_list_parse_insn_buffer(r
, todo_list
->buf
.buf
, todo_list
);
2705 if (is_rebase_i(opts
))
2706 return error(_("please fix this using "
2707 "'git rebase --edit-todo'."));
2708 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2711 if (!todo_list
->nr
&&
2712 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2713 return error(_("no commits parsed."));
2715 if (!is_rebase_i(opts
)) {
2716 enum todo_command valid
=
2717 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2720 for (i
= 0; i
< todo_list
->nr
; i
++)
2721 if (valid
== todo_list
->items
[i
].command
)
2723 else if (valid
== TODO_PICK
)
2724 return error(_("cannot cherry-pick during a revert."));
2726 return error(_("cannot revert during a cherry-pick."));
2729 if (is_rebase_i(opts
)) {
2730 struct todo_list done
= TODO_LIST_INIT
;
2732 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2733 !todo_list_parse_insn_buffer(r
, done
.buf
.buf
, &done
))
2734 todo_list
->done_nr
= count_commands(&done
);
2736 todo_list
->done_nr
= 0;
2738 todo_list
->total_nr
= todo_list
->done_nr
2739 + count_commands(todo_list
);
2740 todo_list_release(&done
);
2742 todo_list_write_total_nr(todo_list
);
2748 static int git_config_string_dup(char **dest
,
2749 const char *var
, const char *value
)
2752 return config_error_nonbool(var
);
2754 *dest
= xstrdup(value
);
2758 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
2760 struct replay_opts
*opts
= data
;
2765 else if (!strcmp(key
, "options.no-commit"))
2766 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
2767 else if (!strcmp(key
, "options.edit"))
2768 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
2769 else if (!strcmp(key
, "options.allow-empty"))
2771 git_config_bool_or_int(key
, value
, &error_flag
);
2772 else if (!strcmp(key
, "options.allow-empty-message"))
2773 opts
->allow_empty_message
=
2774 git_config_bool_or_int(key
, value
, &error_flag
);
2775 else if (!strcmp(key
, "options.keep-redundant-commits"))
2776 opts
->keep_redundant_commits
=
2777 git_config_bool_or_int(key
, value
, &error_flag
);
2778 else if (!strcmp(key
, "options.signoff"))
2779 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
2780 else if (!strcmp(key
, "options.record-origin"))
2781 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
2782 else if (!strcmp(key
, "options.allow-ff"))
2783 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
2784 else if (!strcmp(key
, "options.mainline"))
2785 opts
->mainline
= git_config_int(key
, value
);
2786 else if (!strcmp(key
, "options.strategy"))
2787 git_config_string_dup(&opts
->strategy
, key
, value
);
2788 else if (!strcmp(key
, "options.gpg-sign"))
2789 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
2790 else if (!strcmp(key
, "options.strategy-option")) {
2791 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
2792 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(value
);
2793 } else if (!strcmp(key
, "options.allow-rerere-auto"))
2794 opts
->allow_rerere_auto
=
2795 git_config_bool_or_int(key
, value
, &error_flag
) ?
2796 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
2797 else if (!strcmp(key
, "options.default-msg-cleanup")) {
2798 opts
->explicit_cleanup
= 1;
2799 opts
->default_msg_cleanup
= get_cleanup_mode(value
, 1);
2801 return error(_("invalid key: %s"), key
);
2804 return error(_("invalid value for %s: %s"), key
, value
);
2809 void parse_strategy_opts(struct replay_opts
*opts
, char *raw_opts
)
2812 char *strategy_opts_string
= raw_opts
;
2814 if (*strategy_opts_string
== ' ')
2815 strategy_opts_string
++;
2817 opts
->xopts_nr
= split_cmdline(strategy_opts_string
,
2818 (const char ***)&opts
->xopts
);
2819 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
2820 const char *arg
= opts
->xopts
[i
];
2822 skip_prefix(arg
, "--", &arg
);
2823 opts
->xopts
[i
] = xstrdup(arg
);
2827 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2830 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2832 opts
->strategy
= strbuf_detach(buf
, NULL
);
2833 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2836 parse_strategy_opts(opts
, buf
->buf
);
2839 static int read_populate_opts(struct replay_opts
*opts
)
2841 if (is_rebase_i(opts
)) {
2842 struct strbuf buf
= STRBUF_INIT
;
2845 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(),
2846 READ_ONELINER_SKIP_IF_EMPTY
)) {
2847 if (!starts_with(buf
.buf
, "-S"))
2850 free(opts
->gpg_sign
);
2851 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2856 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(),
2857 READ_ONELINER_SKIP_IF_EMPTY
)) {
2858 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2859 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2860 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2861 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2865 if (file_exists(rebase_path_verbose()))
2868 if (file_exists(rebase_path_quiet()))
2871 if (file_exists(rebase_path_signoff())) {
2876 if (file_exists(rebase_path_cdate_is_adate())) {
2878 opts
->committer_date_is_author_date
= 1;
2881 if (file_exists(rebase_path_ignore_date())) {
2883 opts
->ignore_date
= 1;
2886 if (file_exists(rebase_path_reschedule_failed_exec()))
2887 opts
->reschedule_failed_exec
= 1;
2888 else if (file_exists(rebase_path_no_reschedule_failed_exec()))
2889 opts
->reschedule_failed_exec
= 0;
2891 if (file_exists(rebase_path_drop_redundant_commits()))
2892 opts
->drop_redundant_commits
= 1;
2894 if (file_exists(rebase_path_keep_redundant_commits()))
2895 opts
->keep_redundant_commits
= 1;
2897 read_strategy_opts(opts
, &buf
);
2900 if (read_oneliner(&opts
->current_fixups
,
2901 rebase_path_current_fixups(),
2902 READ_ONELINER_SKIP_IF_EMPTY
)) {
2903 const char *p
= opts
->current_fixups
.buf
;
2904 opts
->current_fixup_count
= 1;
2905 while ((p
= strchr(p
, '\n'))) {
2906 opts
->current_fixup_count
++;
2911 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
2912 if (get_oid_committish(buf
.buf
, &opts
->squash_onto
) < 0) {
2913 ret
= error(_("unusable squash-onto"));
2916 opts
->have_squash_onto
= 1;
2920 strbuf_release(&buf
);
2924 if (!file_exists(git_path_opts_file()))
2927 * The function git_parse_source(), called from git_config_from_file(),
2928 * may die() in case of a syntactically incorrect file. We do not care
2929 * about this case, though, because we wrote that file ourselves, so we
2930 * are pretty certain that it is syntactically correct.
2932 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
2933 return error(_("malformed options sheet: '%s'"),
2934 git_path_opts_file());
2938 static void write_strategy_opts(struct replay_opts
*opts
)
2941 struct strbuf buf
= STRBUF_INIT
;
2943 for (i
= 0; i
< opts
->xopts_nr
; ++i
)
2944 strbuf_addf(&buf
, " --%s", opts
->xopts
[i
]);
2946 write_file(rebase_path_strategy_opts(), "%s\n", buf
.buf
);
2947 strbuf_release(&buf
);
2950 int write_basic_state(struct replay_opts
*opts
, const char *head_name
,
2951 struct commit
*onto
, const struct object_id
*orig_head
)
2954 write_file(rebase_path_head_name(), "%s\n", head_name
);
2956 write_file(rebase_path_onto(), "%s\n",
2957 oid_to_hex(&onto
->object
.oid
));
2959 write_file(rebase_path_orig_head(), "%s\n",
2960 oid_to_hex(orig_head
));
2963 write_file(rebase_path_quiet(), "%s", "");
2965 write_file(rebase_path_verbose(), "%s", "");
2967 write_file(rebase_path_strategy(), "%s\n", opts
->strategy
);
2968 if (opts
->xopts_nr
> 0)
2969 write_strategy_opts(opts
);
2971 if (opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
)
2972 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2973 else if (opts
->allow_rerere_auto
== RERERE_NOAUTOUPDATE
)
2974 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2977 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts
->gpg_sign
);
2979 write_file(rebase_path_signoff(), "--signoff\n");
2980 if (opts
->drop_redundant_commits
)
2981 write_file(rebase_path_drop_redundant_commits(), "%s", "");
2982 if (opts
->keep_redundant_commits
)
2983 write_file(rebase_path_keep_redundant_commits(), "%s", "");
2984 if (opts
->committer_date_is_author_date
)
2985 write_file(rebase_path_cdate_is_adate(), "%s", "");
2986 if (opts
->ignore_date
)
2987 write_file(rebase_path_ignore_date(), "%s", "");
2988 if (opts
->reschedule_failed_exec
)
2989 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
2991 write_file(rebase_path_no_reschedule_failed_exec(), "%s", "");
2996 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
2997 struct replay_opts
*opts
)
2999 enum todo_command command
= opts
->action
== REPLAY_PICK
?
3000 TODO_PICK
: TODO_REVERT
;
3001 const char *command_string
= todo_command_info
[command
].str
;
3002 const char *encoding
;
3003 struct commit
*commit
;
3005 if (prepare_revs(opts
))
3008 encoding
= get_log_output_encoding();
3010 while ((commit
= get_revision(opts
->revs
))) {
3011 struct todo_item
*item
= append_new_todo(todo_list
);
3012 const char *commit_buffer
= logmsg_reencode(commit
, NULL
, encoding
);
3013 const char *subject
;
3016 item
->command
= command
;
3017 item
->commit
= commit
;
3018 item
->arg_offset
= 0;
3020 item
->offset_in_buf
= todo_list
->buf
.len
;
3021 subject_len
= find_commit_subject(commit_buffer
, &subject
);
3022 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
3023 short_commit_name(commit
), subject_len
, subject
);
3024 unuse_commit_buffer(commit
, commit_buffer
);
3028 return error(_("empty commit set passed"));
3033 static int create_seq_dir(struct repository
*r
)
3035 enum replay_action action
;
3036 const char *in_progress_error
= NULL
;
3037 const char *in_progress_advice
= NULL
;
3038 unsigned int advise_skip
=
3039 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD") ||
3040 refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD");
3042 if (!sequencer_get_last_command(r
, &action
)) {
3045 in_progress_error
= _("revert is already in progress");
3046 in_progress_advice
=
3047 _("try \"git revert (--continue | %s--abort | --quit)\"");
3050 in_progress_error
= _("cherry-pick is already in progress");
3051 in_progress_advice
=
3052 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
3055 BUG("unexpected action in create_seq_dir");
3058 if (in_progress_error
) {
3059 error("%s", in_progress_error
);
3060 if (advice_enabled(ADVICE_SEQUENCER_IN_USE
))
3061 advise(in_progress_advice
,
3062 advise_skip
? "--skip | " : "");
3065 if (mkdir(git_path_seq_dir(), 0777) < 0)
3066 return error_errno(_("could not create sequencer directory '%s'"),
3067 git_path_seq_dir());
3072 static int save_head(const char *head
)
3074 struct lock_file head_lock
= LOCK_INIT
;
3075 struct strbuf buf
= STRBUF_INIT
;
3079 fd
= hold_lock_file_for_update(&head_lock
, git_path_head_file(), 0);
3081 return error_errno(_("could not lock HEAD"));
3082 strbuf_addf(&buf
, "%s\n", head
);
3083 written
= write_in_full(fd
, buf
.buf
, buf
.len
);
3084 strbuf_release(&buf
);
3086 error_errno(_("could not write to '%s'"), git_path_head_file());
3087 rollback_lock_file(&head_lock
);
3090 if (commit_lock_file(&head_lock
) < 0)
3091 return error(_("failed to finalize '%s'"), git_path_head_file());
3095 static int rollback_is_safe(void)
3097 struct strbuf sb
= STRBUF_INIT
;
3098 struct object_id expected_head
, actual_head
;
3100 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
3102 if (get_oid_hex(sb
.buf
, &expected_head
)) {
3103 strbuf_release(&sb
);
3104 die(_("could not parse %s"), git_path_abort_safety_file());
3106 strbuf_release(&sb
);
3108 else if (errno
== ENOENT
)
3109 oidclr(&expected_head
);
3111 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
3113 if (get_oid("HEAD", &actual_head
))
3114 oidclr(&actual_head
);
3116 return oideq(&actual_head
, &expected_head
);
3119 static int reset_merge(const struct object_id
*oid
)
3122 struct strvec argv
= STRVEC_INIT
;
3124 strvec_pushl(&argv
, "reset", "--merge", NULL
);
3126 if (!is_null_oid(oid
))
3127 strvec_push(&argv
, oid_to_hex(oid
));
3129 ret
= run_command_v_opt(argv
.v
, RUN_GIT_CMD
);
3130 strvec_clear(&argv
);
3135 static int rollback_single_pick(struct repository
*r
)
3137 struct object_id head_oid
;
3139 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
3140 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
3141 return error(_("no cherry-pick or revert in progress"));
3142 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
3143 return error(_("cannot resolve HEAD"));
3144 if (is_null_oid(&head_oid
))
3145 return error(_("cannot abort from a branch yet to be born"));
3146 return reset_merge(&head_oid
);
3149 static int skip_single_pick(void)
3151 struct object_id head
;
3153 if (read_ref_full("HEAD", 0, &head
, NULL
))
3154 return error(_("cannot resolve HEAD"));
3155 return reset_merge(&head
);
3158 int sequencer_rollback(struct repository
*r
, struct replay_opts
*opts
)
3161 struct object_id oid
;
3162 struct strbuf buf
= STRBUF_INIT
;
3165 f
= fopen(git_path_head_file(), "r");
3166 if (!f
&& errno
== ENOENT
) {
3168 * There is no multiple-cherry-pick in progress.
3169 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
3170 * a single-cherry-pick in progress, abort that.
3172 return rollback_single_pick(r
);
3175 return error_errno(_("cannot open '%s'"), git_path_head_file());
3176 if (strbuf_getline_lf(&buf
, f
)) {
3177 error(_("cannot read '%s': %s"), git_path_head_file(),
3178 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
3183 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
3184 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
3185 git_path_head_file());
3188 if (is_null_oid(&oid
)) {
3189 error(_("cannot abort from a branch yet to be born"));
3193 if (!rollback_is_safe()) {
3194 /* Do not error, just do not rollback */
3195 warning(_("You seem to have moved HEAD. "
3196 "Not rewinding, check your HEAD!"));
3198 if (reset_merge(&oid
))
3200 strbuf_release(&buf
);
3201 return sequencer_remove_state(opts
);
3203 strbuf_release(&buf
);
3207 int sequencer_skip(struct repository
*r
, struct replay_opts
*opts
)
3209 enum replay_action action
= -1;
3210 sequencer_get_last_command(r
, &action
);
3213 * Check whether the subcommand requested to skip the commit is actually
3214 * in progress and that it's safe to skip the commit.
3216 * opts->action tells us which subcommand requested to skip the commit.
3217 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
3218 * action is in progress and we can skip the commit.
3220 * Otherwise we check that the last instruction was related to the
3221 * particular subcommand we're trying to execute and barf if that's not
3224 * Finally we check that the rollback is "safe", i.e., has the HEAD
3225 * moved? In this case, it doesn't make sense to "reset the merge" and
3226 * "skip the commit" as the user already handled this by committing. But
3227 * we'd not want to barf here, instead give advice on how to proceed. We
3228 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
3229 * it gets removed when the user commits, so if it still exists we're
3230 * sure the user can't have committed before.
3232 switch (opts
->action
) {
3234 if (!refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
3235 if (action
!= REPLAY_REVERT
)
3236 return error(_("no revert in progress"));
3237 if (!rollback_is_safe())
3242 if (!refs_ref_exists(get_main_ref_store(r
),
3243 "CHERRY_PICK_HEAD")) {
3244 if (action
!= REPLAY_PICK
)
3245 return error(_("no cherry-pick in progress"));
3246 if (!rollback_is_safe())
3251 BUG("unexpected action in sequencer_skip");
3254 if (skip_single_pick())
3255 return error(_("failed to skip the commit"));
3256 if (!is_directory(git_path_seq_dir()))
3259 return sequencer_continue(r
, opts
);
3262 error(_("there is nothing to skip"));
3264 if (advice_enabled(ADVICE_RESOLVE_CONFLICT
)) {
3265 advise(_("have you committed already?\n"
3266 "try \"git %s --continue\""),
3267 action
== REPLAY_REVERT
? "revert" : "cherry-pick");
3272 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
3274 struct lock_file todo_lock
= LOCK_INIT
;
3275 const char *todo_path
= get_todo_path(opts
);
3276 int next
= todo_list
->current
, offset
, fd
;
3279 * rebase -i writes "git-rebase-todo" without the currently executing
3280 * command, appending it to "done" instead.
3282 if (is_rebase_i(opts
))
3285 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
3287 return error_errno(_("could not lock '%s'"), todo_path
);
3288 offset
= get_item_line_offset(todo_list
, next
);
3289 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
3290 todo_list
->buf
.len
- offset
) < 0)
3291 return error_errno(_("could not write to '%s'"), todo_path
);
3292 if (commit_lock_file(&todo_lock
) < 0)
3293 return error(_("failed to finalize '%s'"), todo_path
);
3295 if (is_rebase_i(opts
) && next
> 0) {
3296 const char *done
= rebase_path_done();
3297 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
3302 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
3303 get_item_line_length(todo_list
, next
- 1))
3305 ret
= error_errno(_("could not write to '%s'"), done
);
3307 ret
= error_errno(_("failed to finalize '%s'"), done
);
3313 static int save_opts(struct replay_opts
*opts
)
3315 const char *opts_file
= git_path_opts_file();
3318 if (opts
->no_commit
)
3319 res
|= git_config_set_in_file_gently(opts_file
,
3320 "options.no-commit", "true");
3321 if (opts
->edit
>= 0)
3322 res
|= git_config_set_in_file_gently(opts_file
, "options.edit",
3323 opts
->edit
? "true" : "false");
3324 if (opts
->allow_empty
)
3325 res
|= git_config_set_in_file_gently(opts_file
,
3326 "options.allow-empty", "true");
3327 if (opts
->allow_empty_message
)
3328 res
|= git_config_set_in_file_gently(opts_file
,
3329 "options.allow-empty-message", "true");
3330 if (opts
->keep_redundant_commits
)
3331 res
|= git_config_set_in_file_gently(opts_file
,
3332 "options.keep-redundant-commits", "true");
3334 res
|= git_config_set_in_file_gently(opts_file
,
3335 "options.signoff", "true");
3336 if (opts
->record_origin
)
3337 res
|= git_config_set_in_file_gently(opts_file
,
3338 "options.record-origin", "true");
3340 res
|= git_config_set_in_file_gently(opts_file
,
3341 "options.allow-ff", "true");
3342 if (opts
->mainline
) {
3343 struct strbuf buf
= STRBUF_INIT
;
3344 strbuf_addf(&buf
, "%d", opts
->mainline
);
3345 res
|= git_config_set_in_file_gently(opts_file
,
3346 "options.mainline", buf
.buf
);
3347 strbuf_release(&buf
);
3350 res
|= git_config_set_in_file_gently(opts_file
,
3351 "options.strategy", opts
->strategy
);
3353 res
|= git_config_set_in_file_gently(opts_file
,
3354 "options.gpg-sign", opts
->gpg_sign
);
3357 for (i
= 0; i
< opts
->xopts_nr
; i
++)
3358 res
|= git_config_set_multivar_in_file_gently(opts_file
,
3359 "options.strategy-option",
3360 opts
->xopts
[i
], "^$", 0);
3362 if (opts
->allow_rerere_auto
)
3363 res
|= git_config_set_in_file_gently(opts_file
,
3364 "options.allow-rerere-auto",
3365 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
3368 if (opts
->explicit_cleanup
)
3369 res
|= git_config_set_in_file_gently(opts_file
,
3370 "options.default-msg-cleanup",
3371 describe_cleanup_mode(opts
->default_msg_cleanup
));
3375 static int make_patch(struct repository
*r
,
3376 struct commit
*commit
,
3377 struct replay_opts
*opts
)
3379 struct strbuf buf
= STRBUF_INIT
;
3380 struct rev_info log_tree_opt
;
3381 const char *subject
;
3382 char hex
[GIT_MAX_HEXSZ
+ 1];
3385 oid_to_hex_r(hex
, &commit
->object
.oid
);
3386 if (write_message(hex
, strlen(hex
), rebase_path_stopped_sha(), 1) < 0)
3388 res
|= write_rebase_head(&commit
->object
.oid
);
3390 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
3391 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3392 repo_init_revisions(r
, &log_tree_opt
, NULL
);
3393 log_tree_opt
.abbrev
= 0;
3394 log_tree_opt
.diff
= 1;
3395 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
3396 log_tree_opt
.disable_stdin
= 1;
3397 log_tree_opt
.no_commit_id
= 1;
3398 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
3399 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
3400 if (!log_tree_opt
.diffopt
.file
)
3401 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
3403 res
|= log_tree_commit(&log_tree_opt
, commit
);
3404 fclose(log_tree_opt
.diffopt
.file
);
3408 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
3409 if (!file_exists(buf
.buf
)) {
3410 const char *encoding
= get_commit_output_encoding();
3411 const char *commit_buffer
= logmsg_reencode(commit
, NULL
, encoding
);
3412 find_commit_subject(commit_buffer
, &subject
);
3413 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
3414 unuse_commit_buffer(commit
, commit_buffer
);
3416 strbuf_release(&buf
);
3421 static int intend_to_amend(void)
3423 struct object_id head
;
3426 if (get_oid("HEAD", &head
))
3427 return error(_("cannot read HEAD"));
3429 p
= oid_to_hex(&head
);
3430 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
3433 static int error_with_patch(struct repository
*r
,
3434 struct commit
*commit
,
3435 const char *subject
, int subject_len
,
3436 struct replay_opts
*opts
,
3437 int exit_code
, int to_amend
)
3440 if (make_patch(r
, commit
, opts
))
3442 } else if (copy_file(rebase_path_message(),
3443 git_path_merge_msg(r
), 0666))
3444 return error(_("unable to copy '%s' to '%s'"),
3445 git_path_merge_msg(r
), rebase_path_message());
3448 if (intend_to_amend())
3452 _("You can amend the commit now, with\n"
3454 " git commit --amend %s\n"
3456 "Once you are satisfied with your changes, run\n"
3458 " git rebase --continue\n"),
3459 gpg_sign_opt_quoted(opts
));
3460 } else if (exit_code
) {
3462 fprintf_ln(stderr
, _("Could not apply %s... %.*s"),
3463 short_commit_name(commit
), subject_len
, subject
);
3466 * We don't have the hash of the parent so
3467 * just print the line from the todo file.
3469 fprintf_ln(stderr
, _("Could not merge %.*s"),
3470 subject_len
, subject
);
3476 static int error_failed_squash(struct repository
*r
,
3477 struct commit
*commit
,
3478 struct replay_opts
*opts
,
3480 const char *subject
)
3482 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3483 return error(_("could not copy '%s' to '%s'"),
3484 rebase_path_squash_msg(), rebase_path_message());
3485 unlink(git_path_merge_msg(r
));
3486 if (copy_file(git_path_merge_msg(r
), rebase_path_message(), 0666))
3487 return error(_("could not copy '%s' to '%s'"),
3488 rebase_path_message(),
3489 git_path_merge_msg(r
));
3490 return error_with_patch(r
, commit
, subject
, subject_len
, opts
, 1, 0);
3493 static int do_exec(struct repository
*r
, const char *command_line
)
3495 struct strvec child_env
= STRVEC_INIT
;
3496 const char *child_argv
[] = { NULL
, NULL
};
3499 fprintf(stderr
, _("Executing: %s\n"), command_line
);
3500 child_argv
[0] = command_line
;
3501 strvec_pushf(&child_env
, "GIT_DIR=%s", absolute_path(get_git_dir()));
3502 strvec_pushf(&child_env
, "GIT_WORK_TREE=%s",
3503 absolute_path(get_git_work_tree()));
3504 status
= run_command_v_opt_cd_env(child_argv
, RUN_USING_SHELL
, NULL
,
3507 /* force re-reading of the cache */
3508 if (discard_index(r
->index
) < 0 || repo_read_index(r
) < 0)
3509 return error(_("could not read index"));
3511 dirty
= require_clean_work_tree(r
, "rebase", NULL
, 1, 1);
3514 warning(_("execution failed: %s\n%s"
3515 "You can fix the problem, and then run\n"
3517 " git rebase --continue\n"
3520 dirty
? N_("and made changes to the index and/or the "
3521 "working tree\n") : "");
3523 /* command not found */
3526 warning(_("execution succeeded: %s\nbut "
3527 "left changes to the index and/or the working tree\n"
3528 "Commit or stash your changes, and then run\n"
3530 " git rebase --continue\n"
3531 "\n"), command_line
);
3535 strvec_clear(&child_env
);
3540 __attribute__((format (printf
, 2, 3)))
3541 static int safe_append(const char *filename
, const char *fmt
, ...)
3544 struct lock_file lock
= LOCK_INIT
;
3545 int fd
= hold_lock_file_for_update(&lock
, filename
,
3546 LOCK_REPORT_ON_ERROR
);
3547 struct strbuf buf
= STRBUF_INIT
;
3552 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
3553 error_errno(_("could not read '%s'"), filename
);
3554 rollback_lock_file(&lock
);
3557 strbuf_complete(&buf
, '\n');
3559 strbuf_vaddf(&buf
, fmt
, ap
);
3562 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
3563 error_errno(_("could not write to '%s'"), filename
);
3564 strbuf_release(&buf
);
3565 rollback_lock_file(&lock
);
3568 if (commit_lock_file(&lock
) < 0) {
3569 strbuf_release(&buf
);
3570 rollback_lock_file(&lock
);
3571 return error(_("failed to finalize '%s'"), filename
);
3574 strbuf_release(&buf
);
3578 static int do_label(struct repository
*r
, const char *name
, int len
)
3580 struct ref_store
*refs
= get_main_ref_store(r
);
3581 struct ref_transaction
*transaction
;
3582 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
3583 struct strbuf msg
= STRBUF_INIT
;
3585 struct object_id head_oid
;
3587 if (len
== 1 && *name
== '#')
3588 return error(_("illegal label name: '%.*s'"), len
, name
);
3590 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3591 strbuf_addf(&msg
, "rebase (label) '%.*s'", len
, name
);
3593 transaction
= ref_store_transaction_begin(refs
, &err
);
3595 error("%s", err
.buf
);
3597 } else if (get_oid("HEAD", &head_oid
)) {
3598 error(_("could not read HEAD"));
3600 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
3601 NULL
, 0, msg
.buf
, &err
) < 0 ||
3602 ref_transaction_commit(transaction
, &err
)) {
3603 error("%s", err
.buf
);
3606 ref_transaction_free(transaction
);
3607 strbuf_release(&err
);
3608 strbuf_release(&msg
);
3611 ret
= safe_append(rebase_path_refs_to_delete(),
3612 "%s\n", ref_name
.buf
);
3613 strbuf_release(&ref_name
);
3618 __attribute__((format (printf
, 3, 4)))
3619 static const char *reflog_message(struct replay_opts
*opts
,
3620 const char *sub_action
, const char *fmt
, ...)
3623 static struct strbuf buf
= STRBUF_INIT
;
3624 char *reflog_action
= getenv(GIT_REFLOG_ACTION
);
3628 strbuf_addstr(&buf
, reflog_action
? reflog_action
: action_name(opts
));
3630 strbuf_addf(&buf
, " (%s)", sub_action
);
3632 strbuf_addstr(&buf
, ": ");
3633 strbuf_vaddf(&buf
, fmt
, ap
);
3640 static int do_reset(struct repository
*r
,
3641 const char *name
, int len
,
3642 struct replay_opts
*opts
)
3644 struct strbuf ref_name
= STRBUF_INIT
;
3645 struct object_id oid
;
3646 struct lock_file lock
= LOCK_INIT
;
3647 struct tree_desc desc
;
3649 struct unpack_trees_options unpack_tree_opts
;
3652 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0)
3655 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
3656 if (!opts
->have_squash_onto
) {
3658 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
3659 NULL
, &opts
->squash_onto
,
3661 return error(_("writing fake root commit"));
3662 opts
->have_squash_onto
= 1;
3663 hex
= oid_to_hex(&opts
->squash_onto
);
3664 if (write_message(hex
, strlen(hex
),
3665 rebase_path_squash_onto(), 0))
3666 return error(_("writing squash-onto"));
3668 oidcpy(&oid
, &opts
->squash_onto
);
3672 /* Determine the length of the label */
3673 for (i
= 0; i
< len
; i
++)
3674 if (isspace(name
[i
]))
3678 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3679 if (get_oid(ref_name
.buf
, &oid
) &&
3680 get_oid(ref_name
.buf
+ strlen("refs/rewritten/"), &oid
)) {
3681 error(_("could not read '%s'"), ref_name
.buf
);
3682 rollback_lock_file(&lock
);
3683 strbuf_release(&ref_name
);
3688 memset(&unpack_tree_opts
, 0, sizeof(unpack_tree_opts
));
3689 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
3690 unpack_tree_opts
.head_idx
= 1;
3691 unpack_tree_opts
.src_index
= r
->index
;
3692 unpack_tree_opts
.dst_index
= r
->index
;
3693 unpack_tree_opts
.fn
= oneway_merge
;
3694 unpack_tree_opts
.merge
= 1;
3695 unpack_tree_opts
.update
= 1;
3696 unpack_tree_opts
.preserve_ignored
= 0; /* FIXME: !overwrite_ignore */
3697 init_checkout_metadata(&unpack_tree_opts
.meta
, name
, &oid
, NULL
);
3699 if (repo_read_index_unmerged(r
)) {
3700 rollback_lock_file(&lock
);
3701 strbuf_release(&ref_name
);
3702 return error_resolve_conflict(_(action_name(opts
)));
3705 if (!fill_tree_descriptor(r
, &desc
, &oid
)) {
3706 error(_("failed to find tree of %s"), oid_to_hex(&oid
));
3707 rollback_lock_file(&lock
);
3708 free((void *)desc
.buffer
);
3709 strbuf_release(&ref_name
);
3713 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
3714 rollback_lock_file(&lock
);
3715 free((void *)desc
.buffer
);
3716 strbuf_release(&ref_name
);
3720 tree
= parse_tree_indirect(&oid
);
3721 prime_cache_tree(r
, r
->index
, tree
);
3723 if (write_locked_index(r
->index
, &lock
, COMMIT_LOCK
) < 0)
3724 ret
= error(_("could not write index"));
3725 free((void *)desc
.buffer
);
3728 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
3729 len
, name
), "HEAD", &oid
,
3730 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3732 strbuf_release(&ref_name
);
3736 static struct commit
*lookup_label(const char *label
, int len
,
3739 struct commit
*commit
;
3742 strbuf_addf(buf
, "refs/rewritten/%.*s", len
, label
);
3743 commit
= lookup_commit_reference_by_name(buf
->buf
);
3745 /* fall back to non-rewritten ref or commit */
3746 strbuf_splice(buf
, 0, strlen("refs/rewritten/"), "", 0);
3747 commit
= lookup_commit_reference_by_name(buf
->buf
);
3751 error(_("could not resolve '%s'"), buf
->buf
);
3756 static int do_merge(struct repository
*r
,
3757 struct commit
*commit
,
3758 const char *arg
, int arg_len
,
3759 int flags
, int *check_todo
, struct replay_opts
*opts
)
3761 int run_commit_flags
= 0;
3762 struct strbuf ref_name
= STRBUF_INIT
;
3763 struct commit
*head_commit
, *merge_commit
, *i
;
3764 struct commit_list
*bases
, *j
, *reversed
= NULL
;
3765 struct commit_list
*to_merge
= NULL
, **tail
= &to_merge
;
3766 const char *strategy
= !opts
->xopts_nr
&&
3768 !strcmp(opts
->strategy
, "recursive") ||
3769 !strcmp(opts
->strategy
, "ort")) ?
3770 NULL
: opts
->strategy
;
3771 struct merge_options o
;
3772 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
, k
;
3773 static struct lock_file lock
;
3776 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0) {
3781 head_commit
= lookup_commit_reference_by_name("HEAD");
3783 ret
= error(_("cannot merge without a current revision"));
3788 * For octopus merges, the arg starts with the list of revisions to be
3789 * merged. The list is optionally followed by '#' and the oneline.
3791 merge_arg_len
= oneline_offset
= arg_len
;
3792 for (p
= arg
; p
- arg
< arg_len
; p
+= strspn(p
, " \t\n")) {
3795 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
3796 p
+= 1 + strspn(p
+ 1, " \t\n");
3797 oneline_offset
= p
- arg
;
3800 k
= strcspn(p
, " \t\n");
3803 merge_commit
= lookup_label(p
, k
, &ref_name
);
3804 if (!merge_commit
) {
3805 ret
= error(_("unable to parse '%.*s'"), k
, p
);
3808 tail
= &commit_list_insert(merge_commit
, tail
)->next
;
3810 merge_arg_len
= p
- arg
;
3814 ret
= error(_("nothing to merge: '%.*s'"), arg_len
, arg
);
3818 if (opts
->have_squash_onto
&&
3819 oideq(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
3821 * When the user tells us to "merge" something into a
3822 * "[new root]", let's simply fast-forward to the merge head.
3824 rollback_lock_file(&lock
);
3826 ret
= error(_("octopus merge cannot be executed on "
3827 "top of a [new root]"));
3829 ret
= fast_forward_to(r
, &to_merge
->item
->object
.oid
,
3830 &head_commit
->object
.oid
, 0,
3836 * If HEAD is not identical to the first parent of the original merge
3837 * commit, we cannot fast-forward.
3839 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
3840 oideq(&commit
->parents
->item
->object
.oid
,
3841 &head_commit
->object
.oid
);
3844 * If any merge head is different from the original one, we cannot
3847 if (can_fast_forward
) {
3848 struct commit_list
*p
= commit
->parents
->next
;
3850 for (j
= to_merge
; j
&& p
; j
= j
->next
, p
= p
->next
)
3851 if (!oideq(&j
->item
->object
.oid
,
3852 &p
->item
->object
.oid
)) {
3853 can_fast_forward
= 0;
3857 * If the number of merge heads differs from the original merge
3858 * commit, we cannot fast-forward.
3861 can_fast_forward
= 0;
3864 if (can_fast_forward
) {
3865 rollback_lock_file(&lock
);
3866 ret
= fast_forward_to(r
, &commit
->object
.oid
,
3867 &head_commit
->object
.oid
, 0, opts
);
3868 if (flags
& TODO_EDIT_MERGE_MSG
)
3869 goto fast_forward_edit
;
3875 const char *encoding
= get_commit_output_encoding();
3876 const char *message
= logmsg_reencode(commit
, NULL
, encoding
);
3881 ret
= error(_("could not get commit message of '%s'"),
3882 oid_to_hex(&commit
->object
.oid
));
3885 write_author_script(message
);
3886 find_commit_subject(message
, &body
);
3888 ret
= write_message(body
, len
, git_path_merge_msg(r
), 0);
3889 unuse_commit_buffer(commit
, message
);
3891 error_errno(_("could not write '%s'"),
3892 git_path_merge_msg(r
));
3896 struct strbuf buf
= STRBUF_INIT
;
3899 strbuf_addf(&buf
, "author %s", git_author_info(0));
3900 write_author_script(buf
.buf
);
3903 if (oneline_offset
< arg_len
) {
3904 p
= arg
+ oneline_offset
;
3905 len
= arg_len
- oneline_offset
;
3907 strbuf_addf(&buf
, "Merge %s '%.*s'",
3908 to_merge
->next
? "branches" : "branch",
3909 merge_arg_len
, arg
);
3914 ret
= write_message(p
, len
, git_path_merge_msg(r
), 0);
3915 strbuf_release(&buf
);
3917 error_errno(_("could not write '%s'"),
3918 git_path_merge_msg(r
));
3923 if (strategy
|| to_merge
->next
) {
3925 struct child_process cmd
= CHILD_PROCESS_INIT
;
3927 if (read_env_script(&cmd
.env_array
)) {
3928 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
3930 ret
= error(_(staged_changes_advice
), gpg_opt
, gpg_opt
);
3934 if (opts
->committer_date_is_author_date
)
3935 strvec_pushf(&cmd
.env_array
, "GIT_COMMITTER_DATE=%s",
3938 author_date_from_env_array(&cmd
.env_array
));
3939 if (opts
->ignore_date
)
3940 strvec_push(&cmd
.env_array
, "GIT_AUTHOR_DATE=");
3943 strvec_push(&cmd
.args
, "merge");
3944 strvec_push(&cmd
.args
, "-s");
3946 strvec_push(&cmd
.args
, "octopus");
3948 strvec_push(&cmd
.args
, strategy
);
3949 for (k
= 0; k
< opts
->xopts_nr
; k
++)
3950 strvec_pushf(&cmd
.args
,
3951 "-X%s", opts
->xopts
[k
]);
3953 if (!(flags
& TODO_EDIT_MERGE_MSG
))
3954 strvec_push(&cmd
.args
, "--no-edit");
3956 strvec_push(&cmd
.args
, "--edit");
3957 strvec_push(&cmd
.args
, "--no-ff");
3958 strvec_push(&cmd
.args
, "--no-log");
3959 strvec_push(&cmd
.args
, "--no-stat");
3960 strvec_push(&cmd
.args
, "-F");
3961 strvec_push(&cmd
.args
, git_path_merge_msg(r
));
3963 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
3965 strvec_push(&cmd
.args
, "--no-gpg-sign");
3967 /* Add the tips to be merged */
3968 for (j
= to_merge
; j
; j
= j
->next
)
3969 strvec_push(&cmd
.args
,
3970 oid_to_hex(&j
->item
->object
.oid
));
3972 strbuf_release(&ref_name
);
3973 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
3975 rollback_lock_file(&lock
);
3977 ret
= run_command(&cmd
);
3979 /* force re-reading of the cache */
3980 if (!ret
&& (discard_index(r
->index
) < 0 ||
3981 repo_read_index(r
) < 0))
3982 ret
= error(_("could not read index"));
3986 merge_commit
= to_merge
->item
;
3987 bases
= get_merge_bases(head_commit
, merge_commit
);
3988 if (bases
&& oideq(&merge_commit
->object
.oid
,
3989 &bases
->item
->object
.oid
)) {
3991 /* skip merging an ancestor of HEAD */
3995 write_message(oid_to_hex(&merge_commit
->object
.oid
), the_hash_algo
->hexsz
,
3996 git_path_merge_head(r
), 0);
3997 write_message("no-ff", 5, git_path_merge_mode(r
), 0);
3999 for (j
= bases
; j
; j
= j
->next
)
4000 commit_list_insert(j
->item
, &reversed
);
4001 free_commit_list(bases
);
4004 init_merge_options(&o
, r
);
4006 o
.branch2
= ref_name
.buf
;
4007 o
.buffer_output
= 2;
4009 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
4011 * TODO: Should use merge_incore_recursive() and
4012 * merge_switch_to_result(), skipping the call to
4013 * merge_switch_to_result() when we don't actually need to
4014 * update the index and working copy immediately.
4016 ret
= merge_ort_recursive(&o
,
4017 head_commit
, merge_commit
, reversed
,
4020 ret
= merge_recursive(&o
, head_commit
, merge_commit
, reversed
,
4024 fputs(o
.obuf
.buf
, stdout
);
4025 strbuf_release(&o
.obuf
);
4027 error(_("could not even attempt to merge '%.*s'"),
4028 merge_arg_len
, arg
);
4032 * The return value of merge_recursive() is 1 on clean, and 0 on
4035 * Let's reverse that, so that do_merge() returns 0 upon success and
4036 * 1 upon failed merge (keeping the return value -1 for the cases where
4037 * we will want to reschedule the `merge` command).
4041 if (r
->index
->cache_changed
&&
4042 write_locked_index(r
->index
, &lock
, COMMIT_LOCK
)) {
4043 ret
= error(_("merge: Unable to write new index file"));
4047 rollback_lock_file(&lock
);
4049 repo_rerere(r
, opts
->allow_rerere_auto
);
4052 * In case of problems, we now want to return a positive
4053 * value (a negative one would indicate that the `merge`
4054 * command needs to be rescheduled).
4056 ret
= !!run_git_commit(git_path_merge_msg(r
), opts
,
4059 if (!ret
&& flags
& TODO_EDIT_MERGE_MSG
) {
4062 run_commit_flags
|= AMEND_MSG
| EDIT_MSG
| VERIFY_MSG
;
4063 ret
= !!run_git_commit(NULL
, opts
, run_commit_flags
);
4068 strbuf_release(&ref_name
);
4069 rollback_lock_file(&lock
);
4070 free_commit_list(to_merge
);
4074 static int is_final_fixup(struct todo_list
*todo_list
)
4076 int i
= todo_list
->current
;
4078 if (!is_fixup(todo_list
->items
[i
].command
))
4081 while (++i
< todo_list
->nr
)
4082 if (is_fixup(todo_list
->items
[i
].command
))
4084 else if (!is_noop(todo_list
->items
[i
].command
))
4089 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
4093 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
4094 if (!is_noop(todo_list
->items
[i
].command
))
4095 return todo_list
->items
[i
].command
;
4100 void create_autostash(struct repository
*r
, const char *path
,
4101 const char *default_reflog_action
)
4103 struct strbuf buf
= STRBUF_INIT
;
4104 struct lock_file lock_file
= LOCK_INIT
;
4107 fd
= repo_hold_locked_index(r
, &lock_file
, 0);
4108 refresh_index(r
->index
, REFRESH_QUIET
, NULL
, NULL
, NULL
);
4110 repo_update_index_if_able(r
, &lock_file
);
4111 rollback_lock_file(&lock_file
);
4113 if (has_unstaged_changes(r
, 1) ||
4114 has_uncommitted_changes(r
, 1)) {
4115 struct child_process stash
= CHILD_PROCESS_INIT
;
4116 struct object_id oid
;
4118 strvec_pushl(&stash
.args
,
4119 "stash", "create", "autostash", NULL
);
4123 if (capture_command(&stash
, &buf
, GIT_MAX_HEXSZ
))
4124 die(_("Cannot autostash"));
4125 strbuf_trim_trailing_newline(&buf
);
4126 if (get_oid(buf
.buf
, &oid
))
4127 die(_("Unexpected stash response: '%s'"),
4130 strbuf_add_unique_abbrev(&buf
, &oid
, DEFAULT_ABBREV
);
4132 if (safe_create_leading_directories_const(path
))
4133 die(_("Could not create directory for '%s'"),
4135 write_file(path
, "%s", oid_to_hex(&oid
));
4136 printf(_("Created autostash: %s\n"), buf
.buf
);
4137 if (reset_head(r
, NULL
, "reset --hard",
4138 NULL
, RESET_HEAD_HARD
, NULL
, NULL
,
4139 default_reflog_action
) < 0)
4140 die(_("could not reset --hard"));
4142 if (discard_index(r
->index
) < 0 ||
4143 repo_read_index(r
) < 0)
4144 die(_("could not read index"));
4146 strbuf_release(&buf
);
4149 static int apply_save_autostash_oid(const char *stash_oid
, int attempt_apply
)
4151 struct child_process child
= CHILD_PROCESS_INIT
;
4154 if (attempt_apply
) {
4156 child
.no_stdout
= 1;
4157 child
.no_stderr
= 1;
4158 strvec_push(&child
.args
, "stash");
4159 strvec_push(&child
.args
, "apply");
4160 strvec_push(&child
.args
, stash_oid
);
4161 ret
= run_command(&child
);
4164 if (attempt_apply
&& !ret
)
4165 fprintf(stderr
, _("Applied autostash.\n"));
4167 struct child_process store
= CHILD_PROCESS_INIT
;
4170 strvec_push(&store
.args
, "stash");
4171 strvec_push(&store
.args
, "store");
4172 strvec_push(&store
.args
, "-m");
4173 strvec_push(&store
.args
, "autostash");
4174 strvec_push(&store
.args
, "-q");
4175 strvec_push(&store
.args
, stash_oid
);
4176 if (run_command(&store
))
4177 ret
= error(_("cannot store %s"), stash_oid
);
4181 "Your changes are safe in the stash.\n"
4182 "You can run \"git stash pop\" or"
4183 " \"git stash drop\" at any time.\n"),
4185 _("Applying autostash resulted in conflicts.") :
4186 _("Autostash exists; creating a new stash entry."));
4192 static int apply_save_autostash(const char *path
, int attempt_apply
)
4194 struct strbuf stash_oid
= STRBUF_INIT
;
4197 if (!read_oneliner(&stash_oid
, path
,
4198 READ_ONELINER_SKIP_IF_EMPTY
)) {
4199 strbuf_release(&stash_oid
);
4202 strbuf_trim(&stash_oid
);
4204 ret
= apply_save_autostash_oid(stash_oid
.buf
, attempt_apply
);
4207 strbuf_release(&stash_oid
);
4211 int save_autostash(const char *path
)
4213 return apply_save_autostash(path
, 0);
4216 int apply_autostash(const char *path
)
4218 return apply_save_autostash(path
, 1);
4221 int apply_autostash_oid(const char *stash_oid
)
4223 return apply_save_autostash_oid(stash_oid
, 1);
4226 static int run_git_checkout(struct repository
*r
, struct replay_opts
*opts
,
4227 const char *commit
, const char *action
)
4229 struct child_process cmd
= CHILD_PROCESS_INIT
;
4234 strvec_push(&cmd
.args
, "checkout");
4235 strvec_push(&cmd
.args
, commit
);
4236 strvec_pushf(&cmd
.env_array
, GIT_REFLOG_ACTION
"=%s", action
);
4239 ret
= run_command(&cmd
);
4241 ret
= run_command_silent_on_success(&cmd
);
4244 discard_index(r
->index
);
4249 static int checkout_onto(struct repository
*r
, struct replay_opts
*opts
,
4250 const char *onto_name
, const struct object_id
*onto
,
4251 const struct object_id
*orig_head
)
4253 const char *action
= reflog_message(opts
, "start", "checkout %s", onto_name
);
4255 if (run_git_checkout(r
, opts
, oid_to_hex(onto
), action
)) {
4256 apply_autostash(rebase_path_autostash());
4257 sequencer_remove_state(opts
);
4258 return error(_("could not detach HEAD"));
4261 return update_ref(NULL
, "ORIG_HEAD", orig_head
, NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
4264 static int stopped_at_head(struct repository
*r
)
4266 struct object_id head
;
4267 struct commit
*commit
;
4268 struct commit_message message
;
4270 if (get_oid("HEAD", &head
) ||
4271 !(commit
= lookup_commit(r
, &head
)) ||
4272 parse_commit(commit
) || get_message(commit
, &message
))
4273 fprintf(stderr
, _("Stopped at HEAD\n"));
4275 fprintf(stderr
, _("Stopped at %s\n"), message
.label
);
4276 free_message(commit
, &message
);
4282 static int reread_todo_if_changed(struct repository
*r
,
4283 struct todo_list
*todo_list
,
4284 struct replay_opts
*opts
)
4287 struct strbuf buf
= STRBUF_INIT
;
4289 if (strbuf_read_file_or_whine(&buf
, get_todo_path(opts
)) < 0)
4291 offset
= get_item_line_offset(todo_list
, todo_list
->current
+ 1);
4292 if (buf
.len
!= todo_list
->buf
.len
- offset
||
4293 memcmp(buf
.buf
, todo_list
->buf
.buf
+ offset
, buf
.len
)) {
4294 /* Reread the todo file if it has changed. */
4295 todo_list_release(todo_list
);
4296 if (read_populate_todo(r
, todo_list
, opts
))
4297 return -1; /* message was printed */
4298 /* `current` will be incremented on return */
4299 todo_list
->current
= -1;
4301 strbuf_release(&buf
);
4306 static const char rescheduled_advice
[] =
4307 N_("Could not execute the todo command\n"
4311 "It has been rescheduled; To edit the command before continuing, please\n"
4312 "edit the todo list first:\n"
4314 " git rebase --edit-todo\n"
4315 " git rebase --continue\n");
4317 static int pick_commits(struct repository
*r
,
4318 struct todo_list
*todo_list
,
4319 struct replay_opts
*opts
)
4321 int res
= 0, reschedule
= 0;
4322 char *prev_reflog_action
;
4324 /* Note that 0 for 3rd parameter of setenv means set only if not set */
4325 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
4326 prev_reflog_action
= xstrdup(getenv(GIT_REFLOG_ACTION
));
4328 assert(!(opts
->signoff
|| opts
->no_commit
||
4329 opts
->record_origin
|| should_edit(opts
) ||
4330 opts
->committer_date_is_author_date
||
4331 opts
->ignore_date
));
4332 if (read_and_refresh_cache(r
, opts
))
4335 while (todo_list
->current
< todo_list
->nr
) {
4336 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
4337 const char *arg
= todo_item_get_arg(todo_list
, item
);
4340 if (save_todo(todo_list
, opts
))
4342 if (is_rebase_i(opts
)) {
4343 if (item
->command
!= TODO_COMMENT
) {
4344 FILE *f
= fopen(rebase_path_msgnum(), "w");
4346 todo_list
->done_nr
++;
4349 fprintf(f
, "%d\n", todo_list
->done_nr
);
4353 fprintf(stderr
, _("Rebasing (%d/%d)%s"),
4355 todo_list
->total_nr
,
4356 opts
->verbose
? "\n" : "\r");
4358 unlink(rebase_path_message());
4359 unlink(rebase_path_author_script());
4360 unlink(rebase_path_stopped_sha());
4361 unlink(rebase_path_amend());
4362 unlink(git_path_merge_head(r
));
4363 unlink(git_path_auto_merge(r
));
4364 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
4366 if (item
->command
== TODO_BREAK
) {
4369 return stopped_at_head(r
);
4372 if (item
->command
<= TODO_SQUASH
) {
4373 if (is_rebase_i(opts
))
4374 setenv(GIT_REFLOG_ACTION
, reflog_message(opts
,
4375 command_to_string(item
->command
), NULL
),
4377 res
= do_pick_commit(r
, item
, opts
,
4378 is_final_fixup(todo_list
),
4380 if (is_rebase_i(opts
))
4381 setenv(GIT_REFLOG_ACTION
, prev_reflog_action
, 1);
4382 if (is_rebase_i(opts
) && res
< 0) {
4384 advise(_(rescheduled_advice
),
4385 get_item_line_length(todo_list
,
4386 todo_list
->current
),
4387 get_item_line(todo_list
,
4388 todo_list
->current
));
4389 todo_list
->current
--;
4390 if (save_todo(todo_list
, opts
))
4393 if (item
->command
== TODO_EDIT
) {
4394 struct commit
*commit
= item
->commit
;
4399 _("Stopped at %s... %.*s\n"),
4400 short_commit_name(commit
),
4401 item
->arg_len
, arg
);
4403 return error_with_patch(r
, commit
,
4404 arg
, item
->arg_len
, opts
, res
, !res
);
4406 if (is_rebase_i(opts
) && !res
)
4407 record_in_rewritten(&item
->commit
->object
.oid
,
4408 peek_command(todo_list
, 1));
4409 if (res
&& is_fixup(item
->command
)) {
4412 return error_failed_squash(r
, item
->commit
, opts
,
4413 item
->arg_len
, arg
);
4414 } else if (res
&& is_rebase_i(opts
) && item
->commit
) {
4416 struct object_id oid
;
4419 * If we are rewording and have either
4420 * fast-forwarded already, or are about to
4421 * create a new root commit, we want to amend,
4422 * otherwise we do not.
4424 if (item
->command
== TODO_REWORD
&&
4425 !get_oid("HEAD", &oid
) &&
4426 (oideq(&item
->commit
->object
.oid
, &oid
) ||
4427 (opts
->have_squash_onto
&&
4428 oideq(&opts
->squash_onto
, &oid
))))
4431 return res
| error_with_patch(r
, item
->commit
,
4432 arg
, item
->arg_len
, opts
,
4435 } else if (item
->command
== TODO_EXEC
) {
4436 char *end_of_arg
= (char *)(arg
+ item
->arg_len
);
4437 int saved
= *end_of_arg
;
4442 res
= do_exec(r
, arg
);
4443 *end_of_arg
= saved
;
4446 if (opts
->reschedule_failed_exec
)
4450 } else if (item
->command
== TODO_LABEL
) {
4451 if ((res
= do_label(r
, arg
, item
->arg_len
)))
4453 } else if (item
->command
== TODO_RESET
) {
4454 if ((res
= do_reset(r
, arg
, item
->arg_len
, opts
)))
4456 } else if (item
->command
== TODO_MERGE
) {
4457 if ((res
= do_merge(r
, item
->commit
, arg
, item
->arg_len
,
4458 item
->flags
, &check_todo
, opts
)) < 0)
4460 else if (item
->commit
)
4461 record_in_rewritten(&item
->commit
->object
.oid
,
4462 peek_command(todo_list
, 1));
4464 /* failed with merge conflicts */
4465 return error_with_patch(r
, item
->commit
,
4468 } else if (!is_noop(item
->command
))
4469 return error(_("unknown command %d"), item
->command
);
4472 advise(_(rescheduled_advice
),
4473 get_item_line_length(todo_list
,
4474 todo_list
->current
),
4475 get_item_line(todo_list
, todo_list
->current
));
4476 todo_list
->current
--;
4477 if (save_todo(todo_list
, opts
))
4480 return error_with_patch(r
,
4484 } else if (is_rebase_i(opts
) && check_todo
&& !res
&&
4485 reread_todo_if_changed(r
, todo_list
, opts
)) {
4489 todo_list
->current
++;
4494 if (is_rebase_i(opts
)) {
4495 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
4498 /* Stopped in the middle, as planned? */
4499 if (todo_list
->current
< todo_list
->nr
)
4502 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
4503 starts_with(head_ref
.buf
, "refs/")) {
4505 struct object_id head
, orig
;
4508 if (get_oid("HEAD", &head
)) {
4509 res
= error(_("cannot read HEAD"));
4511 strbuf_release(&head_ref
);
4512 strbuf_release(&buf
);
4515 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
4516 get_oid_hex(buf
.buf
, &orig
)) {
4517 res
= error(_("could not read orig-head"));
4518 goto cleanup_head_ref
;
4521 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
4522 res
= error(_("could not read 'onto'"));
4523 goto cleanup_head_ref
;
4525 msg
= reflog_message(opts
, "finish", "%s onto %s",
4526 head_ref
.buf
, buf
.buf
);
4527 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
4528 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
4529 res
= error(_("could not update %s"),
4531 goto cleanup_head_ref
;
4533 msg
= reflog_message(opts
, "finish", "returning to %s",
4535 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
4536 res
= error(_("could not update HEAD to %s"),
4538 goto cleanup_head_ref
;
4543 if (opts
->verbose
) {
4544 struct rev_info log_tree_opt
;
4545 struct object_id orig
, head
;
4547 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
4548 repo_init_revisions(r
, &log_tree_opt
, NULL
);
4549 log_tree_opt
.diff
= 1;
4550 log_tree_opt
.diffopt
.output_format
=
4551 DIFF_FORMAT_DIFFSTAT
;
4552 log_tree_opt
.disable_stdin
= 1;
4554 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
4555 !get_oid(buf
.buf
, &orig
) &&
4556 !get_oid("HEAD", &head
)) {
4557 diff_tree_oid(&orig
, &head
, "",
4558 &log_tree_opt
.diffopt
);
4559 log_tree_diff_flush(&log_tree_opt
);
4562 flush_rewritten_pending();
4563 if (!stat(rebase_path_rewritten_list(), &st
) &&
4565 struct child_process child
= CHILD_PROCESS_INIT
;
4566 const char *post_rewrite_hook
=
4567 find_hook("post-rewrite");
4569 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
4571 strvec_push(&child
.args
, "notes");
4572 strvec_push(&child
.args
, "copy");
4573 strvec_push(&child
.args
, "--for-rewrite=rebase");
4574 /* we don't care if this copying failed */
4575 run_command(&child
);
4577 if (post_rewrite_hook
) {
4578 struct child_process hook
= CHILD_PROCESS_INIT
;
4580 hook
.in
= open(rebase_path_rewritten_list(),
4582 hook
.stdout_to_stderr
= 1;
4583 hook
.trace2_hook_name
= "post-rewrite";
4584 strvec_push(&hook
.args
, post_rewrite_hook
);
4585 strvec_push(&hook
.args
, "rebase");
4586 /* we don't care if this hook failed */
4590 apply_autostash(rebase_path_autostash());
4596 _("Successfully rebased and updated %s.\n"),
4600 strbuf_release(&buf
);
4601 strbuf_release(&head_ref
);
4605 * Sequence of picks finished successfully; cleanup by
4606 * removing the .git/sequencer directory
4608 return sequencer_remove_state(opts
);
4611 static int continue_single_pick(struct repository
*r
, struct replay_opts
*opts
)
4613 struct strvec argv
= STRVEC_INIT
;
4616 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
4617 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
4618 return error(_("no cherry-pick or revert in progress"));
4620 strvec_push(&argv
, "commit");
4623 * continue_single_pick() handles the case of recovering from a
4624 * conflict. should_edit() doesn't handle that case; for a conflict,
4625 * we want to edit if the user asked for it, or if they didn't specify
4626 * and stdin is a tty.
4628 if (!opts
->edit
|| (opts
->edit
< 0 && !isatty(0)))
4630 * Include --cleanup=strip as well because we don't want the
4631 * "# Conflicts:" messages.
4633 strvec_pushl(&argv
, "--no-edit", "--cleanup=strip", NULL
);
4635 ret
= run_command_v_opt(argv
.v
, RUN_GIT_CMD
);
4636 strvec_clear(&argv
);
4640 static int commit_staged_changes(struct repository
*r
,
4641 struct replay_opts
*opts
,
4642 struct todo_list
*todo_list
)
4644 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
4645 unsigned int final_fixup
= 0, is_clean
;
4647 if (has_unstaged_changes(r
, 1))
4648 return error(_("cannot rebase: You have unstaged changes."));
4650 is_clean
= !has_uncommitted_changes(r
, 0);
4652 if (file_exists(rebase_path_amend())) {
4653 struct strbuf rev
= STRBUF_INIT
;
4654 struct object_id head
, to_amend
;
4656 if (get_oid("HEAD", &head
))
4657 return error(_("cannot amend non-existing commit"));
4658 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
4659 return error(_("invalid file: '%s'"), rebase_path_amend());
4660 if (get_oid_hex(rev
.buf
, &to_amend
))
4661 return error(_("invalid contents: '%s'"),
4662 rebase_path_amend());
4663 if (!is_clean
&& !oideq(&head
, &to_amend
))
4664 return error(_("\nYou have uncommitted changes in your "
4665 "working tree. Please, commit them\n"
4666 "first and then run 'git rebase "
4667 "--continue' again."));
4669 * When skipping a failed fixup/squash, we need to edit the
4670 * commit message, the current fixup list and count, and if it
4671 * was the last fixup/squash in the chain, we need to clean up
4672 * the commit message and if there was a squash, let the user
4675 if (!is_clean
|| !opts
->current_fixup_count
)
4676 ; /* this is not the final fixup */
4677 else if (!oideq(&head
, &to_amend
) ||
4678 !file_exists(rebase_path_stopped_sha())) {
4679 /* was a final fixup or squash done manually? */
4680 if (!is_fixup(peek_command(todo_list
, 0))) {
4681 unlink(rebase_path_fixup_msg());
4682 unlink(rebase_path_squash_msg());
4683 unlink(rebase_path_current_fixups());
4684 strbuf_reset(&opts
->current_fixups
);
4685 opts
->current_fixup_count
= 0;
4688 /* we are in a fixup/squash chain */
4689 const char *p
= opts
->current_fixups
.buf
;
4690 int len
= opts
->current_fixups
.len
;
4692 opts
->current_fixup_count
--;
4694 BUG("Incorrect current_fixups:\n%s", p
);
4695 while (len
&& p
[len
- 1] != '\n')
4697 strbuf_setlen(&opts
->current_fixups
, len
);
4698 if (write_message(p
, len
, rebase_path_current_fixups(),
4700 return error(_("could not write file: '%s'"),
4701 rebase_path_current_fixups());
4704 * If a fixup/squash in a fixup/squash chain failed, the
4705 * commit message is already correct, no need to commit
4708 * Only if it is the final command in the fixup/squash
4709 * chain, and only if the chain is longer than a single
4710 * fixup/squash command (which was just skipped), do we
4711 * actually need to re-commit with a cleaned up commit
4714 if (opts
->current_fixup_count
> 0 &&
4715 !is_fixup(peek_command(todo_list
, 0))) {
4718 * If there was not a single "squash" in the
4719 * chain, we only need to clean up the commit
4720 * message, no need to bother the user with
4721 * opening the commit message in the editor.
4723 if (!starts_with(p
, "squash ") &&
4724 !strstr(p
, "\nsquash "))
4725 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
4726 } else if (is_fixup(peek_command(todo_list
, 0))) {
4728 * We need to update the squash message to skip
4729 * the latest commit message.
4731 struct commit
*commit
;
4732 const char *path
= rebase_path_squash_msg();
4733 const char *encoding
= get_commit_output_encoding();
4735 if (parse_head(r
, &commit
) ||
4736 !(p
= logmsg_reencode(commit
, NULL
, encoding
)) ||
4737 write_message(p
, strlen(p
), path
, 0)) {
4738 unuse_commit_buffer(commit
, p
);
4739 return error(_("could not write file: "
4742 unuse_commit_buffer(commit
, p
);
4746 strbuf_release(&rev
);
4751 if (refs_ref_exists(get_main_ref_store(r
),
4752 "CHERRY_PICK_HEAD") &&
4753 refs_delete_ref(get_main_ref_store(r
), "",
4754 "CHERRY_PICK_HEAD", NULL
, 0))
4755 return error(_("could not remove CHERRY_PICK_HEAD"));
4756 if (unlink(git_path_merge_msg(r
)) && errno
!= ENOENT
)
4757 return error_errno(_("could not remove '%s'"),
4758 git_path_merge_msg(r
));
4763 if (run_git_commit(final_fixup
? NULL
: rebase_path_message(),
4765 return error(_("could not commit staged changes."));
4766 unlink(rebase_path_amend());
4767 unlink(git_path_merge_head(r
));
4768 unlink(git_path_auto_merge(r
));
4770 unlink(rebase_path_fixup_msg());
4771 unlink(rebase_path_squash_msg());
4773 if (opts
->current_fixup_count
> 0) {
4775 * Whether final fixup or not, we just cleaned up the commit
4778 unlink(rebase_path_current_fixups());
4779 strbuf_reset(&opts
->current_fixups
);
4780 opts
->current_fixup_count
= 0;
4785 int sequencer_continue(struct repository
*r
, struct replay_opts
*opts
)
4787 struct todo_list todo_list
= TODO_LIST_INIT
;
4790 if (read_and_refresh_cache(r
, opts
))
4793 if (read_populate_opts(opts
))
4795 if (is_rebase_i(opts
)) {
4796 if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
4797 goto release_todo_list
;
4799 if (file_exists(rebase_path_dropped())) {
4800 if ((res
= todo_list_check_against_backup(r
, &todo_list
)))
4801 goto release_todo_list
;
4803 unlink(rebase_path_dropped());
4806 if (commit_staged_changes(r
, opts
, &todo_list
)) {
4808 goto release_todo_list
;
4810 } else if (!file_exists(get_todo_path(opts
)))
4811 return continue_single_pick(r
, opts
);
4812 else if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
4813 goto release_todo_list
;
4815 if (!is_rebase_i(opts
)) {
4816 /* Verify that the conflict has been resolved */
4817 if (refs_ref_exists(get_main_ref_store(r
),
4818 "CHERRY_PICK_HEAD") ||
4819 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
4820 res
= continue_single_pick(r
, opts
);
4822 goto release_todo_list
;
4824 if (index_differs_from(r
, "HEAD", NULL
, 0)) {
4825 res
= error_dirty_index(r
, opts
);
4826 goto release_todo_list
;
4828 todo_list
.current
++;
4829 } else if (file_exists(rebase_path_stopped_sha())) {
4830 struct strbuf buf
= STRBUF_INIT
;
4831 struct object_id oid
;
4833 if (read_oneliner(&buf
, rebase_path_stopped_sha(),
4834 READ_ONELINER_SKIP_IF_EMPTY
) &&
4835 !get_oid_hex(buf
.buf
, &oid
))
4836 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
4837 strbuf_release(&buf
);
4840 res
= pick_commits(r
, &todo_list
, opts
);
4842 todo_list_release(&todo_list
);
4846 static int single_pick(struct repository
*r
,
4847 struct commit
*cmit
,
4848 struct replay_opts
*opts
)
4851 struct todo_item item
;
4853 item
.command
= opts
->action
== REPLAY_PICK
?
4854 TODO_PICK
: TODO_REVERT
;
4857 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
4858 return do_pick_commit(r
, &item
, opts
, 0, &check_todo
);
4861 int sequencer_pick_revisions(struct repository
*r
,
4862 struct replay_opts
*opts
)
4864 struct todo_list todo_list
= TODO_LIST_INIT
;
4865 struct object_id oid
;
4869 if (read_and_refresh_cache(r
, opts
))
4872 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
4873 struct object_id oid
;
4874 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
4876 /* This happens when using --stdin. */
4880 if (!get_oid(name
, &oid
)) {
4881 if (!lookup_commit_reference_gently(r
, &oid
, 1)) {
4882 enum object_type type
= oid_object_info(r
,
4885 return error(_("%s: can't cherry-pick a %s"),
4886 name
, type_name(type
));
4889 return error(_("%s: bad revision"), name
);
4893 * If we were called as "git cherry-pick <commit>", just
4894 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4895 * REVERT_HEAD, and don't touch the sequencer state.
4896 * This means it is possible to cherry-pick in the middle
4897 * of a cherry-pick sequence.
4899 if (opts
->revs
->cmdline
.nr
== 1 &&
4900 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
4901 opts
->revs
->no_walk
&&
4902 !opts
->revs
->cmdline
.rev
->flags
) {
4903 struct commit
*cmit
;
4904 if (prepare_revision_walk(opts
->revs
))
4905 return error(_("revision walk setup failed"));
4906 cmit
= get_revision(opts
->revs
);
4908 return error(_("empty commit set passed"));
4909 if (get_revision(opts
->revs
))
4910 BUG("unexpected extra commit from walk");
4911 return single_pick(r
, cmit
, opts
);
4915 * Start a new cherry-pick/ revert sequence; but
4916 * first, make sure that an existing one isn't in
4920 if (walk_revs_populate_todo(&todo_list
, opts
) ||
4921 create_seq_dir(r
) < 0)
4923 if (get_oid("HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
4924 return error(_("can't revert as initial commit"));
4925 if (save_head(oid_to_hex(&oid
)))
4927 if (save_opts(opts
))
4929 update_abort_safety_file();
4930 res
= pick_commits(r
, &todo_list
, opts
);
4931 todo_list_release(&todo_list
);
4935 void append_signoff(struct strbuf
*msgbuf
, size_t ignore_footer
, unsigned flag
)
4937 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
4938 struct strbuf sob
= STRBUF_INIT
;
4941 strbuf_addstr(&sob
, sign_off_header
);
4942 strbuf_addstr(&sob
, fmt_name(WANT_COMMITTER_IDENT
));
4943 strbuf_addch(&sob
, '\n');
4946 strbuf_complete_line(msgbuf
);
4949 * If the whole message buffer is equal to the sob, pretend that we
4950 * found a conforming footer with a matching sob
4952 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
4953 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
4956 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
4959 const char *append_newlines
= NULL
;
4960 size_t len
= msgbuf
->len
- ignore_footer
;
4964 * The buffer is completely empty. Leave foom for
4965 * the title and body to be filled in by the user.
4967 append_newlines
= "\n\n";
4968 } else if (len
== 1) {
4970 * Buffer contains a single newline. Add another
4971 * so that we leave room for the title and body.
4973 append_newlines
= "\n";
4974 } else if (msgbuf
->buf
[len
- 2] != '\n') {
4976 * Buffer ends with a single newline. Add another
4977 * so that there is an empty line between the message
4980 append_newlines
= "\n";
4981 } /* else, the buffer already ends with two newlines. */
4983 if (append_newlines
)
4984 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
4985 append_newlines
, strlen(append_newlines
));
4988 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
4989 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
4992 strbuf_release(&sob
);
4995 struct labels_entry
{
4996 struct hashmap_entry entry
;
4997 char label
[FLEX_ARRAY
];
5000 static int labels_cmp(const void *fndata
, const struct hashmap_entry
*eptr
,
5001 const struct hashmap_entry
*entry_or_key
, const void *key
)
5003 const struct labels_entry
*a
, *b
;
5005 a
= container_of(eptr
, const struct labels_entry
, entry
);
5006 b
= container_of(entry_or_key
, const struct labels_entry
, entry
);
5008 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
5011 struct string_entry
{
5012 struct oidmap_entry entry
;
5013 char string
[FLEX_ARRAY
];
5016 struct label_state
{
5017 struct oidmap commit2label
;
5018 struct hashmap labels
;
5022 static const char *label_oid(struct object_id
*oid
, const char *label
,
5023 struct label_state
*state
)
5025 struct labels_entry
*labels_entry
;
5026 struct string_entry
*string_entry
;
5027 struct object_id dummy
;
5030 string_entry
= oidmap_get(&state
->commit2label
, oid
);
5032 return string_entry
->string
;
5035 * For "uninteresting" commits, i.e. commits that are not to be
5036 * rebased, and which can therefore not be labeled, we use a unique
5037 * abbreviation of the commit name. This is slightly more complicated
5038 * than calling find_unique_abbrev() because we also need to make
5039 * sure that the abbreviation does not conflict with any other
5042 * We disallow "interesting" commits to be labeled by a string that
5043 * is a valid full-length hash, to ensure that we always can find an
5044 * abbreviation for any uninteresting commit's names that does not
5045 * clash with any other label.
5047 strbuf_reset(&state
->buf
);
5051 strbuf_grow(&state
->buf
, GIT_MAX_HEXSZ
);
5052 label
= p
= state
->buf
.buf
;
5054 find_unique_abbrev_r(p
, oid
, default_abbrev
);
5057 * We may need to extend the abbreviated hash so that there is
5058 * no conflicting label.
5060 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
5061 size_t i
= strlen(p
) + 1;
5063 oid_to_hex_r(p
, oid
);
5064 for (; i
< the_hash_algo
->hexsz
; i
++) {
5067 if (!hashmap_get_from_hash(&state
->labels
,
5074 struct strbuf
*buf
= &state
->buf
;
5077 * Sanitize labels by replacing non-alpha-numeric characters
5078 * (including white-space ones) by dashes, as they might be
5079 * illegal in file names (and hence in ref names).
5081 * Note that we retain non-ASCII UTF-8 characters (identified
5082 * via the most significant bit). They should be all acceptable
5083 * in file names. We do not validate the UTF-8 here, that's not
5084 * the job of this function.
5086 for (; *label
; label
++)
5087 if ((*label
& 0x80) || isalnum(*label
))
5088 strbuf_addch(buf
, *label
);
5089 /* avoid leading dash and double-dashes */
5090 else if (buf
->len
&& buf
->buf
[buf
->len
- 1] != '-')
5091 strbuf_addch(buf
, '-');
5093 strbuf_addstr(buf
, "rev-");
5094 strbuf_add_unique_abbrev(buf
, oid
, default_abbrev
);
5098 if ((buf
->len
== the_hash_algo
->hexsz
&&
5099 !get_oid_hex(label
, &dummy
)) ||
5100 (buf
->len
== 1 && *label
== '#') ||
5101 hashmap_get_from_hash(&state
->labels
,
5102 strihash(label
), label
)) {
5104 * If the label already exists, or if the label is a
5105 * valid full OID, or the label is a '#' (which we use
5106 * as a separator between merge heads and oneline), we
5107 * append a dash and a number to make it unique.
5109 size_t len
= buf
->len
;
5111 for (i
= 2; ; i
++) {
5112 strbuf_setlen(buf
, len
);
5113 strbuf_addf(buf
, "-%d", i
);
5114 if (!hashmap_get_from_hash(&state
->labels
,
5124 FLEX_ALLOC_STR(labels_entry
, label
, label
);
5125 hashmap_entry_init(&labels_entry
->entry
, strihash(label
));
5126 hashmap_add(&state
->labels
, &labels_entry
->entry
);
5128 FLEX_ALLOC_STR(string_entry
, string
, label
);
5129 oidcpy(&string_entry
->entry
.oid
, oid
);
5130 oidmap_put(&state
->commit2label
, string_entry
);
5132 return string_entry
->string
;
5135 static int make_script_with_merges(struct pretty_print_context
*pp
,
5136 struct rev_info
*revs
, struct strbuf
*out
,
5139 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5140 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
5141 int root_with_onto
= flags
& TODO_LIST_ROOT_WITH_ONTO
;
5142 int skipped_commit
= 0;
5143 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
5144 struct strbuf label
= STRBUF_INIT
;
5145 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
5146 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
5147 struct commit
*commit
;
5148 struct oidmap commit2todo
= OIDMAP_INIT
;
5149 struct string_entry
*entry
;
5150 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
5151 shown
= OIDSET_INIT
;
5152 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
5154 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
5155 const char *cmd_pick
= abbr
? "p" : "pick",
5156 *cmd_label
= abbr
? "l" : "label",
5157 *cmd_reset
= abbr
? "t" : "reset",
5158 *cmd_merge
= abbr
? "m" : "merge";
5160 oidmap_init(&commit2todo
, 0);
5161 oidmap_init(&state
.commit2label
, 0);
5162 hashmap_init(&state
.labels
, labels_cmp
, NULL
, 0);
5163 strbuf_init(&state
.buf
, 32);
5165 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
5166 struct labels_entry
*onto_label_entry
;
5167 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
5168 FLEX_ALLOC_STR(entry
, string
, "onto");
5169 oidcpy(&entry
->entry
.oid
, oid
);
5170 oidmap_put(&state
.commit2label
, entry
);
5172 FLEX_ALLOC_STR(onto_label_entry
, label
, "onto");
5173 hashmap_entry_init(&onto_label_entry
->entry
, strihash("onto"));
5174 hashmap_add(&state
.labels
, &onto_label_entry
->entry
);
5179 * - get onelines for all commits
5180 * - gather all branch tips (i.e. 2nd or later parents of merges)
5181 * - label all branch tips
5183 while ((commit
= get_revision(revs
))) {
5184 struct commit_list
*to_merge
;
5185 const char *p1
, *p2
;
5186 struct object_id
*oid
;
5189 tail
= &commit_list_insert(commit
, tail
)->next
;
5190 oidset_insert(&interesting
, &commit
->object
.oid
);
5192 is_empty
= is_original_commit_empty(commit
);
5193 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5194 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5195 warning(_("skipped previously applied commit %s"),
5196 short_commit_name(commit
));
5200 if (is_empty
&& !keep_empty
)
5203 strbuf_reset(&oneline
);
5204 pretty_print_commit(pp
, commit
, &oneline
);
5206 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
5208 /* non-merge commit: easy case */
5210 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
5211 oid_to_hex(&commit
->object
.oid
),
5214 strbuf_addf(&buf
, " %c empty",
5217 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5218 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5219 oidmap_put(&commit2todo
, entry
);
5224 /* Create a label */
5225 strbuf_reset(&label
);
5226 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
5227 (p1
= strchr(p1
, '\'')) &&
5228 (p2
= strchr(++p1
, '\'')))
5229 strbuf_add(&label
, p1
, p2
- p1
);
5230 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
5232 (p1
= strstr(p1
, " from ")))
5233 strbuf_addstr(&label
, p1
+ strlen(" from "));
5235 strbuf_addbuf(&label
, &oneline
);
5238 strbuf_addf(&buf
, "%s -C %s",
5239 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
5241 /* label the tips of merged branches */
5242 for (; to_merge
; to_merge
= to_merge
->next
) {
5243 oid
= &to_merge
->item
->object
.oid
;
5244 strbuf_addch(&buf
, ' ');
5246 if (!oidset_contains(&interesting
, oid
)) {
5247 strbuf_addstr(&buf
, label_oid(oid
, NULL
,
5252 tips_tail
= &commit_list_insert(to_merge
->item
,
5255 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
5257 strbuf_addf(&buf
, " # %s", oneline
.buf
);
5259 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5260 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5261 oidmap_put(&commit2todo
, entry
);
5264 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5265 _("use --reapply-cherry-picks to include skipped commits"));
5269 * - label branch points
5270 * - add HEAD to the branch tips
5272 for (iter
= commits
; iter
; iter
= iter
->next
) {
5273 struct commit_list
*parent
= iter
->item
->parents
;
5274 for (; parent
; parent
= parent
->next
) {
5275 struct object_id
*oid
= &parent
->item
->object
.oid
;
5276 if (!oidset_contains(&interesting
, oid
))
5278 if (oidset_insert(&child_seen
, oid
))
5279 label_oid(oid
, "branch-point", &state
);
5282 /* Add HEAD as implicit "tip of branch" */
5284 tips_tail
= &commit_list_insert(iter
->item
,
5289 * Third phase: output the todo list. This is a bit tricky, as we
5290 * want to avoid jumping back and forth between revisions. To
5291 * accomplish that goal, we walk backwards from the branch tips,
5292 * gathering commits not yet shown, reversing the list on the fly,
5293 * then outputting that list (labeling revisions as needed).
5295 strbuf_addf(out
, "%s onto\n", cmd_label
);
5296 for (iter
= tips
; iter
; iter
= iter
->next
) {
5297 struct commit_list
*list
= NULL
, *iter2
;
5299 commit
= iter
->item
;
5300 if (oidset_contains(&shown
, &commit
->object
.oid
))
5302 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
5305 strbuf_addf(out
, "\n%c Branch %s\n", comment_line_char
, entry
->string
);
5307 strbuf_addch(out
, '\n');
5309 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
5310 !oidset_contains(&shown
, &commit
->object
.oid
)) {
5311 commit_list_insert(commit
, &list
);
5312 if (!commit
->parents
) {
5316 commit
= commit
->parents
->item
;
5320 strbuf_addf(out
, "%s %s\n", cmd_reset
,
5321 rebase_cousins
|| root_with_onto
?
5322 "onto" : "[new root]");
5324 const char *to
= NULL
;
5326 entry
= oidmap_get(&state
.commit2label
,
5327 &commit
->object
.oid
);
5330 else if (!rebase_cousins
)
5331 to
= label_oid(&commit
->object
.oid
, NULL
,
5334 if (!to
|| !strcmp(to
, "onto"))
5335 strbuf_addf(out
, "%s onto\n", cmd_reset
);
5337 strbuf_reset(&oneline
);
5338 pretty_print_commit(pp
, commit
, &oneline
);
5339 strbuf_addf(out
, "%s %s # %s\n",
5340 cmd_reset
, to
, oneline
.buf
);
5344 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
5345 struct object_id
*oid
= &iter2
->item
->object
.oid
;
5346 entry
= oidmap_get(&commit2todo
, oid
);
5347 /* only show if not already upstream */
5349 strbuf_addf(out
, "%s\n", entry
->string
);
5350 entry
= oidmap_get(&state
.commit2label
, oid
);
5352 strbuf_addf(out
, "%s %s\n",
5353 cmd_label
, entry
->string
);
5354 oidset_insert(&shown
, oid
);
5357 free_commit_list(list
);
5360 free_commit_list(commits
);
5361 free_commit_list(tips
);
5363 strbuf_release(&label
);
5364 strbuf_release(&oneline
);
5365 strbuf_release(&buf
);
5367 oidmap_free(&commit2todo
, 1);
5368 oidmap_free(&state
.commit2label
, 1);
5369 hashmap_clear_and_free(&state
.labels
, struct labels_entry
, entry
);
5370 strbuf_release(&state
.buf
);
5375 int sequencer_make_script(struct repository
*r
, struct strbuf
*out
, int argc
,
5376 const char **argv
, unsigned flags
)
5378 char *format
= NULL
;
5379 struct pretty_print_context pp
= {0};
5380 struct rev_info revs
;
5381 struct commit
*commit
;
5382 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5383 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
5384 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
5385 int reapply_cherry_picks
= flags
& TODO_LIST_REAPPLY_CHERRY_PICKS
;
5386 int skipped_commit
= 0;
5388 repo_init_revisions(r
, &revs
, NULL
);
5389 revs
.verbose_header
= 1;
5391 revs
.max_parents
= 1;
5392 revs
.cherry_mark
= !reapply_cherry_picks
;
5395 revs
.right_only
= 1;
5396 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
5397 revs
.topo_order
= 1;
5399 revs
.pretty_given
= 1;
5400 git_config_get_string("rebase.instructionFormat", &format
);
5401 if (!format
|| !*format
) {
5403 format
= xstrdup("%s");
5405 get_commit_format(format
, &revs
);
5407 pp
.fmt
= revs
.commit_format
;
5408 pp
.output_encoding
= get_log_output_encoding();
5410 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1)
5411 return error(_("make_script: unhandled options"));
5413 if (prepare_revision_walk(&revs
) < 0)
5414 return error(_("make_script: error preparing revisions"));
5417 return make_script_with_merges(&pp
, &revs
, out
, flags
);
5419 while ((commit
= get_revision(&revs
))) {
5420 int is_empty
= is_original_commit_empty(commit
);
5422 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5423 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5424 warning(_("skipped previously applied commit %s"),
5425 short_commit_name(commit
));
5429 if (is_empty
&& !keep_empty
)
5431 strbuf_addf(out
, "%s %s ", insn
,
5432 oid_to_hex(&commit
->object
.oid
));
5433 pretty_print_commit(&pp
, commit
, out
);
5435 strbuf_addf(out
, " %c empty", comment_line_char
);
5436 strbuf_addch(out
, '\n');
5439 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5440 _("use --reapply-cherry-picks to include skipped commits"));
5445 * Add commands after pick and (series of) squash/fixup commands
5448 void todo_list_add_exec_commands(struct todo_list
*todo_list
,
5449 struct string_list
*commands
)
5451 struct strbuf
*buf
= &todo_list
->buf
;
5452 size_t base_offset
= buf
->len
;
5453 int i
, insert
, nr
= 0, alloc
= 0;
5454 struct todo_item
*items
= NULL
, *base_items
= NULL
;
5456 CALLOC_ARRAY(base_items
, commands
->nr
);
5457 for (i
= 0; i
< commands
->nr
; i
++) {
5458 size_t command_len
= strlen(commands
->items
[i
].string
);
5460 strbuf_addstr(buf
, commands
->items
[i
].string
);
5461 strbuf_addch(buf
, '\n');
5463 base_items
[i
].command
= TODO_EXEC
;
5464 base_items
[i
].offset_in_buf
= base_offset
;
5465 base_items
[i
].arg_offset
= base_offset
+ strlen("exec ");
5466 base_items
[i
].arg_len
= command_len
- strlen("exec ");
5468 base_offset
+= command_len
+ 1;
5472 * Insert <commands> after every pick. Here, fixup/squash chains
5473 * are considered part of the pick, so we insert the commands *after*
5474 * those chains if there are any.
5476 * As we insert the exec commands immediately after rearranging
5477 * any fixups and before the user edits the list, a fixup chain
5478 * can never contain comments (any comments are empty picks that
5479 * have been commented out because the user did not specify
5480 * --keep-empty). So, it is safe to insert an exec command
5481 * without looking at the command following a comment.
5484 for (i
= 0; i
< todo_list
->nr
; i
++) {
5485 enum todo_command command
= todo_list
->items
[i
].command
;
5486 if (insert
&& !is_fixup(command
)) {
5487 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5488 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5494 ALLOC_GROW(items
, nr
+ 1, alloc
);
5495 items
[nr
++] = todo_list
->items
[i
];
5497 if (command
== TODO_PICK
|| command
== TODO_MERGE
)
5501 /* insert or append final <commands> */
5502 if (insert
|| nr
== todo_list
->nr
) {
5503 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5504 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5509 FREE_AND_NULL(todo_list
->items
);
5510 todo_list
->items
= items
;
5512 todo_list
->alloc
= alloc
;
5515 static void todo_list_to_strbuf(struct repository
*r
, struct todo_list
*todo_list
,
5516 struct strbuf
*buf
, int num
, unsigned flags
)
5518 struct todo_item
*item
;
5519 int i
, max
= todo_list
->nr
;
5521 if (num
> 0 && num
< max
)
5524 for (item
= todo_list
->items
, i
= 0; i
< max
; i
++, item
++) {
5527 /* if the item is not a command write it and continue */
5528 if (item
->command
>= TODO_COMMENT
) {
5529 strbuf_addf(buf
, "%.*s\n", item
->arg_len
,
5530 todo_item_get_arg(todo_list
, item
));
5534 /* add command to the buffer */
5535 cmd
= command_to_char(item
->command
);
5536 if ((flags
& TODO_LIST_ABBREVIATE_CMDS
) && cmd
)
5537 strbuf_addch(buf
, cmd
);
5539 strbuf_addstr(buf
, command_to_string(item
->command
));
5543 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
5544 short_commit_name(item
->commit
) :
5545 oid_to_hex(&item
->commit
->object
.oid
);
5547 if (item
->command
== TODO_FIXUP
) {
5548 if (item
->flags
& TODO_EDIT_FIXUP_MSG
)
5549 strbuf_addstr(buf
, " -c");
5550 else if (item
->flags
& TODO_REPLACE_FIXUP_MSG
) {
5551 strbuf_addstr(buf
, " -C");
5555 if (item
->command
== TODO_MERGE
) {
5556 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
5557 strbuf_addstr(buf
, " -c");
5559 strbuf_addstr(buf
, " -C");
5562 strbuf_addf(buf
, " %s", oid
);
5565 /* add all the rest */
5567 strbuf_addch(buf
, '\n');
5569 strbuf_addf(buf
, " %.*s\n", item
->arg_len
,
5570 todo_item_get_arg(todo_list
, item
));
5574 int todo_list_write_to_file(struct repository
*r
, struct todo_list
*todo_list
,
5575 const char *file
, const char *shortrevisions
,
5576 const char *shortonto
, int num
, unsigned flags
)
5579 struct strbuf buf
= STRBUF_INIT
;
5581 todo_list_to_strbuf(r
, todo_list
, &buf
, num
, flags
);
5582 if (flags
& TODO_LIST_APPEND_TODO_HELP
)
5583 append_todo_help(count_commands(todo_list
),
5584 shortrevisions
, shortonto
, &buf
);
5586 res
= write_message(buf
.buf
, buf
.len
, file
, 0);
5587 strbuf_release(&buf
);
5592 /* skip picking commits whose parents are unchanged */
5593 static int skip_unnecessary_picks(struct repository
*r
,
5594 struct todo_list
*todo_list
,
5595 struct object_id
*base_oid
)
5597 struct object_id
*parent_oid
;
5600 for (i
= 0; i
< todo_list
->nr
; i
++) {
5601 struct todo_item
*item
= todo_list
->items
+ i
;
5603 if (item
->command
>= TODO_NOOP
)
5605 if (item
->command
!= TODO_PICK
)
5607 if (parse_commit(item
->commit
)) {
5608 return error(_("could not parse commit '%s'"),
5609 oid_to_hex(&item
->commit
->object
.oid
));
5611 if (!item
->commit
->parents
)
5612 break; /* root commit */
5613 if (item
->commit
->parents
->next
)
5614 break; /* merge commit */
5615 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
5616 if (!oideq(parent_oid
, base_oid
))
5618 oidcpy(base_oid
, &item
->commit
->object
.oid
);
5621 const char *done_path
= rebase_path_done();
5623 if (todo_list_write_to_file(r
, todo_list
, done_path
, NULL
, NULL
, i
, 0)) {
5624 error_errno(_("could not write to '%s'"), done_path
);
5628 MOVE_ARRAY(todo_list
->items
, todo_list
->items
+ i
, todo_list
->nr
- i
);
5630 todo_list
->current
= 0;
5631 todo_list
->done_nr
+= i
;
5633 if (is_fixup(peek_command(todo_list
, 0)))
5634 record_in_rewritten(base_oid
, peek_command(todo_list
, 0));
5640 int complete_action(struct repository
*r
, struct replay_opts
*opts
, unsigned flags
,
5641 const char *shortrevisions
, const char *onto_name
,
5642 struct commit
*onto
, const struct object_id
*orig_head
,
5643 struct string_list
*commands
, unsigned autosquash
,
5644 struct todo_list
*todo_list
)
5646 char shortonto
[GIT_MAX_HEXSZ
+ 1];
5647 const char *todo_file
= rebase_path_todo();
5648 struct todo_list new_todo
= TODO_LIST_INIT
;
5649 struct strbuf
*buf
= &todo_list
->buf
, buf2
= STRBUF_INIT
;
5650 struct object_id oid
= onto
->object
.oid
;
5653 find_unique_abbrev_r(shortonto
, &oid
, DEFAULT_ABBREV
);
5655 if (buf
->len
== 0) {
5656 struct todo_item
*item
= append_new_todo(todo_list
);
5657 item
->command
= TODO_NOOP
;
5658 item
->commit
= NULL
;
5659 item
->arg_len
= item
->arg_offset
= item
->flags
= item
->offset_in_buf
= 0;
5662 if (autosquash
&& todo_list_rearrange_squash(todo_list
))
5666 todo_list_add_exec_commands(todo_list
, commands
);
5668 if (count_commands(todo_list
) == 0) {
5669 apply_autostash(rebase_path_autostash());
5670 sequencer_remove_state(opts
);
5672 return error(_("nothing to do"));
5675 res
= edit_todo_list(r
, todo_list
, &new_todo
, shortrevisions
,
5679 else if (res
== -2) {
5680 apply_autostash(rebase_path_autostash());
5681 sequencer_remove_state(opts
);
5684 } else if (res
== -3) {
5685 apply_autostash(rebase_path_autostash());
5686 sequencer_remove_state(opts
);
5687 todo_list_release(&new_todo
);
5689 return error(_("nothing to do"));
5690 } else if (res
== -4) {
5691 checkout_onto(r
, opts
, onto_name
, &onto
->object
.oid
, orig_head
);
5692 todo_list_release(&new_todo
);
5697 /* Expand the commit IDs */
5698 todo_list_to_strbuf(r
, &new_todo
, &buf2
, -1, 0);
5699 strbuf_swap(&new_todo
.buf
, &buf2
);
5700 strbuf_release(&buf2
);
5701 new_todo
.total_nr
-= new_todo
.nr
;
5702 if (todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
) < 0)
5703 BUG("invalid todo list after expanding IDs:\n%s",
5706 if (opts
->allow_ff
&& skip_unnecessary_picks(r
, &new_todo
, &oid
)) {
5707 todo_list_release(&new_todo
);
5708 return error(_("could not skip unnecessary pick commands"));
5711 if (todo_list_write_to_file(r
, &new_todo
, todo_file
, NULL
, NULL
, -1,
5712 flags
& ~(TODO_LIST_SHORTEN_IDS
))) {
5713 todo_list_release(&new_todo
);
5714 return error_errno(_("could not write '%s'"), todo_file
);
5719 if (checkout_onto(r
, opts
, onto_name
, &oid
, orig_head
))
5722 if (require_clean_work_tree(r
, "rebase", "", 1, 1))
5725 todo_list_write_total_nr(&new_todo
);
5726 res
= pick_commits(r
, &new_todo
, opts
);
5729 todo_list_release(&new_todo
);
5734 struct subject2item_entry
{
5735 struct hashmap_entry entry
;
5737 char subject
[FLEX_ARRAY
];
5740 static int subject2item_cmp(const void *fndata
,
5741 const struct hashmap_entry
*eptr
,
5742 const struct hashmap_entry
*entry_or_key
,
5745 const struct subject2item_entry
*a
, *b
;
5747 a
= container_of(eptr
, const struct subject2item_entry
, entry
);
5748 b
= container_of(entry_or_key
, const struct subject2item_entry
, entry
);
5750 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
5753 define_commit_slab(commit_todo_item
, struct todo_item
*);
5755 static int skip_fixupish(const char *subject
, const char **p
) {
5756 return skip_prefix(subject
, "fixup! ", p
) ||
5757 skip_prefix(subject
, "amend! ", p
) ||
5758 skip_prefix(subject
, "squash! ", p
);
5762 * Rearrange the todo list that has both "pick commit-id msg" and "pick
5763 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
5764 * after the former, and change "pick" to "fixup"/"squash".
5766 * Note that if the config has specified a custom instruction format, each log
5767 * message will have to be retrieved from the commit (as the oneline in the
5768 * script cannot be trusted) in order to normalize the autosquash arrangement.
5770 int todo_list_rearrange_squash(struct todo_list
*todo_list
)
5772 struct hashmap subject2item
;
5773 int rearranged
= 0, *next
, *tail
, i
, nr
= 0, alloc
= 0;
5775 struct commit_todo_item commit_todo
;
5776 struct todo_item
*items
= NULL
;
5778 init_commit_todo_item(&commit_todo
);
5780 * The hashmap maps onelines to the respective todo list index.
5782 * If any items need to be rearranged, the next[i] value will indicate
5783 * which item was moved directly after the i'th.
5785 * In that case, last[i] will indicate the index of the latest item to
5786 * be moved to appear after the i'th.
5788 hashmap_init(&subject2item
, subject2item_cmp
, NULL
, todo_list
->nr
);
5789 ALLOC_ARRAY(next
, todo_list
->nr
);
5790 ALLOC_ARRAY(tail
, todo_list
->nr
);
5791 ALLOC_ARRAY(subjects
, todo_list
->nr
);
5792 for (i
= 0; i
< todo_list
->nr
; i
++) {
5793 struct strbuf buf
= STRBUF_INIT
;
5794 struct todo_item
*item
= todo_list
->items
+ i
;
5795 const char *commit_buffer
, *subject
, *p
;
5798 struct subject2item_entry
*entry
;
5800 next
[i
] = tail
[i
] = -1;
5801 if (!item
->commit
|| item
->command
== TODO_DROP
) {
5806 if (is_fixup(item
->command
)) {
5807 clear_commit_todo_item(&commit_todo
);
5808 return error(_("the script was already rearranged."));
5811 *commit_todo_item_at(&commit_todo
, item
->commit
) = item
;
5813 parse_commit(item
->commit
);
5814 commit_buffer
= logmsg_reencode(item
->commit
, NULL
, "UTF-8");
5815 find_commit_subject(commit_buffer
, &subject
);
5816 format_subject(&buf
, subject
, " ");
5817 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
5818 unuse_commit_buffer(item
->commit
, commit_buffer
);
5819 if (skip_fixupish(subject
, &p
)) {
5820 struct commit
*commit2
;
5825 if (!skip_fixupish(p
, &p
))
5829 entry
= hashmap_get_entry_from_hash(&subject2item
,
5831 struct subject2item_entry
,
5834 /* found by title */
5836 else if (!strchr(p
, ' ') &&
5838 lookup_commit_reference_by_name(p
)) &&
5839 *commit_todo_item_at(&commit_todo
, commit2
))
5840 /* found by commit name */
5841 i2
= *commit_todo_item_at(&commit_todo
, commit2
)
5844 /* copy can be a prefix of the commit subject */
5845 for (i2
= 0; i2
< i
; i2
++)
5847 starts_with(subjects
[i2
], p
))
5855 if (starts_with(subject
, "fixup!")) {
5856 todo_list
->items
[i
].command
= TODO_FIXUP
;
5857 } else if (starts_with(subject
, "amend!")) {
5858 todo_list
->items
[i
].command
= TODO_FIXUP
;
5859 todo_list
->items
[i
].flags
= TODO_REPLACE_FIXUP_MSG
;
5861 todo_list
->items
[i
].command
= TODO_SQUASH
;
5867 next
[i
] = next
[tail
[i2
]];
5871 } else if (!hashmap_get_from_hash(&subject2item
,
5872 strhash(subject
), subject
)) {
5873 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
5875 hashmap_entry_init(&entry
->entry
,
5876 strhash(entry
->subject
));
5877 hashmap_put(&subject2item
, &entry
->entry
);
5882 for (i
= 0; i
< todo_list
->nr
; i
++) {
5883 enum todo_command command
= todo_list
->items
[i
].command
;
5887 * Initially, all commands are 'pick's. If it is a
5888 * fixup or a squash now, we have rearranged it.
5890 if (is_fixup(command
))
5894 ALLOC_GROW(items
, nr
+ 1, alloc
);
5895 items
[nr
++] = todo_list
->items
[cur
];
5900 FREE_AND_NULL(todo_list
->items
);
5901 todo_list
->items
= items
;
5903 todo_list
->alloc
= alloc
;
5908 for (i
= 0; i
< todo_list
->nr
; i
++)
5911 hashmap_clear_and_free(&subject2item
, struct subject2item_entry
, entry
);
5913 clear_commit_todo_item(&commit_todo
);
5918 int sequencer_determine_whence(struct repository
*r
, enum commit_whence
*whence
)
5920 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
5921 struct object_id cherry_pick_head
, rebase_head
;
5923 if (file_exists(git_path_seq_dir()))
5924 *whence
= FROM_CHERRY_PICK_MULTI
;
5925 if (file_exists(rebase_path()) &&
5926 !get_oid("REBASE_HEAD", &rebase_head
) &&
5927 !get_oid("CHERRY_PICK_HEAD", &cherry_pick_head
) &&
5928 oideq(&rebase_head
, &cherry_pick_head
))
5929 *whence
= FROM_REBASE_PICK
;
5931 *whence
= FROM_CHERRY_PICK_SINGLE
;