1 #include "git-compat-util.h"
6 #include "environment.h"
11 #include "object-file.h"
12 #include "object-name.h"
13 #include "object-store-ll.h"
17 #include "sequencer.h"
18 #include "run-command.h"
21 #include "cache-tree.h"
27 #include "merge-ort.h"
28 #include "merge-ort-wrappers.h"
30 #include "sparse-index.h"
35 #include "wt-status.h"
37 #include "notes-utils.h"
39 #include "unpack-trees.h"
42 #include "commit-slab.h"
44 #include "commit-reach.h"
45 #include "rebase-interactive.h"
49 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
52 * To accommodate common filesystem limitations, where the loose refs' file
53 * names must not exceed `NAME_MAX`, the labels generated by `git rebase
54 * --rebase-merges` need to be truncated if the corresponding commit subjects
56 * Add some margin to stay clear from reaching `NAME_MAX`.
58 #define GIT_MAX_LABEL_LENGTH ((NAME_MAX) - (LOCK_SUFFIX_LEN) - 16)
60 static const char sign_off_header
[] = "Signed-off-by: ";
61 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
63 GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
65 static GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
67 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
68 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
69 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
70 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
72 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
74 * The file containing rebase commands, comments, and empty lines.
75 * This file is created by "git rebase -i" then edited by the user. As
76 * the lines are processed, they are removed from the front of this
77 * file and written to the tail of 'done'.
79 GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
80 GIT_PATH_FUNC(rebase_path_todo_backup
, "rebase-merge/git-rebase-todo.backup")
82 GIT_PATH_FUNC(rebase_path_dropped
, "rebase-merge/dropped")
85 * The rebase command lines that have already been processed. A line
86 * is moved here when it is first handled, before any associated user
89 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
91 * The file to keep track of how many commands were already processed (e.g.
94 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum")
96 * The file to keep track of how many commands are to be processed in total
97 * (e.g. for the prompt).
99 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end")
101 * The commit message that is planned to be used for any changes that
102 * need to be committed following a user interaction.
104 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
106 * The file into which is accumulated the suggested commit message for
107 * squash/fixup commands. When the first of a series of squash/fixups
108 * is seen, the file is created and the commit message from the
109 * previous commit and from the first squash/fixup commit are written
110 * to it. The commit message for each subsequent squash/fixup commit
111 * is appended to the file as it is processed.
113 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
115 * If the current series of squash/fixups has not yet included a squash
116 * command, then this file exists and holds the commit message of the
117 * original "pick" commit. (If the series ends without a "squash"
118 * command, then this can be used as the commit message of the combined
119 * commit without opening the editor.)
121 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
123 * This file contains the list fixup/squash commands that have been
124 * accumulated into message-fixup or message-squash so far.
126 static GIT_PATH_FUNC(rebase_path_current_fixups
, "rebase-merge/current-fixups")
128 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
129 * GIT_AUTHOR_DATE that will be used for the commit that is currently
132 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
134 * When an "edit" rebase command is being processed, the SHA1 of the
135 * commit to be edited is recorded in this file. When "git rebase
136 * --continue" is executed, if there are any staged changes then they
137 * will be amended to the HEAD commit, but only provided the HEAD
138 * commit is still the commit to be edited. When any other rebase
139 * command is processed, this file is deleted.
141 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
143 * When we stop at a given patch via the "edit" command, this file contains
144 * the commit object name of the corresponding patch.
146 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
148 * When we stop for the user to resolve conflicts this file contains
149 * the patch of the commit that is being picked.
151 static GIT_PATH_FUNC(rebase_path_patch
, "rebase-merge/patch")
153 * For the post-rewrite hook, we make a list of rewritten commits and
154 * their new sha1s. The rewritten-pending list keeps the sha1s of
155 * commits that have been processed, but not committed yet,
156 * e.g. because they are waiting for a 'squash' command.
158 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
159 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
160 "rebase-merge/rewritten-pending")
163 * The path of the file containing the OID of the "squash onto" commit, i.e.
164 * the dummy commit used for `reset [new root]`.
166 static GIT_PATH_FUNC(rebase_path_squash_onto
, "rebase-merge/squash-onto")
169 * The path of the file listing refs that need to be deleted after the rebase
170 * finishes. This is used by the `label` command to record the need for cleanup.
172 static GIT_PATH_FUNC(rebase_path_refs_to_delete
, "rebase-merge/refs-to-delete")
175 * The update-refs file stores a list of refs that will be updated at the end
176 * of the rebase sequence. The 'update-ref <ref>' commands in the todo file
177 * update the OIDs for the refs in this file, but the refs are not updated
178 * until the end of the rebase sequence.
180 * rebase_path_update_refs() returns the path to this file for a given
181 * worktree directory. For the current worktree, pass the_repository->gitdir.
183 static char *rebase_path_update_refs(const char *wt_git_dir
)
185 return xstrfmt("%s/rebase-merge/update-refs", wt_git_dir
);
189 * The following files are written by git-rebase just after parsing the
192 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
193 static GIT_PATH_FUNC(rebase_path_cdate_is_adate
, "rebase-merge/cdate_is_adate")
194 static GIT_PATH_FUNC(rebase_path_ignore_date
, "rebase-merge/ignore_date")
195 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
196 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
197 static GIT_PATH_FUNC(rebase_path_quiet
, "rebase-merge/quiet")
198 static GIT_PATH_FUNC(rebase_path_signoff
, "rebase-merge/signoff")
199 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
200 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
201 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
202 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
203 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
204 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
205 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec
, "rebase-merge/reschedule-failed-exec")
206 static GIT_PATH_FUNC(rebase_path_no_reschedule_failed_exec
, "rebase-merge/no-reschedule-failed-exec")
207 static GIT_PATH_FUNC(rebase_path_drop_redundant_commits
, "rebase-merge/drop_redundant_commits")
208 static GIT_PATH_FUNC(rebase_path_keep_redundant_commits
, "rebase-merge/keep_redundant_commits")
211 * A 'struct replay_ctx' represents the private state of the sequencer.
215 * The commit message that will be used except at the end of a
216 * chain of fixup and squash commands.
218 struct strbuf message
;
220 * The list of completed fixup and squash commands in the
223 struct strbuf current_fixups
;
225 * Stores the reflog message that will be used when creating a
226 * commit. Points to a static buffer and should not be free()'d.
228 const char *reflog_message
;
230 * The number of completed fixup and squash commands in the
233 int current_fixup_count
;
235 * Whether message contains a commit message.
237 unsigned have_message
:1;
240 struct replay_ctx
* replay_ctx_new(void)
242 struct replay_ctx
*ctx
= xcalloc(1, sizeof(*ctx
));
244 strbuf_init(&ctx
->current_fixups
, 0);
245 strbuf_init(&ctx
->message
, 0);
251 * A 'struct update_refs_record' represents a value in the update-refs
252 * list. We use a string_list to map refs to these (before, after) pairs.
254 struct update_ref_record
{
255 struct object_id before
;
256 struct object_id after
;
259 static struct update_ref_record
*init_update_ref_record(const char *ref
)
261 struct update_ref_record
*rec
;
263 CALLOC_ARRAY(rec
, 1);
265 oidcpy(&rec
->before
, null_oid());
266 oidcpy(&rec
->after
, null_oid());
268 /* This may fail, but that's fine, we will keep the null OID. */
269 read_ref(ref
, &rec
->before
);
274 static int git_sequencer_config(const char *k
, const char *v
,
275 const struct config_context
*ctx
, void *cb
)
277 struct replay_opts
*opts
= cb
;
279 if (!strcmp(k
, "commit.cleanup")) {
281 return config_error_nonbool(k
);
283 if (!strcmp(v
, "verbatim")) {
284 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
285 opts
->explicit_cleanup
= 1;
286 } else if (!strcmp(v
, "whitespace")) {
287 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
288 opts
->explicit_cleanup
= 1;
289 } else if (!strcmp(v
, "strip")) {
290 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_ALL
;
291 opts
->explicit_cleanup
= 1;
292 } else if (!strcmp(v
, "scissors")) {
293 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SCISSORS
;
294 opts
->explicit_cleanup
= 1;
296 warning(_("invalid commit message cleanup mode '%s'"),
303 if (!strcmp(k
, "commit.gpgsign")) {
304 opts
->gpg_sign
= git_config_bool(k
, v
) ? xstrdup("") : NULL
;
308 if (!opts
->default_strategy
&& !strcmp(k
, "pull.twohead")) {
309 int ret
= git_config_string((const char**)&opts
->default_strategy
, k
, v
);
312 * pull.twohead is allowed to be multi-valued; we only
313 * care about the first value.
315 char *tmp
= strchr(opts
->default_strategy
, ' ');
322 if (opts
->action
== REPLAY_REVERT
&& !strcmp(k
, "revert.reference"))
323 opts
->commit_use_reference
= git_config_bool(k
, v
);
325 return git_diff_basic_config(k
, v
, ctx
, NULL
);
328 void sequencer_init_config(struct replay_opts
*opts
)
330 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
331 git_config(git_sequencer_config
, opts
);
334 static inline int is_rebase_i(const struct replay_opts
*opts
)
336 return opts
->action
== REPLAY_INTERACTIVE_REBASE
;
339 static const char *get_dir(const struct replay_opts
*opts
)
341 if (is_rebase_i(opts
))
342 return rebase_path();
343 return git_path_seq_dir();
346 static const char *get_todo_path(const struct replay_opts
*opts
)
348 if (is_rebase_i(opts
))
349 return rebase_path_todo();
350 return git_path_todo_file();
354 * Returns 0 for non-conforming footer
355 * Returns 1 for conforming footer
356 * Returns 2 when sob exists within conforming footer
357 * Returns 3 when sob exists within conforming footer as last entry
359 static int has_conforming_footer(struct strbuf
*sb
, struct strbuf
*sob
,
360 size_t ignore_footer
)
362 struct process_trailer_options opts
= PROCESS_TRAILER_OPTIONS_INIT
;
363 struct trailer_info info
;
365 int found_sob
= 0, found_sob_last
= 0;
371 saved_char
= sb
->buf
[sb
->len
- ignore_footer
];
372 sb
->buf
[sb
->len
- ignore_footer
] = '\0';
375 trailer_info_get(&opts
, sb
->buf
, &info
);
378 sb
->buf
[sb
->len
- ignore_footer
] = saved_char
;
380 if (info
.trailer_block_start
== info
.trailer_block_end
)
383 for (i
= 0; i
< info
.trailer_nr
; i
++)
384 if (sob
&& !strncmp(info
.trailers
[i
], sob
->buf
, sob
->len
)) {
386 if (i
== info
.trailer_nr
- 1)
390 trailer_info_release(&info
);
399 static const char *gpg_sign_opt_quoted(struct replay_opts
*opts
)
401 static struct strbuf buf
= STRBUF_INIT
;
405 sq_quotef(&buf
, "-S%s", opts
->gpg_sign
);
409 static void replay_ctx_release(struct replay_ctx
*ctx
)
411 strbuf_release(&ctx
->current_fixups
);
412 strbuf_release(&ctx
->message
);
415 void replay_opts_release(struct replay_opts
*opts
)
417 struct replay_ctx
*ctx
= opts
->ctx
;
419 free(opts
->gpg_sign
);
420 free(opts
->reflog_action
);
421 free(opts
->default_strategy
);
422 free(opts
->strategy
);
423 strvec_clear (&opts
->xopts
);
425 release_revisions(opts
->revs
);
427 replay_ctx_release(ctx
);
431 int sequencer_remove_state(struct replay_opts
*opts
)
433 struct strbuf buf
= STRBUF_INIT
;
436 if (is_rebase_i(opts
) &&
437 strbuf_read_file(&buf
, rebase_path_refs_to_delete(), 0) > 0) {
440 char *eol
= strchr(p
, '\n');
443 if (delete_ref("(rebase) cleanup", p
, NULL
, 0) < 0) {
444 warning(_("could not delete '%s'"), p
);
454 strbuf_addstr(&buf
, get_dir(opts
));
455 if (remove_dir_recursively(&buf
, 0))
456 ret
= error(_("could not remove '%s'"), buf
.buf
);
457 strbuf_release(&buf
);
462 static const char *action_name(const struct replay_opts
*opts
)
464 switch (opts
->action
) {
468 return N_("cherry-pick");
469 case REPLAY_INTERACTIVE_REBASE
:
472 die(_("unknown action: %d"), opts
->action
);
475 struct commit_message
{
482 static const char *short_commit_name(struct repository
*r
, struct commit
*commit
)
484 return repo_find_unique_abbrev(r
, &commit
->object
.oid
, DEFAULT_ABBREV
);
487 static int get_message(struct commit
*commit
, struct commit_message
*out
)
489 const char *abbrev
, *subject
;
492 out
->message
= repo_logmsg_reencode(the_repository
, commit
, NULL
,
493 get_commit_output_encoding());
494 abbrev
= short_commit_name(the_repository
, commit
);
496 subject_len
= find_commit_subject(out
->message
, &subject
);
498 out
->subject
= xmemdupz(subject
, subject_len
);
499 out
->label
= xstrfmt("%s (%s)", abbrev
, out
->subject
);
500 out
->parent_label
= xstrfmt("parent of %s", out
->label
);
505 static void free_message(struct commit
*commit
, struct commit_message
*msg
)
507 free(msg
->parent_label
);
510 repo_unuse_commit_buffer(the_repository
, commit
, msg
->message
);
513 const char *rebase_resolvemsg
=
514 N_("Resolve all conflicts manually, mark them as resolved with\n"
515 "\"git add/rm <conflicted_files>\", then run \"git rebase --continue\".\n"
516 "You can instead skip this commit: run \"git rebase --skip\".\n"
517 "To abort and get back to the state before \"git rebase\", run "
518 "\"git rebase --abort\".");
520 static void print_advice(struct repository
*r
, int show_hint
,
521 struct replay_opts
*opts
)
525 if (is_rebase_i(opts
))
526 msg
= rebase_resolvemsg
;
528 msg
= getenv("GIT_CHERRY_PICK_HELP");
531 advise_if_enabled(ADVICE_MERGE_CONFLICT
, "%s", msg
);
533 * A conflict has occurred but the porcelain
534 * (typically rebase --interactive) wants to take care
535 * of the commit itself so remove CHERRY_PICK_HEAD
537 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
544 advise_if_enabled(ADVICE_MERGE_CONFLICT
,
545 _("after resolving the conflicts, mark the corrected paths\n"
546 "with 'git add <paths>' or 'git rm <paths>'"));
547 else if (opts
->action
== REPLAY_PICK
)
548 advise_if_enabled(ADVICE_MERGE_CONFLICT
,
549 _("After resolving the conflicts, mark them with\n"
550 "\"git add/rm <pathspec>\", then run\n"
551 "\"git cherry-pick --continue\".\n"
552 "You can instead skip this commit with \"git cherry-pick --skip\".\n"
553 "To abort and get back to the state before \"git cherry-pick\",\n"
554 "run \"git cherry-pick --abort\"."));
555 else if (opts
->action
== REPLAY_REVERT
)
556 advise_if_enabled(ADVICE_MERGE_CONFLICT
,
557 _("After resolving the conflicts, mark them with\n"
558 "\"git add/rm <pathspec>\", then run\n"
559 "\"git revert --continue\".\n"
560 "You can instead skip this commit with \"git revert --skip\".\n"
561 "To abort and get back to the state before \"git revert\",\n"
562 "run \"git revert --abort\"."));
564 BUG("unexpected pick action in print_advice()");
568 static int write_message(const void *buf
, size_t len
, const char *filename
,
571 struct lock_file msg_file
= LOCK_INIT
;
573 int msg_fd
= hold_lock_file_for_update(&msg_file
, filename
, 0);
575 return error_errno(_("could not lock '%s'"), filename
);
576 if (write_in_full(msg_fd
, buf
, len
) < 0) {
577 error_errno(_("could not write to '%s'"), filename
);
578 rollback_lock_file(&msg_file
);
581 if (append_eol
&& write(msg_fd
, "\n", 1) < 0) {
582 error_errno(_("could not write eol to '%s'"), filename
);
583 rollback_lock_file(&msg_file
);
586 if (commit_lock_file(&msg_file
) < 0)
587 return error(_("failed to finalize '%s'"), filename
);
592 int read_oneliner(struct strbuf
*buf
,
593 const char *path
, unsigned flags
)
595 int orig_len
= buf
->len
;
597 if (strbuf_read_file(buf
, path
, 0) < 0) {
598 if ((flags
& READ_ONELINER_WARN_MISSING
) ||
599 (errno
!= ENOENT
&& errno
!= ENOTDIR
))
600 warning_errno(_("could not read '%s'"), path
);
604 if (buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\n') {
605 if (--buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\r')
607 buf
->buf
[buf
->len
] = '\0';
610 if ((flags
& READ_ONELINER_SKIP_IF_EMPTY
) && buf
->len
== orig_len
)
616 static struct tree
*empty_tree(struct repository
*r
)
618 return lookup_tree(r
, the_hash_algo
->empty_tree
);
621 static int error_dirty_index(struct repository
*repo
, struct replay_opts
*opts
)
623 if (repo_read_index_unmerged(repo
))
624 return error_resolve_conflict(action_name(opts
));
626 error(_("your local changes would be overwritten by %s."),
627 _(action_name(opts
)));
629 if (advice_enabled(ADVICE_COMMIT_BEFORE_MERGE
))
630 advise(_("commit your changes or stash them to proceed."));
634 static void update_abort_safety_file(void)
636 struct object_id head
;
638 /* Do nothing on a single-pick */
639 if (!file_exists(git_path_seq_dir()))
642 if (!repo_get_oid(the_repository
, "HEAD", &head
))
643 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head
));
645 write_file(git_path_abort_safety_file(), "%s", "");
648 static int fast_forward_to(struct repository
*r
,
649 const struct object_id
*to
,
650 const struct object_id
*from
,
652 struct replay_opts
*opts
)
654 struct ref_transaction
*transaction
;
655 struct strbuf sb
= STRBUF_INIT
;
656 struct strbuf err
= STRBUF_INIT
;
659 if (checkout_fast_forward(r
, from
, to
, 1))
660 return -1; /* the callee should have complained already */
662 strbuf_addf(&sb
, "%s: fast-forward", action_name(opts
));
664 transaction
= ref_transaction_begin(&err
);
666 ref_transaction_update(transaction
, "HEAD",
667 to
, unborn
&& !is_rebase_i(opts
) ?
670 ref_transaction_commit(transaction
, &err
)) {
671 ref_transaction_free(transaction
);
672 error("%s", err
.buf
);
674 strbuf_release(&err
);
679 strbuf_release(&err
);
680 ref_transaction_free(transaction
);
681 update_abort_safety_file();
685 enum commit_msg_cleanup_mode
get_cleanup_mode(const char *cleanup_arg
,
688 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
689 return use_editor
? COMMIT_MSG_CLEANUP_ALL
:
690 COMMIT_MSG_CLEANUP_SPACE
;
691 else if (!strcmp(cleanup_arg
, "verbatim"))
692 return COMMIT_MSG_CLEANUP_NONE
;
693 else if (!strcmp(cleanup_arg
, "whitespace"))
694 return COMMIT_MSG_CLEANUP_SPACE
;
695 else if (!strcmp(cleanup_arg
, "strip"))
696 return COMMIT_MSG_CLEANUP_ALL
;
697 else if (!strcmp(cleanup_arg
, "scissors"))
698 return use_editor
? COMMIT_MSG_CLEANUP_SCISSORS
:
699 COMMIT_MSG_CLEANUP_SPACE
;
701 die(_("Invalid cleanup mode %s"), cleanup_arg
);
705 * NB using int rather than enum cleanup_mode to stop clang's
706 * -Wtautological-constant-out-of-range-compare complaining that the comparison
709 static const char *describe_cleanup_mode(int cleanup_mode
)
711 static const char *modes
[] = { "whitespace",
716 if (cleanup_mode
< ARRAY_SIZE(modes
))
717 return modes
[cleanup_mode
];
719 BUG("invalid cleanup_mode provided (%d)", cleanup_mode
);
722 void append_conflicts_hint(struct index_state
*istate
,
723 struct strbuf
*msgbuf
, enum commit_msg_cleanup_mode cleanup_mode
)
727 if (cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
) {
728 strbuf_addch(msgbuf
, '\n');
729 wt_status_append_cut_line(msgbuf
);
730 strbuf_addstr(msgbuf
, comment_line_str
);
733 strbuf_addch(msgbuf
, '\n');
734 strbuf_commented_addf(msgbuf
, comment_line_str
, "Conflicts:\n");
735 for (i
= 0; i
< istate
->cache_nr
;) {
736 const struct cache_entry
*ce
= istate
->cache
[i
++];
738 strbuf_commented_addf(msgbuf
, comment_line_str
,
740 while (i
< istate
->cache_nr
&&
741 !strcmp(ce
->name
, istate
->cache
[i
]->name
))
747 static int do_recursive_merge(struct repository
*r
,
748 struct commit
*base
, struct commit
*next
,
749 const char *base_label
, const char *next_label
,
750 struct object_id
*head
, struct strbuf
*msgbuf
,
751 struct replay_opts
*opts
)
753 struct merge_options o
;
754 struct merge_result result
;
755 struct tree
*next_tree
, *base_tree
, *head_tree
;
756 int clean
, show_output
;
758 struct lock_file index_lock
= LOCK_INIT
;
760 if (repo_hold_locked_index(r
, &index_lock
, LOCK_REPORT_ON_ERROR
) < 0)
765 init_merge_options(&o
, r
);
766 o
.ancestor
= base
? base_label
: "(empty tree)";
768 o
.branch2
= next
? next_label
: "(empty tree)";
769 if (is_rebase_i(opts
))
771 o
.show_rename_progress
= 1;
773 head_tree
= parse_tree_indirect(head
);
775 return error(_("unable to read tree (%s)"), oid_to_hex(head
));
776 next_tree
= next
? repo_get_commit_tree(r
, next
) : empty_tree(r
);
777 base_tree
= base
? repo_get_commit_tree(r
, base
) : empty_tree(r
);
779 for (i
= 0; i
< opts
->xopts
.nr
; i
++)
780 parse_merge_opt(&o
, opts
->xopts
.v
[i
]);
782 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
783 memset(&result
, 0, sizeof(result
));
784 merge_incore_nonrecursive(&o
, base_tree
, head_tree
, next_tree
,
786 show_output
= !is_rebase_i(opts
) || !result
.clean
;
788 * TODO: merge_switch_to_result will update index/working tree;
789 * we only really want to do that if !result.clean || this is
790 * the final patch to be picked. But determining this is the
791 * final patch would take some work, and "head_tree" would need
792 * to be replace with the tree the index matched before we
793 * started doing any picks.
795 merge_switch_to_result(&o
, head_tree
, &result
, 1, show_output
);
796 clean
= result
.clean
;
798 ensure_full_index(r
->index
);
799 clean
= merge_trees(&o
, head_tree
, next_tree
, base_tree
);
800 if (is_rebase_i(opts
) && clean
<= 0)
801 fputs(o
.obuf
.buf
, stdout
);
802 strbuf_release(&o
.obuf
);
805 rollback_lock_file(&index_lock
);
809 if (write_locked_index(r
->index
, &index_lock
,
810 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
812 * TRANSLATORS: %s will be "revert", "cherry-pick" or
815 return error(_("%s: Unable to write new index file"),
816 _(action_name(opts
)));
819 append_conflicts_hint(r
->index
, msgbuf
,
820 opts
->default_msg_cleanup
);
825 static struct object_id
*get_cache_tree_oid(struct index_state
*istate
)
827 if (!cache_tree_fully_valid(istate
->cache_tree
))
828 if (cache_tree_update(istate
, 0)) {
829 error(_("unable to update cache tree"));
833 return &istate
->cache_tree
->oid
;
836 static int is_index_unchanged(struct repository
*r
)
838 struct object_id head_oid
, *cache_tree_oid
;
839 const struct object_id
*head_tree_oid
;
840 struct commit
*head_commit
;
841 struct index_state
*istate
= r
->index
;
842 const char *head_name
;
844 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
)) {
845 /* Check to see if this is an unborn branch */
846 head_name
= resolve_ref_unsafe("HEAD",
847 RESOLVE_REF_READING
| RESOLVE_REF_NO_RECURSE
,
850 !starts_with(head_name
, "refs/heads/") ||
851 !is_null_oid(&head_oid
))
852 return error(_("could not resolve HEAD commit"));
853 head_tree_oid
= the_hash_algo
->empty_tree
;
855 head_commit
= lookup_commit(r
, &head_oid
);
858 * If head_commit is NULL, check_commit, called from
859 * lookup_commit, would have indicated that head_commit is not
860 * a commit object already. repo_parse_commit() will return failure
861 * without further complaints in such a case. Otherwise, if
862 * the commit is invalid, repo_parse_commit() will complain. So
863 * there is nothing for us to say here. Just return failure.
865 if (repo_parse_commit(r
, head_commit
))
868 head_tree_oid
= get_commit_tree_oid(head_commit
);
871 if (!(cache_tree_oid
= get_cache_tree_oid(istate
)))
874 return oideq(cache_tree_oid
, head_tree_oid
);
877 static int write_author_script(const char *message
)
879 struct strbuf buf
= STRBUF_INIT
;
884 if (!*message
|| starts_with(message
, "\n")) {
886 /* Missing 'author' line? */
887 unlink(rebase_path_author_script());
889 } else if (skip_prefix(message
, "author ", &message
))
891 else if ((eol
= strchr(message
, '\n')))
896 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
897 while (*message
&& *message
!= '\n' && *message
!= '\r')
898 if (skip_prefix(message
, " <", &message
))
900 else if (*message
!= '\'')
901 strbuf_addch(&buf
, *(message
++));
903 strbuf_addf(&buf
, "'\\%c'", *(message
++));
904 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
905 while (*message
&& *message
!= '\n' && *message
!= '\r')
906 if (skip_prefix(message
, "> ", &message
))
908 else if (*message
!= '\'')
909 strbuf_addch(&buf
, *(message
++));
911 strbuf_addf(&buf
, "'\\%c'", *(message
++));
912 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
913 while (*message
&& *message
!= '\n' && *message
!= '\r')
914 if (*message
!= '\'')
915 strbuf_addch(&buf
, *(message
++));
917 strbuf_addf(&buf
, "'\\%c'", *(message
++));
918 strbuf_addch(&buf
, '\'');
919 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
920 strbuf_release(&buf
);
925 * Take a series of KEY='VALUE' lines where VALUE part is
926 * sq-quoted, and append <KEY, VALUE> at the end of the string list
928 static int parse_key_value_squoted(char *buf
, struct string_list
*list
)
931 struct string_list_item
*item
;
933 char *cp
= strchr(buf
, '=');
935 np
= strchrnul(buf
, '\n');
936 return error(_("no key present in '%.*s'"),
937 (int) (np
- buf
), buf
);
939 np
= strchrnul(cp
, '\n');
941 item
= string_list_append(list
, buf
);
943 buf
= np
+ (*np
== '\n');
947 return error(_("unable to dequote value of '%s'"),
949 item
->util
= xstrdup(cp
);
955 * Reads and parses the state directory's "author-script" file, and sets name,
956 * email and date accordingly.
957 * Returns 0 on success, -1 if the file could not be parsed.
959 * The author script is of the format:
961 * GIT_AUTHOR_NAME='$author_name'
962 * GIT_AUTHOR_EMAIL='$author_email'
963 * GIT_AUTHOR_DATE='$author_date'
965 * where $author_name, $author_email and $author_date are quoted. We are strict
966 * with our parsing, as the file was meant to be eval'd in the now-removed
967 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
968 * from what this function expects, it is better to bail out than to do
969 * something that the user does not expect.
971 int read_author_script(const char *path
, char **name
, char **email
, char **date
,
974 struct strbuf buf
= STRBUF_INIT
;
975 struct string_list kv
= STRING_LIST_INIT_DUP
;
976 int retval
= -1; /* assume failure */
977 int i
, name_i
= -2, email_i
= -2, date_i
= -2, err
= 0;
979 if (strbuf_read_file(&buf
, path
, 256) <= 0) {
980 strbuf_release(&buf
);
981 if (errno
== ENOENT
&& allow_missing
)
984 return error_errno(_("could not open '%s' for reading"),
988 if (parse_key_value_squoted(buf
.buf
, &kv
))
991 for (i
= 0; i
< kv
.nr
; i
++) {
992 if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_NAME")) {
994 name_i
= error(_("'GIT_AUTHOR_NAME' already given"));
997 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_EMAIL")) {
999 email_i
= error(_("'GIT_AUTHOR_EMAIL' already given"));
1002 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_DATE")) {
1004 date_i
= error(_("'GIT_AUTHOR_DATE' already given"));
1008 err
= error(_("unknown variable '%s'"),
1009 kv
.items
[i
].string
);
1013 error(_("missing 'GIT_AUTHOR_NAME'"));
1015 error(_("missing 'GIT_AUTHOR_EMAIL'"));
1017 error(_("missing 'GIT_AUTHOR_DATE'"));
1018 if (name_i
< 0 || email_i
< 0 || date_i
< 0 || err
)
1020 *name
= kv
.items
[name_i
].util
;
1021 *email
= kv
.items
[email_i
].util
;
1022 *date
= kv
.items
[date_i
].util
;
1025 string_list_clear(&kv
, !!retval
);
1026 strbuf_release(&buf
);
1031 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
1032 * file with shell quoting into struct strvec. Returns -1 on
1033 * error, 0 otherwise.
1035 static int read_env_script(struct strvec
*env
)
1037 char *name
, *email
, *date
;
1039 if (read_author_script(rebase_path_author_script(),
1040 &name
, &email
, &date
, 0))
1043 strvec_pushf(env
, "GIT_AUTHOR_NAME=%s", name
);
1044 strvec_pushf(env
, "GIT_AUTHOR_EMAIL=%s", email
);
1045 strvec_pushf(env
, "GIT_AUTHOR_DATE=%s", date
);
1053 static char *get_author(const char *message
)
1058 a
= find_commit_header(message
, "author", &len
);
1060 return xmemdupz(a
, len
);
1065 static const char *author_date_from_env(const struct strvec
*env
)
1070 for (i
= 0; i
< env
->nr
; i
++)
1071 if (skip_prefix(env
->v
[i
],
1072 "GIT_AUTHOR_DATE=", &date
))
1075 * If GIT_AUTHOR_DATE is missing we should have already errored out when
1076 * reading the script
1078 BUG("GIT_AUTHOR_DATE missing from author script");
1081 static const char staged_changes_advice
[] =
1082 N_("you have staged changes in your working tree\n"
1083 "If these changes are meant to be squashed into the previous commit, run:\n"
1085 " git commit --amend %s\n"
1087 "If they are meant to go into a new commit, run:\n"
1091 "In both cases, once you're done, continue with:\n"
1093 " git rebase --continue\n");
1095 #define ALLOW_EMPTY (1<<0)
1096 #define EDIT_MSG (1<<1)
1097 #define AMEND_MSG (1<<2)
1098 #define CLEANUP_MSG (1<<3)
1099 #define VERIFY_MSG (1<<4)
1100 #define CREATE_ROOT_COMMIT (1<<5)
1101 #define VERBATIM_MSG (1<<6)
1103 static int run_command_silent_on_success(struct child_process
*cmd
)
1105 struct strbuf buf
= STRBUF_INIT
;
1108 cmd
->stdout_to_stderr
= 1;
1109 rc
= pipe_command(cmd
,
1115 fputs(buf
.buf
, stderr
);
1116 strbuf_release(&buf
);
1121 * If we are cherry-pick, and if the merge did not result in
1122 * hand-editing, we will hit this commit and inherit the original
1123 * author date and name.
1125 * If we are revert, or if our cherry-pick results in a hand merge,
1126 * we had better say that the current user is responsible for that.
1128 * An exception is when run_git_commit() is called during an
1129 * interactive rebase: in that case, we will want to retain the
1132 static int run_git_commit(const char *defmsg
,
1133 struct replay_opts
*opts
,
1136 struct replay_ctx
*ctx
= opts
->ctx
;
1137 struct child_process cmd
= CHILD_PROCESS_INIT
;
1139 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1140 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1144 if (is_rebase_i(opts
) &&
1145 ((opts
->committer_date_is_author_date
&& !opts
->ignore_date
) ||
1146 !(!defmsg
&& (flags
& AMEND_MSG
))) &&
1147 read_env_script(&cmd
.env
)) {
1148 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
1150 return error(_(staged_changes_advice
),
1154 strvec_pushf(&cmd
.env
, GIT_REFLOG_ACTION
"=%s", ctx
->reflog_message
);
1156 if (opts
->committer_date_is_author_date
)
1157 strvec_pushf(&cmd
.env
, "GIT_COMMITTER_DATE=%s",
1160 author_date_from_env(&cmd
.env
));
1161 if (opts
->ignore_date
)
1162 strvec_push(&cmd
.env
, "GIT_AUTHOR_DATE=");
1164 strvec_push(&cmd
.args
, "commit");
1166 if (!(flags
& VERIFY_MSG
))
1167 strvec_push(&cmd
.args
, "-n");
1168 if ((flags
& AMEND_MSG
))
1169 strvec_push(&cmd
.args
, "--amend");
1171 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
1173 strvec_push(&cmd
.args
, "--no-gpg-sign");
1175 strvec_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
1176 else if (!(flags
& EDIT_MSG
))
1177 strvec_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
1178 if ((flags
& CLEANUP_MSG
))
1179 strvec_push(&cmd
.args
, "--cleanup=strip");
1180 if ((flags
& VERBATIM_MSG
))
1181 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1182 if ((flags
& EDIT_MSG
))
1183 strvec_push(&cmd
.args
, "-e");
1184 else if (!(flags
& CLEANUP_MSG
) &&
1185 !opts
->signoff
&& !opts
->record_origin
&&
1186 !opts
->explicit_cleanup
)
1187 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1189 if ((flags
& ALLOW_EMPTY
))
1190 strvec_push(&cmd
.args
, "--allow-empty");
1192 if (!(flags
& EDIT_MSG
))
1193 strvec_push(&cmd
.args
, "--allow-empty-message");
1195 if (is_rebase_i(opts
) && !(flags
& EDIT_MSG
))
1196 return run_command_silent_on_success(&cmd
);
1198 return run_command(&cmd
);
1201 static int rest_is_empty(const struct strbuf
*sb
, int start
)
1206 /* Check if the rest is just whitespace and Signed-off-by's. */
1207 for (i
= start
; i
< sb
->len
; i
++) {
1208 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1214 if (strlen(sign_off_header
) <= eol
- i
&&
1215 starts_with(sb
->buf
+ i
, sign_off_header
)) {
1220 if (!isspace(sb
->buf
[i
++]))
1227 void cleanup_message(struct strbuf
*msgbuf
,
1228 enum commit_msg_cleanup_mode cleanup_mode
, int verbose
)
1230 if (verbose
|| /* Truncate the message just before the diff, if any. */
1231 cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
1232 strbuf_setlen(msgbuf
, wt_status_locate_end(msgbuf
->buf
, msgbuf
->len
));
1233 if (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
)
1234 strbuf_stripspace(msgbuf
,
1235 cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
? comment_line_str
: NULL
);
1239 * Find out if the message in the strbuf contains only whitespace and
1240 * Signed-off-by lines.
1242 int message_is_empty(const struct strbuf
*sb
,
1243 enum commit_msg_cleanup_mode cleanup_mode
)
1245 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1247 return rest_is_empty(sb
, 0);
1251 * See if the user edited the message in the editor or left what
1252 * was in the template intact
1254 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
1255 enum commit_msg_cleanup_mode cleanup_mode
)
1257 struct strbuf tmpl
= STRBUF_INIT
;
1260 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1263 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
1266 strbuf_stripspace(&tmpl
,
1267 cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
? comment_line_str
: NULL
);
1268 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
1270 strbuf_release(&tmpl
);
1271 return rest_is_empty(sb
, start
- sb
->buf
);
1274 int update_head_with_reflog(const struct commit
*old_head
,
1275 const struct object_id
*new_head
,
1276 const char *action
, const struct strbuf
*msg
,
1279 struct ref_transaction
*transaction
;
1280 struct strbuf sb
= STRBUF_INIT
;
1285 strbuf_addstr(&sb
, action
);
1286 strbuf_addstr(&sb
, ": ");
1289 nl
= strchr(msg
->buf
, '\n');
1291 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
1293 strbuf_addbuf(&sb
, msg
);
1294 strbuf_addch(&sb
, '\n');
1297 transaction
= ref_transaction_begin(err
);
1299 ref_transaction_update(transaction
, "HEAD", new_head
,
1300 old_head
? &old_head
->object
.oid
: null_oid(),
1302 ref_transaction_commit(transaction
, err
)) {
1305 ref_transaction_free(transaction
);
1306 strbuf_release(&sb
);
1311 static int run_rewrite_hook(const struct object_id
*oldoid
,
1312 const struct object_id
*newoid
)
1314 struct child_process proc
= CHILD_PROCESS_INIT
;
1316 struct strbuf sb
= STRBUF_INIT
;
1317 const char *hook_path
= find_hook("post-rewrite");
1322 strvec_pushl(&proc
.args
, hook_path
, "amend", NULL
);
1324 proc
.stdout_to_stderr
= 1;
1325 proc
.trace2_hook_name
= "post-rewrite";
1327 code
= start_command(&proc
);
1330 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
1331 sigchain_push(SIGPIPE
, SIG_IGN
);
1332 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
1334 strbuf_release(&sb
);
1335 sigchain_pop(SIGPIPE
);
1336 return finish_command(&proc
);
1339 void commit_post_rewrite(struct repository
*r
,
1340 const struct commit
*old_head
,
1341 const struct object_id
*new_head
)
1343 struct notes_rewrite_cfg
*cfg
;
1345 cfg
= init_copy_notes_for_rewrite("amend");
1347 /* we are amending, so old_head is not NULL */
1348 copy_note_for_rewrite(cfg
, &old_head
->object
.oid
, new_head
);
1349 finish_copy_notes_for_rewrite(r
, cfg
, "Notes added by 'git commit --amend'");
1351 run_rewrite_hook(&old_head
->object
.oid
, new_head
);
1354 static int run_prepare_commit_msg_hook(struct repository
*r
,
1359 const char *name
, *arg1
= NULL
, *arg2
= NULL
;
1361 name
= git_path_commit_editmsg();
1362 if (write_message(msg
->buf
, msg
->len
, name
, 0))
1371 if (run_commit_hook(0, r
->index_file
, NULL
, "prepare-commit-msg", name
,
1373 ret
= error(_("'prepare-commit-msg' hook failed"));
1378 static const char implicit_ident_advice_noconfig
[] =
1379 N_("Your name and email address were configured automatically based\n"
1380 "on your username and hostname. Please check that they are accurate.\n"
1381 "You can suppress this message by setting them explicitly. Run the\n"
1382 "following command and follow the instructions in your editor to edit\n"
1383 "your configuration file:\n"
1385 " git config --global --edit\n"
1387 "After doing this, you may fix the identity used for this commit with:\n"
1389 " git commit --amend --reset-author\n");
1391 static const char implicit_ident_advice_config
[] =
1392 N_("Your name and email address were configured automatically based\n"
1393 "on your username and hostname. Please check that they are accurate.\n"
1394 "You can suppress this message by setting them explicitly:\n"
1396 " git config --global user.name \"Your Name\"\n"
1397 " git config --global user.email you@example.com\n"
1399 "After doing this, you may fix the identity used for this commit with:\n"
1401 " git commit --amend --reset-author\n");
1403 static const char *implicit_ident_advice(void)
1405 char *user_config
= interpolate_path("~/.gitconfig", 0);
1406 char *xdg_config
= xdg_config_home("config");
1407 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1413 return _(implicit_ident_advice_config
);
1415 return _(implicit_ident_advice_noconfig
);
1419 void print_commit_summary(struct repository
*r
,
1421 const struct object_id
*oid
,
1424 struct rev_info rev
;
1425 struct commit
*commit
;
1426 struct strbuf format
= STRBUF_INIT
;
1428 struct pretty_print_context pctx
= {0};
1429 struct strbuf author_ident
= STRBUF_INIT
;
1430 struct strbuf committer_ident
= STRBUF_INIT
;
1431 struct ref_store
*refs
;
1433 commit
= lookup_commit(r
, oid
);
1435 die(_("couldn't look up newly created commit"));
1436 if (repo_parse_commit(r
, commit
))
1437 die(_("could not parse newly created commit"));
1439 strbuf_addstr(&format
, "format:%h] %s");
1441 repo_format_commit_message(r
, commit
, "%an <%ae>", &author_ident
,
1443 repo_format_commit_message(r
, commit
, "%cn <%ce>", &committer_ident
,
1445 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1446 strbuf_addstr(&format
, "\n Author: ");
1447 strbuf_addbuf_percentquote(&format
, &author_ident
);
1449 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
1450 struct strbuf date
= STRBUF_INIT
;
1452 repo_format_commit_message(r
, commit
, "%ad", &date
, &pctx
);
1453 strbuf_addstr(&format
, "\n Date: ");
1454 strbuf_addbuf_percentquote(&format
, &date
);
1455 strbuf_release(&date
);
1457 if (!committer_ident_sufficiently_given()) {
1458 strbuf_addstr(&format
, "\n Committer: ");
1459 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1460 if (advice_enabled(ADVICE_IMPLICIT_IDENTITY
)) {
1461 strbuf_addch(&format
, '\n');
1462 strbuf_addstr(&format
, implicit_ident_advice());
1465 strbuf_release(&author_ident
);
1466 strbuf_release(&committer_ident
);
1468 repo_init_revisions(r
, &rev
, prefix
);
1469 setup_revisions(0, NULL
, &rev
, NULL
);
1472 rev
.diffopt
.output_format
=
1473 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1475 rev
.verbose_header
= 1;
1476 rev
.show_root_diff
= 1;
1477 get_commit_format(format
.buf
, &rev
);
1478 rev
.always_show_header
= 0;
1479 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1480 diff_setup_done(&rev
.diffopt
);
1482 refs
= get_main_ref_store(r
);
1483 head
= refs_resolve_ref_unsafe(refs
, "HEAD", 0, NULL
, NULL
);
1485 die(_("unable to resolve HEAD after creating commit"));
1486 if (!strcmp(head
, "HEAD"))
1487 head
= _("detached HEAD");
1489 skip_prefix(head
, "refs/heads/", &head
);
1490 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1491 _(" (root-commit)") : "");
1493 if (!log_tree_commit(&rev
, commit
)) {
1494 rev
.always_show_header
= 1;
1495 rev
.use_terminator
= 1;
1496 log_tree_commit(&rev
, commit
);
1499 release_revisions(&rev
);
1500 strbuf_release(&format
);
1503 static int parse_head(struct repository
*r
, struct commit
**head
)
1505 struct commit
*current_head
;
1506 struct object_id oid
;
1508 if (repo_get_oid(r
, "HEAD", &oid
)) {
1509 current_head
= NULL
;
1511 current_head
= lookup_commit_reference(r
, &oid
);
1513 return error(_("could not parse HEAD"));
1514 if (!oideq(&oid
, ¤t_head
->object
.oid
)) {
1515 warning(_("HEAD %s is not a commit!"),
1518 if (repo_parse_commit(r
, current_head
))
1519 return error(_("could not parse HEAD commit"));
1521 *head
= current_head
;
1527 * Try to commit without forking 'git commit'. In some cases we need
1528 * to run 'git commit' to display an error message
1531 * -1 - error unable to commit
1533 * 1 - run 'git commit'
1535 static int try_to_commit(struct repository
*r
,
1536 struct strbuf
*msg
, const char *author
,
1537 struct replay_opts
*opts
, unsigned int flags
,
1538 struct object_id
*oid
)
1540 struct replay_ctx
*ctx
= opts
->ctx
;
1541 struct object_id tree
;
1542 struct commit
*current_head
= NULL
;
1543 struct commit_list
*parents
= NULL
;
1544 struct commit_extra_header
*extra
= NULL
;
1545 struct strbuf err
= STRBUF_INIT
;
1546 struct strbuf commit_msg
= STRBUF_INIT
;
1547 char *amend_author
= NULL
;
1548 const char *committer
= NULL
;
1549 const char *hook_commit
= NULL
;
1550 enum commit_msg_cleanup_mode cleanup
;
1553 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1554 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1556 if (parse_head(r
, ¤t_head
))
1559 if (flags
& AMEND_MSG
) {
1560 const char *exclude_gpgsig
[] = { "gpgsig", "gpgsig-sha256", NULL
};
1561 const char *out_enc
= get_commit_output_encoding();
1562 const char *message
= repo_logmsg_reencode(r
, current_head
,
1566 const char *orig_message
= NULL
;
1568 find_commit_subject(message
, &orig_message
);
1570 strbuf_addstr(msg
, orig_message
);
1571 hook_commit
= "HEAD";
1573 author
= amend_author
= get_author(message
);
1574 repo_unuse_commit_buffer(r
, current_head
,
1577 res
= error(_("unable to parse commit author"));
1580 parents
= copy_commit_list(current_head
->parents
);
1581 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1582 } else if (current_head
&&
1583 (!(flags
& CREATE_ROOT_COMMIT
) || (flags
& AMEND_MSG
))) {
1584 commit_list_insert(current_head
, &parents
);
1587 if (write_index_as_tree(&tree
, r
->index
, r
->index_file
, 0, NULL
)) {
1588 res
= error(_("git write-tree failed to write a tree"));
1592 if (!(flags
& ALLOW_EMPTY
)) {
1593 struct commit
*first_parent
= current_head
;
1595 if (flags
& AMEND_MSG
) {
1596 if (current_head
->parents
) {
1597 first_parent
= current_head
->parents
->item
;
1598 if (repo_parse_commit(r
, first_parent
)) {
1599 res
= error(_("could not parse HEAD commit"));
1603 first_parent
= NULL
;
1606 if (oideq(first_parent
1607 ? get_commit_tree_oid(first_parent
)
1608 : the_hash_algo
->empty_tree
,
1610 res
= 1; /* run 'git commit' to display error message */
1615 if (hook_exists("prepare-commit-msg")) {
1616 res
= run_prepare_commit_msg_hook(r
, msg
, hook_commit
);
1619 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1621 res
= error_errno(_("unable to read commit message "
1623 git_path_commit_editmsg());
1629 if (flags
& CLEANUP_MSG
)
1630 cleanup
= COMMIT_MSG_CLEANUP_ALL
;
1631 else if (flags
& VERBATIM_MSG
)
1632 cleanup
= COMMIT_MSG_CLEANUP_NONE
;
1633 else if ((opts
->signoff
|| opts
->record_origin
) &&
1634 !opts
->explicit_cleanup
)
1635 cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
1637 cleanup
= opts
->default_msg_cleanup
;
1639 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1640 strbuf_stripspace(msg
,
1641 cleanup
== COMMIT_MSG_CLEANUP_ALL
? comment_line_str
: NULL
);
1642 if ((flags
& EDIT_MSG
) && message_is_empty(msg
, cleanup
)) {
1643 res
= 1; /* run 'git commit' to display error message */
1647 if (opts
->committer_date_is_author_date
) {
1648 struct ident_split id
;
1649 struct strbuf date
= STRBUF_INIT
;
1651 if (!opts
->ignore_date
) {
1652 if (split_ident_line(&id
, author
, (int)strlen(author
)) < 0) {
1653 res
= error(_("invalid author identity '%s'"),
1657 if (!id
.date_begin
) {
1659 "corrupt author: missing date information"));
1662 strbuf_addf(&date
, "@%.*s %.*s",
1663 (int)(id
.date_end
- id
.date_begin
),
1665 (int)(id
.tz_end
- id
.tz_begin
),
1670 committer
= fmt_ident(getenv("GIT_COMMITTER_NAME"),
1671 getenv("GIT_COMMITTER_EMAIL"),
1672 WANT_COMMITTER_IDENT
,
1673 opts
->ignore_date
? NULL
: date
.buf
,
1675 strbuf_release(&date
);
1680 if (opts
->ignore_date
) {
1681 struct ident_split id
;
1684 if (split_ident_line(&id
, author
, strlen(author
)) < 0) {
1685 error(_("invalid author identity '%s'"), author
);
1688 name
= xmemdupz(id
.name_begin
, id
.name_end
- id
.name_begin
);
1689 email
= xmemdupz(id
.mail_begin
, id
.mail_end
- id
.mail_begin
);
1690 author
= fmt_ident(name
, email
, WANT_AUTHOR_IDENT
, NULL
,
1696 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
, oid
,
1697 author
, committer
, opts
->gpg_sign
, extra
)) {
1698 res
= error(_("failed to write commit object"));
1702 if (update_head_with_reflog(current_head
, oid
, ctx
->reflog_message
,
1704 res
= error("%s", err
.buf
);
1708 run_commit_hook(0, r
->index_file
, NULL
, "post-commit", NULL
);
1709 if (flags
& AMEND_MSG
)
1710 commit_post_rewrite(r
, current_head
, oid
);
1713 free_commit_extra_headers(extra
);
1714 strbuf_release(&err
);
1715 strbuf_release(&commit_msg
);
1721 static int write_rebase_head(struct object_id
*oid
)
1723 if (update_ref("rebase", "REBASE_HEAD", oid
,
1724 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1725 return error(_("could not update %s"), "REBASE_HEAD");
1730 static int do_commit(struct repository
*r
,
1731 const char *msg_file
, const char *author
,
1732 struct replay_opts
*opts
, unsigned int flags
,
1733 struct object_id
*oid
)
1737 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
)) {
1738 struct object_id oid
;
1739 struct strbuf sb
= STRBUF_INIT
;
1741 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1742 return error_errno(_("unable to read commit message "
1746 res
= try_to_commit(r
, msg_file
? &sb
: NULL
,
1747 author
, opts
, flags
, &oid
);
1748 strbuf_release(&sb
);
1750 refs_delete_ref(get_main_ref_store(r
), "",
1751 "CHERRY_PICK_HEAD", NULL
, REF_NO_DEREF
);
1752 unlink(git_path_merge_msg(r
));
1753 if (!is_rebase_i(opts
))
1754 print_commit_summary(r
, NULL
, &oid
,
1755 SUMMARY_SHOW_AUTHOR_DATE
);
1760 if (is_rebase_i(opts
) && oid
)
1761 if (write_rebase_head(oid
))
1763 return run_git_commit(msg_file
, opts
, flags
);
1769 static int is_original_commit_empty(struct commit
*commit
)
1771 const struct object_id
*ptree_oid
;
1773 if (repo_parse_commit(the_repository
, commit
))
1774 return error(_("could not parse commit %s"),
1775 oid_to_hex(&commit
->object
.oid
));
1776 if (commit
->parents
) {
1777 struct commit
*parent
= commit
->parents
->item
;
1778 if (repo_parse_commit(the_repository
, parent
))
1779 return error(_("could not parse parent commit %s"),
1780 oid_to_hex(&parent
->object
.oid
));
1781 ptree_oid
= get_commit_tree_oid(parent
);
1783 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1786 return oideq(ptree_oid
, get_commit_tree_oid(commit
));
1790 * Should empty commits be allowed? Return status:
1791 * <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1792 * 0: Halt on empty commit
1793 * 1: Allow empty commit
1794 * 2: Drop empty commit
1796 static int allow_empty(struct repository
*r
,
1797 struct replay_opts
*opts
,
1798 struct commit
*commit
)
1800 int index_unchanged
, originally_empty
;
1803 * For a commit that is initially empty, allow_empty determines if it
1804 * should be kept or not
1806 * For a commit that becomes empty, keep_redundant_commits and
1807 * drop_redundant_commits determine whether the commit should be kept or
1808 * dropped. If neither is specified, halt.
1810 index_unchanged
= is_index_unchanged(r
);
1811 if (index_unchanged
< 0)
1812 return index_unchanged
;
1813 if (!index_unchanged
)
1814 return 0; /* we do not have to say --allow-empty */
1816 originally_empty
= is_original_commit_empty(commit
);
1817 if (originally_empty
< 0)
1818 return originally_empty
;
1819 if (originally_empty
)
1820 return opts
->allow_empty
;
1821 else if (opts
->keep_redundant_commits
)
1823 else if (opts
->drop_redundant_commits
)
1832 } todo_command_info
[] = {
1833 [TODO_PICK
] = { 'p', "pick" },
1834 [TODO_REVERT
] = { 0, "revert" },
1835 [TODO_EDIT
] = { 'e', "edit" },
1836 [TODO_REWORD
] = { 'r', "reword" },
1837 [TODO_FIXUP
] = { 'f', "fixup" },
1838 [TODO_SQUASH
] = { 's', "squash" },
1839 [TODO_EXEC
] = { 'x', "exec" },
1840 [TODO_BREAK
] = { 'b', "break" },
1841 [TODO_LABEL
] = { 'l', "label" },
1842 [TODO_RESET
] = { 't', "reset" },
1843 [TODO_MERGE
] = { 'm', "merge" },
1844 [TODO_UPDATE_REF
] = { 'u', "update-ref" },
1845 [TODO_NOOP
] = { 0, "noop" },
1846 [TODO_DROP
] = { 'd', "drop" },
1847 [TODO_COMMENT
] = { 0, NULL
},
1850 static const char *command_to_string(const enum todo_command command
)
1852 if (command
< TODO_COMMENT
)
1853 return todo_command_info
[command
].str
;
1854 if (command
== TODO_COMMENT
)
1855 return comment_line_str
;
1856 die(_("unknown command: %d"), command
);
1859 static char command_to_char(const enum todo_command command
)
1861 if (command
< TODO_COMMENT
)
1862 return todo_command_info
[command
].c
;
1866 static int is_noop(const enum todo_command command
)
1868 return TODO_NOOP
<= command
;
1871 static int is_fixup(enum todo_command command
)
1873 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1876 /* Does this command create a (non-merge) commit? */
1877 static int is_pick_or_similar(enum todo_command command
)
1892 enum todo_item_flags
{
1893 TODO_EDIT_MERGE_MSG
= (1 << 0),
1894 TODO_REPLACE_FIXUP_MSG
= (1 << 1),
1895 TODO_EDIT_FIXUP_MSG
= (1 << 2),
1898 static const char first_commit_msg_str
[] = N_("This is the 1st commit message:");
1899 static const char nth_commit_msg_fmt
[] = N_("This is the commit message #%d:");
1900 static const char skip_first_commit_msg_str
[] = N_("The 1st commit message will be skipped:");
1901 static const char skip_nth_commit_msg_fmt
[] = N_("The commit message #%d will be skipped:");
1902 static const char combined_commit_msg_fmt
[] = N_("This is a combination of %d commits.");
1904 static int is_fixup_flag(enum todo_command command
, unsigned flag
)
1906 return command
== TODO_FIXUP
&& ((flag
& TODO_REPLACE_FIXUP_MSG
) ||
1907 (flag
& TODO_EDIT_FIXUP_MSG
));
1911 * Wrapper around strbuf_add_commented_lines() which avoids double
1912 * commenting commit subjects.
1914 static void add_commented_lines(struct strbuf
*buf
, const void *str
, size_t len
)
1916 const char *s
= str
;
1917 while (starts_with_mem(s
, len
, comment_line_str
)) {
1919 const char *n
= memchr(s
, '\n', len
);
1924 strbuf_add(buf
, s
, count
);
1928 strbuf_add_commented_lines(buf
, s
, len
, comment_line_str
);
1931 /* Does the current fixup chain contain a squash command? */
1932 static int seen_squash(struct replay_ctx
*ctx
)
1934 return starts_with(ctx
->current_fixups
.buf
, "squash") ||
1935 strstr(ctx
->current_fixups
.buf
, "\nsquash");
1938 static void update_comment_bufs(struct strbuf
*buf1
, struct strbuf
*buf2
, int n
)
1940 strbuf_setlen(buf1
, 2);
1941 strbuf_addf(buf1
, _(nth_commit_msg_fmt
), n
);
1942 strbuf_addch(buf1
, '\n');
1943 strbuf_setlen(buf2
, 2);
1944 strbuf_addf(buf2
, _(skip_nth_commit_msg_fmt
), n
);
1945 strbuf_addch(buf2
, '\n');
1949 * Comment out any un-commented commit messages, updating the message comments
1950 * to say they will be skipped but do not comment out the empty lines that
1951 * surround commit messages and their comments.
1953 static void update_squash_message_for_fixup(struct strbuf
*msg
)
1955 void (*copy_lines
)(struct strbuf
*, const void *, size_t) = strbuf_add
;
1956 struct strbuf buf1
= STRBUF_INIT
, buf2
= STRBUF_INIT
;
1957 const char *s
, *start
;
1959 size_t orig_msg_len
;
1962 strbuf_addf(&buf1
, "# %s\n", _(first_commit_msg_str
));
1963 strbuf_addf(&buf2
, "# %s\n", _(skip_first_commit_msg_str
));
1964 s
= start
= orig_msg
= strbuf_detach(msg
, &orig_msg_len
);
1968 if (skip_prefix(s
, buf1
.buf
, &next
)) {
1970 * Copy the last message, preserving the blank line
1971 * preceding the current line
1973 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1974 copy_lines(msg
, start
, s
- start
- off
);
1976 strbuf_addch(msg
, '\n');
1978 * The next message needs to be commented out but the
1979 * message header is already commented out so just copy
1980 * it and the blank line that follows it.
1982 strbuf_addbuf(msg
, &buf2
);
1984 strbuf_addch(msg
, *next
++);
1986 copy_lines
= add_commented_lines
;
1987 update_comment_bufs(&buf1
, &buf2
, ++i
);
1988 } else if (skip_prefix(s
, buf2
.buf
, &next
)) {
1989 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1990 copy_lines(msg
, start
, s
- start
- off
);
1993 copy_lines
= strbuf_add
;
1994 update_comment_bufs(&buf1
, &buf2
, ++i
);
1996 s
= strchr(s
, '\n');
2001 copy_lines(msg
, start
, orig_msg_len
- (start
- orig_msg
));
2003 strbuf_release(&buf1
);
2004 strbuf_release(&buf2
);
2007 static int append_squash_message(struct strbuf
*buf
, const char *body
,
2008 enum todo_command command
, struct replay_opts
*opts
,
2011 struct replay_ctx
*ctx
= opts
->ctx
;
2012 const char *fixup_msg
;
2013 size_t commented_len
= 0, fixup_off
;
2015 * amend is non-interactive and not normally used with fixup!
2016 * or squash! commits, so only comment out those subjects when
2017 * squashing commit messages.
2019 if (starts_with(body
, "amend!") ||
2020 ((command
== TODO_SQUASH
|| seen_squash(ctx
)) &&
2021 (starts_with(body
, "squash!") || starts_with(body
, "fixup!"))))
2022 commented_len
= commit_subject_length(body
);
2024 strbuf_addf(buf
, "\n%s ", comment_line_str
);
2025 strbuf_addf(buf
, _(nth_commit_msg_fmt
),
2026 ++ctx
->current_fixup_count
+ 1);
2027 strbuf_addstr(buf
, "\n\n");
2028 strbuf_add_commented_lines(buf
, body
, commented_len
, comment_line_str
);
2029 /* buf->buf may be reallocated so store an offset into the buffer */
2030 fixup_off
= buf
->len
;
2031 strbuf_addstr(buf
, body
+ commented_len
);
2033 /* fixup -C after squash behaves like squash */
2034 if (is_fixup_flag(command
, flag
) && !seen_squash(ctx
)) {
2036 * We're replacing the commit message so we need to
2037 * append the Signed-off-by: trailer if the user
2038 * requested '--signoff'.
2041 append_signoff(buf
, 0, 0);
2043 if ((command
== TODO_FIXUP
) &&
2044 (flag
& TODO_REPLACE_FIXUP_MSG
) &&
2045 (file_exists(rebase_path_fixup_msg()) ||
2046 !file_exists(rebase_path_squash_msg()))) {
2047 fixup_msg
= skip_blank_lines(buf
->buf
+ fixup_off
);
2048 if (write_message(fixup_msg
, strlen(fixup_msg
),
2049 rebase_path_fixup_msg(), 0) < 0)
2050 return error(_("cannot write '%s'"),
2051 rebase_path_fixup_msg());
2053 unlink(rebase_path_fixup_msg());
2056 unlink(rebase_path_fixup_msg());
2062 static int update_squash_messages(struct repository
*r
,
2063 enum todo_command command
,
2064 struct commit
*commit
,
2065 struct replay_opts
*opts
,
2068 struct replay_ctx
*ctx
= opts
->ctx
;
2069 struct strbuf buf
= STRBUF_INIT
;
2071 const char *message
, *body
;
2072 const char *encoding
= get_commit_output_encoding();
2074 if (ctx
->current_fixup_count
> 0) {
2075 struct strbuf header
= STRBUF_INIT
;
2078 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
2079 return error(_("could not read '%s'"),
2080 rebase_path_squash_msg());
2082 eol
= !starts_with(buf
.buf
, comment_line_str
) ?
2083 buf
.buf
: strchrnul(buf
.buf
, '\n');
2085 strbuf_addf(&header
, "%s ", comment_line_str
);
2086 strbuf_addf(&header
, _(combined_commit_msg_fmt
),
2087 ctx
->current_fixup_count
+ 2);
2088 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
2089 strbuf_release(&header
);
2090 if (is_fixup_flag(command
, flag
) && !seen_squash(ctx
))
2091 update_squash_message_for_fixup(&buf
);
2093 struct object_id head
;
2094 struct commit
*head_commit
;
2095 const char *head_message
, *body
;
2097 if (repo_get_oid(r
, "HEAD", &head
))
2098 return error(_("need a HEAD to fixup"));
2099 if (!(head_commit
= lookup_commit_reference(r
, &head
)))
2100 return error(_("could not read HEAD"));
2101 if (!(head_message
= repo_logmsg_reencode(r
, head_commit
, NULL
,
2103 return error(_("could not read HEAD's commit message"));
2105 find_commit_subject(head_message
, &body
);
2106 if (command
== TODO_FIXUP
&& !flag
&& write_message(body
, strlen(body
),
2107 rebase_path_fixup_msg(), 0) < 0) {
2108 repo_unuse_commit_buffer(r
, head_commit
, head_message
);
2109 return error(_("cannot write '%s'"), rebase_path_fixup_msg());
2111 strbuf_addf(&buf
, "%s ", comment_line_str
);
2112 strbuf_addf(&buf
, _(combined_commit_msg_fmt
), 2);
2113 strbuf_addf(&buf
, "\n%s ", comment_line_str
);
2114 strbuf_addstr(&buf
, is_fixup_flag(command
, flag
) ?
2115 _(skip_first_commit_msg_str
) :
2116 _(first_commit_msg_str
));
2117 strbuf_addstr(&buf
, "\n\n");
2118 if (is_fixup_flag(command
, flag
))
2119 strbuf_add_commented_lines(&buf
, body
, strlen(body
),
2122 strbuf_addstr(&buf
, body
);
2124 repo_unuse_commit_buffer(r
, head_commit
, head_message
);
2127 if (!(message
= repo_logmsg_reencode(r
, commit
, NULL
, encoding
)))
2128 return error(_("could not read commit message of %s"),
2129 oid_to_hex(&commit
->object
.oid
));
2130 find_commit_subject(message
, &body
);
2132 if (command
== TODO_SQUASH
|| is_fixup_flag(command
, flag
)) {
2133 res
= append_squash_message(&buf
, body
, command
, opts
, flag
);
2134 } else if (command
== TODO_FIXUP
) {
2135 strbuf_addf(&buf
, "\n%s ", comment_line_str
);
2136 strbuf_addf(&buf
, _(skip_nth_commit_msg_fmt
),
2137 ++ctx
->current_fixup_count
+ 1);
2138 strbuf_addstr(&buf
, "\n\n");
2139 strbuf_add_commented_lines(&buf
, body
, strlen(body
),
2142 return error(_("unknown command: %d"), command
);
2143 repo_unuse_commit_buffer(r
, commit
, message
);
2146 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(),
2148 strbuf_release(&buf
);
2151 strbuf_addf(&ctx
->current_fixups
, "%s%s %s",
2152 ctx
->current_fixups
.len
? "\n" : "",
2153 command_to_string(command
),
2154 oid_to_hex(&commit
->object
.oid
));
2155 res
= write_message(ctx
->current_fixups
.buf
,
2156 ctx
->current_fixups
.len
,
2157 rebase_path_current_fixups(), 0);
2163 static void flush_rewritten_pending(void)
2165 struct strbuf buf
= STRBUF_INIT
;
2166 struct object_id newoid
;
2169 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
2170 !repo_get_oid(the_repository
, "HEAD", &newoid
) &&
2171 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
2172 char *bol
= buf
.buf
, *eol
;
2175 eol
= strchrnul(bol
, '\n');
2176 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
2177 bol
, oid_to_hex(&newoid
));
2183 unlink(rebase_path_rewritten_pending());
2185 strbuf_release(&buf
);
2188 static void record_in_rewritten(struct object_id
*oid
,
2189 enum todo_command next_command
)
2191 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
2196 fprintf(out
, "%s\n", oid_to_hex(oid
));
2199 if (!is_fixup(next_command
))
2200 flush_rewritten_pending();
2203 static int should_edit(struct replay_opts
*opts
) {
2206 * Note that we only handle the case of non-conflicted
2207 * commits; continue_single_pick() handles the conflicted
2208 * commits itself instead of calling this function.
2210 return (opts
->action
== REPLAY_REVERT
&& isatty(0)) ? 1 : 0;
2214 static void refer_to_commit(struct replay_opts
*opts
,
2215 struct strbuf
*msgbuf
, struct commit
*commit
)
2217 if (opts
->commit_use_reference
) {
2218 struct pretty_print_context ctx
= {
2219 .abbrev
= DEFAULT_ABBREV
,
2220 .date_mode
.type
= DATE_SHORT
,
2222 repo_format_commit_message(the_repository
, commit
,
2223 "%h (%s, %ad)", msgbuf
, &ctx
);
2225 strbuf_addstr(msgbuf
, oid_to_hex(&commit
->object
.oid
));
2229 static int do_pick_commit(struct repository
*r
,
2230 struct todo_item
*item
,
2231 struct replay_opts
*opts
,
2232 int final_fixup
, int *check_todo
)
2234 struct replay_ctx
*ctx
= opts
->ctx
;
2235 unsigned int flags
= should_edit(opts
) ? EDIT_MSG
: 0;
2236 const char *msg_file
= should_edit(opts
) ? NULL
: git_path_merge_msg(r
);
2237 struct object_id head
;
2238 struct commit
*base
, *next
, *parent
;
2239 const char *base_label
, *next_label
;
2240 char *author
= NULL
;
2241 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
2242 int res
, unborn
= 0, reword
= 0, allow
, drop_commit
;
2243 enum todo_command command
= item
->command
;
2244 struct commit
*commit
= item
->commit
;
2246 if (opts
->no_commit
) {
2248 * We do not intend to commit immediately. We just want to
2249 * merge the differences in, so let's compute the tree
2250 * that represents the "current" state for the merge machinery
2253 if (write_index_as_tree(&head
, r
->index
, r
->index_file
, 0, NULL
))
2254 return error(_("your index file is unmerged."));
2256 unborn
= repo_get_oid(r
, "HEAD", &head
);
2257 /* Do we want to generate a root commit? */
2258 if (is_pick_or_similar(command
) && opts
->have_squash_onto
&&
2259 oideq(&head
, &opts
->squash_onto
)) {
2260 if (is_fixup(command
))
2261 return error(_("cannot fixup root commit"));
2262 flags
|= CREATE_ROOT_COMMIT
;
2265 oidcpy(&head
, the_hash_algo
->empty_tree
);
2266 if (index_differs_from(r
, unborn
? empty_tree_oid_hex() : "HEAD",
2268 return error_dirty_index(r
, opts
);
2270 discard_index(r
->index
);
2272 if (!commit
->parents
)
2274 else if (commit
->parents
->next
) {
2275 /* Reverting or cherry-picking a merge commit */
2277 struct commit_list
*p
;
2279 if (!opts
->mainline
)
2280 return error(_("commit %s is a merge but no -m option was given."),
2281 oid_to_hex(&commit
->object
.oid
));
2283 for (cnt
= 1, p
= commit
->parents
;
2284 cnt
!= opts
->mainline
&& p
;
2287 if (cnt
!= opts
->mainline
|| !p
)
2288 return error(_("commit %s does not have parent %d"),
2289 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2291 } else if (1 < opts
->mainline
)
2293 * Non-first parent explicitly specified as mainline for
2296 return error(_("commit %s does not have parent %d"),
2297 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2299 parent
= commit
->parents
->item
;
2301 if (get_message(commit
, &msg
) != 0)
2302 return error(_("cannot get commit message for %s"),
2303 oid_to_hex(&commit
->object
.oid
));
2305 if (opts
->allow_ff
&& !is_fixup(command
) &&
2306 ((parent
&& oideq(&parent
->object
.oid
, &head
)) ||
2307 (!parent
&& unborn
))) {
2308 if (is_rebase_i(opts
))
2309 write_author_script(msg
.message
);
2310 res
= fast_forward_to(r
, &commit
->object
.oid
, &head
, unborn
,
2312 if (res
|| command
!= TODO_REWORD
)
2316 goto fast_forward_edit
;
2318 if (parent
&& repo_parse_commit(r
, parent
) < 0)
2319 /* TRANSLATORS: The first %s will be a "todo" command like
2320 "revert" or "pick", the second %s a SHA1. */
2321 return error(_("%s: cannot parse parent commit %s"),
2322 command_to_string(command
),
2323 oid_to_hex(&parent
->object
.oid
));
2326 * "commit" is an existing commit. We would want to apply
2327 * the difference it introduces since its first parent "prev"
2328 * on top of the current HEAD if we are cherry-pick. Or the
2329 * reverse of it if we are revert.
2332 if (command
== TODO_REVERT
) {
2333 const char *orig_subject
;
2336 base_label
= msg
.label
;
2338 next_label
= msg
.parent_label
;
2339 if (opts
->commit_use_reference
) {
2340 strbuf_addstr(&ctx
->message
,
2341 "# *** SAY WHY WE ARE REVERTING ON THE TITLE LINE ***");
2342 } else if (skip_prefix(msg
.subject
, "Revert \"", &orig_subject
) &&
2344 * We don't touch pre-existing repeated reverts, because
2345 * theoretically these can be nested arbitrarily deeply,
2346 * thus requiring excessive complexity to deal with.
2348 !starts_with(orig_subject
, "Revert \"")) {
2349 strbuf_addstr(&ctx
->message
, "Reapply \"");
2350 strbuf_addstr(&ctx
->message
, orig_subject
);
2352 strbuf_addstr(&ctx
->message
, "Revert \"");
2353 strbuf_addstr(&ctx
->message
, msg
.subject
);
2354 strbuf_addstr(&ctx
->message
, "\"");
2356 strbuf_addstr(&ctx
->message
, "\n\nThis reverts commit ");
2357 refer_to_commit(opts
, &ctx
->message
, commit
);
2359 if (commit
->parents
&& commit
->parents
->next
) {
2360 strbuf_addstr(&ctx
->message
, ", reversing\nchanges made to ");
2361 refer_to_commit(opts
, &ctx
->message
, parent
);
2363 strbuf_addstr(&ctx
->message
, ".\n");
2368 base_label
= msg
.parent_label
;
2370 next_label
= msg
.label
;
2372 /* Append the commit log message to ctx->message. */
2373 if (find_commit_subject(msg
.message
, &p
))
2374 strbuf_addstr(&ctx
->message
, p
);
2376 if (opts
->record_origin
) {
2377 strbuf_complete_line(&ctx
->message
);
2378 if (!has_conforming_footer(&ctx
->message
, NULL
, 0))
2379 strbuf_addch(&ctx
->message
, '\n');
2380 strbuf_addstr(&ctx
->message
, cherry_picked_prefix
);
2381 strbuf_addstr(&ctx
->message
, oid_to_hex(&commit
->object
.oid
));
2382 strbuf_addstr(&ctx
->message
, ")\n");
2384 if (!is_fixup(command
))
2385 author
= get_author(msg
.message
);
2387 ctx
->have_message
= 1;
2389 if (command
== TODO_REWORD
)
2391 else if (is_fixup(command
)) {
2392 if (update_squash_messages(r
, command
, commit
,
2393 opts
, item
->flags
)) {
2399 msg_file
= rebase_path_squash_msg();
2400 else if (file_exists(rebase_path_fixup_msg())) {
2401 flags
|= VERBATIM_MSG
;
2402 msg_file
= rebase_path_fixup_msg();
2404 const char *dest
= git_path_squash_msg(r
);
2406 if (copy_file(dest
, rebase_path_squash_msg(), 0666)) {
2407 res
= error(_("could not copy '%s' to '%s'"),
2408 rebase_path_squash_msg(), dest
);
2411 unlink(git_path_merge_msg(r
));
2417 if (opts
->signoff
&& !is_fixup(command
))
2418 append_signoff(&ctx
->message
, 0, 0);
2420 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
2422 else if (!opts
->strategy
||
2423 !strcmp(opts
->strategy
, "recursive") ||
2424 !strcmp(opts
->strategy
, "ort") ||
2425 command
== TODO_REVERT
) {
2426 res
= do_recursive_merge(r
, base
, next
, base_label
, next_label
,
2427 &head
, &ctx
->message
, opts
);
2431 res
|= write_message(ctx
->message
.buf
, ctx
->message
.len
,
2432 git_path_merge_msg(r
), 0);
2434 struct commit_list
*common
= NULL
;
2435 struct commit_list
*remotes
= NULL
;
2437 res
= write_message(ctx
->message
.buf
, ctx
->message
.len
,
2438 git_path_merge_msg(r
), 0);
2440 commit_list_insert(base
, &common
);
2441 commit_list_insert(next
, &remotes
);
2442 res
|= try_merge_command(r
, opts
->strategy
,
2443 opts
->xopts
.nr
, opts
->xopts
.v
,
2444 common
, oid_to_hex(&head
), remotes
);
2445 free_commit_list(common
);
2446 free_commit_list(remotes
);
2450 * If the merge was clean or if it failed due to conflict, we write
2451 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
2452 * However, if the merge did not even start, then we don't want to
2455 if ((command
== TODO_PICK
|| command
== TODO_REWORD
||
2456 command
== TODO_EDIT
) && !opts
->no_commit
&&
2457 (res
== 0 || res
== 1) &&
2458 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
2459 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2461 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
2462 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
2463 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2467 error(command
== TODO_REVERT
2468 ? _("could not revert %s... %s")
2469 : _("could not apply %s... %s"),
2470 short_commit_name(r
, commit
), msg
.subject
);
2471 print_advice(r
, res
== 1, opts
);
2472 repo_rerere(r
, opts
->allow_rerere_auto
);
2477 allow
= allow_empty(r
, opts
, commit
);
2481 } else if (allow
== 1) {
2482 flags
|= ALLOW_EMPTY
;
2483 } else if (allow
== 2) {
2485 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
2486 NULL
, REF_NO_DEREF
);
2487 unlink(git_path_merge_msg(r
));
2488 refs_delete_ref(get_main_ref_store(r
), "", "AUTO_MERGE",
2489 NULL
, REF_NO_DEREF
);
2491 _("dropping %s %s -- patch contents already upstream\n"),
2492 oid_to_hex(&commit
->object
.oid
), msg
.subject
);
2493 } /* else allow == 0 and there's nothing special to do */
2494 if (!opts
->no_commit
&& !drop_commit
) {
2495 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
2496 res
= do_commit(r
, msg_file
, author
, opts
, flags
,
2497 commit
? &commit
->object
.oid
: NULL
);
2499 res
= error(_("unable to parse commit author"));
2500 *check_todo
= !!(flags
& EDIT_MSG
);
2501 if (!res
&& reword
) {
2503 res
= run_git_commit(NULL
, opts
, EDIT_MSG
|
2504 VERIFY_MSG
| AMEND_MSG
|
2505 (flags
& ALLOW_EMPTY
));
2511 if (!res
&& final_fixup
) {
2512 unlink(rebase_path_fixup_msg());
2513 unlink(rebase_path_squash_msg());
2514 unlink(rebase_path_current_fixups());
2515 strbuf_reset(&ctx
->current_fixups
);
2516 ctx
->current_fixup_count
= 0;
2520 free_message(commit
, &msg
);
2522 update_abort_safety_file();
2527 static int prepare_revs(struct replay_opts
*opts
)
2530 * picking (but not reverting) ranges (but not individual revisions)
2531 * should be done in reverse
2533 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
2534 opts
->revs
->reverse
^= 1;
2536 if (prepare_revision_walk(opts
->revs
))
2537 return error(_("revision walk setup failed"));
2542 static int read_and_refresh_cache(struct repository
*r
,
2543 struct replay_opts
*opts
)
2545 struct lock_file index_lock
= LOCK_INIT
;
2546 int index_fd
= repo_hold_locked_index(r
, &index_lock
, 0);
2547 if (repo_read_index(r
) < 0) {
2548 rollback_lock_file(&index_lock
);
2549 return error(_("git %s: failed to read the index"),
2552 refresh_index(r
->index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
2554 if (index_fd
>= 0) {
2555 if (write_locked_index(r
->index
, &index_lock
,
2556 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
2557 return error(_("git %s: failed to refresh the index"),
2563 * If we are resolving merges in any way other than "ort", then
2564 * expand the sparse index.
2566 if (opts
->strategy
&& strcmp(opts
->strategy
, "ort"))
2567 ensure_full_index(r
->index
);
2571 void todo_list_release(struct todo_list
*todo_list
)
2573 strbuf_release(&todo_list
->buf
);
2574 FREE_AND_NULL(todo_list
->items
);
2575 todo_list
->nr
= todo_list
->alloc
= 0;
2578 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
2580 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
2581 return todo_list
->items
+ todo_list
->nr
++;
2584 const char *todo_item_get_arg(struct todo_list
*todo_list
,
2585 struct todo_item
*item
)
2587 return todo_list
->buf
.buf
+ item
->arg_offset
;
2590 static int is_command(enum todo_command command
, const char **bol
)
2592 const char *str
= todo_command_info
[command
].str
;
2593 const char nick
= todo_command_info
[command
].c
;
2594 const char *p
= *bol
;
2596 return (skip_prefix(p
, str
, &p
) || (nick
&& *p
++ == nick
)) &&
2597 (*p
== ' ' || *p
== '\t' || *p
== '\n' || *p
== '\r' || !*p
) &&
2601 static int check_label_or_ref_arg(enum todo_command command
, const char *arg
)
2606 * '#' is not a valid label as the merge command uses it to
2607 * separate merge parents from the commit subject.
2609 if (!strcmp(arg
, "#") ||
2610 check_refname_format(arg
, REFNAME_ALLOW_ONELEVEL
))
2611 return error(_("'%s' is not a valid label"), arg
);
2614 case TODO_UPDATE_REF
:
2615 if (check_refname_format(arg
, REFNAME_ALLOW_ONELEVEL
))
2616 return error(_("'%s' is not a valid refname"), arg
);
2617 if (check_refname_format(arg
, 0))
2618 return error(_("update-ref requires a fully qualified "
2619 "refname e.g. refs/heads/%s"), arg
);
2623 BUG("unexpected todo_command");
2629 static int parse_insn_line(struct repository
*r
, struct todo_item
*item
,
2630 const char *buf
, const char *bol
, char *eol
)
2632 struct object_id commit_oid
;
2633 char *end_of_object_name
;
2634 int i
, saved
, status
, padding
;
2639 bol
+= strspn(bol
, " \t");
2641 if (bol
== eol
|| *bol
== '\r' || starts_with_mem(bol
, eol
- bol
, comment_line_str
)) {
2642 item
->command
= TODO_COMMENT
;
2643 item
->commit
= NULL
;
2644 item
->arg_offset
= bol
- buf
;
2645 item
->arg_len
= eol
- bol
;
2649 for (i
= 0; i
< TODO_COMMENT
; i
++)
2650 if (is_command(i
, &bol
)) {
2654 if (i
>= TODO_COMMENT
)
2655 return error(_("invalid command '%.*s'"),
2656 (int)strcspn(bol
, " \t\r\n"), bol
);
2658 /* Eat up extra spaces/ tabs before object name */
2659 padding
= strspn(bol
, " \t");
2662 if (item
->command
== TODO_NOOP
|| item
->command
== TODO_BREAK
) {
2664 return error(_("%s does not accept arguments: '%s'"),
2665 command_to_string(item
->command
), bol
);
2666 item
->commit
= NULL
;
2667 item
->arg_offset
= bol
- buf
;
2668 item
->arg_len
= eol
- bol
;
2673 return error(_("missing arguments for %s"),
2674 command_to_string(item
->command
));
2676 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
2677 item
->command
== TODO_RESET
|| item
->command
== TODO_UPDATE_REF
) {
2680 item
->commit
= NULL
;
2681 item
->arg_offset
= bol
- buf
;
2682 item
->arg_len
= (int)(eol
- bol
);
2683 if (item
->command
== TODO_LABEL
||
2684 item
->command
== TODO_UPDATE_REF
) {
2687 ret
= check_label_or_ref_arg(item
->command
, bol
);
2693 if (item
->command
== TODO_FIXUP
) {
2694 if (skip_prefix(bol
, "-C", &bol
)) {
2695 bol
+= strspn(bol
, " \t");
2696 item
->flags
|= TODO_REPLACE_FIXUP_MSG
;
2697 } else if (skip_prefix(bol
, "-c", &bol
)) {
2698 bol
+= strspn(bol
, " \t");
2699 item
->flags
|= TODO_EDIT_FIXUP_MSG
;
2703 if (item
->command
== TODO_MERGE
) {
2704 if (skip_prefix(bol
, "-C", &bol
))
2705 bol
+= strspn(bol
, " \t");
2706 else if (skip_prefix(bol
, "-c", &bol
)) {
2707 bol
+= strspn(bol
, " \t");
2708 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2710 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2711 item
->commit
= NULL
;
2712 item
->arg_offset
= bol
- buf
;
2713 item
->arg_len
= (int)(eol
- bol
);
2718 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
2719 saved
= *end_of_object_name
;
2720 *end_of_object_name
= '\0';
2721 status
= repo_get_oid(r
, bol
, &commit_oid
);
2723 error(_("could not parse '%s'"), bol
); /* return later */
2724 *end_of_object_name
= saved
;
2726 bol
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2727 item
->arg_offset
= bol
- buf
;
2728 item
->arg_len
= (int)(eol
- bol
);
2733 item
->commit
= lookup_commit_reference(r
, &commit_oid
);
2734 return item
->commit
? 0 : -1;
2737 int sequencer_get_last_command(struct repository
*r UNUSED
, enum replay_action
*action
)
2739 const char *todo_file
, *bol
;
2740 struct strbuf buf
= STRBUF_INIT
;
2743 todo_file
= git_path_todo_file();
2744 if (strbuf_read_file(&buf
, todo_file
, 0) < 0) {
2745 if (errno
== ENOENT
|| errno
== ENOTDIR
)
2748 return error_errno("unable to open '%s'", todo_file
);
2750 bol
= buf
.buf
+ strspn(buf
.buf
, " \t\r\n");
2751 if (is_command(TODO_PICK
, &bol
) && (*bol
== ' ' || *bol
== '\t'))
2752 *action
= REPLAY_PICK
;
2753 else if (is_command(TODO_REVERT
, &bol
) &&
2754 (*bol
== ' ' || *bol
== '\t'))
2755 *action
= REPLAY_REVERT
;
2759 strbuf_release(&buf
);
2764 int todo_list_parse_insn_buffer(struct repository
*r
, char *buf
,
2765 struct todo_list
*todo_list
)
2767 struct todo_item
*item
;
2768 char *p
= buf
, *next_p
;
2769 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2771 todo_list
->current
= todo_list
->nr
= todo_list
->total_nr
= 0;
2773 for (i
= 1; *p
; i
++, p
= next_p
) {
2774 char *eol
= strchrnul(p
, '\n');
2776 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2778 if (p
!= eol
&& eol
[-1] == '\r')
2779 eol
--; /* strip Carriage Return */
2781 item
= append_new_todo(todo_list
);
2782 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2783 if (parse_insn_line(r
, item
, buf
, p
, eol
)) {
2784 res
= error(_("invalid line %d: %.*s"),
2785 i
, (int)(eol
- p
), p
);
2786 item
->command
= TODO_COMMENT
+ 1;
2787 item
->arg_offset
= p
- buf
;
2788 item
->arg_len
= (int)(eol
- p
);
2789 item
->commit
= NULL
;
2792 if (item
->command
!= TODO_COMMENT
)
2793 todo_list
->total_nr
++;
2797 else if (is_fixup(item
->command
))
2798 res
= error(_("cannot '%s' without a previous commit"),
2799 command_to_string(item
->command
));
2800 else if (!is_noop(item
->command
))
2807 static int count_commands(struct todo_list
*todo_list
)
2811 for (i
= 0; i
< todo_list
->nr
; i
++)
2812 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2818 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2820 return index
< todo_list
->nr
?
2821 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2824 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2826 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2829 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2831 return get_item_line_offset(todo_list
, index
+ 1)
2832 - get_item_line_offset(todo_list
, index
);
2835 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2840 fd
= open(path
, O_RDONLY
);
2842 return error_errno(_("could not open '%s'"), path
);
2843 len
= strbuf_read(sb
, fd
, 0);
2846 return error(_("could not read '%s'."), path
);
2850 static int have_finished_the_last_pick(void)
2852 struct strbuf buf
= STRBUF_INIT
;
2854 const char *todo_path
= git_path_todo_file();
2857 if (strbuf_read_file(&buf
, todo_path
, 0) < 0) {
2858 if (errno
== ENOENT
) {
2861 error_errno("unable to open '%s'", todo_path
);
2865 /* If there is only one line then we are done */
2866 eol
= strchr(buf
.buf
, '\n');
2867 if (!eol
|| !eol
[1])
2870 strbuf_release(&buf
);
2875 void sequencer_post_commit_cleanup(struct repository
*r
, int verbose
)
2877 struct replay_opts opts
= REPLAY_OPTS_INIT
;
2878 int need_cleanup
= 0;
2880 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
2881 if (!refs_delete_ref(get_main_ref_store(r
), "",
2882 "CHERRY_PICK_HEAD", NULL
, REF_NO_DEREF
) &&
2884 warning(_("cancelling a cherry picking in progress"));
2885 opts
.action
= REPLAY_PICK
;
2889 if (refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
2890 if (!refs_delete_ref(get_main_ref_store(r
), "", "REVERT_HEAD",
2891 NULL
, REF_NO_DEREF
) &&
2893 warning(_("cancelling a revert in progress"));
2894 opts
.action
= REPLAY_REVERT
;
2898 refs_delete_ref(get_main_ref_store(r
), "", "AUTO_MERGE",
2899 NULL
, REF_NO_DEREF
);
2904 if (!have_finished_the_last_pick())
2907 sequencer_remove_state(&opts
);
2909 replay_opts_release(&opts
);
2912 static void todo_list_write_total_nr(struct todo_list
*todo_list
)
2914 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2917 fprintf(f
, "%d\n", todo_list
->total_nr
);
2922 static int read_populate_todo(struct repository
*r
,
2923 struct todo_list
*todo_list
,
2924 struct replay_opts
*opts
)
2926 const char *todo_file
= get_todo_path(opts
);
2929 strbuf_reset(&todo_list
->buf
);
2930 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2933 res
= todo_list_parse_insn_buffer(r
, todo_list
->buf
.buf
, todo_list
);
2935 if (is_rebase_i(opts
))
2936 return error(_("please fix this using "
2937 "'git rebase --edit-todo'."));
2938 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2941 if (!todo_list
->nr
&&
2942 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2943 return error(_("no commits parsed."));
2945 if (!is_rebase_i(opts
)) {
2946 enum todo_command valid
=
2947 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2950 for (i
= 0; i
< todo_list
->nr
; i
++)
2951 if (valid
== todo_list
->items
[i
].command
)
2953 else if (valid
== TODO_PICK
)
2954 return error(_("cannot cherry-pick during a revert."));
2956 return error(_("cannot revert during a cherry-pick."));
2959 if (is_rebase_i(opts
)) {
2960 struct todo_list done
= TODO_LIST_INIT
;
2962 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2963 !todo_list_parse_insn_buffer(r
, done
.buf
.buf
, &done
))
2964 todo_list
->done_nr
= count_commands(&done
);
2966 todo_list
->done_nr
= 0;
2968 todo_list
->total_nr
= todo_list
->done_nr
2969 + count_commands(todo_list
);
2970 todo_list_release(&done
);
2972 todo_list_write_total_nr(todo_list
);
2978 static int git_config_string_dup(char **dest
,
2979 const char *var
, const char *value
)
2982 return config_error_nonbool(var
);
2984 *dest
= xstrdup(value
);
2988 static int populate_opts_cb(const char *key
, const char *value
,
2989 const struct config_context
*ctx
,
2992 struct replay_opts
*opts
= data
;
2997 else if (!strcmp(key
, "options.no-commit"))
2998 opts
->no_commit
= git_config_bool_or_int(key
, value
, ctx
->kvi
, &error_flag
);
2999 else if (!strcmp(key
, "options.edit"))
3000 opts
->edit
= git_config_bool_or_int(key
, value
, ctx
->kvi
, &error_flag
);
3001 else if (!strcmp(key
, "options.allow-empty"))
3003 git_config_bool_or_int(key
, value
, ctx
->kvi
, &error_flag
);
3004 else if (!strcmp(key
, "options.allow-empty-message"))
3005 opts
->allow_empty_message
=
3006 git_config_bool_or_int(key
, value
, ctx
->kvi
, &error_flag
);
3007 else if (!strcmp(key
, "options.drop-redundant-commits"))
3008 opts
->drop_redundant_commits
=
3009 git_config_bool_or_int(key
, value
, ctx
->kvi
, &error_flag
);
3010 else if (!strcmp(key
, "options.keep-redundant-commits"))
3011 opts
->keep_redundant_commits
=
3012 git_config_bool_or_int(key
, value
, ctx
->kvi
, &error_flag
);
3013 else if (!strcmp(key
, "options.signoff"))
3014 opts
->signoff
= git_config_bool_or_int(key
, value
, ctx
->kvi
, &error_flag
);
3015 else if (!strcmp(key
, "options.record-origin"))
3016 opts
->record_origin
= git_config_bool_or_int(key
, value
, ctx
->kvi
, &error_flag
);
3017 else if (!strcmp(key
, "options.allow-ff"))
3018 opts
->allow_ff
= git_config_bool_or_int(key
, value
, ctx
->kvi
, &error_flag
);
3019 else if (!strcmp(key
, "options.mainline"))
3020 opts
->mainline
= git_config_int(key
, value
, ctx
->kvi
);
3021 else if (!strcmp(key
, "options.strategy"))
3022 git_config_string_dup(&opts
->strategy
, key
, value
);
3023 else if (!strcmp(key
, "options.gpg-sign"))
3024 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
3025 else if (!strcmp(key
, "options.strategy-option")) {
3026 strvec_push(&opts
->xopts
, value
);
3027 } else if (!strcmp(key
, "options.allow-rerere-auto"))
3028 opts
->allow_rerere_auto
=
3029 git_config_bool_or_int(key
, value
, ctx
->kvi
, &error_flag
) ?
3030 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
3031 else if (!strcmp(key
, "options.default-msg-cleanup")) {
3032 opts
->explicit_cleanup
= 1;
3033 opts
->default_msg_cleanup
= get_cleanup_mode(value
, 1);
3035 return error(_("invalid key: %s"), key
);
3038 return error(_("invalid value for '%s': '%s'"), key
, value
);
3043 static void parse_strategy_opts(struct replay_opts
*opts
, char *raw_opts
)
3048 char *strategy_opts_string
= raw_opts
;
3050 if (*strategy_opts_string
== ' ')
3051 strategy_opts_string
++;
3053 count
= split_cmdline(strategy_opts_string
, &argv
);
3055 BUG("could not split '%s': %s", strategy_opts_string
,
3056 split_cmdline_strerror(count
));
3057 for (i
= 0; i
< count
; i
++) {
3058 const char *arg
= argv
[i
];
3060 skip_prefix(arg
, "--", &arg
);
3061 strvec_push(&opts
->xopts
, arg
);
3066 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
3069 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
3071 opts
->strategy
= strbuf_detach(buf
, NULL
);
3072 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
3075 parse_strategy_opts(opts
, buf
->buf
);
3078 static int read_populate_opts(struct replay_opts
*opts
)
3080 struct replay_ctx
*ctx
= opts
->ctx
;
3082 if (is_rebase_i(opts
)) {
3083 struct strbuf buf
= STRBUF_INIT
;
3086 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(),
3087 READ_ONELINER_SKIP_IF_EMPTY
)) {
3088 if (!starts_with(buf
.buf
, "-S"))
3091 free(opts
->gpg_sign
);
3092 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
3097 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(),
3098 READ_ONELINER_SKIP_IF_EMPTY
)) {
3099 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
3100 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
3101 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
3102 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
3106 if (file_exists(rebase_path_verbose()))
3109 if (file_exists(rebase_path_quiet()))
3112 if (file_exists(rebase_path_signoff())) {
3117 if (file_exists(rebase_path_cdate_is_adate())) {
3119 opts
->committer_date_is_author_date
= 1;
3122 if (file_exists(rebase_path_ignore_date())) {
3124 opts
->ignore_date
= 1;
3127 if (file_exists(rebase_path_reschedule_failed_exec()))
3128 opts
->reschedule_failed_exec
= 1;
3129 else if (file_exists(rebase_path_no_reschedule_failed_exec()))
3130 opts
->reschedule_failed_exec
= 0;
3132 if (file_exists(rebase_path_drop_redundant_commits()))
3133 opts
->drop_redundant_commits
= 1;
3135 if (file_exists(rebase_path_keep_redundant_commits()))
3136 opts
->keep_redundant_commits
= 1;
3138 read_strategy_opts(opts
, &buf
);
3141 if (read_oneliner(&ctx
->current_fixups
,
3142 rebase_path_current_fixups(),
3143 READ_ONELINER_SKIP_IF_EMPTY
)) {
3144 const char *p
= ctx
->current_fixups
.buf
;
3145 ctx
->current_fixup_count
= 1;
3146 while ((p
= strchr(p
, '\n'))) {
3147 ctx
->current_fixup_count
++;
3152 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
3153 if (repo_get_oid_committish(the_repository
, buf
.buf
, &opts
->squash_onto
) < 0) {
3154 ret
= error(_("unusable squash-onto"));
3157 opts
->have_squash_onto
= 1;
3161 strbuf_release(&buf
);
3165 if (!file_exists(git_path_opts_file()))
3168 * The function git_parse_source(), called from git_config_from_file(),
3169 * may die() in case of a syntactically incorrect file. We do not care
3170 * about this case, though, because we wrote that file ourselves, so we
3171 * are pretty certain that it is syntactically correct.
3173 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
3174 return error(_("malformed options sheet: '%s'"),
3175 git_path_opts_file());
3179 static void write_strategy_opts(struct replay_opts
*opts
)
3181 struct strbuf buf
= STRBUF_INIT
;
3184 * Quote strategy options so that they can be read correctly
3185 * by split_cmdline().
3187 quote_cmdline(&buf
, opts
->xopts
.v
);
3188 write_file(rebase_path_strategy_opts(), "%s\n", buf
.buf
);
3189 strbuf_release(&buf
);
3192 int write_basic_state(struct replay_opts
*opts
, const char *head_name
,
3193 struct commit
*onto
, const struct object_id
*orig_head
)
3196 write_file(rebase_path_head_name(), "%s\n", head_name
);
3198 write_file(rebase_path_onto(), "%s\n",
3199 oid_to_hex(&onto
->object
.oid
));
3201 write_file(rebase_path_orig_head(), "%s\n",
3202 oid_to_hex(orig_head
));
3205 write_file(rebase_path_quiet(), "%s", "");
3207 write_file(rebase_path_verbose(), "%s", "");
3209 write_file(rebase_path_strategy(), "%s\n", opts
->strategy
);
3210 if (opts
->xopts
.nr
> 0)
3211 write_strategy_opts(opts
);
3213 if (opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
)
3214 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
3215 else if (opts
->allow_rerere_auto
== RERERE_NOAUTOUPDATE
)
3216 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
3219 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts
->gpg_sign
);
3221 write_file(rebase_path_signoff(), "--signoff\n");
3222 if (opts
->drop_redundant_commits
)
3223 write_file(rebase_path_drop_redundant_commits(), "%s", "");
3224 if (opts
->keep_redundant_commits
)
3225 write_file(rebase_path_keep_redundant_commits(), "%s", "");
3226 if (opts
->committer_date_is_author_date
)
3227 write_file(rebase_path_cdate_is_adate(), "%s", "");
3228 if (opts
->ignore_date
)
3229 write_file(rebase_path_ignore_date(), "%s", "");
3230 if (opts
->reschedule_failed_exec
)
3231 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
3233 write_file(rebase_path_no_reschedule_failed_exec(), "%s", "");
3238 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
3239 struct replay_opts
*opts
)
3241 enum todo_command command
= opts
->action
== REPLAY_PICK
?
3242 TODO_PICK
: TODO_REVERT
;
3243 const char *command_string
= todo_command_info
[command
].str
;
3244 const char *encoding
;
3245 struct commit
*commit
;
3247 if (prepare_revs(opts
))
3250 encoding
= get_log_output_encoding();
3252 while ((commit
= get_revision(opts
->revs
))) {
3253 struct todo_item
*item
= append_new_todo(todo_list
);
3254 const char *commit_buffer
= repo_logmsg_reencode(the_repository
,
3257 const char *subject
;
3260 item
->command
= command
;
3261 item
->commit
= commit
;
3262 item
->arg_offset
= 0;
3264 item
->offset_in_buf
= todo_list
->buf
.len
;
3265 subject_len
= find_commit_subject(commit_buffer
, &subject
);
3266 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
3267 short_commit_name(the_repository
, commit
),
3268 subject_len
, subject
);
3269 repo_unuse_commit_buffer(the_repository
, commit
,
3274 return error(_("empty commit set passed"));
3279 static int create_seq_dir(struct repository
*r
)
3281 enum replay_action action
;
3282 const char *in_progress_error
= NULL
;
3283 const char *in_progress_advice
= NULL
;
3284 unsigned int advise_skip
=
3285 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD") ||
3286 refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD");
3288 if (!sequencer_get_last_command(r
, &action
)) {
3291 in_progress_error
= _("revert is already in progress");
3292 in_progress_advice
=
3293 _("try \"git revert (--continue | %s--abort | --quit)\"");
3296 in_progress_error
= _("cherry-pick is already in progress");
3297 in_progress_advice
=
3298 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
3301 BUG("unexpected action in create_seq_dir");
3304 if (in_progress_error
) {
3305 error("%s", in_progress_error
);
3306 if (advice_enabled(ADVICE_SEQUENCER_IN_USE
))
3307 advise(in_progress_advice
,
3308 advise_skip
? "--skip | " : "");
3311 if (mkdir(git_path_seq_dir(), 0777) < 0)
3312 return error_errno(_("could not create sequencer directory '%s'"),
3313 git_path_seq_dir());
3318 static int save_head(const char *head
)
3320 return write_message(head
, strlen(head
), git_path_head_file(), 1);
3323 static int rollback_is_safe(void)
3325 struct strbuf sb
= STRBUF_INIT
;
3326 struct object_id expected_head
, actual_head
;
3328 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
3330 if (get_oid_hex(sb
.buf
, &expected_head
)) {
3331 strbuf_release(&sb
);
3332 die(_("could not parse %s"), git_path_abort_safety_file());
3334 strbuf_release(&sb
);
3336 else if (errno
== ENOENT
)
3337 oidclr(&expected_head
);
3339 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
3341 if (repo_get_oid(the_repository
, "HEAD", &actual_head
))
3342 oidclr(&actual_head
);
3344 return oideq(&actual_head
, &expected_head
);
3347 static int reset_merge(const struct object_id
*oid
)
3349 struct child_process cmd
= CHILD_PROCESS_INIT
;
3352 strvec_pushl(&cmd
.args
, "reset", "--merge", NULL
);
3354 if (!is_null_oid(oid
))
3355 strvec_push(&cmd
.args
, oid_to_hex(oid
));
3357 return run_command(&cmd
);
3360 static int rollback_single_pick(struct repository
*r
)
3362 struct object_id head_oid
;
3364 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
3365 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
3366 return error(_("no cherry-pick or revert in progress"));
3367 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
3368 return error(_("cannot resolve HEAD"));
3369 if (is_null_oid(&head_oid
))
3370 return error(_("cannot abort from a branch yet to be born"));
3371 return reset_merge(&head_oid
);
3374 static int skip_single_pick(void)
3376 struct object_id head
;
3378 if (read_ref_full("HEAD", 0, &head
, NULL
))
3379 return error(_("cannot resolve HEAD"));
3380 return reset_merge(&head
);
3383 int sequencer_rollback(struct repository
*r
, struct replay_opts
*opts
)
3386 struct object_id oid
;
3387 struct strbuf buf
= STRBUF_INIT
;
3390 f
= fopen(git_path_head_file(), "r");
3391 if (!f
&& errno
== ENOENT
) {
3393 * There is no multiple-cherry-pick in progress.
3394 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
3395 * a single-cherry-pick in progress, abort that.
3397 return rollback_single_pick(r
);
3400 return error_errno(_("cannot open '%s'"), git_path_head_file());
3401 if (strbuf_getline_lf(&buf
, f
)) {
3402 error(_("cannot read '%s': %s"), git_path_head_file(),
3403 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
3408 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
3409 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
3410 git_path_head_file());
3413 if (is_null_oid(&oid
)) {
3414 error(_("cannot abort from a branch yet to be born"));
3418 if (!rollback_is_safe()) {
3419 /* Do not error, just do not rollback */
3420 warning(_("You seem to have moved HEAD. "
3421 "Not rewinding, check your HEAD!"));
3423 if (reset_merge(&oid
))
3425 strbuf_release(&buf
);
3426 return sequencer_remove_state(opts
);
3428 strbuf_release(&buf
);
3432 int sequencer_skip(struct repository
*r
, struct replay_opts
*opts
)
3434 enum replay_action action
= -1;
3435 sequencer_get_last_command(r
, &action
);
3438 * Check whether the subcommand requested to skip the commit is actually
3439 * in progress and that it's safe to skip the commit.
3441 * opts->action tells us which subcommand requested to skip the commit.
3442 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
3443 * action is in progress and we can skip the commit.
3445 * Otherwise we check that the last instruction was related to the
3446 * particular subcommand we're trying to execute and barf if that's not
3449 * Finally we check that the rollback is "safe", i.e., has the HEAD
3450 * moved? In this case, it doesn't make sense to "reset the merge" and
3451 * "skip the commit" as the user already handled this by committing. But
3452 * we'd not want to barf here, instead give advice on how to proceed. We
3453 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
3454 * it gets removed when the user commits, so if it still exists we're
3455 * sure the user can't have committed before.
3457 switch (opts
->action
) {
3459 if (!refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
3460 if (action
!= REPLAY_REVERT
)
3461 return error(_("no revert in progress"));
3462 if (!rollback_is_safe())
3467 if (!refs_ref_exists(get_main_ref_store(r
),
3468 "CHERRY_PICK_HEAD")) {
3469 if (action
!= REPLAY_PICK
)
3470 return error(_("no cherry-pick in progress"));
3471 if (!rollback_is_safe())
3476 BUG("unexpected action in sequencer_skip");
3479 if (skip_single_pick())
3480 return error(_("failed to skip the commit"));
3481 if (!is_directory(git_path_seq_dir()))
3484 return sequencer_continue(r
, opts
);
3487 error(_("there is nothing to skip"));
3489 if (advice_enabled(ADVICE_RESOLVE_CONFLICT
)) {
3490 advise(_("have you committed already?\n"
3491 "try \"git %s --continue\""),
3492 action
== REPLAY_REVERT
? "revert" : "cherry-pick");
3497 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
,
3500 struct lock_file todo_lock
= LOCK_INIT
;
3501 const char *todo_path
= get_todo_path(opts
);
3502 int next
= todo_list
->current
, offset
, fd
;
3505 * rebase -i writes "git-rebase-todo" without the currently executing
3506 * command, appending it to "done" instead.
3508 if (is_rebase_i(opts
) && !reschedule
)
3511 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
3513 return error_errno(_("could not lock '%s'"), todo_path
);
3514 offset
= get_item_line_offset(todo_list
, next
);
3515 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
3516 todo_list
->buf
.len
- offset
) < 0)
3517 return error_errno(_("could not write to '%s'"), todo_path
);
3518 if (commit_lock_file(&todo_lock
) < 0)
3519 return error(_("failed to finalize '%s'"), todo_path
);
3521 if (is_rebase_i(opts
) && !reschedule
&& next
> 0) {
3522 const char *done
= rebase_path_done();
3523 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
3528 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
3529 get_item_line_length(todo_list
, next
- 1))
3531 ret
= error_errno(_("could not write to '%s'"), done
);
3533 ret
= error_errno(_("failed to finalize '%s'"), done
);
3539 static int save_opts(struct replay_opts
*opts
)
3541 const char *opts_file
= git_path_opts_file();
3544 if (opts
->no_commit
)
3545 res
|= git_config_set_in_file_gently(opts_file
,
3546 "options.no-commit", NULL
, "true");
3547 if (opts
->edit
>= 0)
3548 res
|= git_config_set_in_file_gently(opts_file
, "options.edit", NULL
,
3549 opts
->edit
? "true" : "false");
3550 if (opts
->allow_empty
)
3551 res
|= git_config_set_in_file_gently(opts_file
,
3552 "options.allow-empty", NULL
, "true");
3553 if (opts
->allow_empty_message
)
3554 res
|= git_config_set_in_file_gently(opts_file
,
3555 "options.allow-empty-message", NULL
, "true");
3556 if (opts
->drop_redundant_commits
)
3557 res
|= git_config_set_in_file_gently(opts_file
,
3558 "options.drop-redundant-commits", NULL
, "true");
3559 if (opts
->keep_redundant_commits
)
3560 res
|= git_config_set_in_file_gently(opts_file
,
3561 "options.keep-redundant-commits", NULL
, "true");
3563 res
|= git_config_set_in_file_gently(opts_file
,
3564 "options.signoff", NULL
, "true");
3565 if (opts
->record_origin
)
3566 res
|= git_config_set_in_file_gently(opts_file
,
3567 "options.record-origin", NULL
, "true");
3569 res
|= git_config_set_in_file_gently(opts_file
,
3570 "options.allow-ff", NULL
, "true");
3571 if (opts
->mainline
) {
3572 struct strbuf buf
= STRBUF_INIT
;
3573 strbuf_addf(&buf
, "%d", opts
->mainline
);
3574 res
|= git_config_set_in_file_gently(opts_file
,
3575 "options.mainline", NULL
, buf
.buf
);
3576 strbuf_release(&buf
);
3579 res
|= git_config_set_in_file_gently(opts_file
,
3580 "options.strategy", NULL
, opts
->strategy
);
3582 res
|= git_config_set_in_file_gently(opts_file
,
3583 "options.gpg-sign", NULL
, opts
->gpg_sign
);
3584 for (size_t i
= 0; i
< opts
->xopts
.nr
; i
++)
3585 res
|= git_config_set_multivar_in_file_gently(opts_file
,
3586 "options.strategy-option",
3587 opts
->xopts
.v
[i
], "^$", NULL
, 0);
3588 if (opts
->allow_rerere_auto
)
3589 res
|= git_config_set_in_file_gently(opts_file
,
3590 "options.allow-rerere-auto", NULL
,
3591 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
3594 if (opts
->explicit_cleanup
)
3595 res
|= git_config_set_in_file_gently(opts_file
,
3596 "options.default-msg-cleanup", NULL
,
3597 describe_cleanup_mode(opts
->default_msg_cleanup
));
3601 static int make_patch(struct repository
*r
,
3602 struct commit
*commit
,
3603 struct replay_opts
*opts
)
3605 struct rev_info log_tree_opt
;
3606 const char *subject
;
3607 char hex
[GIT_MAX_HEXSZ
+ 1];
3610 if (!is_rebase_i(opts
))
3611 BUG("make_patch should only be called when rebasing");
3613 oid_to_hex_r(hex
, &commit
->object
.oid
);
3614 if (write_message(hex
, strlen(hex
), rebase_path_stopped_sha(), 1) < 0)
3616 res
|= write_rebase_head(&commit
->object
.oid
);
3618 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3619 repo_init_revisions(r
, &log_tree_opt
, NULL
);
3620 log_tree_opt
.abbrev
= 0;
3621 log_tree_opt
.diff
= 1;
3622 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
3623 log_tree_opt
.disable_stdin
= 1;
3624 log_tree_opt
.no_commit_id
= 1;
3625 log_tree_opt
.diffopt
.file
= fopen(rebase_path_patch(), "w");
3626 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
3627 if (!log_tree_opt
.diffopt
.file
)
3628 res
|= error_errno(_("could not open '%s'"),
3629 rebase_path_patch());
3631 res
|= log_tree_commit(&log_tree_opt
, commit
);
3632 fclose(log_tree_opt
.diffopt
.file
);
3635 if (!file_exists(rebase_path_message())) {
3636 const char *encoding
= get_commit_output_encoding();
3637 const char *commit_buffer
= repo_logmsg_reencode(r
,
3640 find_commit_subject(commit_buffer
, &subject
);
3641 res
|= write_message(subject
, strlen(subject
), rebase_path_message(), 1);
3642 repo_unuse_commit_buffer(r
, commit
,
3645 release_revisions(&log_tree_opt
);
3650 static int intend_to_amend(void)
3652 struct object_id head
;
3655 if (repo_get_oid(the_repository
, "HEAD", &head
))
3656 return error(_("cannot read HEAD"));
3658 p
= oid_to_hex(&head
);
3659 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
3662 static int error_with_patch(struct repository
*r
,
3663 struct commit
*commit
,
3664 const char *subject
, int subject_len
,
3665 struct replay_opts
*opts
,
3666 int exit_code
, int to_amend
)
3668 struct replay_ctx
*ctx
= opts
->ctx
;
3671 * Write the commit message to be used by "git rebase
3672 * --continue". If a "fixup" or "squash" command has conflicts
3673 * then we will have already written rebase_path_message() in
3674 * error_failed_squash(). If an "edit" command was
3675 * fast-forwarded then we don't have a message in ctx->message
3676 * and rely on make_patch() to write rebase_path_message()
3679 if (ctx
->have_message
&& !file_exists(rebase_path_message()) &&
3680 write_message(ctx
->message
.buf
, ctx
->message
.len
,
3681 rebase_path_message(), 0))
3682 return error(_("could not write commit message file"));
3684 if (commit
&& make_patch(r
, commit
, opts
))
3688 if (intend_to_amend())
3692 _("You can amend the commit now, with\n"
3694 " git commit --amend %s\n"
3696 "Once you are satisfied with your changes, run\n"
3698 " git rebase --continue\n"),
3699 gpg_sign_opt_quoted(opts
));
3700 } else if (exit_code
) {
3702 fprintf_ln(stderr
, _("Could not apply %s... %.*s"),
3703 short_commit_name(r
, commit
), subject_len
, subject
);
3706 * We don't have the hash of the parent so
3707 * just print the line from the todo file.
3709 fprintf_ln(stderr
, _("Could not merge %.*s"),
3710 subject_len
, subject
);
3716 static int error_failed_squash(struct repository
*r
,
3717 struct commit
*commit
,
3718 struct replay_opts
*opts
,
3720 const char *subject
)
3722 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3723 return error(_("could not copy '%s' to '%s'"),
3724 rebase_path_squash_msg(), rebase_path_message());
3725 unlink(git_path_merge_msg(r
));
3726 if (copy_file(git_path_merge_msg(r
), rebase_path_message(), 0666))
3727 return error(_("could not copy '%s' to '%s'"),
3728 rebase_path_message(),
3729 git_path_merge_msg(r
));
3730 return error_with_patch(r
, commit
, subject
, subject_len
, opts
, 1, 0);
3733 static int do_exec(struct repository
*r
, const char *command_line
)
3735 struct child_process cmd
= CHILD_PROCESS_INIT
;
3738 fprintf(stderr
, _("Executing: %s\n"), command_line
);
3740 strvec_push(&cmd
.args
, command_line
);
3741 strvec_push(&cmd
.env
, "GIT_CHERRY_PICK_HELP");
3742 status
= run_command(&cmd
);
3744 /* force re-reading of the cache */
3745 discard_index(r
->index
);
3746 if (repo_read_index(r
) < 0)
3747 return error(_("could not read index"));
3749 dirty
= require_clean_work_tree(r
, "rebase", NULL
, 1, 1);
3752 warning(_("execution failed: %s\n%s"
3753 "You can fix the problem, and then run\n"
3755 " git rebase --continue\n"
3758 dirty
? _("and made changes to the index and/or the "
3759 "working tree.\n") : "");
3761 /* command not found */
3764 warning(_("execution succeeded: %s\nbut "
3765 "left changes to the index and/or the working tree.\n"
3766 "Commit or stash your changes, and then run\n"
3768 " git rebase --continue\n"
3769 "\n"), command_line
);
3776 __attribute__((format (printf
, 2, 3)))
3777 static int safe_append(const char *filename
, const char *fmt
, ...)
3780 struct lock_file lock
= LOCK_INIT
;
3781 int fd
= hold_lock_file_for_update(&lock
, filename
,
3782 LOCK_REPORT_ON_ERROR
);
3783 struct strbuf buf
= STRBUF_INIT
;
3788 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
3789 error_errno(_("could not read '%s'"), filename
);
3790 rollback_lock_file(&lock
);
3793 strbuf_complete(&buf
, '\n');
3795 strbuf_vaddf(&buf
, fmt
, ap
);
3798 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
3799 error_errno(_("could not write to '%s'"), filename
);
3800 strbuf_release(&buf
);
3801 rollback_lock_file(&lock
);
3804 if (commit_lock_file(&lock
) < 0) {
3805 strbuf_release(&buf
);
3806 return error(_("failed to finalize '%s'"), filename
);
3809 strbuf_release(&buf
);
3813 static int do_label(struct repository
*r
, const char *name
, int len
)
3815 struct ref_store
*refs
= get_main_ref_store(r
);
3816 struct ref_transaction
*transaction
;
3817 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
3818 struct strbuf msg
= STRBUF_INIT
;
3820 struct object_id head_oid
;
3822 if (len
== 1 && *name
== '#')
3823 return error(_("illegal label name: '%.*s'"), len
, name
);
3825 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3826 strbuf_addf(&msg
, "rebase (label) '%.*s'", len
, name
);
3828 transaction
= ref_store_transaction_begin(refs
, &err
);
3830 error("%s", err
.buf
);
3832 } else if (repo_get_oid(r
, "HEAD", &head_oid
)) {
3833 error(_("could not read HEAD"));
3835 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
3836 NULL
, 0, msg
.buf
, &err
) < 0 ||
3837 ref_transaction_commit(transaction
, &err
)) {
3838 error("%s", err
.buf
);
3841 ref_transaction_free(transaction
);
3842 strbuf_release(&err
);
3843 strbuf_release(&msg
);
3846 ret
= safe_append(rebase_path_refs_to_delete(),
3847 "%s\n", ref_name
.buf
);
3848 strbuf_release(&ref_name
);
3853 static const char *sequencer_reflog_action(struct replay_opts
*opts
)
3855 if (!opts
->reflog_action
) {
3856 opts
->reflog_action
= getenv(GIT_REFLOG_ACTION
);
3857 opts
->reflog_action
=
3858 xstrdup(opts
->reflog_action
? opts
->reflog_action
3859 : action_name(opts
));
3862 return opts
->reflog_action
;
3865 __attribute__((format (printf
, 3, 4)))
3866 static const char *reflog_message(struct replay_opts
*opts
,
3867 const char *sub_action
, const char *fmt
, ...)
3870 static struct strbuf buf
= STRBUF_INIT
;
3874 strbuf_addstr(&buf
, sequencer_reflog_action(opts
));
3876 strbuf_addf(&buf
, " (%s)", sub_action
);
3878 strbuf_addstr(&buf
, ": ");
3879 strbuf_vaddf(&buf
, fmt
, ap
);
3886 static struct commit
*lookup_label(struct repository
*r
, const char *label
,
3887 int len
, struct strbuf
*buf
)
3889 struct commit
*commit
;
3890 struct object_id oid
;
3893 strbuf_addf(buf
, "refs/rewritten/%.*s", len
, label
);
3894 if (!read_ref(buf
->buf
, &oid
)) {
3895 commit
= lookup_commit_object(r
, &oid
);
3897 /* fall back to non-rewritten ref or commit */
3898 strbuf_splice(buf
, 0, strlen("refs/rewritten/"), "", 0);
3899 commit
= lookup_commit_reference_by_name(buf
->buf
);
3903 error(_("could not resolve '%s'"), buf
->buf
);
3908 static int do_reset(struct repository
*r
,
3909 const char *name
, int len
,
3910 struct replay_opts
*opts
)
3912 struct strbuf ref_name
= STRBUF_INIT
;
3913 struct object_id oid
;
3914 struct lock_file lock
= LOCK_INIT
;
3915 struct tree_desc desc
= { 0 };
3917 struct unpack_trees_options unpack_tree_opts
= { 0 };
3920 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0)
3923 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
3924 if (!opts
->have_squash_onto
) {
3926 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
3927 NULL
, &opts
->squash_onto
,
3929 return error(_("writing fake root commit"));
3930 opts
->have_squash_onto
= 1;
3931 hex
= oid_to_hex(&opts
->squash_onto
);
3932 if (write_message(hex
, strlen(hex
),
3933 rebase_path_squash_onto(), 0))
3934 return error(_("writing squash-onto"));
3936 oidcpy(&oid
, &opts
->squash_onto
);
3939 struct commit
*commit
;
3941 /* Determine the length of the label */
3942 for (i
= 0; i
< len
; i
++)
3943 if (isspace(name
[i
]))
3947 commit
= lookup_label(r
, name
, len
, &ref_name
);
3952 oid
= commit
->object
.oid
;
3955 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
3956 unpack_tree_opts
.head_idx
= 1;
3957 unpack_tree_opts
.src_index
= r
->index
;
3958 unpack_tree_opts
.dst_index
= r
->index
;
3959 unpack_tree_opts
.fn
= oneway_merge
;
3960 unpack_tree_opts
.merge
= 1;
3961 unpack_tree_opts
.update
= 1;
3962 unpack_tree_opts
.preserve_ignored
= 0; /* FIXME: !overwrite_ignore */
3963 unpack_tree_opts
.skip_cache_tree_update
= 1;
3964 init_checkout_metadata(&unpack_tree_opts
.meta
, name
, &oid
, NULL
);
3966 if (repo_read_index_unmerged(r
)) {
3967 ret
= error_resolve_conflict(action_name(opts
));
3971 if (!fill_tree_descriptor(r
, &desc
, &oid
)) {
3972 ret
= error(_("failed to find tree of %s"), oid_to_hex(&oid
));
3976 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
3981 tree
= parse_tree_indirect(&oid
);
3983 return error(_("unable to read tree (%s)"), oid_to_hex(&oid
));
3984 prime_cache_tree(r
, r
->index
, tree
);
3986 if (write_locked_index(r
->index
, &lock
, COMMIT_LOCK
) < 0)
3987 ret
= error(_("could not write index"));
3990 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
3991 len
, name
), "HEAD", &oid
,
3992 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3994 free((void *)desc
.buffer
);
3996 rollback_lock_file(&lock
);
3997 strbuf_release(&ref_name
);
3998 clear_unpack_trees_porcelain(&unpack_tree_opts
);
4002 static int do_merge(struct repository
*r
,
4003 struct commit
*commit
,
4004 const char *arg
, int arg_len
,
4005 int flags
, int *check_todo
, struct replay_opts
*opts
)
4007 struct replay_ctx
*ctx
= opts
->ctx
;
4008 int run_commit_flags
= 0;
4009 struct strbuf ref_name
= STRBUF_INIT
;
4010 struct commit
*head_commit
, *merge_commit
, *i
;
4011 struct commit_list
*bases
= NULL
, *j
;
4012 struct commit_list
*to_merge
= NULL
, **tail
= &to_merge
;
4013 const char *strategy
= !opts
->xopts
.nr
&&
4015 !strcmp(opts
->strategy
, "recursive") ||
4016 !strcmp(opts
->strategy
, "ort")) ?
4017 NULL
: opts
->strategy
;
4018 struct merge_options o
;
4019 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
, k
;
4020 static struct lock_file lock
;
4023 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0) {
4028 head_commit
= lookup_commit_reference_by_name("HEAD");
4030 ret
= error(_("cannot merge without a current revision"));
4035 * For octopus merges, the arg starts with the list of revisions to be
4036 * merged. The list is optionally followed by '#' and the oneline.
4038 merge_arg_len
= oneline_offset
= arg_len
;
4039 for (p
= arg
; p
- arg
< arg_len
; p
+= strspn(p
, " \t\n")) {
4042 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
4043 p
+= 1 + strspn(p
+ 1, " \t\n");
4044 oneline_offset
= p
- arg
;
4047 k
= strcspn(p
, " \t\n");
4050 merge_commit
= lookup_label(r
, p
, k
, &ref_name
);
4051 if (!merge_commit
) {
4052 ret
= error(_("unable to parse '%.*s'"), k
, p
);
4055 tail
= &commit_list_insert(merge_commit
, tail
)->next
;
4057 merge_arg_len
= p
- arg
;
4061 ret
= error(_("nothing to merge: '%.*s'"), arg_len
, arg
);
4065 if (opts
->have_squash_onto
&&
4066 oideq(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
4068 * When the user tells us to "merge" something into a
4069 * "[new root]", let's simply fast-forward to the merge head.
4071 rollback_lock_file(&lock
);
4073 ret
= error(_("octopus merge cannot be executed on "
4074 "top of a [new root]"));
4076 ret
= fast_forward_to(r
, &to_merge
->item
->object
.oid
,
4077 &head_commit
->object
.oid
, 0,
4083 * If HEAD is not identical to the first parent of the original merge
4084 * commit, we cannot fast-forward.
4086 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
4087 oideq(&commit
->parents
->item
->object
.oid
,
4088 &head_commit
->object
.oid
);
4091 * If any merge head is different from the original one, we cannot
4094 if (can_fast_forward
) {
4095 struct commit_list
*p
= commit
->parents
->next
;
4097 for (j
= to_merge
; j
&& p
; j
= j
->next
, p
= p
->next
)
4098 if (!oideq(&j
->item
->object
.oid
,
4099 &p
->item
->object
.oid
)) {
4100 can_fast_forward
= 0;
4104 * If the number of merge heads differs from the original merge
4105 * commit, we cannot fast-forward.
4108 can_fast_forward
= 0;
4111 if (can_fast_forward
) {
4112 rollback_lock_file(&lock
);
4113 ret
= fast_forward_to(r
, &commit
->object
.oid
,
4114 &head_commit
->object
.oid
, 0, opts
);
4115 if (flags
& TODO_EDIT_MERGE_MSG
)
4116 goto fast_forward_edit
;
4122 const char *encoding
= get_commit_output_encoding();
4123 const char *message
= repo_logmsg_reencode(r
, commit
, NULL
,
4129 ret
= error(_("could not get commit message of '%s'"),
4130 oid_to_hex(&commit
->object
.oid
));
4133 write_author_script(message
);
4134 find_commit_subject(message
, &body
);
4136 strbuf_add(&ctx
->message
, body
, len
);
4137 repo_unuse_commit_buffer(r
, commit
, message
);
4139 struct strbuf buf
= STRBUF_INIT
;
4141 strbuf_addf(&buf
, "author %s", git_author_info(0));
4142 write_author_script(buf
.buf
);
4143 strbuf_release(&buf
);
4145 if (oneline_offset
< arg_len
) {
4146 strbuf_add(&ctx
->message
, arg
+ oneline_offset
,
4147 arg_len
- oneline_offset
);
4149 strbuf_addf(&ctx
->message
, "Merge %s '%.*s'",
4150 to_merge
->next
? "branches" : "branch",
4151 merge_arg_len
, arg
);
4154 ctx
->have_message
= 1;
4155 if (write_message(ctx
->message
.buf
, ctx
->message
.len
,
4156 git_path_merge_msg(r
), 0)) {
4157 ret
= error_errno(_("could not write '%s'"),
4158 git_path_merge_msg(r
));
4162 if (strategy
|| to_merge
->next
) {
4164 struct child_process cmd
= CHILD_PROCESS_INIT
;
4166 if (read_env_script(&cmd
.env
)) {
4167 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
4169 ret
= error(_(staged_changes_advice
), gpg_opt
, gpg_opt
);
4173 if (opts
->committer_date_is_author_date
)
4174 strvec_pushf(&cmd
.env
, "GIT_COMMITTER_DATE=%s",
4177 author_date_from_env(&cmd
.env
));
4178 if (opts
->ignore_date
)
4179 strvec_push(&cmd
.env
, "GIT_AUTHOR_DATE=");
4182 strvec_push(&cmd
.args
, "merge");
4183 strvec_push(&cmd
.args
, "-s");
4185 strvec_push(&cmd
.args
, "octopus");
4187 strvec_push(&cmd
.args
, strategy
);
4188 for (k
= 0; k
< opts
->xopts
.nr
; k
++)
4189 strvec_pushf(&cmd
.args
,
4190 "-X%s", opts
->xopts
.v
[k
]);
4192 if (!(flags
& TODO_EDIT_MERGE_MSG
))
4193 strvec_push(&cmd
.args
, "--no-edit");
4195 strvec_push(&cmd
.args
, "--edit");
4196 strvec_push(&cmd
.args
, "--no-ff");
4197 strvec_push(&cmd
.args
, "--no-log");
4198 strvec_push(&cmd
.args
, "--no-stat");
4199 strvec_push(&cmd
.args
, "-F");
4200 strvec_push(&cmd
.args
, git_path_merge_msg(r
));
4202 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
4204 strvec_push(&cmd
.args
, "--no-gpg-sign");
4206 /* Add the tips to be merged */
4207 for (j
= to_merge
; j
; j
= j
->next
)
4208 strvec_push(&cmd
.args
,
4209 oid_to_hex(&j
->item
->object
.oid
));
4211 strbuf_release(&ref_name
);
4212 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
4213 NULL
, REF_NO_DEREF
);
4214 rollback_lock_file(&lock
);
4216 ret
= run_command(&cmd
);
4218 /* force re-reading of the cache */
4220 discard_index(r
->index
);
4221 if (repo_read_index(r
) < 0)
4222 ret
= error(_("could not read index"));
4227 merge_commit
= to_merge
->item
;
4228 if (repo_get_merge_bases(r
, head_commit
, merge_commit
, &bases
) < 0) {
4233 if (bases
&& oideq(&merge_commit
->object
.oid
,
4234 &bases
->item
->object
.oid
)) {
4236 /* skip merging an ancestor of HEAD */
4240 write_message(oid_to_hex(&merge_commit
->object
.oid
), the_hash_algo
->hexsz
,
4241 git_path_merge_head(r
), 0);
4242 write_message("no-ff", 5, git_path_merge_mode(r
), 0);
4244 bases
= reverse_commit_list(bases
);
4247 init_merge_options(&o
, r
);
4249 o
.branch2
= ref_name
.buf
;
4250 o
.buffer_output
= 2;
4252 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
4254 * TODO: Should use merge_incore_recursive() and
4255 * merge_switch_to_result(), skipping the call to
4256 * merge_switch_to_result() when we don't actually need to
4257 * update the index and working copy immediately.
4259 ret
= merge_ort_recursive(&o
,
4260 head_commit
, merge_commit
, bases
,
4263 ret
= merge_recursive(&o
, head_commit
, merge_commit
, bases
,
4267 fputs(o
.obuf
.buf
, stdout
);
4268 strbuf_release(&o
.obuf
);
4270 error(_("could not even attempt to merge '%.*s'"),
4271 merge_arg_len
, arg
);
4272 unlink(git_path_merge_msg(r
));
4276 * The return value of merge_recursive() is 1 on clean, and 0 on
4279 * Let's reverse that, so that do_merge() returns 0 upon success and
4280 * 1 upon failed merge (keeping the return value -1 for the cases where
4281 * we will want to reschedule the `merge` command).
4285 if (r
->index
->cache_changed
&&
4286 write_locked_index(r
->index
, &lock
, COMMIT_LOCK
)) {
4287 ret
= error(_("merge: Unable to write new index file"));
4291 rollback_lock_file(&lock
);
4293 repo_rerere(r
, opts
->allow_rerere_auto
);
4296 * In case of problems, we now want to return a positive
4297 * value (a negative one would indicate that the `merge`
4298 * command needs to be rescheduled).
4300 ret
= !!run_git_commit(git_path_merge_msg(r
), opts
,
4303 if (!ret
&& flags
& TODO_EDIT_MERGE_MSG
) {
4306 run_commit_flags
|= AMEND_MSG
| EDIT_MSG
| VERIFY_MSG
;
4307 ret
= !!run_git_commit(NULL
, opts
, run_commit_flags
);
4312 strbuf_release(&ref_name
);
4313 rollback_lock_file(&lock
);
4314 free_commit_list(to_merge
);
4318 static int write_update_refs_state(struct string_list
*refs_to_oids
)
4321 struct lock_file lock
= LOCK_INIT
;
4323 struct string_list_item
*item
;
4326 path
= rebase_path_update_refs(the_repository
->gitdir
);
4328 if (!refs_to_oids
->nr
) {
4329 if (unlink(path
) && errno
!= ENOENT
)
4330 result
= error_errno(_("could not unlink: %s"), path
);
4334 if (safe_create_leading_directories(path
)) {
4335 result
= error(_("unable to create leading directories of %s"),
4340 if (hold_lock_file_for_update(&lock
, path
, 0) < 0) {
4341 result
= error(_("another 'rebase' process appears to be running; "
4342 "'%s.lock' already exists"),
4347 fp
= fdopen_lock_file(&lock
, "w");
4349 result
= error_errno(_("could not open '%s' for writing"), path
);
4350 rollback_lock_file(&lock
);
4354 for_each_string_list_item(item
, refs_to_oids
) {
4355 struct update_ref_record
*rec
= item
->util
;
4356 fprintf(fp
, "%s\n%s\n%s\n", item
->string
,
4357 oid_to_hex(&rec
->before
), oid_to_hex(&rec
->after
));
4360 result
= commit_lock_file(&lock
);
4368 * Parse the update-refs file for the current rebase, then remove the
4369 * refs that do not appear in the todo_list (and have not had updated
4370 * values stored) and add refs that are in the todo_list but not
4371 * represented in the update-refs file.
4373 * If there are changes to the update-refs list, then write the new state
4376 void todo_list_filter_update_refs(struct repository
*r
,
4377 struct todo_list
*todo_list
)
4381 struct string_list update_refs
= STRING_LIST_INIT_DUP
;
4383 sequencer_get_update_refs_state(r
->gitdir
, &update_refs
);
4386 * For each item in the update_refs list, if it has no updated
4387 * value and does not appear in the todo_list, then remove it
4388 * from the update_refs list.
4390 for (i
= 0; i
< update_refs
.nr
; i
++) {
4393 const char *ref
= update_refs
.items
[i
].string
;
4394 size_t reflen
= strlen(ref
);
4395 struct update_ref_record
*rec
= update_refs
.items
[i
].util
;
4397 /* OID already stored as updated. */
4398 if (!is_null_oid(&rec
->after
))
4401 for (j
= 0; !found
&& j
< todo_list
->nr
; j
++) {
4402 struct todo_item
*item
= &todo_list
->items
[j
];
4403 const char *arg
= todo_list
->buf
.buf
+ item
->arg_offset
;
4405 if (item
->command
!= TODO_UPDATE_REF
)
4408 if (item
->arg_len
!= reflen
||
4409 strncmp(arg
, ref
, reflen
))
4416 free(update_refs
.items
[i
].string
);
4417 free(update_refs
.items
[i
].util
);
4420 MOVE_ARRAY(update_refs
.items
+ i
, update_refs
.items
+ i
+ 1, update_refs
.nr
- i
);
4428 * For each todo_item, check if its ref is in the update_refs list.
4429 * If not, then add it as an un-updated ref.
4431 for (i
= 0; i
< todo_list
->nr
; i
++) {
4432 struct todo_item
*item
= &todo_list
->items
[i
];
4433 const char *arg
= todo_list
->buf
.buf
+ item
->arg_offset
;
4436 if (item
->command
!= TODO_UPDATE_REF
)
4439 for (j
= 0; !found
&& j
< update_refs
.nr
; j
++) {
4440 const char *ref
= update_refs
.items
[j
].string
;
4442 found
= strlen(ref
) == item
->arg_len
&&
4443 !strncmp(ref
, arg
, item
->arg_len
);
4447 struct string_list_item
*inserted
;
4448 struct strbuf argref
= STRBUF_INIT
;
4450 strbuf_add(&argref
, arg
, item
->arg_len
);
4451 inserted
= string_list_insert(&update_refs
, argref
.buf
);
4452 inserted
->util
= init_update_ref_record(argref
.buf
);
4453 strbuf_release(&argref
);
4459 write_update_refs_state(&update_refs
);
4460 string_list_clear(&update_refs
, 1);
4463 static int do_update_ref(struct repository
*r
, const char *refname
)
4465 struct string_list_item
*item
;
4466 struct string_list list
= STRING_LIST_INIT_DUP
;
4468 if (sequencer_get_update_refs_state(r
->gitdir
, &list
))
4471 for_each_string_list_item(item
, &list
) {
4472 if (!strcmp(item
->string
, refname
)) {
4473 struct update_ref_record
*rec
= item
->util
;
4474 if (read_ref("HEAD", &rec
->after
))
4480 write_update_refs_state(&list
);
4481 string_list_clear(&list
, 1);
4485 static int do_update_refs(struct repository
*r
, int quiet
)
4488 struct string_list_item
*item
;
4489 struct string_list refs_to_oids
= STRING_LIST_INIT_DUP
;
4490 struct ref_store
*refs
= get_main_ref_store(r
);
4491 struct strbuf update_msg
= STRBUF_INIT
;
4492 struct strbuf error_msg
= STRBUF_INIT
;
4494 if ((res
= sequencer_get_update_refs_state(r
->gitdir
, &refs_to_oids
)))
4497 for_each_string_list_item(item
, &refs_to_oids
) {
4498 struct update_ref_record
*rec
= item
->util
;
4501 loop_res
= refs_update_ref(refs
, "rewritten during rebase",
4503 &rec
->after
, &rec
->before
,
4504 0, UPDATE_REFS_MSG_ON_ERR
);
4511 strbuf_addf(&error_msg
, "\t%s\n", item
->string
);
4513 strbuf_addf(&update_msg
, "\t%s\n", item
->string
);
4517 (update_msg
.len
|| error_msg
.len
)) {
4519 _("Updated the following refs with %s:\n%s"),
4525 _("Failed to update the following refs with %s:\n%s"),
4530 string_list_clear(&refs_to_oids
, 1);
4531 strbuf_release(&update_msg
);
4532 strbuf_release(&error_msg
);
4536 static int is_final_fixup(struct todo_list
*todo_list
)
4538 int i
= todo_list
->current
;
4540 if (!is_fixup(todo_list
->items
[i
].command
))
4543 while (++i
< todo_list
->nr
)
4544 if (is_fixup(todo_list
->items
[i
].command
))
4546 else if (!is_noop(todo_list
->items
[i
].command
))
4551 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
4555 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
4556 if (!is_noop(todo_list
->items
[i
].command
))
4557 return todo_list
->items
[i
].command
;
4562 static void create_autostash_internal(struct repository
*r
,
4564 const char *refname
)
4566 struct strbuf buf
= STRBUF_INIT
;
4567 struct lock_file lock_file
= LOCK_INIT
;
4570 if (path
&& refname
)
4571 BUG("can only pass path or refname");
4573 fd
= repo_hold_locked_index(r
, &lock_file
, 0);
4574 refresh_index(r
->index
, REFRESH_QUIET
, NULL
, NULL
, NULL
);
4576 repo_update_index_if_able(r
, &lock_file
);
4577 rollback_lock_file(&lock_file
);
4579 if (has_unstaged_changes(r
, 1) ||
4580 has_uncommitted_changes(r
, 1)) {
4581 struct child_process stash
= CHILD_PROCESS_INIT
;
4582 struct reset_head_opts ropts
= { .flags
= RESET_HEAD_HARD
};
4583 struct object_id oid
;
4585 strvec_pushl(&stash
.args
,
4586 "stash", "create", "autostash", NULL
);
4590 if (capture_command(&stash
, &buf
, GIT_MAX_HEXSZ
))
4591 die(_("Cannot autostash"));
4592 strbuf_trim_trailing_newline(&buf
);
4593 if (repo_get_oid(r
, buf
.buf
, &oid
))
4594 die(_("Unexpected stash response: '%s'"),
4597 strbuf_add_unique_abbrev(&buf
, &oid
, DEFAULT_ABBREV
);
4600 if (safe_create_leading_directories_const(path
))
4601 die(_("Could not create directory for '%s'"),
4603 write_file(path
, "%s", oid_to_hex(&oid
));
4605 refs_update_ref(get_main_ref_store(r
), "", refname
,
4606 &oid
, null_oid(), 0, UPDATE_REFS_DIE_ON_ERR
);
4609 printf(_("Created autostash: %s\n"), buf
.buf
);
4610 if (reset_head(r
, &ropts
) < 0)
4611 die(_("could not reset --hard"));
4612 discard_index(r
->index
);
4613 if (repo_read_index(r
) < 0)
4614 die(_("could not read index"));
4616 strbuf_release(&buf
);
4619 void create_autostash(struct repository
*r
, const char *path
)
4621 create_autostash_internal(r
, path
, NULL
);
4624 void create_autostash_ref(struct repository
*r
, const char *refname
)
4626 create_autostash_internal(r
, NULL
, refname
);
4629 static int apply_save_autostash_oid(const char *stash_oid
, int attempt_apply
)
4631 struct child_process child
= CHILD_PROCESS_INIT
;
4634 if (attempt_apply
) {
4636 child
.no_stdout
= 1;
4637 child
.no_stderr
= 1;
4638 strvec_push(&child
.args
, "stash");
4639 strvec_push(&child
.args
, "apply");
4640 strvec_push(&child
.args
, stash_oid
);
4641 ret
= run_command(&child
);
4644 if (attempt_apply
&& !ret
)
4645 fprintf(stderr
, _("Applied autostash.\n"));
4647 struct child_process store
= CHILD_PROCESS_INIT
;
4650 strvec_push(&store
.args
, "stash");
4651 strvec_push(&store
.args
, "store");
4652 strvec_push(&store
.args
, "-m");
4653 strvec_push(&store
.args
, "autostash");
4654 strvec_push(&store
.args
, "-q");
4655 strvec_push(&store
.args
, stash_oid
);
4656 if (run_command(&store
))
4657 ret
= error(_("cannot store %s"), stash_oid
);
4661 "Your changes are safe in the stash.\n"
4662 "You can run \"git stash pop\" or"
4663 " \"git stash drop\" at any time.\n"),
4665 _("Applying autostash resulted in conflicts.") :
4666 _("Autostash exists; creating a new stash entry."));
4672 static int apply_save_autostash(const char *path
, int attempt_apply
)
4674 struct strbuf stash_oid
= STRBUF_INIT
;
4677 if (!read_oneliner(&stash_oid
, path
,
4678 READ_ONELINER_SKIP_IF_EMPTY
)) {
4679 strbuf_release(&stash_oid
);
4682 strbuf_trim(&stash_oid
);
4684 ret
= apply_save_autostash_oid(stash_oid
.buf
, attempt_apply
);
4687 strbuf_release(&stash_oid
);
4691 int save_autostash(const char *path
)
4693 return apply_save_autostash(path
, 0);
4696 int apply_autostash(const char *path
)
4698 return apply_save_autostash(path
, 1);
4701 int apply_autostash_oid(const char *stash_oid
)
4703 return apply_save_autostash_oid(stash_oid
, 1);
4706 static int apply_save_autostash_ref(struct repository
*r
, const char *refname
,
4709 struct object_id stash_oid
;
4710 char stash_oid_hex
[GIT_MAX_HEXSZ
+ 1];
4713 if (!refs_ref_exists(get_main_ref_store(r
), refname
))
4716 if (!refs_resolve_ref_unsafe(get_main_ref_store(r
), refname
,
4717 RESOLVE_REF_READING
, &stash_oid
, &flag
))
4719 if (flag
& REF_ISSYMREF
)
4720 return error(_("autostash reference is a symref"));
4722 oid_to_hex_r(stash_oid_hex
, &stash_oid
);
4723 ret
= apply_save_autostash_oid(stash_oid_hex
, attempt_apply
);
4725 refs_delete_ref(get_main_ref_store(r
), "", refname
,
4726 &stash_oid
, REF_NO_DEREF
);
4731 int save_autostash_ref(struct repository
*r
, const char *refname
)
4733 return apply_save_autostash_ref(r
, refname
, 0);
4736 int apply_autostash_ref(struct repository
*r
, const char *refname
)
4738 return apply_save_autostash_ref(r
, refname
, 1);
4741 static int checkout_onto(struct repository
*r
, struct replay_opts
*opts
,
4742 const char *onto_name
, const struct object_id
*onto
,
4743 const struct object_id
*orig_head
)
4745 struct reset_head_opts ropts
= {
4747 .orig_head
= orig_head
,
4748 .flags
= RESET_HEAD_DETACH
| RESET_ORIG_HEAD
|
4749 RESET_HEAD_RUN_POST_CHECKOUT_HOOK
,
4750 .head_msg
= reflog_message(opts
, "start", "checkout %s",
4752 .default_reflog_action
= sequencer_reflog_action(opts
)
4754 if (reset_head(r
, &ropts
)) {
4755 apply_autostash(rebase_path_autostash());
4756 sequencer_remove_state(opts
);
4757 return error(_("could not detach HEAD"));
4763 static int stopped_at_head(struct repository
*r
)
4765 struct object_id head
;
4766 struct commit
*commit
;
4767 struct commit_message message
;
4769 if (repo_get_oid(r
, "HEAD", &head
) ||
4770 !(commit
= lookup_commit(r
, &head
)) ||
4771 repo_parse_commit(r
, commit
) || get_message(commit
, &message
))
4772 fprintf(stderr
, _("Stopped at HEAD\n"));
4774 fprintf(stderr
, _("Stopped at %s\n"), message
.label
);
4775 free_message(commit
, &message
);
4781 static int reread_todo_if_changed(struct repository
*r
,
4782 struct todo_list
*todo_list
,
4783 struct replay_opts
*opts
)
4786 struct strbuf buf
= STRBUF_INIT
;
4788 if (strbuf_read_file_or_whine(&buf
, get_todo_path(opts
)) < 0)
4790 offset
= get_item_line_offset(todo_list
, todo_list
->current
+ 1);
4791 if (buf
.len
!= todo_list
->buf
.len
- offset
||
4792 memcmp(buf
.buf
, todo_list
->buf
.buf
+ offset
, buf
.len
)) {
4793 /* Reread the todo file if it has changed. */
4794 todo_list_release(todo_list
);
4795 if (read_populate_todo(r
, todo_list
, opts
))
4796 return -1; /* message was printed */
4797 /* `current` will be incremented on return */
4798 todo_list
->current
= -1;
4800 strbuf_release(&buf
);
4805 static const char rescheduled_advice
[] =
4806 N_("Could not execute the todo command\n"
4810 "It has been rescheduled; To edit the command before continuing, please\n"
4811 "edit the todo list first:\n"
4813 " git rebase --edit-todo\n"
4814 " git rebase --continue\n");
4816 static int pick_one_commit(struct repository
*r
,
4817 struct todo_list
*todo_list
,
4818 struct replay_opts
*opts
,
4819 int *check_todo
, int* reschedule
)
4821 struct replay_ctx
*ctx
= opts
->ctx
;
4823 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
4824 const char *arg
= todo_item_get_arg(todo_list
, item
);
4825 if (is_rebase_i(opts
))
4826 ctx
->reflog_message
= reflog_message(
4827 opts
, command_to_string(item
->command
), NULL
);
4829 res
= do_pick_commit(r
, item
, opts
, is_final_fixup(todo_list
),
4831 if (is_rebase_i(opts
) && res
< 0) {
4836 if (item
->command
== TODO_EDIT
) {
4837 struct commit
*commit
= item
->commit
;
4841 fprintf(stderr
, _("Stopped at %s... %.*s\n"),
4842 short_commit_name(r
, commit
), item
->arg_len
, arg
);
4844 return error_with_patch(r
, commit
,
4845 arg
, item
->arg_len
, opts
, res
, !res
);
4847 if (is_rebase_i(opts
) && !res
)
4848 record_in_rewritten(&item
->commit
->object
.oid
,
4849 peek_command(todo_list
, 1));
4850 if (res
&& is_fixup(item
->command
)) {
4853 return error_failed_squash(r
, item
->commit
, opts
,
4854 item
->arg_len
, arg
);
4855 } else if (res
&& is_rebase_i(opts
) && item
->commit
) {
4857 struct object_id oid
;
4860 * If we are rewording and have either
4861 * fast-forwarded already, or are about to
4862 * create a new root commit, we want to amend,
4863 * otherwise we do not.
4865 if (item
->command
== TODO_REWORD
&&
4866 !repo_get_oid(r
, "HEAD", &oid
) &&
4867 (oideq(&item
->commit
->object
.oid
, &oid
) ||
4868 (opts
->have_squash_onto
&&
4869 oideq(&opts
->squash_onto
, &oid
))))
4872 return res
| error_with_patch(r
, item
->commit
,
4873 arg
, item
->arg_len
, opts
,
4879 static int pick_commits(struct repository
*r
,
4880 struct todo_list
*todo_list
,
4881 struct replay_opts
*opts
)
4883 struct replay_ctx
*ctx
= opts
->ctx
;
4884 int res
= 0, reschedule
= 0;
4886 ctx
->reflog_message
= sequencer_reflog_action(opts
);
4888 assert(!(opts
->signoff
|| opts
->no_commit
||
4889 opts
->record_origin
|| should_edit(opts
) ||
4890 opts
->committer_date_is_author_date
||
4891 opts
->ignore_date
));
4892 if (read_and_refresh_cache(r
, opts
))
4895 unlink(rebase_path_message());
4896 unlink(rebase_path_stopped_sha());
4897 unlink(rebase_path_amend());
4898 unlink(rebase_path_patch());
4900 while (todo_list
->current
< todo_list
->nr
) {
4901 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
4902 const char *arg
= todo_item_get_arg(todo_list
, item
);
4905 if (save_todo(todo_list
, opts
, reschedule
))
4907 if (is_rebase_i(opts
)) {
4908 if (item
->command
!= TODO_COMMENT
) {
4909 FILE *f
= fopen(rebase_path_msgnum(), "w");
4911 todo_list
->done_nr
++;
4914 fprintf(f
, "%d\n", todo_list
->done_nr
);
4918 fprintf(stderr
, _("Rebasing (%d/%d)%s"),
4920 todo_list
->total_nr
,
4921 opts
->verbose
? "\n" : "\r");
4923 unlink(rebase_path_author_script());
4924 unlink(git_path_merge_head(r
));
4925 refs_delete_ref(get_main_ref_store(r
), "", "AUTO_MERGE",
4926 NULL
, REF_NO_DEREF
);
4927 refs_delete_ref(get_main_ref_store(r
), "", "REBASE_HEAD",
4928 NULL
, REF_NO_DEREF
);
4930 if (item
->command
== TODO_BREAK
) {
4933 return stopped_at_head(r
);
4936 strbuf_reset(&ctx
->message
);
4937 ctx
->have_message
= 0;
4938 if (item
->command
<= TODO_SQUASH
) {
4939 res
= pick_one_commit(r
, todo_list
, opts
, &check_todo
,
4941 if (!res
&& item
->command
== TODO_EDIT
)
4943 } else if (item
->command
== TODO_EXEC
) {
4944 char *end_of_arg
= (char *)(arg
+ item
->arg_len
);
4945 int saved
= *end_of_arg
;
4950 res
= do_exec(r
, arg
);
4951 *end_of_arg
= saved
;
4954 if (opts
->reschedule_failed_exec
)
4958 } else if (item
->command
== TODO_LABEL
) {
4959 if ((res
= do_label(r
, arg
, item
->arg_len
)))
4961 } else if (item
->command
== TODO_RESET
) {
4962 if ((res
= do_reset(r
, arg
, item
->arg_len
, opts
)))
4964 } else if (item
->command
== TODO_MERGE
) {
4965 if ((res
= do_merge(r
, item
->commit
, arg
, item
->arg_len
,
4966 item
->flags
, &check_todo
, opts
)) < 0)
4968 else if (item
->commit
)
4969 record_in_rewritten(&item
->commit
->object
.oid
,
4970 peek_command(todo_list
, 1));
4972 /* failed with merge conflicts */
4973 return error_with_patch(r
, item
->commit
,
4976 } else if (item
->command
== TODO_UPDATE_REF
) {
4977 struct strbuf ref
= STRBUF_INIT
;
4978 strbuf_add(&ref
, arg
, item
->arg_len
);
4979 if ((res
= do_update_ref(r
, ref
.buf
)))
4981 strbuf_release(&ref
);
4982 } else if (!is_noop(item
->command
))
4983 return error(_("unknown command %d"), item
->command
);
4986 advise(_(rescheduled_advice
),
4987 get_item_line_length(todo_list
,
4988 todo_list
->current
),
4989 get_item_line(todo_list
, todo_list
->current
));
4990 if (save_todo(todo_list
, opts
, reschedule
))
4993 write_rebase_head(&item
->commit
->object
.oid
);
4994 } else if (is_rebase_i(opts
) && check_todo
&& !res
&&
4995 reread_todo_if_changed(r
, todo_list
, opts
)) {
5002 todo_list
->current
++;
5005 if (is_rebase_i(opts
)) {
5006 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
5009 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
5010 starts_with(head_ref
.buf
, "refs/")) {
5012 struct object_id head
, orig
;
5015 if (repo_get_oid(r
, "HEAD", &head
)) {
5016 res
= error(_("cannot read HEAD"));
5018 strbuf_release(&head_ref
);
5019 strbuf_release(&buf
);
5022 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
5023 get_oid_hex(buf
.buf
, &orig
)) {
5024 res
= error(_("could not read orig-head"));
5025 goto cleanup_head_ref
;
5028 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
5029 res
= error(_("could not read 'onto'"));
5030 goto cleanup_head_ref
;
5032 msg
= reflog_message(opts
, "finish", "%s onto %s",
5033 head_ref
.buf
, buf
.buf
);
5034 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
5035 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
5036 res
= error(_("could not update %s"),
5038 goto cleanup_head_ref
;
5040 msg
= reflog_message(opts
, "finish", "returning to %s",
5042 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
5043 res
= error(_("could not update HEAD to %s"),
5045 goto cleanup_head_ref
;
5050 if (opts
->verbose
) {
5051 struct rev_info log_tree_opt
;
5052 struct object_id orig
, head
;
5054 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
5055 repo_init_revisions(r
, &log_tree_opt
, NULL
);
5056 log_tree_opt
.diff
= 1;
5057 log_tree_opt
.diffopt
.output_format
=
5058 DIFF_FORMAT_DIFFSTAT
;
5059 log_tree_opt
.disable_stdin
= 1;
5061 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
5062 !repo_get_oid(r
, buf
.buf
, &orig
) &&
5063 !repo_get_oid(r
, "HEAD", &head
)) {
5064 diff_tree_oid(&orig
, &head
, "",
5065 &log_tree_opt
.diffopt
);
5066 log_tree_diff_flush(&log_tree_opt
);
5068 release_revisions(&log_tree_opt
);
5070 flush_rewritten_pending();
5071 if (!stat(rebase_path_rewritten_list(), &st
) &&
5073 struct child_process child
= CHILD_PROCESS_INIT
;
5074 struct run_hooks_opt hook_opt
= RUN_HOOKS_OPT_INIT
;
5076 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
5078 strvec_push(&child
.args
, "notes");
5079 strvec_push(&child
.args
, "copy");
5080 strvec_push(&child
.args
, "--for-rewrite=rebase");
5081 /* we don't care if this copying failed */
5082 run_command(&child
);
5084 hook_opt
.path_to_stdin
= rebase_path_rewritten_list();
5085 strvec_push(&hook_opt
.args
, "rebase");
5086 run_hooks_opt("post-rewrite", &hook_opt
);
5088 apply_autostash(rebase_path_autostash());
5094 _("Successfully rebased and updated %s.\n"),
5098 strbuf_release(&buf
);
5099 strbuf_release(&head_ref
);
5101 if (do_update_refs(r
, opts
->quiet
))
5106 * Sequence of picks finished successfully; cleanup by
5107 * removing the .git/sequencer directory
5109 return sequencer_remove_state(opts
);
5112 static int continue_single_pick(struct repository
*r
, struct replay_opts
*opts
)
5114 struct child_process cmd
= CHILD_PROCESS_INIT
;
5116 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
5117 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
5118 return error(_("no cherry-pick or revert in progress"));
5121 strvec_push(&cmd
.args
, "commit");
5124 * continue_single_pick() handles the case of recovering from a
5125 * conflict. should_edit() doesn't handle that case; for a conflict,
5126 * we want to edit if the user asked for it, or if they didn't specify
5127 * and stdin is a tty.
5129 if (!opts
->edit
|| (opts
->edit
< 0 && !isatty(0)))
5131 * Include --cleanup=strip as well because we don't want the
5132 * "# Conflicts:" messages.
5134 strvec_pushl(&cmd
.args
, "--no-edit", "--cleanup=strip", NULL
);
5136 return run_command(&cmd
);
5139 static int commit_staged_changes(struct repository
*r
,
5140 struct replay_opts
*opts
,
5141 struct todo_list
*todo_list
)
5143 struct replay_ctx
*ctx
= opts
->ctx
;
5144 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
5145 unsigned int final_fixup
= 0, is_clean
;
5147 if (has_unstaged_changes(r
, 1))
5148 return error(_("cannot rebase: You have unstaged changes."));
5150 is_clean
= !has_uncommitted_changes(r
, 0);
5152 if (!is_clean
&& !file_exists(rebase_path_message())) {
5153 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
5155 return error(_(staged_changes_advice
), gpg_opt
, gpg_opt
);
5157 if (file_exists(rebase_path_amend())) {
5158 struct strbuf rev
= STRBUF_INIT
;
5159 struct object_id head
, to_amend
;
5161 if (repo_get_oid(r
, "HEAD", &head
))
5162 return error(_("cannot amend non-existing commit"));
5163 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
5164 return error(_("invalid file: '%s'"), rebase_path_amend());
5165 if (get_oid_hex(rev
.buf
, &to_amend
))
5166 return error(_("invalid contents: '%s'"),
5167 rebase_path_amend());
5168 if (!is_clean
&& !oideq(&head
, &to_amend
))
5169 return error(_("\nYou have uncommitted changes in your "
5170 "working tree. Please, commit them\n"
5171 "first and then run 'git rebase "
5172 "--continue' again."));
5174 * When skipping a failed fixup/squash, we need to edit the
5175 * commit message, the current fixup list and count, and if it
5176 * was the last fixup/squash in the chain, we need to clean up
5177 * the commit message and if there was a squash, let the user
5180 if (!is_clean
|| !ctx
->current_fixup_count
)
5181 ; /* this is not the final fixup */
5182 else if (!oideq(&head
, &to_amend
) ||
5183 !file_exists(rebase_path_stopped_sha())) {
5184 /* was a final fixup or squash done manually? */
5185 if (!is_fixup(peek_command(todo_list
, 0))) {
5186 unlink(rebase_path_fixup_msg());
5187 unlink(rebase_path_squash_msg());
5188 unlink(rebase_path_current_fixups());
5189 strbuf_reset(&ctx
->current_fixups
);
5190 ctx
->current_fixup_count
= 0;
5193 /* we are in a fixup/squash chain */
5194 const char *p
= ctx
->current_fixups
.buf
;
5195 int len
= ctx
->current_fixups
.len
;
5197 ctx
->current_fixup_count
--;
5199 BUG("Incorrect current_fixups:\n%s", p
);
5200 while (len
&& p
[len
- 1] != '\n')
5202 strbuf_setlen(&ctx
->current_fixups
, len
);
5203 if (write_message(p
, len
, rebase_path_current_fixups(),
5205 return error(_("could not write file: '%s'"),
5206 rebase_path_current_fixups());
5209 * If a fixup/squash in a fixup/squash chain failed, the
5210 * commit message is already correct, no need to commit
5213 * Only if it is the final command in the fixup/squash
5214 * chain, and only if the chain is longer than a single
5215 * fixup/squash command (which was just skipped), do we
5216 * actually need to re-commit with a cleaned up commit
5219 if (ctx
->current_fixup_count
> 0 &&
5220 !is_fixup(peek_command(todo_list
, 0))) {
5223 * If there was not a single "squash" in the
5224 * chain, we only need to clean up the commit
5225 * message, no need to bother the user with
5226 * opening the commit message in the editor.
5228 if (!starts_with(p
, "squash ") &&
5229 !strstr(p
, "\nsquash "))
5230 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
5231 } else if (is_fixup(peek_command(todo_list
, 0))) {
5233 * We need to update the squash message to skip
5234 * the latest commit message.
5237 struct commit
*commit
;
5239 const char *path
= rebase_path_squash_msg();
5240 const char *encoding
= get_commit_output_encoding();
5242 if (parse_head(r
, &commit
))
5243 return error(_("could not parse HEAD"));
5245 p
= repo_logmsg_reencode(r
, commit
, NULL
, encoding
);
5247 res
= error(_("could not parse commit %s"),
5248 oid_to_hex(&commit
->object
.oid
));
5249 goto unuse_commit_buffer
;
5251 find_commit_subject(p
, &msg
);
5252 if (write_message(msg
, strlen(msg
), path
, 0)) {
5253 res
= error(_("could not write file: "
5255 goto unuse_commit_buffer
;
5257 unuse_commit_buffer
:
5258 repo_unuse_commit_buffer(r
, commit
, p
);
5264 strbuf_release(&rev
);
5269 if (refs_ref_exists(get_main_ref_store(r
),
5270 "CHERRY_PICK_HEAD") &&
5271 refs_delete_ref(get_main_ref_store(r
), "",
5272 "CHERRY_PICK_HEAD", NULL
, REF_NO_DEREF
))
5273 return error(_("could not remove CHERRY_PICK_HEAD"));
5274 if (unlink(git_path_merge_msg(r
)) && errno
!= ENOENT
)
5275 return error_errno(_("could not remove '%s'"),
5276 git_path_merge_msg(r
));
5281 if (run_git_commit(final_fixup
? NULL
: rebase_path_message(),
5283 return error(_("could not commit staged changes."));
5284 unlink(rebase_path_amend());
5285 unlink(git_path_merge_head(r
));
5286 refs_delete_ref(get_main_ref_store(r
), "", "AUTO_MERGE",
5287 NULL
, REF_NO_DEREF
);
5289 unlink(rebase_path_fixup_msg());
5290 unlink(rebase_path_squash_msg());
5292 if (ctx
->current_fixup_count
> 0) {
5294 * Whether final fixup or not, we just cleaned up the commit
5297 unlink(rebase_path_current_fixups());
5298 strbuf_reset(&ctx
->current_fixups
);
5299 ctx
->current_fixup_count
= 0;
5304 int sequencer_continue(struct repository
*r
, struct replay_opts
*opts
)
5306 struct replay_ctx
*ctx
= opts
->ctx
;
5307 struct todo_list todo_list
= TODO_LIST_INIT
;
5310 if (read_and_refresh_cache(r
, opts
))
5313 if (read_populate_opts(opts
))
5315 if (is_rebase_i(opts
)) {
5316 if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
5317 goto release_todo_list
;
5319 if (file_exists(rebase_path_dropped())) {
5320 if ((res
= todo_list_check_against_backup(r
, &todo_list
)))
5321 goto release_todo_list
;
5323 unlink(rebase_path_dropped());
5326 ctx
->reflog_message
= reflog_message(opts
, "continue", NULL
);
5327 if (commit_staged_changes(r
, opts
, &todo_list
)) {
5329 goto release_todo_list
;
5331 } else if (!file_exists(get_todo_path(opts
)))
5332 return continue_single_pick(r
, opts
);
5333 else if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
5334 goto release_todo_list
;
5336 if (!is_rebase_i(opts
)) {
5337 /* Verify that the conflict has been resolved */
5338 if (refs_ref_exists(get_main_ref_store(r
),
5339 "CHERRY_PICK_HEAD") ||
5340 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
5341 res
= continue_single_pick(r
, opts
);
5343 goto release_todo_list
;
5345 if (index_differs_from(r
, "HEAD", NULL
, 0)) {
5346 res
= error_dirty_index(r
, opts
);
5347 goto release_todo_list
;
5349 todo_list
.current
++;
5350 } else if (file_exists(rebase_path_stopped_sha())) {
5351 struct strbuf buf
= STRBUF_INIT
;
5352 struct object_id oid
;
5354 if (read_oneliner(&buf
, rebase_path_stopped_sha(),
5355 READ_ONELINER_SKIP_IF_EMPTY
) &&
5356 !get_oid_hex(buf
.buf
, &oid
))
5357 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
5358 strbuf_release(&buf
);
5361 res
= pick_commits(r
, &todo_list
, opts
);
5363 todo_list_release(&todo_list
);
5367 static int single_pick(struct repository
*r
,
5368 struct commit
*cmit
,
5369 struct replay_opts
*opts
)
5372 struct todo_item item
;
5374 item
.command
= opts
->action
== REPLAY_PICK
?
5375 TODO_PICK
: TODO_REVERT
;
5378 opts
->ctx
->reflog_message
= sequencer_reflog_action(opts
);
5379 return do_pick_commit(r
, &item
, opts
, 0, &check_todo
);
5382 int sequencer_pick_revisions(struct repository
*r
,
5383 struct replay_opts
*opts
)
5385 struct todo_list todo_list
= TODO_LIST_INIT
;
5386 struct object_id oid
;
5390 if (read_and_refresh_cache(r
, opts
))
5393 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
5394 struct object_id oid
;
5395 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
5397 /* This happens when using --stdin. */
5401 if (!repo_get_oid(r
, name
, &oid
)) {
5402 if (!lookup_commit_reference_gently(r
, &oid
, 1)) {
5403 enum object_type type
= oid_object_info(r
,
5406 return error(_("%s: can't cherry-pick a %s"),
5407 name
, type_name(type
));
5410 return error(_("%s: bad revision"), name
);
5414 * If we were called as "git cherry-pick <commit>", just
5415 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
5416 * REVERT_HEAD, and don't touch the sequencer state.
5417 * This means it is possible to cherry-pick in the middle
5418 * of a cherry-pick sequence.
5420 if (opts
->revs
->cmdline
.nr
== 1 &&
5421 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
5422 opts
->revs
->no_walk
&&
5423 !opts
->revs
->cmdline
.rev
->flags
) {
5424 struct commit
*cmit
;
5425 if (prepare_revision_walk(opts
->revs
))
5426 return error(_("revision walk setup failed"));
5427 cmit
= get_revision(opts
->revs
);
5429 return error(_("empty commit set passed"));
5430 if (get_revision(opts
->revs
))
5431 BUG("unexpected extra commit from walk");
5432 return single_pick(r
, cmit
, opts
);
5436 * Start a new cherry-pick/ revert sequence; but
5437 * first, make sure that an existing one isn't in
5441 if (walk_revs_populate_todo(&todo_list
, opts
) ||
5442 create_seq_dir(r
) < 0)
5444 if (repo_get_oid(r
, "HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
5445 return error(_("can't revert as initial commit"));
5446 if (save_head(oid_to_hex(&oid
)))
5448 if (save_opts(opts
))
5450 update_abort_safety_file();
5451 res
= pick_commits(r
, &todo_list
, opts
);
5452 todo_list_release(&todo_list
);
5456 void append_signoff(struct strbuf
*msgbuf
, size_t ignore_footer
, unsigned flag
)
5458 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
5459 struct strbuf sob
= STRBUF_INIT
;
5462 strbuf_addstr(&sob
, sign_off_header
);
5463 strbuf_addstr(&sob
, fmt_name(WANT_COMMITTER_IDENT
));
5464 strbuf_addch(&sob
, '\n');
5467 strbuf_complete_line(msgbuf
);
5470 * If the whole message buffer is equal to the sob, pretend that we
5471 * found a conforming footer with a matching sob
5473 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
5474 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
5477 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
5480 const char *append_newlines
= NULL
;
5481 size_t len
= msgbuf
->len
- ignore_footer
;
5485 * The buffer is completely empty. Leave foom for
5486 * the title and body to be filled in by the user.
5488 append_newlines
= "\n\n";
5489 } else if (len
== 1) {
5491 * Buffer contains a single newline. Add another
5492 * so that we leave room for the title and body.
5494 append_newlines
= "\n";
5495 } else if (msgbuf
->buf
[len
- 2] != '\n') {
5497 * Buffer ends with a single newline. Add another
5498 * so that there is an empty line between the message
5501 append_newlines
= "\n";
5502 } /* else, the buffer already ends with two newlines. */
5504 if (append_newlines
)
5505 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
5506 append_newlines
, strlen(append_newlines
));
5509 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
5510 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
5513 strbuf_release(&sob
);
5516 struct labels_entry
{
5517 struct hashmap_entry entry
;
5518 char label
[FLEX_ARRAY
];
5521 static int labels_cmp(const void *fndata UNUSED
,
5522 const struct hashmap_entry
*eptr
,
5523 const struct hashmap_entry
*entry_or_key
, const void *key
)
5525 const struct labels_entry
*a
, *b
;
5527 a
= container_of(eptr
, const struct labels_entry
, entry
);
5528 b
= container_of(entry_or_key
, const struct labels_entry
, entry
);
5530 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
5533 struct string_entry
{
5534 struct oidmap_entry entry
;
5535 char string
[FLEX_ARRAY
];
5538 struct label_state
{
5539 struct oidmap commit2label
;
5540 struct hashmap labels
;
5542 int max_label_length
;
5545 static const char *label_oid(struct object_id
*oid
, const char *label
,
5546 struct label_state
*state
)
5548 struct labels_entry
*labels_entry
;
5549 struct string_entry
*string_entry
;
5550 struct object_id dummy
;
5553 string_entry
= oidmap_get(&state
->commit2label
, oid
);
5555 return string_entry
->string
;
5558 * For "uninteresting" commits, i.e. commits that are not to be
5559 * rebased, and which can therefore not be labeled, we use a unique
5560 * abbreviation of the commit name. This is slightly more complicated
5561 * than calling repo_find_unique_abbrev() because we also need to make
5562 * sure that the abbreviation does not conflict with any other
5565 * We disallow "interesting" commits to be labeled by a string that
5566 * is a valid full-length hash, to ensure that we always can find an
5567 * abbreviation for any uninteresting commit's names that does not
5568 * clash with any other label.
5570 strbuf_reset(&state
->buf
);
5574 strbuf_grow(&state
->buf
, GIT_MAX_HEXSZ
);
5575 label
= p
= state
->buf
.buf
;
5577 repo_find_unique_abbrev_r(the_repository
, p
, oid
,
5581 * We may need to extend the abbreviated hash so that there is
5582 * no conflicting label.
5584 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
5585 size_t i
= strlen(p
) + 1;
5587 oid_to_hex_r(p
, oid
);
5588 for (; i
< the_hash_algo
->hexsz
; i
++) {
5591 if (!hashmap_get_from_hash(&state
->labels
,
5598 struct strbuf
*buf
= &state
->buf
;
5599 int label_is_utf8
= 1; /* start with this assumption */
5600 size_t max_len
= buf
->len
+ state
->max_label_length
;
5603 * Sanitize labels by replacing non-alpha-numeric characters
5604 * (including white-space ones) by dashes, as they might be
5605 * illegal in file names (and hence in ref names).
5607 * Note that we retain non-ASCII UTF-8 characters (identified
5608 * via the most significant bit). They should be all acceptable
5611 * As we will use the labels as names of (loose) refs, it is
5612 * vital that the name not be longer than the maximum component
5613 * size of the file system (`NAME_MAX`). We are careful to
5614 * truncate the label accordingly, allowing for the `.lock`
5615 * suffix and for the label to be UTF-8 encoded (i.e. we avoid
5616 * truncating in the middle of a character).
5618 for (; *label
&& buf
->len
+ 1 < max_len
; label
++)
5619 if (isalnum(*label
) ||
5620 (!label_is_utf8
&& (*label
& 0x80)))
5621 strbuf_addch(buf
, *label
);
5622 else if (*label
& 0x80) {
5623 const char *p
= label
;
5625 utf8_width(&p
, NULL
);
5627 if (buf
->len
+ (p
- label
) > max_len
)
5629 strbuf_add(buf
, label
, p
- label
);
5633 strbuf_addch(buf
, *label
);
5635 /* avoid leading dash and double-dashes */
5636 } else if (buf
->len
&& buf
->buf
[buf
->len
- 1] != '-')
5637 strbuf_addch(buf
, '-');
5639 strbuf_addstr(buf
, "rev-");
5640 strbuf_add_unique_abbrev(buf
, oid
, default_abbrev
);
5644 if ((buf
->len
== the_hash_algo
->hexsz
&&
5645 !get_oid_hex(label
, &dummy
)) ||
5646 (buf
->len
== 1 && *label
== '#') ||
5647 hashmap_get_from_hash(&state
->labels
,
5648 strihash(label
), label
)) {
5650 * If the label already exists, or if the label is a
5651 * valid full OID, or the label is a '#' (which we use
5652 * as a separator between merge heads and oneline), we
5653 * append a dash and a number to make it unique.
5655 size_t len
= buf
->len
;
5657 for (i
= 2; ; i
++) {
5658 strbuf_setlen(buf
, len
);
5659 strbuf_addf(buf
, "-%d", i
);
5660 if (!hashmap_get_from_hash(&state
->labels
,
5670 FLEX_ALLOC_STR(labels_entry
, label
, label
);
5671 hashmap_entry_init(&labels_entry
->entry
, strihash(label
));
5672 hashmap_add(&state
->labels
, &labels_entry
->entry
);
5674 FLEX_ALLOC_STR(string_entry
, string
, label
);
5675 oidcpy(&string_entry
->entry
.oid
, oid
);
5676 oidmap_put(&state
->commit2label
, string_entry
);
5678 return string_entry
->string
;
5681 static int make_script_with_merges(struct pretty_print_context
*pp
,
5682 struct rev_info
*revs
, struct strbuf
*out
,
5685 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5686 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
5687 int root_with_onto
= flags
& TODO_LIST_ROOT_WITH_ONTO
;
5688 int skipped_commit
= 0;
5689 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
5690 struct strbuf label
= STRBUF_INIT
;
5691 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
5692 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
5693 struct commit
*commit
;
5694 struct oidmap commit2todo
= OIDMAP_INIT
;
5695 struct string_entry
*entry
;
5696 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
5697 shown
= OIDSET_INIT
;
5698 struct label_state state
=
5699 { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
, GIT_MAX_LABEL_LENGTH
};
5701 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
5702 const char *cmd_pick
= abbr
? "p" : "pick",
5703 *cmd_label
= abbr
? "l" : "label",
5704 *cmd_reset
= abbr
? "t" : "reset",
5705 *cmd_merge
= abbr
? "m" : "merge";
5707 git_config_get_int("rebase.maxlabellength", &state
.max_label_length
);
5709 oidmap_init(&commit2todo
, 0);
5710 oidmap_init(&state
.commit2label
, 0);
5711 hashmap_init(&state
.labels
, labels_cmp
, NULL
, 0);
5712 strbuf_init(&state
.buf
, 32);
5714 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
5715 struct labels_entry
*onto_label_entry
;
5716 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
5717 FLEX_ALLOC_STR(entry
, string
, "onto");
5718 oidcpy(&entry
->entry
.oid
, oid
);
5719 oidmap_put(&state
.commit2label
, entry
);
5721 FLEX_ALLOC_STR(onto_label_entry
, label
, "onto");
5722 hashmap_entry_init(&onto_label_entry
->entry
, strihash("onto"));
5723 hashmap_add(&state
.labels
, &onto_label_entry
->entry
);
5728 * - get onelines for all commits
5729 * - gather all branch tips (i.e. 2nd or later parents of merges)
5730 * - label all branch tips
5732 while ((commit
= get_revision(revs
))) {
5733 struct commit_list
*to_merge
;
5734 const char *p1
, *p2
;
5735 struct object_id
*oid
;
5738 tail
= &commit_list_insert(commit
, tail
)->next
;
5739 oidset_insert(&interesting
, &commit
->object
.oid
);
5741 is_empty
= is_original_commit_empty(commit
);
5742 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5743 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5744 warning(_("skipped previously applied commit %s"),
5745 short_commit_name(the_repository
, commit
));
5749 if (is_empty
&& !keep_empty
)
5752 strbuf_reset(&oneline
);
5753 pretty_print_commit(pp
, commit
, &oneline
);
5755 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
5757 /* non-merge commit: easy case */
5759 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
5760 oid_to_hex(&commit
->object
.oid
),
5763 strbuf_addf(&buf
, " %s empty",
5766 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5767 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5768 oidmap_put(&commit2todo
, entry
);
5773 /* Create a label */
5774 strbuf_reset(&label
);
5775 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
5776 (p1
= strchr(p1
, '\'')) &&
5777 (p2
= strchr(++p1
, '\'')))
5778 strbuf_add(&label
, p1
, p2
- p1
);
5779 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
5781 (p1
= strstr(p1
, " from ")))
5782 strbuf_addstr(&label
, p1
+ strlen(" from "));
5784 strbuf_addbuf(&label
, &oneline
);
5787 strbuf_addf(&buf
, "%s -C %s",
5788 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
5790 /* label the tips of merged branches */
5791 for (; to_merge
; to_merge
= to_merge
->next
) {
5792 oid
= &to_merge
->item
->object
.oid
;
5793 strbuf_addch(&buf
, ' ');
5795 if (!oidset_contains(&interesting
, oid
)) {
5796 strbuf_addstr(&buf
, label_oid(oid
, NULL
,
5801 tips_tail
= &commit_list_insert(to_merge
->item
,
5804 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
5806 strbuf_addf(&buf
, " # %s", oneline
.buf
);
5808 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5809 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5810 oidmap_put(&commit2todo
, entry
);
5813 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5814 _("use --reapply-cherry-picks to include skipped commits"));
5818 * - label branch points
5819 * - add HEAD to the branch tips
5821 for (iter
= commits
; iter
; iter
= iter
->next
) {
5822 struct commit_list
*parent
= iter
->item
->parents
;
5823 for (; parent
; parent
= parent
->next
) {
5824 struct object_id
*oid
= &parent
->item
->object
.oid
;
5825 if (!oidset_contains(&interesting
, oid
))
5827 if (oidset_insert(&child_seen
, oid
))
5828 label_oid(oid
, "branch-point", &state
);
5831 /* Add HEAD as implicit "tip of branch" */
5833 tips_tail
= &commit_list_insert(iter
->item
,
5838 * Third phase: output the todo list. This is a bit tricky, as we
5839 * want to avoid jumping back and forth between revisions. To
5840 * accomplish that goal, we walk backwards from the branch tips,
5841 * gathering commits not yet shown, reversing the list on the fly,
5842 * then outputting that list (labeling revisions as needed).
5844 strbuf_addf(out
, "%s onto\n", cmd_label
);
5845 for (iter
= tips
; iter
; iter
= iter
->next
) {
5846 struct commit_list
*list
= NULL
, *iter2
;
5848 commit
= iter
->item
;
5849 if (oidset_contains(&shown
, &commit
->object
.oid
))
5851 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
5854 strbuf_addf(out
, "\n%s Branch %s\n", comment_line_str
, entry
->string
);
5856 strbuf_addch(out
, '\n');
5858 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
5859 !oidset_contains(&shown
, &commit
->object
.oid
)) {
5860 commit_list_insert(commit
, &list
);
5861 if (!commit
->parents
) {
5865 commit
= commit
->parents
->item
;
5869 strbuf_addf(out
, "%s %s\n", cmd_reset
,
5870 rebase_cousins
|| root_with_onto
?
5871 "onto" : "[new root]");
5873 const char *to
= NULL
;
5875 entry
= oidmap_get(&state
.commit2label
,
5876 &commit
->object
.oid
);
5879 else if (!rebase_cousins
)
5880 to
= label_oid(&commit
->object
.oid
, NULL
,
5883 if (!to
|| !strcmp(to
, "onto"))
5884 strbuf_addf(out
, "%s onto\n", cmd_reset
);
5886 strbuf_reset(&oneline
);
5887 pretty_print_commit(pp
, commit
, &oneline
);
5888 strbuf_addf(out
, "%s %s # %s\n",
5889 cmd_reset
, to
, oneline
.buf
);
5893 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
5894 struct object_id
*oid
= &iter2
->item
->object
.oid
;
5895 entry
= oidmap_get(&commit2todo
, oid
);
5896 /* only show if not already upstream */
5898 strbuf_addf(out
, "%s\n", entry
->string
);
5899 entry
= oidmap_get(&state
.commit2label
, oid
);
5901 strbuf_addf(out
, "%s %s\n",
5902 cmd_label
, entry
->string
);
5903 oidset_insert(&shown
, oid
);
5906 free_commit_list(list
);
5909 free_commit_list(commits
);
5910 free_commit_list(tips
);
5912 strbuf_release(&label
);
5913 strbuf_release(&oneline
);
5914 strbuf_release(&buf
);
5916 oidmap_free(&commit2todo
, 1);
5917 oidmap_free(&state
.commit2label
, 1);
5918 hashmap_clear_and_free(&state
.labels
, struct labels_entry
, entry
);
5919 strbuf_release(&state
.buf
);
5924 int sequencer_make_script(struct repository
*r
, struct strbuf
*out
, int argc
,
5925 const char **argv
, unsigned flags
)
5927 char *format
= NULL
;
5928 struct pretty_print_context pp
= {0};
5929 struct rev_info revs
;
5930 struct commit
*commit
;
5931 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5932 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
5933 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
5934 int reapply_cherry_picks
= flags
& TODO_LIST_REAPPLY_CHERRY_PICKS
;
5935 int skipped_commit
= 0;
5938 repo_init_revisions(r
, &revs
, NULL
);
5939 revs
.verbose_header
= 1;
5941 revs
.max_parents
= 1;
5942 revs
.cherry_mark
= !reapply_cherry_picks
;
5945 revs
.right_only
= 1;
5946 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
5947 revs
.topo_order
= 1;
5949 revs
.pretty_given
= 1;
5950 git_config_get_string("rebase.instructionFormat", &format
);
5951 if (!format
|| !*format
) {
5953 format
= xstrdup("%s");
5955 get_commit_format(format
, &revs
);
5957 pp
.fmt
= revs
.commit_format
;
5958 pp
.output_encoding
= get_log_output_encoding();
5960 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1) {
5961 ret
= error(_("make_script: unhandled options"));
5965 if (prepare_revision_walk(&revs
) < 0) {
5966 ret
= error(_("make_script: error preparing revisions"));
5970 if (rebase_merges
) {
5971 ret
= make_script_with_merges(&pp
, &revs
, out
, flags
);
5975 while ((commit
= get_revision(&revs
))) {
5976 int is_empty
= is_original_commit_empty(commit
);
5978 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5979 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5980 warning(_("skipped previously applied commit %s"),
5981 short_commit_name(r
, commit
));
5985 if (is_empty
&& !keep_empty
)
5987 strbuf_addf(out
, "%s %s ", insn
,
5988 oid_to_hex(&commit
->object
.oid
));
5989 pretty_print_commit(&pp
, commit
, out
);
5991 strbuf_addf(out
, " %s empty", comment_line_str
);
5992 strbuf_addch(out
, '\n');
5995 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5996 _("use --reapply-cherry-picks to include skipped commits"));
5998 release_revisions(&revs
);
6003 * Add commands after pick and (series of) squash/fixup commands
6006 static void todo_list_add_exec_commands(struct todo_list
*todo_list
,
6007 struct string_list
*commands
)
6009 struct strbuf
*buf
= &todo_list
->buf
;
6010 size_t base_offset
= buf
->len
;
6011 int i
, insert
, nr
= 0, alloc
= 0;
6012 struct todo_item
*items
= NULL
, *base_items
= NULL
;
6014 CALLOC_ARRAY(base_items
, commands
->nr
);
6015 for (i
= 0; i
< commands
->nr
; i
++) {
6016 size_t command_len
= strlen(commands
->items
[i
].string
);
6018 strbuf_addstr(buf
, commands
->items
[i
].string
);
6019 strbuf_addch(buf
, '\n');
6021 base_items
[i
].command
= TODO_EXEC
;
6022 base_items
[i
].offset_in_buf
= base_offset
;
6023 base_items
[i
].arg_offset
= base_offset
;
6024 base_items
[i
].arg_len
= command_len
;
6026 base_offset
+= command_len
+ 1;
6030 * Insert <commands> after every pick. Here, fixup/squash chains
6031 * are considered part of the pick, so we insert the commands *after*
6032 * those chains if there are any.
6034 * As we insert the exec commands immediately after rearranging
6035 * any fixups and before the user edits the list, a fixup chain
6036 * can never contain comments (any comments are empty picks that
6037 * have been commented out because the user did not specify
6038 * --keep-empty). So, it is safe to insert an exec command
6039 * without looking at the command following a comment.
6042 for (i
= 0; i
< todo_list
->nr
; i
++) {
6043 enum todo_command command
= todo_list
->items
[i
].command
;
6044 if (insert
&& !is_fixup(command
)) {
6045 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
6046 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
6052 ALLOC_GROW(items
, nr
+ 1, alloc
);
6053 items
[nr
++] = todo_list
->items
[i
];
6055 if (command
== TODO_PICK
|| command
== TODO_MERGE
)
6059 /* insert or append final <commands> */
6061 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
6062 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
6067 FREE_AND_NULL(todo_list
->items
);
6068 todo_list
->items
= items
;
6070 todo_list
->alloc
= alloc
;
6073 static void todo_list_to_strbuf(struct repository
*r
,
6074 struct todo_list
*todo_list
,
6075 struct strbuf
*buf
, int num
, unsigned flags
)
6077 struct todo_item
*item
;
6078 int i
, max
= todo_list
->nr
;
6080 if (num
> 0 && num
< max
)
6083 for (item
= todo_list
->items
, i
= 0; i
< max
; i
++, item
++) {
6086 /* if the item is not a command write it and continue */
6087 if (item
->command
>= TODO_COMMENT
) {
6088 strbuf_addf(buf
, "%.*s\n", item
->arg_len
,
6089 todo_item_get_arg(todo_list
, item
));
6093 /* add command to the buffer */
6094 cmd
= command_to_char(item
->command
);
6095 if ((flags
& TODO_LIST_ABBREVIATE_CMDS
) && cmd
)
6096 strbuf_addch(buf
, cmd
);
6098 strbuf_addstr(buf
, command_to_string(item
->command
));
6102 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
6103 short_commit_name(r
, item
->commit
) :
6104 oid_to_hex(&item
->commit
->object
.oid
);
6106 if (item
->command
== TODO_FIXUP
) {
6107 if (item
->flags
& TODO_EDIT_FIXUP_MSG
)
6108 strbuf_addstr(buf
, " -c");
6109 else if (item
->flags
& TODO_REPLACE_FIXUP_MSG
) {
6110 strbuf_addstr(buf
, " -C");
6114 if (item
->command
== TODO_MERGE
) {
6115 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
6116 strbuf_addstr(buf
, " -c");
6118 strbuf_addstr(buf
, " -C");
6121 strbuf_addf(buf
, " %s", oid
);
6124 /* add all the rest */
6126 strbuf_addch(buf
, '\n');
6128 strbuf_addf(buf
, " %.*s\n", item
->arg_len
,
6129 todo_item_get_arg(todo_list
, item
));
6133 int todo_list_write_to_file(struct repository
*r
, struct todo_list
*todo_list
,
6134 const char *file
, const char *shortrevisions
,
6135 const char *shortonto
, int num
, unsigned flags
)
6138 struct strbuf buf
= STRBUF_INIT
;
6140 todo_list_to_strbuf(r
, todo_list
, &buf
, num
, flags
);
6141 if (flags
& TODO_LIST_APPEND_TODO_HELP
)
6142 append_todo_help(count_commands(todo_list
),
6143 shortrevisions
, shortonto
, &buf
);
6145 res
= write_message(buf
.buf
, buf
.len
, file
, 0);
6146 strbuf_release(&buf
);
6151 /* skip picking commits whose parents are unchanged */
6152 static int skip_unnecessary_picks(struct repository
*r
,
6153 struct todo_list
*todo_list
,
6154 struct object_id
*base_oid
)
6156 struct object_id
*parent_oid
;
6159 for (i
= 0; i
< todo_list
->nr
; i
++) {
6160 struct todo_item
*item
= todo_list
->items
+ i
;
6162 if (item
->command
>= TODO_NOOP
)
6164 if (item
->command
!= TODO_PICK
)
6166 if (repo_parse_commit(r
, item
->commit
)) {
6167 return error(_("could not parse commit '%s'"),
6168 oid_to_hex(&item
->commit
->object
.oid
));
6170 if (!item
->commit
->parents
)
6171 break; /* root commit */
6172 if (item
->commit
->parents
->next
)
6173 break; /* merge commit */
6174 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
6175 if (!oideq(parent_oid
, base_oid
))
6177 oidcpy(base_oid
, &item
->commit
->object
.oid
);
6180 const char *done_path
= rebase_path_done();
6182 if (todo_list_write_to_file(r
, todo_list
, done_path
, NULL
, NULL
, i
, 0)) {
6183 error_errno(_("could not write to '%s'"), done_path
);
6187 MOVE_ARRAY(todo_list
->items
, todo_list
->items
+ i
, todo_list
->nr
- i
);
6189 todo_list
->current
= 0;
6190 todo_list
->done_nr
+= i
;
6192 if (is_fixup(peek_command(todo_list
, 0)))
6193 record_in_rewritten(base_oid
, peek_command(todo_list
, 0));
6199 struct todo_add_branch_context
{
6200 struct todo_item
*items
;
6204 struct commit
*commit
;
6205 struct string_list refs_to_oids
;
6208 static int add_decorations_to_list(const struct commit
*commit
,
6209 struct todo_add_branch_context
*ctx
)
6211 const struct name_decoration
*decoration
= get_name_decoration(&commit
->object
);
6212 const char *head_ref
= resolve_ref_unsafe("HEAD",
6213 RESOLVE_REF_READING
,
6217 while (decoration
) {
6218 struct todo_item
*item
;
6220 size_t base_offset
= ctx
->buf
->len
;
6223 * If the branch is the current HEAD, then it will be
6224 * updated by the default rebase behavior.
6226 if (head_ref
&& !strcmp(head_ref
, decoration
->name
)) {
6227 decoration
= decoration
->next
;
6231 ALLOC_GROW(ctx
->items
,
6234 item
= &ctx
->items
[ctx
->items_nr
];
6235 memset(item
, 0, sizeof(*item
));
6237 /* If the branch is checked out, then leave a comment instead. */
6238 if ((path
= branch_checked_out(decoration
->name
))) {
6239 item
->command
= TODO_COMMENT
;
6240 strbuf_addf(ctx
->buf
, "# Ref %s checked out at '%s'\n",
6241 decoration
->name
, path
);
6243 struct string_list_item
*sti
;
6244 item
->command
= TODO_UPDATE_REF
;
6245 strbuf_addf(ctx
->buf
, "%s\n", decoration
->name
);
6247 sti
= string_list_insert(&ctx
->refs_to_oids
,
6249 sti
->util
= init_update_ref_record(decoration
->name
);
6252 item
->offset_in_buf
= base_offset
;
6253 item
->arg_offset
= base_offset
;
6254 item
->arg_len
= ctx
->buf
->len
- base_offset
;
6257 decoration
= decoration
->next
;
6264 * For each 'pick' command, find out if the commit has a decoration in
6265 * refs/heads/. If so, then add a 'label for-update-refs/' command.
6267 static int todo_list_add_update_ref_commands(struct todo_list
*todo_list
)
6270 static struct string_list decorate_refs_exclude
= STRING_LIST_INIT_NODUP
;
6271 static struct string_list decorate_refs_exclude_config
= STRING_LIST_INIT_NODUP
;
6272 static struct string_list decorate_refs_include
= STRING_LIST_INIT_NODUP
;
6273 struct decoration_filter decoration_filter
= {
6274 .include_ref_pattern
= &decorate_refs_include
,
6275 .exclude_ref_pattern
= &decorate_refs_exclude
,
6276 .exclude_ref_config_pattern
= &decorate_refs_exclude_config
,
6278 struct todo_add_branch_context ctx
= {
6279 .buf
= &todo_list
->buf
,
6280 .refs_to_oids
= STRING_LIST_INIT_DUP
,
6283 ctx
.items_alloc
= 2 * todo_list
->nr
+ 1;
6284 ALLOC_ARRAY(ctx
.items
, ctx
.items_alloc
);
6286 string_list_append(&decorate_refs_include
, "refs/heads/");
6287 load_ref_decorations(&decoration_filter
, 0);
6289 for (i
= 0; i
< todo_list
->nr
; ) {
6290 struct todo_item
*item
= &todo_list
->items
[i
];
6292 /* insert ith item into new list */
6293 ALLOC_GROW(ctx
.items
,
6297 ctx
.items
[ctx
.items_nr
++] = todo_list
->items
[i
++];
6300 ctx
.commit
= item
->commit
;
6301 add_decorations_to_list(item
->commit
, &ctx
);
6305 res
= write_update_refs_state(&ctx
.refs_to_oids
);
6307 string_list_clear(&ctx
.refs_to_oids
, 1);
6310 /* we failed, so clean up the new list. */
6315 free(todo_list
->items
);
6316 todo_list
->items
= ctx
.items
;
6317 todo_list
->nr
= ctx
.items_nr
;
6318 todo_list
->alloc
= ctx
.items_alloc
;
6323 int complete_action(struct repository
*r
, struct replay_opts
*opts
, unsigned flags
,
6324 const char *shortrevisions
, const char *onto_name
,
6325 struct commit
*onto
, const struct object_id
*orig_head
,
6326 struct string_list
*commands
, unsigned autosquash
,
6327 unsigned update_refs
,
6328 struct todo_list
*todo_list
)
6330 char shortonto
[GIT_MAX_HEXSZ
+ 1];
6331 const char *todo_file
= rebase_path_todo();
6332 struct todo_list new_todo
= TODO_LIST_INIT
;
6333 struct strbuf
*buf
= &todo_list
->buf
, buf2
= STRBUF_INIT
;
6334 struct object_id oid
= onto
->object
.oid
;
6337 repo_find_unique_abbrev_r(r
, shortonto
, &oid
,
6340 if (buf
->len
== 0) {
6341 struct todo_item
*item
= append_new_todo(todo_list
);
6342 item
->command
= TODO_NOOP
;
6343 item
->commit
= NULL
;
6344 item
->arg_len
= item
->arg_offset
= item
->flags
= item
->offset_in_buf
= 0;
6347 if (update_refs
&& todo_list_add_update_ref_commands(todo_list
))
6350 if (autosquash
&& todo_list_rearrange_squash(todo_list
))
6354 todo_list_add_exec_commands(todo_list
, commands
);
6356 if (count_commands(todo_list
) == 0) {
6357 apply_autostash(rebase_path_autostash());
6358 sequencer_remove_state(opts
);
6360 return error(_("nothing to do"));
6363 res
= edit_todo_list(r
, todo_list
, &new_todo
, shortrevisions
,
6367 else if (res
== -2) {
6368 apply_autostash(rebase_path_autostash());
6369 sequencer_remove_state(opts
);
6372 } else if (res
== -3) {
6373 apply_autostash(rebase_path_autostash());
6374 sequencer_remove_state(opts
);
6375 todo_list_release(&new_todo
);
6377 return error(_("nothing to do"));
6378 } else if (res
== -4) {
6379 checkout_onto(r
, opts
, onto_name
, &onto
->object
.oid
, orig_head
);
6380 todo_list_release(&new_todo
);
6385 /* Expand the commit IDs */
6386 todo_list_to_strbuf(r
, &new_todo
, &buf2
, -1, 0);
6387 strbuf_swap(&new_todo
.buf
, &buf2
);
6388 strbuf_release(&buf2
);
6389 /* Nothing is done yet, and we're reparsing, so let's reset the count */
6390 new_todo
.total_nr
= 0;
6391 if (todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
) < 0)
6392 BUG("invalid todo list after expanding IDs:\n%s",
6395 if (opts
->allow_ff
&& skip_unnecessary_picks(r
, &new_todo
, &oid
)) {
6396 todo_list_release(&new_todo
);
6397 return error(_("could not skip unnecessary pick commands"));
6400 if (todo_list_write_to_file(r
, &new_todo
, todo_file
, NULL
, NULL
, -1,
6401 flags
& ~(TODO_LIST_SHORTEN_IDS
))) {
6402 todo_list_release(&new_todo
);
6403 return error_errno(_("could not write '%s'"), todo_file
);
6408 if (checkout_onto(r
, opts
, onto_name
, &oid
, orig_head
))
6411 if (require_clean_work_tree(r
, "rebase", NULL
, 1, 1))
6414 todo_list_write_total_nr(&new_todo
);
6415 res
= pick_commits(r
, &new_todo
, opts
);
6418 todo_list_release(&new_todo
);
6423 struct subject2item_entry
{
6424 struct hashmap_entry entry
;
6426 char subject
[FLEX_ARRAY
];
6429 static int subject2item_cmp(const void *fndata UNUSED
,
6430 const struct hashmap_entry
*eptr
,
6431 const struct hashmap_entry
*entry_or_key
,
6434 const struct subject2item_entry
*a
, *b
;
6436 a
= container_of(eptr
, const struct subject2item_entry
, entry
);
6437 b
= container_of(entry_or_key
, const struct subject2item_entry
, entry
);
6439 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
6442 define_commit_slab(commit_todo_item
, struct todo_item
*);
6444 static int skip_fixupish(const char *subject
, const char **p
) {
6445 return skip_prefix(subject
, "fixup! ", p
) ||
6446 skip_prefix(subject
, "amend! ", p
) ||
6447 skip_prefix(subject
, "squash! ", p
);
6451 * Rearrange the todo list that has both "pick commit-id msg" and "pick
6452 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
6453 * after the former, and change "pick" to "fixup"/"squash".
6455 * Note that if the config has specified a custom instruction format, each log
6456 * message will have to be retrieved from the commit (as the oneline in the
6457 * script cannot be trusted) in order to normalize the autosquash arrangement.
6459 int todo_list_rearrange_squash(struct todo_list
*todo_list
)
6461 struct hashmap subject2item
;
6462 int rearranged
= 0, *next
, *tail
, i
, nr
= 0;
6464 struct commit_todo_item commit_todo
;
6465 struct todo_item
*items
= NULL
;
6467 init_commit_todo_item(&commit_todo
);
6469 * The hashmap maps onelines to the respective todo list index.
6471 * If any items need to be rearranged, the next[i] value will indicate
6472 * which item was moved directly after the i'th.
6474 * In that case, last[i] will indicate the index of the latest item to
6475 * be moved to appear after the i'th.
6477 hashmap_init(&subject2item
, subject2item_cmp
, NULL
, todo_list
->nr
);
6478 ALLOC_ARRAY(next
, todo_list
->nr
);
6479 ALLOC_ARRAY(tail
, todo_list
->nr
);
6480 ALLOC_ARRAY(subjects
, todo_list
->nr
);
6481 for (i
= 0; i
< todo_list
->nr
; i
++) {
6482 struct strbuf buf
= STRBUF_INIT
;
6483 struct todo_item
*item
= todo_list
->items
+ i
;
6484 const char *commit_buffer
, *subject
, *p
;
6487 struct subject2item_entry
*entry
;
6489 next
[i
] = tail
[i
] = -1;
6490 if (!item
->commit
|| item
->command
== TODO_DROP
) {
6495 if (is_fixup(item
->command
)) {
6496 clear_commit_todo_item(&commit_todo
);
6497 return error(_("the script was already rearranged."));
6500 repo_parse_commit(the_repository
, item
->commit
);
6501 commit_buffer
= repo_logmsg_reencode(the_repository
,
6504 find_commit_subject(commit_buffer
, &subject
);
6505 format_subject(&buf
, subject
, " ");
6506 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
6507 repo_unuse_commit_buffer(the_repository
, item
->commit
,
6509 if (skip_fixupish(subject
, &p
)) {
6510 struct commit
*commit2
;
6515 if (!skip_fixupish(p
, &p
))
6519 entry
= hashmap_get_entry_from_hash(&subject2item
,
6521 struct subject2item_entry
,
6524 /* found by title */
6526 else if (!strchr(p
, ' ') &&
6528 lookup_commit_reference_by_name(p
)) &&
6529 *commit_todo_item_at(&commit_todo
, commit2
))
6530 /* found by commit name */
6531 i2
= *commit_todo_item_at(&commit_todo
, commit2
)
6534 /* copy can be a prefix of the commit subject */
6535 for (i2
= 0; i2
< i
; i2
++)
6537 starts_with(subjects
[i2
], p
))
6545 if (starts_with(subject
, "fixup!")) {
6546 todo_list
->items
[i
].command
= TODO_FIXUP
;
6547 } else if (starts_with(subject
, "amend!")) {
6548 todo_list
->items
[i
].command
= TODO_FIXUP
;
6549 todo_list
->items
[i
].flags
= TODO_REPLACE_FIXUP_MSG
;
6551 todo_list
->items
[i
].command
= TODO_SQUASH
;
6557 next
[i
] = next
[tail
[i2
]];
6561 } else if (!hashmap_get_from_hash(&subject2item
,
6562 strhash(subject
), subject
)) {
6563 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
6565 hashmap_entry_init(&entry
->entry
,
6566 strhash(entry
->subject
));
6567 hashmap_put(&subject2item
, &entry
->entry
);
6570 *commit_todo_item_at(&commit_todo
, item
->commit
) = item
;
6574 ALLOC_ARRAY(items
, todo_list
->nr
);
6576 for (i
= 0; i
< todo_list
->nr
; i
++) {
6577 enum todo_command command
= todo_list
->items
[i
].command
;
6581 * Initially, all commands are 'pick's. If it is a
6582 * fixup or a squash now, we have rearranged it.
6584 if (is_fixup(command
))
6588 items
[nr
++] = todo_list
->items
[cur
];
6593 assert(nr
== todo_list
->nr
);
6594 todo_list
->alloc
= nr
;
6595 FREE_AND_NULL(todo_list
->items
);
6596 todo_list
->items
= items
;
6601 for (i
= 0; i
< todo_list
->nr
; i
++)
6604 hashmap_clear_and_free(&subject2item
, struct subject2item_entry
, entry
);
6606 clear_commit_todo_item(&commit_todo
);
6611 int sequencer_determine_whence(struct repository
*r
, enum commit_whence
*whence
)
6613 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
6614 struct object_id cherry_pick_head
, rebase_head
;
6616 if (file_exists(git_path_seq_dir()))
6617 *whence
= FROM_CHERRY_PICK_MULTI
;
6618 if (file_exists(rebase_path()) &&
6619 !repo_get_oid(r
, "REBASE_HEAD", &rebase_head
) &&
6620 !repo_get_oid(r
, "CHERRY_PICK_HEAD", &cherry_pick_head
) &&
6621 oideq(&rebase_head
, &cherry_pick_head
))
6622 *whence
= FROM_REBASE_PICK
;
6624 *whence
= FROM_CHERRY_PICK_SINGLE
;
6632 int sequencer_get_update_refs_state(const char *wt_dir
,
6633 struct string_list
*refs
)
6637 struct strbuf ref
= STRBUF_INIT
;
6638 struct strbuf hash
= STRBUF_INIT
;
6639 struct update_ref_record
*rec
= NULL
;
6641 char *path
= rebase_path_update_refs(wt_dir
);
6643 fp
= fopen(path
, "r");
6647 while (strbuf_getline(&ref
, fp
) != EOF
) {
6648 struct string_list_item
*item
;
6650 CALLOC_ARRAY(rec
, 1);
6652 if (strbuf_getline(&hash
, fp
) == EOF
||
6653 get_oid_hex(hash
.buf
, &rec
->before
)) {
6654 warning(_("update-refs file at '%s' is invalid"),
6660 if (strbuf_getline(&hash
, fp
) == EOF
||
6661 get_oid_hex(hash
.buf
, &rec
->after
)) {
6662 warning(_("update-refs file at '%s' is invalid"),
6668 item
= string_list_insert(refs
, ref
.buf
);
6678 strbuf_release(&ref
);
6679 strbuf_release(&hash
);