5 #include "object-store.h"
10 #include "run-command.h"
14 #include "cache-tree.h"
18 #include "merge-ort.h"
19 #include "merge-ort-wrappers.h"
25 #include "wt-status.h"
27 #include "notes-utils.h"
29 #include "unpack-trees.h"
33 #include "commit-slab.h"
35 #include "commit-reach.h"
36 #include "rebase-interactive.h"
40 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
42 static const char sign_off_header
[] = "Signed-off-by: ";
43 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
45 GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
47 static GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
49 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
50 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
51 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
52 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
54 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
56 * The file containing rebase commands, comments, and empty lines.
57 * This file is created by "git rebase -i" then edited by the user. As
58 * the lines are processed, they are removed from the front of this
59 * file and written to the tail of 'done'.
61 GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
62 GIT_PATH_FUNC(rebase_path_todo_backup
, "rebase-merge/git-rebase-todo.backup")
64 GIT_PATH_FUNC(rebase_path_dropped
, "rebase-merge/dropped")
67 * The rebase command lines that have already been processed. A line
68 * is moved here when it is first handled, before any associated user
71 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
73 * The file to keep track of how many commands were already processed (e.g.
76 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum")
78 * The file to keep track of how many commands are to be processed in total
79 * (e.g. for the prompt).
81 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end")
83 * The commit message that is planned to be used for any changes that
84 * need to be committed following a user interaction.
86 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
88 * The file into which is accumulated the suggested commit message for
89 * squash/fixup commands. When the first of a series of squash/fixups
90 * is seen, the file is created and the commit message from the
91 * previous commit and from the first squash/fixup commit are written
92 * to it. The commit message for each subsequent squash/fixup commit
93 * is appended to the file as it is processed.
95 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
97 * If the current series of squash/fixups has not yet included a squash
98 * command, then this file exists and holds the commit message of the
99 * original "pick" commit. (If the series ends without a "squash"
100 * command, then this can be used as the commit message of the combined
101 * commit without opening the editor.)
103 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
105 * This file contains the list fixup/squash commands that have been
106 * accumulated into message-fixup or message-squash so far.
108 static GIT_PATH_FUNC(rebase_path_current_fixups
, "rebase-merge/current-fixups")
110 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
111 * GIT_AUTHOR_DATE that will be used for the commit that is currently
114 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
116 * When an "edit" rebase command is being processed, the SHA1 of the
117 * commit to be edited is recorded in this file. When "git rebase
118 * --continue" is executed, if there are any staged changes then they
119 * will be amended to the HEAD commit, but only provided the HEAD
120 * commit is still the commit to be edited. When any other rebase
121 * command is processed, this file is deleted.
123 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
125 * When we stop at a given patch via the "edit" command, this file contains
126 * the commit object name of the corresponding patch.
128 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
130 * For the post-rewrite hook, we make a list of rewritten commits and
131 * their new sha1s. The rewritten-pending list keeps the sha1s of
132 * commits that have been processed, but not committed yet,
133 * e.g. because they are waiting for a 'squash' command.
135 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
136 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
137 "rebase-merge/rewritten-pending")
140 * The path of the file containing the OID of the "squash onto" commit, i.e.
141 * the dummy commit used for `reset [new root]`.
143 static GIT_PATH_FUNC(rebase_path_squash_onto
, "rebase-merge/squash-onto")
146 * The path of the file listing refs that need to be deleted after the rebase
147 * finishes. This is used by the `label` command to record the need for cleanup.
149 static GIT_PATH_FUNC(rebase_path_refs_to_delete
, "rebase-merge/refs-to-delete")
152 * The update-refs file stores a list of refs that will be updated at the end
153 * of the rebase sequence. The 'update-ref <ref>' commands in the todo file
154 * update the OIDs for the refs in this file, but the refs are not updated
155 * until the end of the rebase sequence.
157 * rebase_path_update_refs() returns the path to this file for a given
158 * worktree directory. For the current worktree, pass the_repository->gitdir.
160 static char *rebase_path_update_refs(const char *wt_git_dir
)
162 return xstrfmt("%s/rebase-merge/update-refs", wt_git_dir
);
166 * The following files are written by git-rebase just after parsing the
169 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
170 static GIT_PATH_FUNC(rebase_path_cdate_is_adate
, "rebase-merge/cdate_is_adate")
171 static GIT_PATH_FUNC(rebase_path_ignore_date
, "rebase-merge/ignore_date")
172 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
173 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
174 static GIT_PATH_FUNC(rebase_path_quiet
, "rebase-merge/quiet")
175 static GIT_PATH_FUNC(rebase_path_signoff
, "rebase-merge/signoff")
176 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
177 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
178 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
179 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
180 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
181 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
182 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec
, "rebase-merge/reschedule-failed-exec")
183 static GIT_PATH_FUNC(rebase_path_no_reschedule_failed_exec
, "rebase-merge/no-reschedule-failed-exec")
184 static GIT_PATH_FUNC(rebase_path_drop_redundant_commits
, "rebase-merge/drop_redundant_commits")
185 static GIT_PATH_FUNC(rebase_path_keep_redundant_commits
, "rebase-merge/keep_redundant_commits")
188 * A 'struct update_refs_record' represents a value in the update-refs
189 * list. We use a string_list to map refs to these (before, after) pairs.
191 struct update_ref_record
{
192 struct object_id before
;
193 struct object_id after
;
196 static struct update_ref_record
*init_update_ref_record(const char *ref
)
198 struct update_ref_record
*rec
;
200 CALLOC_ARRAY(rec
, 1);
202 oidcpy(&rec
->before
, null_oid());
203 oidcpy(&rec
->after
, null_oid());
205 /* This may fail, but that's fine, we will keep the null OID. */
206 read_ref(ref
, &rec
->before
);
211 static int git_sequencer_config(const char *k
, const char *v
, void *cb
)
213 struct replay_opts
*opts
= cb
;
216 if (!strcmp(k
, "commit.cleanup")) {
219 status
= git_config_string(&s
, k
, v
);
223 if (!strcmp(s
, "verbatim")) {
224 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
225 opts
->explicit_cleanup
= 1;
226 } else if (!strcmp(s
, "whitespace")) {
227 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
228 opts
->explicit_cleanup
= 1;
229 } else if (!strcmp(s
, "strip")) {
230 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_ALL
;
231 opts
->explicit_cleanup
= 1;
232 } else if (!strcmp(s
, "scissors")) {
233 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SCISSORS
;
234 opts
->explicit_cleanup
= 1;
236 warning(_("invalid commit message cleanup mode '%s'"),
244 if (!strcmp(k
, "commit.gpgsign")) {
245 opts
->gpg_sign
= git_config_bool(k
, v
) ? xstrdup("") : NULL
;
249 if (!opts
->default_strategy
&& !strcmp(k
, "pull.twohead")) {
250 int ret
= git_config_string((const char**)&opts
->default_strategy
, k
, v
);
253 * pull.twohead is allowed to be multi-valued; we only
254 * care about the first value.
256 char *tmp
= strchr(opts
->default_strategy
, ' ');
263 if (opts
->action
== REPLAY_REVERT
&& !strcmp(k
, "revert.reference"))
264 opts
->commit_use_reference
= git_config_bool(k
, v
);
266 status
= git_gpg_config(k
, v
, NULL
);
270 return git_diff_basic_config(k
, v
, NULL
);
273 void sequencer_init_config(struct replay_opts
*opts
)
275 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
276 git_config(git_sequencer_config
, opts
);
279 static inline int is_rebase_i(const struct replay_opts
*opts
)
281 return opts
->action
== REPLAY_INTERACTIVE_REBASE
;
284 static const char *get_dir(const struct replay_opts
*opts
)
286 if (is_rebase_i(opts
))
287 return rebase_path();
288 return git_path_seq_dir();
291 static const char *get_todo_path(const struct replay_opts
*opts
)
293 if (is_rebase_i(opts
))
294 return rebase_path_todo();
295 return git_path_todo_file();
299 * Returns 0 for non-conforming footer
300 * Returns 1 for conforming footer
301 * Returns 2 when sob exists within conforming footer
302 * Returns 3 when sob exists within conforming footer as last entry
304 static int has_conforming_footer(struct strbuf
*sb
, struct strbuf
*sob
,
305 size_t ignore_footer
)
307 struct process_trailer_options opts
= PROCESS_TRAILER_OPTIONS_INIT
;
308 struct trailer_info info
;
310 int found_sob
= 0, found_sob_last
= 0;
316 saved_char
= sb
->buf
[sb
->len
- ignore_footer
];
317 sb
->buf
[sb
->len
- ignore_footer
] = '\0';
320 trailer_info_get(&info
, sb
->buf
, &opts
);
323 sb
->buf
[sb
->len
- ignore_footer
] = saved_char
;
325 if (info
.trailer_start
== info
.trailer_end
)
328 for (i
= 0; i
< info
.trailer_nr
; i
++)
329 if (sob
&& !strncmp(info
.trailers
[i
], sob
->buf
, sob
->len
)) {
331 if (i
== info
.trailer_nr
- 1)
335 trailer_info_release(&info
);
344 static const char *gpg_sign_opt_quoted(struct replay_opts
*opts
)
346 static struct strbuf buf
= STRBUF_INIT
;
350 sq_quotef(&buf
, "-S%s", opts
->gpg_sign
);
354 void replay_opts_release(struct replay_opts
*opts
)
356 free(opts
->gpg_sign
);
357 free(opts
->reflog_action
);
358 free(opts
->default_strategy
);
359 free(opts
->strategy
);
360 for (size_t i
= 0; i
< opts
->xopts_nr
; i
++)
361 free(opts
->xopts
[i
]);
363 strbuf_release(&opts
->current_fixups
);
365 release_revisions(opts
->revs
);
369 int sequencer_remove_state(struct replay_opts
*opts
)
371 struct strbuf buf
= STRBUF_INIT
;
374 if (is_rebase_i(opts
) &&
375 strbuf_read_file(&buf
, rebase_path_refs_to_delete(), 0) > 0) {
378 char *eol
= strchr(p
, '\n');
381 if (delete_ref("(rebase) cleanup", p
, NULL
, 0) < 0) {
382 warning(_("could not delete '%s'"), p
);
392 strbuf_addstr(&buf
, get_dir(opts
));
393 if (remove_dir_recursively(&buf
, 0))
394 ret
= error(_("could not remove '%s'"), buf
.buf
);
395 strbuf_release(&buf
);
400 static const char *action_name(const struct replay_opts
*opts
)
402 switch (opts
->action
) {
406 return N_("cherry-pick");
407 case REPLAY_INTERACTIVE_REBASE
:
410 die(_("unknown action: %d"), opts
->action
);
413 struct commit_message
{
420 static const char *short_commit_name(struct commit
*commit
)
422 return find_unique_abbrev(&commit
->object
.oid
, DEFAULT_ABBREV
);
425 static int get_message(struct commit
*commit
, struct commit_message
*out
)
427 const char *abbrev
, *subject
;
430 out
->message
= logmsg_reencode(commit
, NULL
, get_commit_output_encoding());
431 abbrev
= short_commit_name(commit
);
433 subject_len
= find_commit_subject(out
->message
, &subject
);
435 out
->subject
= xmemdupz(subject
, subject_len
);
436 out
->label
= xstrfmt("%s (%s)", abbrev
, out
->subject
);
437 out
->parent_label
= xstrfmt("parent of %s", out
->label
);
442 static void free_message(struct commit
*commit
, struct commit_message
*msg
)
444 free(msg
->parent_label
);
447 unuse_commit_buffer(commit
, msg
->message
);
450 static void print_advice(struct repository
*r
, int show_hint
,
451 struct replay_opts
*opts
)
453 char *msg
= getenv("GIT_CHERRY_PICK_HELP");
458 * A conflict has occurred but the porcelain
459 * (typically rebase --interactive) wants to take care
460 * of the commit itself so remove CHERRY_PICK_HEAD
462 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
469 advise(_("after resolving the conflicts, mark the corrected paths\n"
470 "with 'git add <paths>' or 'git rm <paths>'"));
471 else if (opts
->action
== REPLAY_PICK
)
472 advise(_("After resolving the conflicts, mark them with\n"
473 "\"git add/rm <pathspec>\", then run\n"
474 "\"git cherry-pick --continue\".\n"
475 "You can instead skip this commit with \"git cherry-pick --skip\".\n"
476 "To abort and get back to the state before \"git cherry-pick\",\n"
477 "run \"git cherry-pick --abort\"."));
478 else if (opts
->action
== REPLAY_REVERT
)
479 advise(_("After resolving the conflicts, mark them with\n"
480 "\"git add/rm <pathspec>\", then run\n"
481 "\"git revert --continue\".\n"
482 "You can instead skip this commit with \"git revert --skip\".\n"
483 "To abort and get back to the state before \"git revert\",\n"
484 "run \"git revert --abort\"."));
486 BUG("unexpected pick action in print_advice()");
490 static int write_message(const void *buf
, size_t len
, const char *filename
,
493 struct lock_file msg_file
= LOCK_INIT
;
495 int msg_fd
= hold_lock_file_for_update(&msg_file
, filename
, 0);
497 return error_errno(_("could not lock '%s'"), filename
);
498 if (write_in_full(msg_fd
, buf
, len
) < 0) {
499 error_errno(_("could not write to '%s'"), filename
);
500 rollback_lock_file(&msg_file
);
503 if (append_eol
&& write(msg_fd
, "\n", 1) < 0) {
504 error_errno(_("could not write eol to '%s'"), filename
);
505 rollback_lock_file(&msg_file
);
508 if (commit_lock_file(&msg_file
) < 0)
509 return error(_("failed to finalize '%s'"), filename
);
514 int read_oneliner(struct strbuf
*buf
,
515 const char *path
, unsigned flags
)
517 int orig_len
= buf
->len
;
519 if (strbuf_read_file(buf
, path
, 0) < 0) {
520 if ((flags
& READ_ONELINER_WARN_MISSING
) ||
521 (errno
!= ENOENT
&& errno
!= ENOTDIR
))
522 warning_errno(_("could not read '%s'"), path
);
526 if (buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\n') {
527 if (--buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\r')
529 buf
->buf
[buf
->len
] = '\0';
532 if ((flags
& READ_ONELINER_SKIP_IF_EMPTY
) && buf
->len
== orig_len
)
538 static struct tree
*empty_tree(struct repository
*r
)
540 return lookup_tree(r
, the_hash_algo
->empty_tree
);
543 static int error_dirty_index(struct repository
*repo
, struct replay_opts
*opts
)
545 if (repo_read_index_unmerged(repo
))
546 return error_resolve_conflict(action_name(opts
));
548 error(_("your local changes would be overwritten by %s."),
549 _(action_name(opts
)));
551 if (advice_enabled(ADVICE_COMMIT_BEFORE_MERGE
))
552 advise(_("commit your changes or stash them to proceed."));
556 static void update_abort_safety_file(void)
558 struct object_id head
;
560 /* Do nothing on a single-pick */
561 if (!file_exists(git_path_seq_dir()))
564 if (!get_oid("HEAD", &head
))
565 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head
));
567 write_file(git_path_abort_safety_file(), "%s", "");
570 static int fast_forward_to(struct repository
*r
,
571 const struct object_id
*to
,
572 const struct object_id
*from
,
574 struct replay_opts
*opts
)
576 struct ref_transaction
*transaction
;
577 struct strbuf sb
= STRBUF_INIT
;
578 struct strbuf err
= STRBUF_INIT
;
581 if (checkout_fast_forward(r
, from
, to
, 1))
582 return -1; /* the callee should have complained already */
584 strbuf_addf(&sb
, "%s: fast-forward", action_name(opts
));
586 transaction
= ref_transaction_begin(&err
);
588 ref_transaction_update(transaction
, "HEAD",
589 to
, unborn
&& !is_rebase_i(opts
) ?
592 ref_transaction_commit(transaction
, &err
)) {
593 ref_transaction_free(transaction
);
594 error("%s", err
.buf
);
596 strbuf_release(&err
);
601 strbuf_release(&err
);
602 ref_transaction_free(transaction
);
603 update_abort_safety_file();
607 enum commit_msg_cleanup_mode
get_cleanup_mode(const char *cleanup_arg
,
610 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
611 return use_editor
? COMMIT_MSG_CLEANUP_ALL
:
612 COMMIT_MSG_CLEANUP_SPACE
;
613 else if (!strcmp(cleanup_arg
, "verbatim"))
614 return COMMIT_MSG_CLEANUP_NONE
;
615 else if (!strcmp(cleanup_arg
, "whitespace"))
616 return COMMIT_MSG_CLEANUP_SPACE
;
617 else if (!strcmp(cleanup_arg
, "strip"))
618 return COMMIT_MSG_CLEANUP_ALL
;
619 else if (!strcmp(cleanup_arg
, "scissors"))
620 return use_editor
? COMMIT_MSG_CLEANUP_SCISSORS
:
621 COMMIT_MSG_CLEANUP_SPACE
;
623 die(_("Invalid cleanup mode %s"), cleanup_arg
);
627 * NB using int rather than enum cleanup_mode to stop clang's
628 * -Wtautological-constant-out-of-range-compare complaining that the comparison
631 static const char *describe_cleanup_mode(int cleanup_mode
)
633 static const char *modes
[] = { "whitespace",
638 if (cleanup_mode
< ARRAY_SIZE(modes
))
639 return modes
[cleanup_mode
];
641 BUG("invalid cleanup_mode provided (%d)", cleanup_mode
);
644 void append_conflicts_hint(struct index_state
*istate
,
645 struct strbuf
*msgbuf
, enum commit_msg_cleanup_mode cleanup_mode
)
649 if (cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
) {
650 strbuf_addch(msgbuf
, '\n');
651 wt_status_append_cut_line(msgbuf
);
652 strbuf_addch(msgbuf
, comment_line_char
);
655 strbuf_addch(msgbuf
, '\n');
656 strbuf_commented_addf(msgbuf
, "Conflicts:\n");
657 for (i
= 0; i
< istate
->cache_nr
;) {
658 const struct cache_entry
*ce
= istate
->cache
[i
++];
660 strbuf_commented_addf(msgbuf
, "\t%s\n", ce
->name
);
661 while (i
< istate
->cache_nr
&&
662 !strcmp(ce
->name
, istate
->cache
[i
]->name
))
668 static int do_recursive_merge(struct repository
*r
,
669 struct commit
*base
, struct commit
*next
,
670 const char *base_label
, const char *next_label
,
671 struct object_id
*head
, struct strbuf
*msgbuf
,
672 struct replay_opts
*opts
)
674 struct merge_options o
;
675 struct merge_result result
;
676 struct tree
*next_tree
, *base_tree
, *head_tree
;
677 int clean
, show_output
;
679 struct lock_file index_lock
= LOCK_INIT
;
681 if (repo_hold_locked_index(r
, &index_lock
, LOCK_REPORT_ON_ERROR
) < 0)
686 init_merge_options(&o
, r
);
687 o
.ancestor
= base
? base_label
: "(empty tree)";
689 o
.branch2
= next
? next_label
: "(empty tree)";
690 if (is_rebase_i(opts
))
692 o
.show_rename_progress
= 1;
694 head_tree
= parse_tree_indirect(head
);
695 next_tree
= next
? get_commit_tree(next
) : empty_tree(r
);
696 base_tree
= base
? get_commit_tree(base
) : empty_tree(r
);
698 for (i
= 0; i
< opts
->xopts_nr
; i
++)
699 parse_merge_opt(&o
, opts
->xopts
[i
]);
701 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
702 memset(&result
, 0, sizeof(result
));
703 merge_incore_nonrecursive(&o
, base_tree
, head_tree
, next_tree
,
705 show_output
= !is_rebase_i(opts
) || !result
.clean
;
707 * TODO: merge_switch_to_result will update index/working tree;
708 * we only really want to do that if !result.clean || this is
709 * the final patch to be picked. But determining this is the
710 * final patch would take some work, and "head_tree" would need
711 * to be replace with the tree the index matched before we
712 * started doing any picks.
714 merge_switch_to_result(&o
, head_tree
, &result
, 1, show_output
);
715 clean
= result
.clean
;
717 ensure_full_index(r
->index
);
718 clean
= merge_trees(&o
, head_tree
, next_tree
, base_tree
);
719 if (is_rebase_i(opts
) && clean
<= 0)
720 fputs(o
.obuf
.buf
, stdout
);
721 strbuf_release(&o
.obuf
);
724 rollback_lock_file(&index_lock
);
728 if (write_locked_index(r
->index
, &index_lock
,
729 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
731 * TRANSLATORS: %s will be "revert", "cherry-pick" or
734 return error(_("%s: Unable to write new index file"),
735 _(action_name(opts
)));
738 append_conflicts_hint(r
->index
, msgbuf
,
739 opts
->default_msg_cleanup
);
744 static struct object_id
*get_cache_tree_oid(struct index_state
*istate
)
746 if (!cache_tree_fully_valid(istate
->cache_tree
))
747 if (cache_tree_update(istate
, 0)) {
748 error(_("unable to update cache tree"));
752 return &istate
->cache_tree
->oid
;
755 static int is_index_unchanged(struct repository
*r
)
757 struct object_id head_oid
, *cache_tree_oid
;
758 struct commit
*head_commit
;
759 struct index_state
*istate
= r
->index
;
761 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
762 return error(_("could not resolve HEAD commit"));
764 head_commit
= lookup_commit(r
, &head_oid
);
767 * If head_commit is NULL, check_commit, called from
768 * lookup_commit, would have indicated that head_commit is not
769 * a commit object already. parse_commit() will return failure
770 * without further complaints in such a case. Otherwise, if
771 * the commit is invalid, parse_commit() will complain. So
772 * there is nothing for us to say here. Just return failure.
774 if (parse_commit(head_commit
))
777 if (!(cache_tree_oid
= get_cache_tree_oid(istate
)))
780 return oideq(cache_tree_oid
, get_commit_tree_oid(head_commit
));
783 static int write_author_script(const char *message
)
785 struct strbuf buf
= STRBUF_INIT
;
790 if (!*message
|| starts_with(message
, "\n")) {
792 /* Missing 'author' line? */
793 unlink(rebase_path_author_script());
795 } else if (skip_prefix(message
, "author ", &message
))
797 else if ((eol
= strchr(message
, '\n')))
802 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
803 while (*message
&& *message
!= '\n' && *message
!= '\r')
804 if (skip_prefix(message
, " <", &message
))
806 else if (*message
!= '\'')
807 strbuf_addch(&buf
, *(message
++));
809 strbuf_addf(&buf
, "'\\%c'", *(message
++));
810 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
811 while (*message
&& *message
!= '\n' && *message
!= '\r')
812 if (skip_prefix(message
, "> ", &message
))
814 else if (*message
!= '\'')
815 strbuf_addch(&buf
, *(message
++));
817 strbuf_addf(&buf
, "'\\%c'", *(message
++));
818 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
819 while (*message
&& *message
!= '\n' && *message
!= '\r')
820 if (*message
!= '\'')
821 strbuf_addch(&buf
, *(message
++));
823 strbuf_addf(&buf
, "'\\%c'", *(message
++));
824 strbuf_addch(&buf
, '\'');
825 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
826 strbuf_release(&buf
);
831 * Take a series of KEY='VALUE' lines where VALUE part is
832 * sq-quoted, and append <KEY, VALUE> at the end of the string list
834 static int parse_key_value_squoted(char *buf
, struct string_list
*list
)
837 struct string_list_item
*item
;
839 char *cp
= strchr(buf
, '=');
841 np
= strchrnul(buf
, '\n');
842 return error(_("no key present in '%.*s'"),
843 (int) (np
- buf
), buf
);
845 np
= strchrnul(cp
, '\n');
847 item
= string_list_append(list
, buf
);
849 buf
= np
+ (*np
== '\n');
853 return error(_("unable to dequote value of '%s'"),
855 item
->util
= xstrdup(cp
);
861 * Reads and parses the state directory's "author-script" file, and sets name,
862 * email and date accordingly.
863 * Returns 0 on success, -1 if the file could not be parsed.
865 * The author script is of the format:
867 * GIT_AUTHOR_NAME='$author_name'
868 * GIT_AUTHOR_EMAIL='$author_email'
869 * GIT_AUTHOR_DATE='$author_date'
871 * where $author_name, $author_email and $author_date are quoted. We are strict
872 * with our parsing, as the file was meant to be eval'd in the now-removed
873 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
874 * from what this function expects, it is better to bail out than to do
875 * something that the user does not expect.
877 int read_author_script(const char *path
, char **name
, char **email
, char **date
,
880 struct strbuf buf
= STRBUF_INIT
;
881 struct string_list kv
= STRING_LIST_INIT_DUP
;
882 int retval
= -1; /* assume failure */
883 int i
, name_i
= -2, email_i
= -2, date_i
= -2, err
= 0;
885 if (strbuf_read_file(&buf
, path
, 256) <= 0) {
886 strbuf_release(&buf
);
887 if (errno
== ENOENT
&& allow_missing
)
890 return error_errno(_("could not open '%s' for reading"),
894 if (parse_key_value_squoted(buf
.buf
, &kv
))
897 for (i
= 0; i
< kv
.nr
; i
++) {
898 if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_NAME")) {
900 name_i
= error(_("'GIT_AUTHOR_NAME' already given"));
903 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_EMAIL")) {
905 email_i
= error(_("'GIT_AUTHOR_EMAIL' already given"));
908 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_DATE")) {
910 date_i
= error(_("'GIT_AUTHOR_DATE' already given"));
914 err
= error(_("unknown variable '%s'"),
919 error(_("missing 'GIT_AUTHOR_NAME'"));
921 error(_("missing 'GIT_AUTHOR_EMAIL'"));
923 error(_("missing 'GIT_AUTHOR_DATE'"));
924 if (name_i
< 0 || email_i
< 0 || date_i
< 0 || err
)
926 *name
= kv
.items
[name_i
].util
;
927 *email
= kv
.items
[email_i
].util
;
928 *date
= kv
.items
[date_i
].util
;
931 string_list_clear(&kv
, !!retval
);
932 strbuf_release(&buf
);
937 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
938 * file with shell quoting into struct strvec. Returns -1 on
939 * error, 0 otherwise.
941 static int read_env_script(struct strvec
*env
)
943 char *name
, *email
, *date
;
945 if (read_author_script(rebase_path_author_script(),
946 &name
, &email
, &date
, 0))
949 strvec_pushf(env
, "GIT_AUTHOR_NAME=%s", name
);
950 strvec_pushf(env
, "GIT_AUTHOR_EMAIL=%s", email
);
951 strvec_pushf(env
, "GIT_AUTHOR_DATE=%s", date
);
959 static char *get_author(const char *message
)
964 a
= find_commit_header(message
, "author", &len
);
966 return xmemdupz(a
, len
);
971 static const char *author_date_from_env(const struct strvec
*env
)
976 for (i
= 0; i
< env
->nr
; i
++)
977 if (skip_prefix(env
->v
[i
],
978 "GIT_AUTHOR_DATE=", &date
))
981 * If GIT_AUTHOR_DATE is missing we should have already errored out when
984 BUG("GIT_AUTHOR_DATE missing from author script");
987 static const char staged_changes_advice
[] =
988 N_("you have staged changes in your working tree\n"
989 "If these changes are meant to be squashed into the previous commit, run:\n"
991 " git commit --amend %s\n"
993 "If they are meant to go into a new commit, run:\n"
997 "In both cases, once you're done, continue with:\n"
999 " git rebase --continue\n");
1001 #define ALLOW_EMPTY (1<<0)
1002 #define EDIT_MSG (1<<1)
1003 #define AMEND_MSG (1<<2)
1004 #define CLEANUP_MSG (1<<3)
1005 #define VERIFY_MSG (1<<4)
1006 #define CREATE_ROOT_COMMIT (1<<5)
1007 #define VERBATIM_MSG (1<<6)
1009 static int run_command_silent_on_success(struct child_process
*cmd
)
1011 struct strbuf buf
= STRBUF_INIT
;
1014 cmd
->stdout_to_stderr
= 1;
1015 rc
= pipe_command(cmd
,
1021 fputs(buf
.buf
, stderr
);
1022 strbuf_release(&buf
);
1027 * If we are cherry-pick, and if the merge did not result in
1028 * hand-editing, we will hit this commit and inherit the original
1029 * author date and name.
1031 * If we are revert, or if our cherry-pick results in a hand merge,
1032 * we had better say that the current user is responsible for that.
1034 * An exception is when run_git_commit() is called during an
1035 * interactive rebase: in that case, we will want to retain the
1038 static int run_git_commit(const char *defmsg
,
1039 struct replay_opts
*opts
,
1042 struct child_process cmd
= CHILD_PROCESS_INIT
;
1044 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1045 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1049 if (is_rebase_i(opts
) &&
1050 ((opts
->committer_date_is_author_date
&& !opts
->ignore_date
) ||
1051 !(!defmsg
&& (flags
& AMEND_MSG
))) &&
1052 read_env_script(&cmd
.env
)) {
1053 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
1055 return error(_(staged_changes_advice
),
1059 strvec_pushf(&cmd
.env
, GIT_REFLOG_ACTION
"=%s", opts
->reflog_message
);
1061 if (opts
->committer_date_is_author_date
)
1062 strvec_pushf(&cmd
.env
, "GIT_COMMITTER_DATE=%s",
1065 author_date_from_env(&cmd
.env
));
1066 if (opts
->ignore_date
)
1067 strvec_push(&cmd
.env
, "GIT_AUTHOR_DATE=");
1069 strvec_push(&cmd
.args
, "commit");
1071 if (!(flags
& VERIFY_MSG
))
1072 strvec_push(&cmd
.args
, "-n");
1073 if ((flags
& AMEND_MSG
))
1074 strvec_push(&cmd
.args
, "--amend");
1076 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
1078 strvec_push(&cmd
.args
, "--no-gpg-sign");
1080 strvec_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
1081 else if (!(flags
& EDIT_MSG
))
1082 strvec_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
1083 if ((flags
& CLEANUP_MSG
))
1084 strvec_push(&cmd
.args
, "--cleanup=strip");
1085 if ((flags
& VERBATIM_MSG
))
1086 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1087 if ((flags
& EDIT_MSG
))
1088 strvec_push(&cmd
.args
, "-e");
1089 else if (!(flags
& CLEANUP_MSG
) &&
1090 !opts
->signoff
&& !opts
->record_origin
&&
1091 !opts
->explicit_cleanup
)
1092 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1094 if ((flags
& ALLOW_EMPTY
))
1095 strvec_push(&cmd
.args
, "--allow-empty");
1097 if (!(flags
& EDIT_MSG
))
1098 strvec_push(&cmd
.args
, "--allow-empty-message");
1100 if (is_rebase_i(opts
) && !(flags
& EDIT_MSG
))
1101 return run_command_silent_on_success(&cmd
);
1103 return run_command(&cmd
);
1106 static int rest_is_empty(const struct strbuf
*sb
, int start
)
1111 /* Check if the rest is just whitespace and Signed-off-by's. */
1112 for (i
= start
; i
< sb
->len
; i
++) {
1113 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1119 if (strlen(sign_off_header
) <= eol
- i
&&
1120 starts_with(sb
->buf
+ i
, sign_off_header
)) {
1125 if (!isspace(sb
->buf
[i
++]))
1132 void cleanup_message(struct strbuf
*msgbuf
,
1133 enum commit_msg_cleanup_mode cleanup_mode
, int verbose
)
1135 if (verbose
|| /* Truncate the message just before the diff, if any. */
1136 cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
1137 strbuf_setlen(msgbuf
, wt_status_locate_end(msgbuf
->buf
, msgbuf
->len
));
1138 if (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
)
1139 strbuf_stripspace(msgbuf
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1143 * Find out if the message in the strbuf contains only whitespace and
1144 * Signed-off-by lines.
1146 int message_is_empty(const struct strbuf
*sb
,
1147 enum commit_msg_cleanup_mode cleanup_mode
)
1149 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1151 return rest_is_empty(sb
, 0);
1155 * See if the user edited the message in the editor or left what
1156 * was in the template intact
1158 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
1159 enum commit_msg_cleanup_mode cleanup_mode
)
1161 struct strbuf tmpl
= STRBUF_INIT
;
1164 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1167 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
1170 strbuf_stripspace(&tmpl
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1171 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
1173 strbuf_release(&tmpl
);
1174 return rest_is_empty(sb
, start
- sb
->buf
);
1177 int update_head_with_reflog(const struct commit
*old_head
,
1178 const struct object_id
*new_head
,
1179 const char *action
, const struct strbuf
*msg
,
1182 struct ref_transaction
*transaction
;
1183 struct strbuf sb
= STRBUF_INIT
;
1188 strbuf_addstr(&sb
, action
);
1189 strbuf_addstr(&sb
, ": ");
1192 nl
= strchr(msg
->buf
, '\n');
1194 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
1196 strbuf_addbuf(&sb
, msg
);
1197 strbuf_addch(&sb
, '\n');
1200 transaction
= ref_transaction_begin(err
);
1202 ref_transaction_update(transaction
, "HEAD", new_head
,
1203 old_head
? &old_head
->object
.oid
: null_oid(),
1205 ref_transaction_commit(transaction
, err
)) {
1208 ref_transaction_free(transaction
);
1209 strbuf_release(&sb
);
1214 static int run_rewrite_hook(const struct object_id
*oldoid
,
1215 const struct object_id
*newoid
)
1217 struct child_process proc
= CHILD_PROCESS_INIT
;
1219 struct strbuf sb
= STRBUF_INIT
;
1220 const char *hook_path
= find_hook("post-rewrite");
1225 strvec_pushl(&proc
.args
, hook_path
, "amend", NULL
);
1227 proc
.stdout_to_stderr
= 1;
1228 proc
.trace2_hook_name
= "post-rewrite";
1230 code
= start_command(&proc
);
1233 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
1234 sigchain_push(SIGPIPE
, SIG_IGN
);
1235 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
1237 strbuf_release(&sb
);
1238 sigchain_pop(SIGPIPE
);
1239 return finish_command(&proc
);
1242 void commit_post_rewrite(struct repository
*r
,
1243 const struct commit
*old_head
,
1244 const struct object_id
*new_head
)
1246 struct notes_rewrite_cfg
*cfg
;
1248 cfg
= init_copy_notes_for_rewrite("amend");
1250 /* we are amending, so old_head is not NULL */
1251 copy_note_for_rewrite(cfg
, &old_head
->object
.oid
, new_head
);
1252 finish_copy_notes_for_rewrite(r
, cfg
, "Notes added by 'git commit --amend'");
1254 run_rewrite_hook(&old_head
->object
.oid
, new_head
);
1257 static int run_prepare_commit_msg_hook(struct repository
*r
,
1262 const char *name
, *arg1
= NULL
, *arg2
= NULL
;
1264 name
= git_path_commit_editmsg();
1265 if (write_message(msg
->buf
, msg
->len
, name
, 0))
1274 if (run_commit_hook(0, r
->index_file
, NULL
, "prepare-commit-msg", name
,
1276 ret
= error(_("'prepare-commit-msg' hook failed"));
1281 static const char implicit_ident_advice_noconfig
[] =
1282 N_("Your name and email address were configured automatically based\n"
1283 "on your username and hostname. Please check that they are accurate.\n"
1284 "You can suppress this message by setting them explicitly. Run the\n"
1285 "following command and follow the instructions in your editor to edit\n"
1286 "your configuration file:\n"
1288 " git config --global --edit\n"
1290 "After doing this, you may fix the identity used for this commit with:\n"
1292 " git commit --amend --reset-author\n");
1294 static const char implicit_ident_advice_config
[] =
1295 N_("Your name and email address were configured automatically based\n"
1296 "on your username and hostname. Please check that they are accurate.\n"
1297 "You can suppress this message by setting them explicitly:\n"
1299 " git config --global user.name \"Your Name\"\n"
1300 " git config --global user.email you@example.com\n"
1302 "After doing this, you may fix the identity used for this commit with:\n"
1304 " git commit --amend --reset-author\n");
1306 static const char *implicit_ident_advice(void)
1308 char *user_config
= interpolate_path("~/.gitconfig", 0);
1309 char *xdg_config
= xdg_config_home("config");
1310 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1316 return _(implicit_ident_advice_config
);
1318 return _(implicit_ident_advice_noconfig
);
1322 void print_commit_summary(struct repository
*r
,
1324 const struct object_id
*oid
,
1327 struct rev_info rev
;
1328 struct commit
*commit
;
1329 struct strbuf format
= STRBUF_INIT
;
1331 struct pretty_print_context pctx
= {0};
1332 struct strbuf author_ident
= STRBUF_INIT
;
1333 struct strbuf committer_ident
= STRBUF_INIT
;
1334 struct ref_store
*refs
;
1336 commit
= lookup_commit(r
, oid
);
1338 die(_("couldn't look up newly created commit"));
1339 if (parse_commit(commit
))
1340 die(_("could not parse newly created commit"));
1342 strbuf_addstr(&format
, "format:%h] %s");
1344 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1345 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1346 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1347 strbuf_addstr(&format
, "\n Author: ");
1348 strbuf_addbuf_percentquote(&format
, &author_ident
);
1350 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
1351 struct strbuf date
= STRBUF_INIT
;
1353 format_commit_message(commit
, "%ad", &date
, &pctx
);
1354 strbuf_addstr(&format
, "\n Date: ");
1355 strbuf_addbuf_percentquote(&format
, &date
);
1356 strbuf_release(&date
);
1358 if (!committer_ident_sufficiently_given()) {
1359 strbuf_addstr(&format
, "\n Committer: ");
1360 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1361 if (advice_enabled(ADVICE_IMPLICIT_IDENTITY
)) {
1362 strbuf_addch(&format
, '\n');
1363 strbuf_addstr(&format
, implicit_ident_advice());
1366 strbuf_release(&author_ident
);
1367 strbuf_release(&committer_ident
);
1369 repo_init_revisions(r
, &rev
, prefix
);
1370 setup_revisions(0, NULL
, &rev
, NULL
);
1373 rev
.diffopt
.output_format
=
1374 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1376 rev
.verbose_header
= 1;
1377 rev
.show_root_diff
= 1;
1378 get_commit_format(format
.buf
, &rev
);
1379 rev
.always_show_header
= 0;
1380 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1381 diff_setup_done(&rev
.diffopt
);
1383 refs
= get_main_ref_store(the_repository
);
1384 head
= refs_resolve_ref_unsafe(refs
, "HEAD", 0, NULL
, NULL
);
1386 die(_("unable to resolve HEAD after creating commit"));
1387 if (!strcmp(head
, "HEAD"))
1388 head
= _("detached HEAD");
1390 skip_prefix(head
, "refs/heads/", &head
);
1391 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1392 _(" (root-commit)") : "");
1394 if (!log_tree_commit(&rev
, commit
)) {
1395 rev
.always_show_header
= 1;
1396 rev
.use_terminator
= 1;
1397 log_tree_commit(&rev
, commit
);
1400 release_revisions(&rev
);
1401 strbuf_release(&format
);
1404 static int parse_head(struct repository
*r
, struct commit
**head
)
1406 struct commit
*current_head
;
1407 struct object_id oid
;
1409 if (get_oid("HEAD", &oid
)) {
1410 current_head
= NULL
;
1412 current_head
= lookup_commit_reference(r
, &oid
);
1414 return error(_("could not parse HEAD"));
1415 if (!oideq(&oid
, ¤t_head
->object
.oid
)) {
1416 warning(_("HEAD %s is not a commit!"),
1419 if (parse_commit(current_head
))
1420 return error(_("could not parse HEAD commit"));
1422 *head
= current_head
;
1428 * Try to commit without forking 'git commit'. In some cases we need
1429 * to run 'git commit' to display an error message
1432 * -1 - error unable to commit
1434 * 1 - run 'git commit'
1436 static int try_to_commit(struct repository
*r
,
1437 struct strbuf
*msg
, const char *author
,
1438 struct replay_opts
*opts
, unsigned int flags
,
1439 struct object_id
*oid
)
1441 struct object_id tree
;
1442 struct commit
*current_head
= NULL
;
1443 struct commit_list
*parents
= NULL
;
1444 struct commit_extra_header
*extra
= NULL
;
1445 struct strbuf err
= STRBUF_INIT
;
1446 struct strbuf commit_msg
= STRBUF_INIT
;
1447 char *amend_author
= NULL
;
1448 const char *committer
= NULL
;
1449 const char *hook_commit
= NULL
;
1450 enum commit_msg_cleanup_mode cleanup
;
1453 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1454 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1456 if (parse_head(r
, ¤t_head
))
1459 if (flags
& AMEND_MSG
) {
1460 const char *exclude_gpgsig
[] = { "gpgsig", "gpgsig-sha256", NULL
};
1461 const char *out_enc
= get_commit_output_encoding();
1462 const char *message
= logmsg_reencode(current_head
, NULL
,
1466 const char *orig_message
= NULL
;
1468 find_commit_subject(message
, &orig_message
);
1470 strbuf_addstr(msg
, orig_message
);
1471 hook_commit
= "HEAD";
1473 author
= amend_author
= get_author(message
);
1474 unuse_commit_buffer(current_head
, message
);
1476 res
= error(_("unable to parse commit author"));
1479 parents
= copy_commit_list(current_head
->parents
);
1480 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1481 } else if (current_head
&&
1482 (!(flags
& CREATE_ROOT_COMMIT
) || (flags
& AMEND_MSG
))) {
1483 commit_list_insert(current_head
, &parents
);
1486 if (write_index_as_tree(&tree
, r
->index
, r
->index_file
, 0, NULL
)) {
1487 res
= error(_("git write-tree failed to write a tree"));
1491 if (!(flags
& ALLOW_EMPTY
)) {
1492 struct commit
*first_parent
= current_head
;
1494 if (flags
& AMEND_MSG
) {
1495 if (current_head
->parents
) {
1496 first_parent
= current_head
->parents
->item
;
1497 if (repo_parse_commit(r
, first_parent
)) {
1498 res
= error(_("could not parse HEAD commit"));
1502 first_parent
= NULL
;
1505 if (oideq(first_parent
1506 ? get_commit_tree_oid(first_parent
)
1507 : the_hash_algo
->empty_tree
,
1509 res
= 1; /* run 'git commit' to display error message */
1514 if (hook_exists("prepare-commit-msg")) {
1515 res
= run_prepare_commit_msg_hook(r
, msg
, hook_commit
);
1518 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1520 res
= error_errno(_("unable to read commit message "
1522 git_path_commit_editmsg());
1528 if (flags
& CLEANUP_MSG
)
1529 cleanup
= COMMIT_MSG_CLEANUP_ALL
;
1530 else if (flags
& VERBATIM_MSG
)
1531 cleanup
= COMMIT_MSG_CLEANUP_NONE
;
1532 else if ((opts
->signoff
|| opts
->record_origin
) &&
1533 !opts
->explicit_cleanup
)
1534 cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
1536 cleanup
= opts
->default_msg_cleanup
;
1538 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1539 strbuf_stripspace(msg
, cleanup
== COMMIT_MSG_CLEANUP_ALL
);
1540 if ((flags
& EDIT_MSG
) && message_is_empty(msg
, cleanup
)) {
1541 res
= 1; /* run 'git commit' to display error message */
1545 if (opts
->committer_date_is_author_date
) {
1546 struct ident_split id
;
1547 struct strbuf date
= STRBUF_INIT
;
1549 if (!opts
->ignore_date
) {
1550 if (split_ident_line(&id
, author
, (int)strlen(author
)) < 0) {
1551 res
= error(_("invalid author identity '%s'"),
1555 if (!id
.date_begin
) {
1557 "corrupt author: missing date information"));
1560 strbuf_addf(&date
, "@%.*s %.*s",
1561 (int)(id
.date_end
- id
.date_begin
),
1563 (int)(id
.tz_end
- id
.tz_begin
),
1568 committer
= fmt_ident(getenv("GIT_COMMITTER_NAME"),
1569 getenv("GIT_COMMITTER_EMAIL"),
1570 WANT_COMMITTER_IDENT
,
1571 opts
->ignore_date
? NULL
: date
.buf
,
1573 strbuf_release(&date
);
1578 if (opts
->ignore_date
) {
1579 struct ident_split id
;
1582 if (split_ident_line(&id
, author
, strlen(author
)) < 0) {
1583 error(_("invalid author identity '%s'"), author
);
1586 name
= xmemdupz(id
.name_begin
, id
.name_end
- id
.name_begin
);
1587 email
= xmemdupz(id
.mail_begin
, id
.mail_end
- id
.mail_begin
);
1588 author
= fmt_ident(name
, email
, WANT_AUTHOR_IDENT
, NULL
,
1594 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
, oid
,
1595 author
, committer
, opts
->gpg_sign
, extra
)) {
1596 res
= error(_("failed to write commit object"));
1600 if (update_head_with_reflog(current_head
, oid
, opts
->reflog_message
,
1602 res
= error("%s", err
.buf
);
1606 run_commit_hook(0, r
->index_file
, NULL
, "post-commit", NULL
);
1607 if (flags
& AMEND_MSG
)
1608 commit_post_rewrite(r
, current_head
, oid
);
1611 free_commit_extra_headers(extra
);
1612 strbuf_release(&err
);
1613 strbuf_release(&commit_msg
);
1619 static int write_rebase_head(struct object_id
*oid
)
1621 if (update_ref("rebase", "REBASE_HEAD", oid
,
1622 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1623 return error(_("could not update %s"), "REBASE_HEAD");
1628 static int do_commit(struct repository
*r
,
1629 const char *msg_file
, const char *author
,
1630 struct replay_opts
*opts
, unsigned int flags
,
1631 struct object_id
*oid
)
1635 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
)) {
1636 struct object_id oid
;
1637 struct strbuf sb
= STRBUF_INIT
;
1639 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1640 return error_errno(_("unable to read commit message "
1644 res
= try_to_commit(r
, msg_file
? &sb
: NULL
,
1645 author
, opts
, flags
, &oid
);
1646 strbuf_release(&sb
);
1648 refs_delete_ref(get_main_ref_store(r
), "",
1649 "CHERRY_PICK_HEAD", NULL
, 0);
1650 unlink(git_path_merge_msg(r
));
1651 if (!is_rebase_i(opts
))
1652 print_commit_summary(r
, NULL
, &oid
,
1653 SUMMARY_SHOW_AUTHOR_DATE
);
1658 if (is_rebase_i(opts
) && oid
)
1659 if (write_rebase_head(oid
))
1661 return run_git_commit(msg_file
, opts
, flags
);
1667 static int is_original_commit_empty(struct commit
*commit
)
1669 const struct object_id
*ptree_oid
;
1671 if (parse_commit(commit
))
1672 return error(_("could not parse commit %s"),
1673 oid_to_hex(&commit
->object
.oid
));
1674 if (commit
->parents
) {
1675 struct commit
*parent
= commit
->parents
->item
;
1676 if (parse_commit(parent
))
1677 return error(_("could not parse parent commit %s"),
1678 oid_to_hex(&parent
->object
.oid
));
1679 ptree_oid
= get_commit_tree_oid(parent
);
1681 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1684 return oideq(ptree_oid
, get_commit_tree_oid(commit
));
1688 * Should empty commits be allowed? Return status:
1689 * <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1690 * 0: Halt on empty commit
1691 * 1: Allow empty commit
1692 * 2: Drop empty commit
1694 static int allow_empty(struct repository
*r
,
1695 struct replay_opts
*opts
,
1696 struct commit
*commit
)
1698 int index_unchanged
, originally_empty
;
1703 * (1) we do not allow empty at all and error out.
1705 * (2) we allow ones that were initially empty, and
1706 * just drop the ones that become empty
1708 * (3) we allow ones that were initially empty, but
1709 * halt for the ones that become empty;
1711 * (4) we allow both.
1713 if (!opts
->allow_empty
)
1714 return 0; /* let "git commit" barf as necessary */
1716 index_unchanged
= is_index_unchanged(r
);
1717 if (index_unchanged
< 0)
1718 return index_unchanged
;
1719 if (!index_unchanged
)
1720 return 0; /* we do not have to say --allow-empty */
1722 if (opts
->keep_redundant_commits
)
1725 originally_empty
= is_original_commit_empty(commit
);
1726 if (originally_empty
< 0)
1727 return originally_empty
;
1728 if (originally_empty
)
1730 else if (opts
->drop_redundant_commits
)
1739 } todo_command_info
[] = {
1740 [TODO_PICK
] = { 'p', "pick" },
1741 [TODO_REVERT
] = { 0, "revert" },
1742 [TODO_EDIT
] = { 'e', "edit" },
1743 [TODO_REWORD
] = { 'r', "reword" },
1744 [TODO_FIXUP
] = { 'f', "fixup" },
1745 [TODO_SQUASH
] = { 's', "squash" },
1746 [TODO_EXEC
] = { 'x', "exec" },
1747 [TODO_BREAK
] = { 'b', "break" },
1748 [TODO_LABEL
] = { 'l', "label" },
1749 [TODO_RESET
] = { 't', "reset" },
1750 [TODO_MERGE
] = { 'm', "merge" },
1751 [TODO_UPDATE_REF
] = { 'u', "update-ref" },
1752 [TODO_NOOP
] = { 0, "noop" },
1753 [TODO_DROP
] = { 'd', "drop" },
1754 [TODO_COMMENT
] = { 0, NULL
},
1757 static const char *command_to_string(const enum todo_command command
)
1759 if (command
< TODO_COMMENT
)
1760 return todo_command_info
[command
].str
;
1761 die(_("unknown command: %d"), command
);
1764 static char command_to_char(const enum todo_command command
)
1766 if (command
< TODO_COMMENT
)
1767 return todo_command_info
[command
].c
;
1768 return comment_line_char
;
1771 static int is_noop(const enum todo_command command
)
1773 return TODO_NOOP
<= command
;
1776 static int is_fixup(enum todo_command command
)
1778 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1781 /* Does this command create a (non-merge) commit? */
1782 static int is_pick_or_similar(enum todo_command command
)
1797 enum todo_item_flags
{
1798 TODO_EDIT_MERGE_MSG
= (1 << 0),
1799 TODO_REPLACE_FIXUP_MSG
= (1 << 1),
1800 TODO_EDIT_FIXUP_MSG
= (1 << 2),
1803 static const char first_commit_msg_str
[] = N_("This is the 1st commit message:");
1804 static const char nth_commit_msg_fmt
[] = N_("This is the commit message #%d:");
1805 static const char skip_first_commit_msg_str
[] = N_("The 1st commit message will be skipped:");
1806 static const char skip_nth_commit_msg_fmt
[] = N_("The commit message #%d will be skipped:");
1807 static const char combined_commit_msg_fmt
[] = N_("This is a combination of %d commits.");
1809 static int is_fixup_flag(enum todo_command command
, unsigned flag
)
1811 return command
== TODO_FIXUP
&& ((flag
& TODO_REPLACE_FIXUP_MSG
) ||
1812 (flag
& TODO_EDIT_FIXUP_MSG
));
1816 * Wrapper around strbuf_add_commented_lines() which avoids double
1817 * commenting commit subjects.
1819 static void add_commented_lines(struct strbuf
*buf
, const void *str
, size_t len
)
1821 const char *s
= str
;
1822 while (len
> 0 && s
[0] == comment_line_char
) {
1824 const char *n
= memchr(s
, '\n', len
);
1829 strbuf_add(buf
, s
, count
);
1833 strbuf_add_commented_lines(buf
, s
, len
);
1836 /* Does the current fixup chain contain a squash command? */
1837 static int seen_squash(struct replay_opts
*opts
)
1839 return starts_with(opts
->current_fixups
.buf
, "squash") ||
1840 strstr(opts
->current_fixups
.buf
, "\nsquash");
1843 static void update_comment_bufs(struct strbuf
*buf1
, struct strbuf
*buf2
, int n
)
1845 strbuf_setlen(buf1
, 2);
1846 strbuf_addf(buf1
, _(nth_commit_msg_fmt
), n
);
1847 strbuf_addch(buf1
, '\n');
1848 strbuf_setlen(buf2
, 2);
1849 strbuf_addf(buf2
, _(skip_nth_commit_msg_fmt
), n
);
1850 strbuf_addch(buf2
, '\n');
1854 * Comment out any un-commented commit messages, updating the message comments
1855 * to say they will be skipped but do not comment out the empty lines that
1856 * surround commit messages and their comments.
1858 static void update_squash_message_for_fixup(struct strbuf
*msg
)
1860 void (*copy_lines
)(struct strbuf
*, const void *, size_t) = strbuf_add
;
1861 struct strbuf buf1
= STRBUF_INIT
, buf2
= STRBUF_INIT
;
1862 const char *s
, *start
;
1864 size_t orig_msg_len
;
1867 strbuf_addf(&buf1
, "# %s\n", _(first_commit_msg_str
));
1868 strbuf_addf(&buf2
, "# %s\n", _(skip_first_commit_msg_str
));
1869 s
= start
= orig_msg
= strbuf_detach(msg
, &orig_msg_len
);
1873 if (skip_prefix(s
, buf1
.buf
, &next
)) {
1875 * Copy the last message, preserving the blank line
1876 * preceding the current line
1878 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1879 copy_lines(msg
, start
, s
- start
- off
);
1881 strbuf_addch(msg
, '\n');
1883 * The next message needs to be commented out but the
1884 * message header is already commented out so just copy
1885 * it and the blank line that follows it.
1887 strbuf_addbuf(msg
, &buf2
);
1889 strbuf_addch(msg
, *next
++);
1891 copy_lines
= add_commented_lines
;
1892 update_comment_bufs(&buf1
, &buf2
, ++i
);
1893 } else if (skip_prefix(s
, buf2
.buf
, &next
)) {
1894 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1895 copy_lines(msg
, start
, s
- start
- off
);
1898 copy_lines
= strbuf_add
;
1899 update_comment_bufs(&buf1
, &buf2
, ++i
);
1901 s
= strchr(s
, '\n');
1906 copy_lines(msg
, start
, orig_msg_len
- (start
- orig_msg
));
1908 strbuf_release(&buf1
);
1909 strbuf_release(&buf2
);
1912 static int append_squash_message(struct strbuf
*buf
, const char *body
,
1913 enum todo_command command
, struct replay_opts
*opts
,
1916 const char *fixup_msg
;
1917 size_t commented_len
= 0, fixup_off
;
1919 * amend is non-interactive and not normally used with fixup!
1920 * or squash! commits, so only comment out those subjects when
1921 * squashing commit messages.
1923 if (starts_with(body
, "amend!") ||
1924 ((command
== TODO_SQUASH
|| seen_squash(opts
)) &&
1925 (starts_with(body
, "squash!") || starts_with(body
, "fixup!"))))
1926 commented_len
= commit_subject_length(body
);
1928 strbuf_addf(buf
, "\n%c ", comment_line_char
);
1929 strbuf_addf(buf
, _(nth_commit_msg_fmt
),
1930 ++opts
->current_fixup_count
+ 1);
1931 strbuf_addstr(buf
, "\n\n");
1932 strbuf_add_commented_lines(buf
, body
, commented_len
);
1933 /* buf->buf may be reallocated so store an offset into the buffer */
1934 fixup_off
= buf
->len
;
1935 strbuf_addstr(buf
, body
+ commented_len
);
1937 /* fixup -C after squash behaves like squash */
1938 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
)) {
1940 * We're replacing the commit message so we need to
1941 * append the Signed-off-by: trailer if the user
1942 * requested '--signoff'.
1945 append_signoff(buf
, 0, 0);
1947 if ((command
== TODO_FIXUP
) &&
1948 (flag
& TODO_REPLACE_FIXUP_MSG
) &&
1949 (file_exists(rebase_path_fixup_msg()) ||
1950 !file_exists(rebase_path_squash_msg()))) {
1951 fixup_msg
= skip_blank_lines(buf
->buf
+ fixup_off
);
1952 if (write_message(fixup_msg
, strlen(fixup_msg
),
1953 rebase_path_fixup_msg(), 0) < 0)
1954 return error(_("cannot write '%s'"),
1955 rebase_path_fixup_msg());
1957 unlink(rebase_path_fixup_msg());
1960 unlink(rebase_path_fixup_msg());
1966 static int update_squash_messages(struct repository
*r
,
1967 enum todo_command command
,
1968 struct commit
*commit
,
1969 struct replay_opts
*opts
,
1972 struct strbuf buf
= STRBUF_INIT
;
1974 const char *message
, *body
;
1975 const char *encoding
= get_commit_output_encoding();
1977 if (opts
->current_fixup_count
> 0) {
1978 struct strbuf header
= STRBUF_INIT
;
1981 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
1982 return error(_("could not read '%s'"),
1983 rebase_path_squash_msg());
1985 eol
= buf
.buf
[0] != comment_line_char
?
1986 buf
.buf
: strchrnul(buf
.buf
, '\n');
1988 strbuf_addf(&header
, "%c ", comment_line_char
);
1989 strbuf_addf(&header
, _(combined_commit_msg_fmt
),
1990 opts
->current_fixup_count
+ 2);
1991 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
1992 strbuf_release(&header
);
1993 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
))
1994 update_squash_message_for_fixup(&buf
);
1996 struct object_id head
;
1997 struct commit
*head_commit
;
1998 const char *head_message
, *body
;
2000 if (get_oid("HEAD", &head
))
2001 return error(_("need a HEAD to fixup"));
2002 if (!(head_commit
= lookup_commit_reference(r
, &head
)))
2003 return error(_("could not read HEAD"));
2004 if (!(head_message
= logmsg_reencode(head_commit
, NULL
, encoding
)))
2005 return error(_("could not read HEAD's commit message"));
2007 find_commit_subject(head_message
, &body
);
2008 if (command
== TODO_FIXUP
&& !flag
&& write_message(body
, strlen(body
),
2009 rebase_path_fixup_msg(), 0) < 0) {
2010 unuse_commit_buffer(head_commit
, head_message
);
2011 return error(_("cannot write '%s'"), rebase_path_fixup_msg());
2013 strbuf_addf(&buf
, "%c ", comment_line_char
);
2014 strbuf_addf(&buf
, _(combined_commit_msg_fmt
), 2);
2015 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
2016 strbuf_addstr(&buf
, is_fixup_flag(command
, flag
) ?
2017 _(skip_first_commit_msg_str
) :
2018 _(first_commit_msg_str
));
2019 strbuf_addstr(&buf
, "\n\n");
2020 if (is_fixup_flag(command
, flag
))
2021 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
2023 strbuf_addstr(&buf
, body
);
2025 unuse_commit_buffer(head_commit
, head_message
);
2028 if (!(message
= logmsg_reencode(commit
, NULL
, encoding
)))
2029 return error(_("could not read commit message of %s"),
2030 oid_to_hex(&commit
->object
.oid
));
2031 find_commit_subject(message
, &body
);
2033 if (command
== TODO_SQUASH
|| is_fixup_flag(command
, flag
)) {
2034 res
= append_squash_message(&buf
, body
, command
, opts
, flag
);
2035 } else if (command
== TODO_FIXUP
) {
2036 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
2037 strbuf_addf(&buf
, _(skip_nth_commit_msg_fmt
),
2038 ++opts
->current_fixup_count
+ 1);
2039 strbuf_addstr(&buf
, "\n\n");
2040 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
2042 return error(_("unknown command: %d"), command
);
2043 unuse_commit_buffer(commit
, message
);
2046 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(),
2048 strbuf_release(&buf
);
2051 strbuf_addf(&opts
->current_fixups
, "%s%s %s",
2052 opts
->current_fixups
.len
? "\n" : "",
2053 command_to_string(command
),
2054 oid_to_hex(&commit
->object
.oid
));
2055 res
= write_message(opts
->current_fixups
.buf
,
2056 opts
->current_fixups
.len
,
2057 rebase_path_current_fixups(), 0);
2063 static void flush_rewritten_pending(void)
2065 struct strbuf buf
= STRBUF_INIT
;
2066 struct object_id newoid
;
2069 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
2070 !get_oid("HEAD", &newoid
) &&
2071 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
2072 char *bol
= buf
.buf
, *eol
;
2075 eol
= strchrnul(bol
, '\n');
2076 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
2077 bol
, oid_to_hex(&newoid
));
2083 unlink(rebase_path_rewritten_pending());
2085 strbuf_release(&buf
);
2088 static void record_in_rewritten(struct object_id
*oid
,
2089 enum todo_command next_command
)
2091 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
2096 fprintf(out
, "%s\n", oid_to_hex(oid
));
2099 if (!is_fixup(next_command
))
2100 flush_rewritten_pending();
2103 static int should_edit(struct replay_opts
*opts
) {
2106 * Note that we only handle the case of non-conflicted
2107 * commits; continue_single_pick() handles the conflicted
2108 * commits itself instead of calling this function.
2110 return (opts
->action
== REPLAY_REVERT
&& isatty(0)) ? 1 : 0;
2114 static void refer_to_commit(struct replay_opts
*opts
,
2115 struct strbuf
*msgbuf
, struct commit
*commit
)
2117 if (opts
->commit_use_reference
) {
2118 struct pretty_print_context ctx
= {
2119 .abbrev
= DEFAULT_ABBREV
,
2120 .date_mode
.type
= DATE_SHORT
,
2122 format_commit_message(commit
, "%h (%s, %ad)", msgbuf
, &ctx
);
2124 strbuf_addstr(msgbuf
, oid_to_hex(&commit
->object
.oid
));
2128 static int do_pick_commit(struct repository
*r
,
2129 struct todo_item
*item
,
2130 struct replay_opts
*opts
,
2131 int final_fixup
, int *check_todo
)
2133 unsigned int flags
= should_edit(opts
) ? EDIT_MSG
: 0;
2134 const char *msg_file
= should_edit(opts
) ? NULL
: git_path_merge_msg(r
);
2135 struct object_id head
;
2136 struct commit
*base
, *next
, *parent
;
2137 const char *base_label
, *next_label
;
2138 char *author
= NULL
;
2139 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
2140 struct strbuf msgbuf
= STRBUF_INIT
;
2141 int res
, unborn
= 0, reword
= 0, allow
, drop_commit
;
2142 enum todo_command command
= item
->command
;
2143 struct commit
*commit
= item
->commit
;
2145 if (opts
->no_commit
) {
2147 * We do not intend to commit immediately. We just want to
2148 * merge the differences in, so let's compute the tree
2149 * that represents the "current" state for the merge machinery
2152 if (write_index_as_tree(&head
, r
->index
, r
->index_file
, 0, NULL
))
2153 return error(_("your index file is unmerged."));
2155 unborn
= get_oid("HEAD", &head
);
2156 /* Do we want to generate a root commit? */
2157 if (is_pick_or_similar(command
) && opts
->have_squash_onto
&&
2158 oideq(&head
, &opts
->squash_onto
)) {
2159 if (is_fixup(command
))
2160 return error(_("cannot fixup root commit"));
2161 flags
|= CREATE_ROOT_COMMIT
;
2164 oidcpy(&head
, the_hash_algo
->empty_tree
);
2165 if (index_differs_from(r
, unborn
? empty_tree_oid_hex() : "HEAD",
2167 return error_dirty_index(r
, opts
);
2169 discard_index(r
->index
);
2171 if (!commit
->parents
)
2173 else if (commit
->parents
->next
) {
2174 /* Reverting or cherry-picking a merge commit */
2176 struct commit_list
*p
;
2178 if (!opts
->mainline
)
2179 return error(_("commit %s is a merge but no -m option was given."),
2180 oid_to_hex(&commit
->object
.oid
));
2182 for (cnt
= 1, p
= commit
->parents
;
2183 cnt
!= opts
->mainline
&& p
;
2186 if (cnt
!= opts
->mainline
|| !p
)
2187 return error(_("commit %s does not have parent %d"),
2188 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2190 } else if (1 < opts
->mainline
)
2192 * Non-first parent explicitly specified as mainline for
2195 return error(_("commit %s does not have parent %d"),
2196 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2198 parent
= commit
->parents
->item
;
2200 if (get_message(commit
, &msg
) != 0)
2201 return error(_("cannot get commit message for %s"),
2202 oid_to_hex(&commit
->object
.oid
));
2204 if (opts
->allow_ff
&& !is_fixup(command
) &&
2205 ((parent
&& oideq(&parent
->object
.oid
, &head
)) ||
2206 (!parent
&& unborn
))) {
2207 if (is_rebase_i(opts
))
2208 write_author_script(msg
.message
);
2209 res
= fast_forward_to(r
, &commit
->object
.oid
, &head
, unborn
,
2211 if (res
|| command
!= TODO_REWORD
)
2215 goto fast_forward_edit
;
2217 if (parent
&& parse_commit(parent
) < 0)
2218 /* TRANSLATORS: The first %s will be a "todo" command like
2219 "revert" or "pick", the second %s a SHA1. */
2220 return error(_("%s: cannot parse parent commit %s"),
2221 command_to_string(command
),
2222 oid_to_hex(&parent
->object
.oid
));
2225 * "commit" is an existing commit. We would want to apply
2226 * the difference it introduces since its first parent "prev"
2227 * on top of the current HEAD if we are cherry-pick. Or the
2228 * reverse of it if we are revert.
2231 if (command
== TODO_REVERT
) {
2233 base_label
= msg
.label
;
2235 next_label
= msg
.parent_label
;
2236 if (opts
->commit_use_reference
) {
2237 strbuf_addstr(&msgbuf
,
2238 "# *** SAY WHY WE ARE REVERTING ON THE TITLE LINE ***");
2240 strbuf_addstr(&msgbuf
, "Revert \"");
2241 strbuf_addstr(&msgbuf
, msg
.subject
);
2242 strbuf_addstr(&msgbuf
, "\"");
2244 strbuf_addstr(&msgbuf
, "\n\nThis reverts commit ");
2245 refer_to_commit(opts
, &msgbuf
, commit
);
2247 if (commit
->parents
&& commit
->parents
->next
) {
2248 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
2249 refer_to_commit(opts
, &msgbuf
, parent
);
2251 strbuf_addstr(&msgbuf
, ".\n");
2256 base_label
= msg
.parent_label
;
2258 next_label
= msg
.label
;
2260 /* Append the commit log message to msgbuf. */
2261 if (find_commit_subject(msg
.message
, &p
))
2262 strbuf_addstr(&msgbuf
, p
);
2264 if (opts
->record_origin
) {
2265 strbuf_complete_line(&msgbuf
);
2266 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
2267 strbuf_addch(&msgbuf
, '\n');
2268 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
2269 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
2270 strbuf_addstr(&msgbuf
, ")\n");
2272 if (!is_fixup(command
))
2273 author
= get_author(msg
.message
);
2276 if (command
== TODO_REWORD
)
2278 else if (is_fixup(command
)) {
2279 if (update_squash_messages(r
, command
, commit
,
2280 opts
, item
->flags
)) {
2286 msg_file
= rebase_path_squash_msg();
2287 else if (file_exists(rebase_path_fixup_msg())) {
2288 flags
|= VERBATIM_MSG
;
2289 msg_file
= rebase_path_fixup_msg();
2291 const char *dest
= git_path_squash_msg(r
);
2293 if (copy_file(dest
, rebase_path_squash_msg(), 0666)) {
2294 res
= error(_("could not rename '%s' to '%s'"),
2295 rebase_path_squash_msg(), dest
);
2298 unlink(git_path_merge_msg(r
));
2304 if (opts
->signoff
&& !is_fixup(command
))
2305 append_signoff(&msgbuf
, 0, 0);
2307 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
2309 else if (!opts
->strategy
||
2310 !strcmp(opts
->strategy
, "recursive") ||
2311 !strcmp(opts
->strategy
, "ort") ||
2312 command
== TODO_REVERT
) {
2313 res
= do_recursive_merge(r
, base
, next
, base_label
, next_label
,
2314 &head
, &msgbuf
, opts
);
2318 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
2319 git_path_merge_msg(r
), 0);
2321 struct commit_list
*common
= NULL
;
2322 struct commit_list
*remotes
= NULL
;
2324 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
2325 git_path_merge_msg(r
), 0);
2327 commit_list_insert(base
, &common
);
2328 commit_list_insert(next
, &remotes
);
2329 res
|= try_merge_command(r
, opts
->strategy
,
2330 opts
->xopts_nr
, (const char **)opts
->xopts
,
2331 common
, oid_to_hex(&head
), remotes
);
2332 free_commit_list(common
);
2333 free_commit_list(remotes
);
2337 * If the merge was clean or if it failed due to conflict, we write
2338 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
2339 * However, if the merge did not even start, then we don't want to
2342 if ((command
== TODO_PICK
|| command
== TODO_REWORD
||
2343 command
== TODO_EDIT
) && !opts
->no_commit
&&
2344 (res
== 0 || res
== 1) &&
2345 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
2346 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2348 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
2349 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
2350 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2354 error(command
== TODO_REVERT
2355 ? _("could not revert %s... %s")
2356 : _("could not apply %s... %s"),
2357 short_commit_name(commit
), msg
.subject
);
2358 print_advice(r
, res
== 1, opts
);
2359 repo_rerere(r
, opts
->allow_rerere_auto
);
2364 allow
= allow_empty(r
, opts
, commit
);
2368 } else if (allow
== 1) {
2369 flags
|= ALLOW_EMPTY
;
2370 } else if (allow
== 2) {
2372 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
2374 unlink(git_path_merge_msg(r
));
2375 unlink(git_path_auto_merge(r
));
2377 _("dropping %s %s -- patch contents already upstream\n"),
2378 oid_to_hex(&commit
->object
.oid
), msg
.subject
);
2379 } /* else allow == 0 and there's nothing special to do */
2380 if (!opts
->no_commit
&& !drop_commit
) {
2381 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
2382 res
= do_commit(r
, msg_file
, author
, opts
, flags
,
2383 commit
? &commit
->object
.oid
: NULL
);
2385 res
= error(_("unable to parse commit author"));
2386 *check_todo
= !!(flags
& EDIT_MSG
);
2387 if (!res
&& reword
) {
2389 res
= run_git_commit(NULL
, opts
, EDIT_MSG
|
2390 VERIFY_MSG
| AMEND_MSG
|
2391 (flags
& ALLOW_EMPTY
));
2397 if (!res
&& final_fixup
) {
2398 unlink(rebase_path_fixup_msg());
2399 unlink(rebase_path_squash_msg());
2400 unlink(rebase_path_current_fixups());
2401 strbuf_reset(&opts
->current_fixups
);
2402 opts
->current_fixup_count
= 0;
2406 free_message(commit
, &msg
);
2408 strbuf_release(&msgbuf
);
2409 update_abort_safety_file();
2414 static int prepare_revs(struct replay_opts
*opts
)
2417 * picking (but not reverting) ranges (but not individual revisions)
2418 * should be done in reverse
2420 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
2421 opts
->revs
->reverse
^= 1;
2423 if (prepare_revision_walk(opts
->revs
))
2424 return error(_("revision walk setup failed"));
2429 static int read_and_refresh_cache(struct repository
*r
,
2430 struct replay_opts
*opts
)
2432 struct lock_file index_lock
= LOCK_INIT
;
2433 int index_fd
= repo_hold_locked_index(r
, &index_lock
, 0);
2434 if (repo_read_index(r
) < 0) {
2435 rollback_lock_file(&index_lock
);
2436 return error(_("git %s: failed to read the index"),
2439 refresh_index(r
->index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
2441 if (index_fd
>= 0) {
2442 if (write_locked_index(r
->index
, &index_lock
,
2443 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
2444 return error(_("git %s: failed to refresh the index"),
2450 * If we are resolving merges in any way other than "ort", then
2451 * expand the sparse index.
2453 if (opts
->strategy
&& strcmp(opts
->strategy
, "ort"))
2454 ensure_full_index(r
->index
);
2458 void todo_list_release(struct todo_list
*todo_list
)
2460 strbuf_release(&todo_list
->buf
);
2461 FREE_AND_NULL(todo_list
->items
);
2462 todo_list
->nr
= todo_list
->alloc
= 0;
2465 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
2467 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
2468 todo_list
->total_nr
++;
2469 return todo_list
->items
+ todo_list
->nr
++;
2472 const char *todo_item_get_arg(struct todo_list
*todo_list
,
2473 struct todo_item
*item
)
2475 return todo_list
->buf
.buf
+ item
->arg_offset
;
2478 static int is_command(enum todo_command command
, const char **bol
)
2480 const char *str
= todo_command_info
[command
].str
;
2481 const char nick
= todo_command_info
[command
].c
;
2482 const char *p
= *bol
+ 1;
2484 return skip_prefix(*bol
, str
, bol
) ||
2485 ((nick
&& **bol
== nick
) &&
2486 (*p
== ' ' || *p
== '\t' || *p
== '\n' || *p
== '\r' || !*p
) &&
2490 static int check_label_or_ref_arg(enum todo_command command
, const char *arg
)
2495 * '#' is not a valid label as the merge command uses it to
2496 * separate merge parents from the commit subject.
2498 if (!strcmp(arg
, "#") ||
2499 check_refname_format(arg
, REFNAME_ALLOW_ONELEVEL
))
2500 return error(_("'%s' is not a valid label"), arg
);
2503 case TODO_UPDATE_REF
:
2504 if (check_refname_format(arg
, REFNAME_ALLOW_ONELEVEL
))
2505 return error(_("'%s' is not a valid refname"), arg
);
2506 if (check_refname_format(arg
, 0))
2507 return error(_("update-ref requires a fully qualified "
2508 "refname e.g. refs/heads/%s"), arg
);
2512 BUG("unexpected todo_command");
2518 static int parse_insn_line(struct repository
*r
, struct todo_item
*item
,
2519 const char *buf
, const char *bol
, char *eol
)
2521 struct object_id commit_oid
;
2522 char *end_of_object_name
;
2523 int i
, saved
, status
, padding
;
2528 bol
+= strspn(bol
, " \t");
2530 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
2531 item
->command
= TODO_COMMENT
;
2532 item
->commit
= NULL
;
2533 item
->arg_offset
= bol
- buf
;
2534 item
->arg_len
= eol
- bol
;
2538 for (i
= 0; i
< TODO_COMMENT
; i
++)
2539 if (is_command(i
, &bol
)) {
2543 if (i
>= TODO_COMMENT
)
2546 /* Eat up extra spaces/ tabs before object name */
2547 padding
= strspn(bol
, " \t");
2550 if (item
->command
== TODO_NOOP
|| item
->command
== TODO_BREAK
) {
2552 return error(_("%s does not accept arguments: '%s'"),
2553 command_to_string(item
->command
), bol
);
2554 item
->commit
= NULL
;
2555 item
->arg_offset
= bol
- buf
;
2556 item
->arg_len
= eol
- bol
;
2561 return error(_("missing arguments for %s"),
2562 command_to_string(item
->command
));
2564 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
2565 item
->command
== TODO_RESET
|| item
->command
== TODO_UPDATE_REF
) {
2568 item
->commit
= NULL
;
2569 item
->arg_offset
= bol
- buf
;
2570 item
->arg_len
= (int)(eol
- bol
);
2571 if (item
->command
== TODO_LABEL
||
2572 item
->command
== TODO_UPDATE_REF
) {
2575 ret
= check_label_or_ref_arg(item
->command
, bol
);
2581 if (item
->command
== TODO_FIXUP
) {
2582 if (skip_prefix(bol
, "-C", &bol
) &&
2583 (*bol
== ' ' || *bol
== '\t')) {
2584 bol
+= strspn(bol
, " \t");
2585 item
->flags
|= TODO_REPLACE_FIXUP_MSG
;
2586 } else if (skip_prefix(bol
, "-c", &bol
) &&
2587 (*bol
== ' ' || *bol
== '\t')) {
2588 bol
+= strspn(bol
, " \t");
2589 item
->flags
|= TODO_EDIT_FIXUP_MSG
;
2593 if (item
->command
== TODO_MERGE
) {
2594 if (skip_prefix(bol
, "-C", &bol
))
2595 bol
+= strspn(bol
, " \t");
2596 else if (skip_prefix(bol
, "-c", &bol
)) {
2597 bol
+= strspn(bol
, " \t");
2598 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2600 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2601 item
->commit
= NULL
;
2602 item
->arg_offset
= bol
- buf
;
2603 item
->arg_len
= (int)(eol
- bol
);
2608 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
2609 saved
= *end_of_object_name
;
2610 *end_of_object_name
= '\0';
2611 status
= get_oid(bol
, &commit_oid
);
2613 error(_("could not parse '%s'"), bol
); /* return later */
2614 *end_of_object_name
= saved
;
2616 bol
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2617 item
->arg_offset
= bol
- buf
;
2618 item
->arg_len
= (int)(eol
- bol
);
2623 item
->commit
= lookup_commit_reference(r
, &commit_oid
);
2624 return item
->commit
? 0 : -1;
2627 int sequencer_get_last_command(struct repository
*r
, enum replay_action
*action
)
2629 const char *todo_file
, *bol
;
2630 struct strbuf buf
= STRBUF_INIT
;
2633 todo_file
= git_path_todo_file();
2634 if (strbuf_read_file(&buf
, todo_file
, 0) < 0) {
2635 if (errno
== ENOENT
|| errno
== ENOTDIR
)
2638 return error_errno("unable to open '%s'", todo_file
);
2640 bol
= buf
.buf
+ strspn(buf
.buf
, " \t\r\n");
2641 if (is_command(TODO_PICK
, &bol
) && (*bol
== ' ' || *bol
== '\t'))
2642 *action
= REPLAY_PICK
;
2643 else if (is_command(TODO_REVERT
, &bol
) &&
2644 (*bol
== ' ' || *bol
== '\t'))
2645 *action
= REPLAY_REVERT
;
2649 strbuf_release(&buf
);
2654 int todo_list_parse_insn_buffer(struct repository
*r
, char *buf
,
2655 struct todo_list
*todo_list
)
2657 struct todo_item
*item
;
2658 char *p
= buf
, *next_p
;
2659 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2661 todo_list
->current
= todo_list
->nr
= 0;
2663 for (i
= 1; *p
; i
++, p
= next_p
) {
2664 char *eol
= strchrnul(p
, '\n');
2666 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2668 if (p
!= eol
&& eol
[-1] == '\r')
2669 eol
--; /* strip Carriage Return */
2671 item
= append_new_todo(todo_list
);
2672 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2673 if (parse_insn_line(r
, item
, buf
, p
, eol
)) {
2674 res
= error(_("invalid line %d: %.*s"),
2675 i
, (int)(eol
- p
), p
);
2676 item
->command
= TODO_COMMENT
+ 1;
2677 item
->arg_offset
= p
- buf
;
2678 item
->arg_len
= (int)(eol
- p
);
2679 item
->commit
= NULL
;
2684 else if (is_fixup(item
->command
))
2685 return error(_("cannot '%s' without a previous commit"),
2686 command_to_string(item
->command
));
2687 else if (!is_noop(item
->command
))
2694 static int count_commands(struct todo_list
*todo_list
)
2698 for (i
= 0; i
< todo_list
->nr
; i
++)
2699 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2705 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2707 return index
< todo_list
->nr
?
2708 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2711 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2713 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2716 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2718 return get_item_line_offset(todo_list
, index
+ 1)
2719 - get_item_line_offset(todo_list
, index
);
2722 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2727 fd
= open(path
, O_RDONLY
);
2729 return error_errno(_("could not open '%s'"), path
);
2730 len
= strbuf_read(sb
, fd
, 0);
2733 return error(_("could not read '%s'."), path
);
2737 static int have_finished_the_last_pick(void)
2739 struct strbuf buf
= STRBUF_INIT
;
2741 const char *todo_path
= git_path_todo_file();
2744 if (strbuf_read_file(&buf
, todo_path
, 0) < 0) {
2745 if (errno
== ENOENT
) {
2748 error_errno("unable to open '%s'", todo_path
);
2752 /* If there is only one line then we are done */
2753 eol
= strchr(buf
.buf
, '\n');
2754 if (!eol
|| !eol
[1])
2757 strbuf_release(&buf
);
2762 void sequencer_post_commit_cleanup(struct repository
*r
, int verbose
)
2764 struct replay_opts opts
= REPLAY_OPTS_INIT
;
2765 int need_cleanup
= 0;
2767 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
2768 if (!refs_delete_ref(get_main_ref_store(r
), "",
2769 "CHERRY_PICK_HEAD", NULL
, 0) &&
2771 warning(_("cancelling a cherry picking in progress"));
2772 opts
.action
= REPLAY_PICK
;
2776 if (refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
2777 if (!refs_delete_ref(get_main_ref_store(r
), "", "REVERT_HEAD",
2780 warning(_("cancelling a revert in progress"));
2781 opts
.action
= REPLAY_REVERT
;
2785 unlink(git_path_auto_merge(r
));
2790 if (!have_finished_the_last_pick())
2793 sequencer_remove_state(&opts
);
2796 static void todo_list_write_total_nr(struct todo_list
*todo_list
)
2798 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2801 fprintf(f
, "%d\n", todo_list
->total_nr
);
2806 static int read_populate_todo(struct repository
*r
,
2807 struct todo_list
*todo_list
,
2808 struct replay_opts
*opts
)
2810 const char *todo_file
= get_todo_path(opts
);
2813 strbuf_reset(&todo_list
->buf
);
2814 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2817 res
= todo_list_parse_insn_buffer(r
, todo_list
->buf
.buf
, todo_list
);
2819 if (is_rebase_i(opts
))
2820 return error(_("please fix this using "
2821 "'git rebase --edit-todo'."));
2822 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2825 if (!todo_list
->nr
&&
2826 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2827 return error(_("no commits parsed."));
2829 if (!is_rebase_i(opts
)) {
2830 enum todo_command valid
=
2831 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2834 for (i
= 0; i
< todo_list
->nr
; i
++)
2835 if (valid
== todo_list
->items
[i
].command
)
2837 else if (valid
== TODO_PICK
)
2838 return error(_("cannot cherry-pick during a revert."));
2840 return error(_("cannot revert during a cherry-pick."));
2843 if (is_rebase_i(opts
)) {
2844 struct todo_list done
= TODO_LIST_INIT
;
2846 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2847 !todo_list_parse_insn_buffer(r
, done
.buf
.buf
, &done
))
2848 todo_list
->done_nr
= count_commands(&done
);
2850 todo_list
->done_nr
= 0;
2852 todo_list
->total_nr
= todo_list
->done_nr
2853 + count_commands(todo_list
);
2854 todo_list_release(&done
);
2856 todo_list_write_total_nr(todo_list
);
2862 static int git_config_string_dup(char **dest
,
2863 const char *var
, const char *value
)
2866 return config_error_nonbool(var
);
2868 *dest
= xstrdup(value
);
2872 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
2874 struct replay_opts
*opts
= data
;
2879 else if (!strcmp(key
, "options.no-commit"))
2880 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
2881 else if (!strcmp(key
, "options.edit"))
2882 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
2883 else if (!strcmp(key
, "options.allow-empty"))
2885 git_config_bool_or_int(key
, value
, &error_flag
);
2886 else if (!strcmp(key
, "options.allow-empty-message"))
2887 opts
->allow_empty_message
=
2888 git_config_bool_or_int(key
, value
, &error_flag
);
2889 else if (!strcmp(key
, "options.keep-redundant-commits"))
2890 opts
->keep_redundant_commits
=
2891 git_config_bool_or_int(key
, value
, &error_flag
);
2892 else if (!strcmp(key
, "options.signoff"))
2893 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
2894 else if (!strcmp(key
, "options.record-origin"))
2895 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
2896 else if (!strcmp(key
, "options.allow-ff"))
2897 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
2898 else if (!strcmp(key
, "options.mainline"))
2899 opts
->mainline
= git_config_int(key
, value
);
2900 else if (!strcmp(key
, "options.strategy"))
2901 git_config_string_dup(&opts
->strategy
, key
, value
);
2902 else if (!strcmp(key
, "options.gpg-sign"))
2903 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
2904 else if (!strcmp(key
, "options.strategy-option")) {
2905 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
2906 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(value
);
2907 } else if (!strcmp(key
, "options.allow-rerere-auto"))
2908 opts
->allow_rerere_auto
=
2909 git_config_bool_or_int(key
, value
, &error_flag
) ?
2910 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
2911 else if (!strcmp(key
, "options.default-msg-cleanup")) {
2912 opts
->explicit_cleanup
= 1;
2913 opts
->default_msg_cleanup
= get_cleanup_mode(value
, 1);
2915 return error(_("invalid key: %s"), key
);
2918 return error(_("invalid value for '%s': '%s'"), key
, value
);
2923 void parse_strategy_opts(struct replay_opts
*opts
, char *raw_opts
)
2926 char *strategy_opts_string
= raw_opts
;
2928 if (*strategy_opts_string
== ' ')
2929 strategy_opts_string
++;
2931 opts
->xopts_nr
= split_cmdline(strategy_opts_string
,
2932 (const char ***)&opts
->xopts
);
2933 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
2934 const char *arg
= opts
->xopts
[i
];
2936 skip_prefix(arg
, "--", &arg
);
2937 opts
->xopts
[i
] = xstrdup(arg
);
2941 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2944 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2946 free(opts
->strategy
);
2947 opts
->strategy
= strbuf_detach(buf
, NULL
);
2948 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2951 parse_strategy_opts(opts
, buf
->buf
);
2954 static int read_populate_opts(struct replay_opts
*opts
)
2956 if (is_rebase_i(opts
)) {
2957 struct strbuf buf
= STRBUF_INIT
;
2960 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(),
2961 READ_ONELINER_SKIP_IF_EMPTY
)) {
2962 if (!starts_with(buf
.buf
, "-S"))
2965 free(opts
->gpg_sign
);
2966 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2971 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(),
2972 READ_ONELINER_SKIP_IF_EMPTY
)) {
2973 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2974 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2975 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2976 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2980 if (file_exists(rebase_path_verbose()))
2983 if (file_exists(rebase_path_quiet()))
2986 if (file_exists(rebase_path_signoff())) {
2991 if (file_exists(rebase_path_cdate_is_adate())) {
2993 opts
->committer_date_is_author_date
= 1;
2996 if (file_exists(rebase_path_ignore_date())) {
2998 opts
->ignore_date
= 1;
3001 if (file_exists(rebase_path_reschedule_failed_exec()))
3002 opts
->reschedule_failed_exec
= 1;
3003 else if (file_exists(rebase_path_no_reschedule_failed_exec()))
3004 opts
->reschedule_failed_exec
= 0;
3006 if (file_exists(rebase_path_drop_redundant_commits()))
3007 opts
->drop_redundant_commits
= 1;
3009 if (file_exists(rebase_path_keep_redundant_commits()))
3010 opts
->keep_redundant_commits
= 1;
3012 read_strategy_opts(opts
, &buf
);
3015 if (read_oneliner(&opts
->current_fixups
,
3016 rebase_path_current_fixups(),
3017 READ_ONELINER_SKIP_IF_EMPTY
)) {
3018 const char *p
= opts
->current_fixups
.buf
;
3019 opts
->current_fixup_count
= 1;
3020 while ((p
= strchr(p
, '\n'))) {
3021 opts
->current_fixup_count
++;
3026 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
3027 if (get_oid_committish(buf
.buf
, &opts
->squash_onto
) < 0) {
3028 ret
= error(_("unusable squash-onto"));
3031 opts
->have_squash_onto
= 1;
3035 strbuf_release(&buf
);
3039 if (!file_exists(git_path_opts_file()))
3042 * The function git_parse_source(), called from git_config_from_file(),
3043 * may die() in case of a syntactically incorrect file. We do not care
3044 * about this case, though, because we wrote that file ourselves, so we
3045 * are pretty certain that it is syntactically correct.
3047 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
3048 return error(_("malformed options sheet: '%s'"),
3049 git_path_opts_file());
3053 static void write_strategy_opts(struct replay_opts
*opts
)
3056 struct strbuf buf
= STRBUF_INIT
;
3058 for (i
= 0; i
< opts
->xopts_nr
; ++i
)
3059 strbuf_addf(&buf
, " --%s", opts
->xopts
[i
]);
3061 write_file(rebase_path_strategy_opts(), "%s\n", buf
.buf
);
3062 strbuf_release(&buf
);
3065 int write_basic_state(struct replay_opts
*opts
, const char *head_name
,
3066 struct commit
*onto
, const struct object_id
*orig_head
)
3069 write_file(rebase_path_head_name(), "%s\n", head_name
);
3071 write_file(rebase_path_onto(), "%s\n",
3072 oid_to_hex(&onto
->object
.oid
));
3074 write_file(rebase_path_orig_head(), "%s\n",
3075 oid_to_hex(orig_head
));
3078 write_file(rebase_path_quiet(), "%s", "");
3080 write_file(rebase_path_verbose(), "%s", "");
3082 write_file(rebase_path_strategy(), "%s\n", opts
->strategy
);
3083 if (opts
->xopts_nr
> 0)
3084 write_strategy_opts(opts
);
3086 if (opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
)
3087 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
3088 else if (opts
->allow_rerere_auto
== RERERE_NOAUTOUPDATE
)
3089 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
3092 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts
->gpg_sign
);
3094 write_file(rebase_path_signoff(), "--signoff\n");
3095 if (opts
->drop_redundant_commits
)
3096 write_file(rebase_path_drop_redundant_commits(), "%s", "");
3097 if (opts
->keep_redundant_commits
)
3098 write_file(rebase_path_keep_redundant_commits(), "%s", "");
3099 if (opts
->committer_date_is_author_date
)
3100 write_file(rebase_path_cdate_is_adate(), "%s", "");
3101 if (opts
->ignore_date
)
3102 write_file(rebase_path_ignore_date(), "%s", "");
3103 if (opts
->reschedule_failed_exec
)
3104 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
3106 write_file(rebase_path_no_reschedule_failed_exec(), "%s", "");
3111 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
3112 struct replay_opts
*opts
)
3114 enum todo_command command
= opts
->action
== REPLAY_PICK
?
3115 TODO_PICK
: TODO_REVERT
;
3116 const char *command_string
= todo_command_info
[command
].str
;
3117 const char *encoding
;
3118 struct commit
*commit
;
3120 if (prepare_revs(opts
))
3123 encoding
= get_log_output_encoding();
3125 while ((commit
= get_revision(opts
->revs
))) {
3126 struct todo_item
*item
= append_new_todo(todo_list
);
3127 const char *commit_buffer
= logmsg_reencode(commit
, NULL
, encoding
);
3128 const char *subject
;
3131 item
->command
= command
;
3132 item
->commit
= commit
;
3133 item
->arg_offset
= 0;
3135 item
->offset_in_buf
= todo_list
->buf
.len
;
3136 subject_len
= find_commit_subject(commit_buffer
, &subject
);
3137 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
3138 short_commit_name(commit
), subject_len
, subject
);
3139 unuse_commit_buffer(commit
, commit_buffer
);
3143 return error(_("empty commit set passed"));
3148 static int create_seq_dir(struct repository
*r
)
3150 enum replay_action action
;
3151 const char *in_progress_error
= NULL
;
3152 const char *in_progress_advice
= NULL
;
3153 unsigned int advise_skip
=
3154 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD") ||
3155 refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD");
3157 if (!sequencer_get_last_command(r
, &action
)) {
3160 in_progress_error
= _("revert is already in progress");
3161 in_progress_advice
=
3162 _("try \"git revert (--continue | %s--abort | --quit)\"");
3165 in_progress_error
= _("cherry-pick is already in progress");
3166 in_progress_advice
=
3167 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
3170 BUG("unexpected action in create_seq_dir");
3173 if (in_progress_error
) {
3174 error("%s", in_progress_error
);
3175 if (advice_enabled(ADVICE_SEQUENCER_IN_USE
))
3176 advise(in_progress_advice
,
3177 advise_skip
? "--skip | " : "");
3180 if (mkdir(git_path_seq_dir(), 0777) < 0)
3181 return error_errno(_("could not create sequencer directory '%s'"),
3182 git_path_seq_dir());
3187 static int save_head(const char *head
)
3189 struct lock_file head_lock
= LOCK_INIT
;
3190 struct strbuf buf
= STRBUF_INIT
;
3194 fd
= hold_lock_file_for_update(&head_lock
, git_path_head_file(), 0);
3196 return error_errno(_("could not lock HEAD"));
3197 strbuf_addf(&buf
, "%s\n", head
);
3198 written
= write_in_full(fd
, buf
.buf
, buf
.len
);
3199 strbuf_release(&buf
);
3201 error_errno(_("could not write to '%s'"), git_path_head_file());
3202 rollback_lock_file(&head_lock
);
3205 if (commit_lock_file(&head_lock
) < 0)
3206 return error(_("failed to finalize '%s'"), git_path_head_file());
3210 static int rollback_is_safe(void)
3212 struct strbuf sb
= STRBUF_INIT
;
3213 struct object_id expected_head
, actual_head
;
3215 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
3217 if (get_oid_hex(sb
.buf
, &expected_head
)) {
3218 strbuf_release(&sb
);
3219 die(_("could not parse %s"), git_path_abort_safety_file());
3221 strbuf_release(&sb
);
3223 else if (errno
== ENOENT
)
3224 oidclr(&expected_head
);
3226 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
3228 if (get_oid("HEAD", &actual_head
))
3229 oidclr(&actual_head
);
3231 return oideq(&actual_head
, &expected_head
);
3234 static int reset_merge(const struct object_id
*oid
)
3236 struct child_process cmd
= CHILD_PROCESS_INIT
;
3239 strvec_pushl(&cmd
.args
, "reset", "--merge", NULL
);
3241 if (!is_null_oid(oid
))
3242 strvec_push(&cmd
.args
, oid_to_hex(oid
));
3244 return run_command(&cmd
);
3247 static int rollback_single_pick(struct repository
*r
)
3249 struct object_id head_oid
;
3251 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
3252 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
3253 return error(_("no cherry-pick or revert in progress"));
3254 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
3255 return error(_("cannot resolve HEAD"));
3256 if (is_null_oid(&head_oid
))
3257 return error(_("cannot abort from a branch yet to be born"));
3258 return reset_merge(&head_oid
);
3261 static int skip_single_pick(void)
3263 struct object_id head
;
3265 if (read_ref_full("HEAD", 0, &head
, NULL
))
3266 return error(_("cannot resolve HEAD"));
3267 return reset_merge(&head
);
3270 int sequencer_rollback(struct repository
*r
, struct replay_opts
*opts
)
3273 struct object_id oid
;
3274 struct strbuf buf
= STRBUF_INIT
;
3277 f
= fopen(git_path_head_file(), "r");
3278 if (!f
&& errno
== ENOENT
) {
3280 * There is no multiple-cherry-pick in progress.
3281 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
3282 * a single-cherry-pick in progress, abort that.
3284 return rollback_single_pick(r
);
3287 return error_errno(_("cannot open '%s'"), git_path_head_file());
3288 if (strbuf_getline_lf(&buf
, f
)) {
3289 error(_("cannot read '%s': %s"), git_path_head_file(),
3290 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
3295 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
3296 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
3297 git_path_head_file());
3300 if (is_null_oid(&oid
)) {
3301 error(_("cannot abort from a branch yet to be born"));
3305 if (!rollback_is_safe()) {
3306 /* Do not error, just do not rollback */
3307 warning(_("You seem to have moved HEAD. "
3308 "Not rewinding, check your HEAD!"));
3310 if (reset_merge(&oid
))
3312 strbuf_release(&buf
);
3313 return sequencer_remove_state(opts
);
3315 strbuf_release(&buf
);
3319 int sequencer_skip(struct repository
*r
, struct replay_opts
*opts
)
3321 enum replay_action action
= -1;
3322 sequencer_get_last_command(r
, &action
);
3325 * Check whether the subcommand requested to skip the commit is actually
3326 * in progress and that it's safe to skip the commit.
3328 * opts->action tells us which subcommand requested to skip the commit.
3329 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
3330 * action is in progress and we can skip the commit.
3332 * Otherwise we check that the last instruction was related to the
3333 * particular subcommand we're trying to execute and barf if that's not
3336 * Finally we check that the rollback is "safe", i.e., has the HEAD
3337 * moved? In this case, it doesn't make sense to "reset the merge" and
3338 * "skip the commit" as the user already handled this by committing. But
3339 * we'd not want to barf here, instead give advice on how to proceed. We
3340 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
3341 * it gets removed when the user commits, so if it still exists we're
3342 * sure the user can't have committed before.
3344 switch (opts
->action
) {
3346 if (!refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
3347 if (action
!= REPLAY_REVERT
)
3348 return error(_("no revert in progress"));
3349 if (!rollback_is_safe())
3354 if (!refs_ref_exists(get_main_ref_store(r
),
3355 "CHERRY_PICK_HEAD")) {
3356 if (action
!= REPLAY_PICK
)
3357 return error(_("no cherry-pick in progress"));
3358 if (!rollback_is_safe())
3363 BUG("unexpected action in sequencer_skip");
3366 if (skip_single_pick())
3367 return error(_("failed to skip the commit"));
3368 if (!is_directory(git_path_seq_dir()))
3371 return sequencer_continue(r
, opts
);
3374 error(_("there is nothing to skip"));
3376 if (advice_enabled(ADVICE_RESOLVE_CONFLICT
)) {
3377 advise(_("have you committed already?\n"
3378 "try \"git %s --continue\""),
3379 action
== REPLAY_REVERT
? "revert" : "cherry-pick");
3384 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
3386 struct lock_file todo_lock
= LOCK_INIT
;
3387 const char *todo_path
= get_todo_path(opts
);
3388 int next
= todo_list
->current
, offset
, fd
;
3391 * rebase -i writes "git-rebase-todo" without the currently executing
3392 * command, appending it to "done" instead.
3394 if (is_rebase_i(opts
))
3397 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
3399 return error_errno(_("could not lock '%s'"), todo_path
);
3400 offset
= get_item_line_offset(todo_list
, next
);
3401 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
3402 todo_list
->buf
.len
- offset
) < 0)
3403 return error_errno(_("could not write to '%s'"), todo_path
);
3404 if (commit_lock_file(&todo_lock
) < 0)
3405 return error(_("failed to finalize '%s'"), todo_path
);
3407 if (is_rebase_i(opts
) && next
> 0) {
3408 const char *done
= rebase_path_done();
3409 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
3414 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
3415 get_item_line_length(todo_list
, next
- 1))
3417 ret
= error_errno(_("could not write to '%s'"), done
);
3419 ret
= error_errno(_("failed to finalize '%s'"), done
);
3425 static int save_opts(struct replay_opts
*opts
)
3427 const char *opts_file
= git_path_opts_file();
3430 if (opts
->no_commit
)
3431 res
|= git_config_set_in_file_gently(opts_file
,
3432 "options.no-commit", "true");
3433 if (opts
->edit
>= 0)
3434 res
|= git_config_set_in_file_gently(opts_file
, "options.edit",
3435 opts
->edit
? "true" : "false");
3436 if (opts
->allow_empty
)
3437 res
|= git_config_set_in_file_gently(opts_file
,
3438 "options.allow-empty", "true");
3439 if (opts
->allow_empty_message
)
3440 res
|= git_config_set_in_file_gently(opts_file
,
3441 "options.allow-empty-message", "true");
3442 if (opts
->keep_redundant_commits
)
3443 res
|= git_config_set_in_file_gently(opts_file
,
3444 "options.keep-redundant-commits", "true");
3446 res
|= git_config_set_in_file_gently(opts_file
,
3447 "options.signoff", "true");
3448 if (opts
->record_origin
)
3449 res
|= git_config_set_in_file_gently(opts_file
,
3450 "options.record-origin", "true");
3452 res
|= git_config_set_in_file_gently(opts_file
,
3453 "options.allow-ff", "true");
3454 if (opts
->mainline
) {
3455 struct strbuf buf
= STRBUF_INIT
;
3456 strbuf_addf(&buf
, "%d", opts
->mainline
);
3457 res
|= git_config_set_in_file_gently(opts_file
,
3458 "options.mainline", buf
.buf
);
3459 strbuf_release(&buf
);
3462 res
|= git_config_set_in_file_gently(opts_file
,
3463 "options.strategy", opts
->strategy
);
3465 res
|= git_config_set_in_file_gently(opts_file
,
3466 "options.gpg-sign", opts
->gpg_sign
);
3469 for (i
= 0; i
< opts
->xopts_nr
; i
++)
3470 res
|= git_config_set_multivar_in_file_gently(opts_file
,
3471 "options.strategy-option",
3472 opts
->xopts
[i
], "^$", 0);
3474 if (opts
->allow_rerere_auto
)
3475 res
|= git_config_set_in_file_gently(opts_file
,
3476 "options.allow-rerere-auto",
3477 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
3480 if (opts
->explicit_cleanup
)
3481 res
|= git_config_set_in_file_gently(opts_file
,
3482 "options.default-msg-cleanup",
3483 describe_cleanup_mode(opts
->default_msg_cleanup
));
3487 static int make_patch(struct repository
*r
,
3488 struct commit
*commit
,
3489 struct replay_opts
*opts
)
3491 struct strbuf buf
= STRBUF_INIT
;
3492 struct rev_info log_tree_opt
;
3493 const char *subject
;
3494 char hex
[GIT_MAX_HEXSZ
+ 1];
3497 oid_to_hex_r(hex
, &commit
->object
.oid
);
3498 if (write_message(hex
, strlen(hex
), rebase_path_stopped_sha(), 1) < 0)
3500 res
|= write_rebase_head(&commit
->object
.oid
);
3502 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
3503 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3504 repo_init_revisions(r
, &log_tree_opt
, NULL
);
3505 log_tree_opt
.abbrev
= 0;
3506 log_tree_opt
.diff
= 1;
3507 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
3508 log_tree_opt
.disable_stdin
= 1;
3509 log_tree_opt
.no_commit_id
= 1;
3510 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
3511 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
3512 if (!log_tree_opt
.diffopt
.file
)
3513 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
3515 res
|= log_tree_commit(&log_tree_opt
, commit
);
3516 fclose(log_tree_opt
.diffopt
.file
);
3520 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
3521 if (!file_exists(buf
.buf
)) {
3522 const char *encoding
= get_commit_output_encoding();
3523 const char *commit_buffer
= logmsg_reencode(commit
, NULL
, encoding
);
3524 find_commit_subject(commit_buffer
, &subject
);
3525 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
3526 unuse_commit_buffer(commit
, commit_buffer
);
3528 strbuf_release(&buf
);
3529 release_revisions(&log_tree_opt
);
3534 static int intend_to_amend(void)
3536 struct object_id head
;
3539 if (get_oid("HEAD", &head
))
3540 return error(_("cannot read HEAD"));
3542 p
= oid_to_hex(&head
);
3543 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
3546 static int error_with_patch(struct repository
*r
,
3547 struct commit
*commit
,
3548 const char *subject
, int subject_len
,
3549 struct replay_opts
*opts
,
3550 int exit_code
, int to_amend
)
3553 if (make_patch(r
, commit
, opts
))
3555 } else if (copy_file(rebase_path_message(),
3556 git_path_merge_msg(r
), 0666))
3557 return error(_("unable to copy '%s' to '%s'"),
3558 git_path_merge_msg(r
), rebase_path_message());
3561 if (intend_to_amend())
3565 _("You can amend the commit now, with\n"
3567 " git commit --amend %s\n"
3569 "Once you are satisfied with your changes, run\n"
3571 " git rebase --continue\n"),
3572 gpg_sign_opt_quoted(opts
));
3573 } else if (exit_code
) {
3575 fprintf_ln(stderr
, _("Could not apply %s... %.*s"),
3576 short_commit_name(commit
), subject_len
, subject
);
3579 * We don't have the hash of the parent so
3580 * just print the line from the todo file.
3582 fprintf_ln(stderr
, _("Could not merge %.*s"),
3583 subject_len
, subject
);
3589 static int error_failed_squash(struct repository
*r
,
3590 struct commit
*commit
,
3591 struct replay_opts
*opts
,
3593 const char *subject
)
3595 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3596 return error(_("could not copy '%s' to '%s'"),
3597 rebase_path_squash_msg(), rebase_path_message());
3598 unlink(git_path_merge_msg(r
));
3599 if (copy_file(git_path_merge_msg(r
), rebase_path_message(), 0666))
3600 return error(_("could not copy '%s' to '%s'"),
3601 rebase_path_message(),
3602 git_path_merge_msg(r
));
3603 return error_with_patch(r
, commit
, subject
, subject_len
, opts
, 1, 0);
3606 static int do_exec(struct repository
*r
, const char *command_line
)
3608 struct child_process cmd
= CHILD_PROCESS_INIT
;
3611 fprintf(stderr
, _("Executing: %s\n"), command_line
);
3613 strvec_push(&cmd
.args
, command_line
);
3614 status
= run_command(&cmd
);
3616 /* force re-reading of the cache */
3617 discard_index(r
->index
);
3618 if (repo_read_index(r
) < 0)
3619 return error(_("could not read index"));
3621 dirty
= require_clean_work_tree(r
, "rebase", NULL
, 1, 1);
3624 warning(_("execution failed: %s\n%s"
3625 "You can fix the problem, and then run\n"
3627 " git rebase --continue\n"
3630 dirty
? N_("and made changes to the index and/or the "
3631 "working tree\n") : "");
3633 /* command not found */
3636 warning(_("execution succeeded: %s\nbut "
3637 "left changes to the index and/or the working tree\n"
3638 "Commit or stash your changes, and then run\n"
3640 " git rebase --continue\n"
3641 "\n"), command_line
);
3648 __attribute__((format (printf
, 2, 3)))
3649 static int safe_append(const char *filename
, const char *fmt
, ...)
3652 struct lock_file lock
= LOCK_INIT
;
3653 int fd
= hold_lock_file_for_update(&lock
, filename
,
3654 LOCK_REPORT_ON_ERROR
);
3655 struct strbuf buf
= STRBUF_INIT
;
3660 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
3661 error_errno(_("could not read '%s'"), filename
);
3662 rollback_lock_file(&lock
);
3665 strbuf_complete(&buf
, '\n');
3667 strbuf_vaddf(&buf
, fmt
, ap
);
3670 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
3671 error_errno(_("could not write to '%s'"), filename
);
3672 strbuf_release(&buf
);
3673 rollback_lock_file(&lock
);
3676 if (commit_lock_file(&lock
) < 0) {
3677 strbuf_release(&buf
);
3678 rollback_lock_file(&lock
);
3679 return error(_("failed to finalize '%s'"), filename
);
3682 strbuf_release(&buf
);
3686 static int do_label(struct repository
*r
, const char *name
, int len
)
3688 struct ref_store
*refs
= get_main_ref_store(r
);
3689 struct ref_transaction
*transaction
;
3690 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
3691 struct strbuf msg
= STRBUF_INIT
;
3693 struct object_id head_oid
;
3695 if (len
== 1 && *name
== '#')
3696 return error(_("illegal label name: '%.*s'"), len
, name
);
3698 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3699 strbuf_addf(&msg
, "rebase (label) '%.*s'", len
, name
);
3701 transaction
= ref_store_transaction_begin(refs
, &err
);
3703 error("%s", err
.buf
);
3705 } else if (get_oid("HEAD", &head_oid
)) {
3706 error(_("could not read HEAD"));
3708 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
3709 NULL
, 0, msg
.buf
, &err
) < 0 ||
3710 ref_transaction_commit(transaction
, &err
)) {
3711 error("%s", err
.buf
);
3714 ref_transaction_free(transaction
);
3715 strbuf_release(&err
);
3716 strbuf_release(&msg
);
3719 ret
= safe_append(rebase_path_refs_to_delete(),
3720 "%s\n", ref_name
.buf
);
3721 strbuf_release(&ref_name
);
3726 static const char *sequencer_reflog_action(struct replay_opts
*opts
)
3728 if (!opts
->reflog_action
) {
3729 opts
->reflog_action
= getenv(GIT_REFLOG_ACTION
);
3730 opts
->reflog_action
=
3731 xstrdup(opts
->reflog_action
? opts
->reflog_action
3732 : action_name(opts
));
3735 return opts
->reflog_action
;
3738 __attribute__((format (printf
, 3, 4)))
3739 static const char *reflog_message(struct replay_opts
*opts
,
3740 const char *sub_action
, const char *fmt
, ...)
3743 static struct strbuf buf
= STRBUF_INIT
;
3747 strbuf_addstr(&buf
, sequencer_reflog_action(opts
));
3749 strbuf_addf(&buf
, " (%s)", sub_action
);
3751 strbuf_addstr(&buf
, ": ");
3752 strbuf_vaddf(&buf
, fmt
, ap
);
3759 static struct commit
*lookup_label(struct repository
*r
, const char *label
,
3760 int len
, struct strbuf
*buf
)
3762 struct commit
*commit
;
3763 struct object_id oid
;
3766 strbuf_addf(buf
, "refs/rewritten/%.*s", len
, label
);
3767 if (!read_ref(buf
->buf
, &oid
)) {
3768 commit
= lookup_commit_object(r
, &oid
);
3770 /* fall back to non-rewritten ref or commit */
3771 strbuf_splice(buf
, 0, strlen("refs/rewritten/"), "", 0);
3772 commit
= lookup_commit_reference_by_name(buf
->buf
);
3776 error(_("could not resolve '%s'"), buf
->buf
);
3781 static int do_reset(struct repository
*r
,
3782 const char *name
, int len
,
3783 struct replay_opts
*opts
)
3785 struct strbuf ref_name
= STRBUF_INIT
;
3786 struct object_id oid
;
3787 struct lock_file lock
= LOCK_INIT
;
3788 struct tree_desc desc
= { 0 };
3790 struct unpack_trees_options unpack_tree_opts
= { 0 };
3793 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0)
3796 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
3797 if (!opts
->have_squash_onto
) {
3799 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
3800 NULL
, &opts
->squash_onto
,
3802 return error(_("writing fake root commit"));
3803 opts
->have_squash_onto
= 1;
3804 hex
= oid_to_hex(&opts
->squash_onto
);
3805 if (write_message(hex
, strlen(hex
),
3806 rebase_path_squash_onto(), 0))
3807 return error(_("writing squash-onto"));
3809 oidcpy(&oid
, &opts
->squash_onto
);
3812 struct commit
*commit
;
3814 /* Determine the length of the label */
3815 for (i
= 0; i
< len
; i
++)
3816 if (isspace(name
[i
]))
3820 commit
= lookup_label(r
, name
, len
, &ref_name
);
3825 oid
= commit
->object
.oid
;
3828 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
3829 unpack_tree_opts
.head_idx
= 1;
3830 unpack_tree_opts
.src_index
= r
->index
;
3831 unpack_tree_opts
.dst_index
= r
->index
;
3832 unpack_tree_opts
.fn
= oneway_merge
;
3833 unpack_tree_opts
.merge
= 1;
3834 unpack_tree_opts
.update
= 1;
3835 unpack_tree_opts
.preserve_ignored
= 0; /* FIXME: !overwrite_ignore */
3836 unpack_tree_opts
.skip_cache_tree_update
= 1;
3837 init_checkout_metadata(&unpack_tree_opts
.meta
, name
, &oid
, NULL
);
3839 if (repo_read_index_unmerged(r
)) {
3840 ret
= error_resolve_conflict(action_name(opts
));
3844 if (!fill_tree_descriptor(r
, &desc
, &oid
)) {
3845 ret
= error(_("failed to find tree of %s"), oid_to_hex(&oid
));
3849 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
3854 tree
= parse_tree_indirect(&oid
);
3855 prime_cache_tree(r
, r
->index
, tree
);
3857 if (write_locked_index(r
->index
, &lock
, COMMIT_LOCK
) < 0)
3858 ret
= error(_("could not write index"));
3861 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
3862 len
, name
), "HEAD", &oid
,
3863 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3865 free((void *)desc
.buffer
);
3867 rollback_lock_file(&lock
);
3868 strbuf_release(&ref_name
);
3869 clear_unpack_trees_porcelain(&unpack_tree_opts
);
3873 static int do_merge(struct repository
*r
,
3874 struct commit
*commit
,
3875 const char *arg
, int arg_len
,
3876 int flags
, int *check_todo
, struct replay_opts
*opts
)
3878 int run_commit_flags
= 0;
3879 struct strbuf ref_name
= STRBUF_INIT
;
3880 struct commit
*head_commit
, *merge_commit
, *i
;
3881 struct commit_list
*bases
, *j
;
3882 struct commit_list
*to_merge
= NULL
, **tail
= &to_merge
;
3883 const char *strategy
= !opts
->xopts_nr
&&
3885 !strcmp(opts
->strategy
, "recursive") ||
3886 !strcmp(opts
->strategy
, "ort")) ?
3887 NULL
: opts
->strategy
;
3888 struct merge_options o
;
3889 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
, k
;
3890 static struct lock_file lock
;
3893 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0) {
3898 head_commit
= lookup_commit_reference_by_name("HEAD");
3900 ret
= error(_("cannot merge without a current revision"));
3905 * For octopus merges, the arg starts with the list of revisions to be
3906 * merged. The list is optionally followed by '#' and the oneline.
3908 merge_arg_len
= oneline_offset
= arg_len
;
3909 for (p
= arg
; p
- arg
< arg_len
; p
+= strspn(p
, " \t\n")) {
3912 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
3913 p
+= 1 + strspn(p
+ 1, " \t\n");
3914 oneline_offset
= p
- arg
;
3917 k
= strcspn(p
, " \t\n");
3920 merge_commit
= lookup_label(r
, p
, k
, &ref_name
);
3921 if (!merge_commit
) {
3922 ret
= error(_("unable to parse '%.*s'"), k
, p
);
3925 tail
= &commit_list_insert(merge_commit
, tail
)->next
;
3927 merge_arg_len
= p
- arg
;
3931 ret
= error(_("nothing to merge: '%.*s'"), arg_len
, arg
);
3935 if (opts
->have_squash_onto
&&
3936 oideq(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
3938 * When the user tells us to "merge" something into a
3939 * "[new root]", let's simply fast-forward to the merge head.
3941 rollback_lock_file(&lock
);
3943 ret
= error(_("octopus merge cannot be executed on "
3944 "top of a [new root]"));
3946 ret
= fast_forward_to(r
, &to_merge
->item
->object
.oid
,
3947 &head_commit
->object
.oid
, 0,
3953 * If HEAD is not identical to the first parent of the original merge
3954 * commit, we cannot fast-forward.
3956 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
3957 oideq(&commit
->parents
->item
->object
.oid
,
3958 &head_commit
->object
.oid
);
3961 * If any merge head is different from the original one, we cannot
3964 if (can_fast_forward
) {
3965 struct commit_list
*p
= commit
->parents
->next
;
3967 for (j
= to_merge
; j
&& p
; j
= j
->next
, p
= p
->next
)
3968 if (!oideq(&j
->item
->object
.oid
,
3969 &p
->item
->object
.oid
)) {
3970 can_fast_forward
= 0;
3974 * If the number of merge heads differs from the original merge
3975 * commit, we cannot fast-forward.
3978 can_fast_forward
= 0;
3981 if (can_fast_forward
) {
3982 rollback_lock_file(&lock
);
3983 ret
= fast_forward_to(r
, &commit
->object
.oid
,
3984 &head_commit
->object
.oid
, 0, opts
);
3985 if (flags
& TODO_EDIT_MERGE_MSG
)
3986 goto fast_forward_edit
;
3992 const char *encoding
= get_commit_output_encoding();
3993 const char *message
= logmsg_reencode(commit
, NULL
, encoding
);
3998 ret
= error(_("could not get commit message of '%s'"),
3999 oid_to_hex(&commit
->object
.oid
));
4002 write_author_script(message
);
4003 find_commit_subject(message
, &body
);
4005 ret
= write_message(body
, len
, git_path_merge_msg(r
), 0);
4006 unuse_commit_buffer(commit
, message
);
4008 error_errno(_("could not write '%s'"),
4009 git_path_merge_msg(r
));
4013 struct strbuf buf
= STRBUF_INIT
;
4016 strbuf_addf(&buf
, "author %s", git_author_info(0));
4017 write_author_script(buf
.buf
);
4020 if (oneline_offset
< arg_len
) {
4021 p
= arg
+ oneline_offset
;
4022 len
= arg_len
- oneline_offset
;
4024 strbuf_addf(&buf
, "Merge %s '%.*s'",
4025 to_merge
->next
? "branches" : "branch",
4026 merge_arg_len
, arg
);
4031 ret
= write_message(p
, len
, git_path_merge_msg(r
), 0);
4032 strbuf_release(&buf
);
4034 error_errno(_("could not write '%s'"),
4035 git_path_merge_msg(r
));
4040 if (strategy
|| to_merge
->next
) {
4042 struct child_process cmd
= CHILD_PROCESS_INIT
;
4044 if (read_env_script(&cmd
.env
)) {
4045 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
4047 ret
= error(_(staged_changes_advice
), gpg_opt
, gpg_opt
);
4051 if (opts
->committer_date_is_author_date
)
4052 strvec_pushf(&cmd
.env
, "GIT_COMMITTER_DATE=%s",
4055 author_date_from_env(&cmd
.env
));
4056 if (opts
->ignore_date
)
4057 strvec_push(&cmd
.env
, "GIT_AUTHOR_DATE=");
4060 strvec_push(&cmd
.args
, "merge");
4061 strvec_push(&cmd
.args
, "-s");
4063 strvec_push(&cmd
.args
, "octopus");
4065 strvec_push(&cmd
.args
, strategy
);
4066 for (k
= 0; k
< opts
->xopts_nr
; k
++)
4067 strvec_pushf(&cmd
.args
,
4068 "-X%s", opts
->xopts
[k
]);
4070 if (!(flags
& TODO_EDIT_MERGE_MSG
))
4071 strvec_push(&cmd
.args
, "--no-edit");
4073 strvec_push(&cmd
.args
, "--edit");
4074 strvec_push(&cmd
.args
, "--no-ff");
4075 strvec_push(&cmd
.args
, "--no-log");
4076 strvec_push(&cmd
.args
, "--no-stat");
4077 strvec_push(&cmd
.args
, "-F");
4078 strvec_push(&cmd
.args
, git_path_merge_msg(r
));
4080 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
4082 strvec_push(&cmd
.args
, "--no-gpg-sign");
4084 /* Add the tips to be merged */
4085 for (j
= to_merge
; j
; j
= j
->next
)
4086 strvec_push(&cmd
.args
,
4087 oid_to_hex(&j
->item
->object
.oid
));
4089 strbuf_release(&ref_name
);
4090 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
4092 rollback_lock_file(&lock
);
4094 ret
= run_command(&cmd
);
4096 /* force re-reading of the cache */
4098 discard_index(r
->index
);
4099 if (repo_read_index(r
) < 0)
4100 ret
= error(_("could not read index"));
4105 merge_commit
= to_merge
->item
;
4106 bases
= get_merge_bases(head_commit
, merge_commit
);
4107 if (bases
&& oideq(&merge_commit
->object
.oid
,
4108 &bases
->item
->object
.oid
)) {
4110 /* skip merging an ancestor of HEAD */
4114 write_message(oid_to_hex(&merge_commit
->object
.oid
), the_hash_algo
->hexsz
,
4115 git_path_merge_head(r
), 0);
4116 write_message("no-ff", 5, git_path_merge_mode(r
), 0);
4118 bases
= reverse_commit_list(bases
);
4121 init_merge_options(&o
, r
);
4123 o
.branch2
= ref_name
.buf
;
4124 o
.buffer_output
= 2;
4126 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
4128 * TODO: Should use merge_incore_recursive() and
4129 * merge_switch_to_result(), skipping the call to
4130 * merge_switch_to_result() when we don't actually need to
4131 * update the index and working copy immediately.
4133 ret
= merge_ort_recursive(&o
,
4134 head_commit
, merge_commit
, bases
,
4137 ret
= merge_recursive(&o
, head_commit
, merge_commit
, bases
,
4141 fputs(o
.obuf
.buf
, stdout
);
4142 strbuf_release(&o
.obuf
);
4144 error(_("could not even attempt to merge '%.*s'"),
4145 merge_arg_len
, arg
);
4149 * The return value of merge_recursive() is 1 on clean, and 0 on
4152 * Let's reverse that, so that do_merge() returns 0 upon success and
4153 * 1 upon failed merge (keeping the return value -1 for the cases where
4154 * we will want to reschedule the `merge` command).
4158 if (r
->index
->cache_changed
&&
4159 write_locked_index(r
->index
, &lock
, COMMIT_LOCK
)) {
4160 ret
= error(_("merge: Unable to write new index file"));
4164 rollback_lock_file(&lock
);
4166 repo_rerere(r
, opts
->allow_rerere_auto
);
4169 * In case of problems, we now want to return a positive
4170 * value (a negative one would indicate that the `merge`
4171 * command needs to be rescheduled).
4173 ret
= !!run_git_commit(git_path_merge_msg(r
), opts
,
4176 if (!ret
&& flags
& TODO_EDIT_MERGE_MSG
) {
4179 run_commit_flags
|= AMEND_MSG
| EDIT_MSG
| VERIFY_MSG
;
4180 ret
= !!run_git_commit(NULL
, opts
, run_commit_flags
);
4185 strbuf_release(&ref_name
);
4186 rollback_lock_file(&lock
);
4187 free_commit_list(to_merge
);
4191 static int write_update_refs_state(struct string_list
*refs_to_oids
)
4194 struct lock_file lock
= LOCK_INIT
;
4196 struct string_list_item
*item
;
4199 path
= rebase_path_update_refs(the_repository
->gitdir
);
4201 if (!refs_to_oids
->nr
) {
4202 if (unlink(path
) && errno
!= ENOENT
)
4203 result
= error_errno(_("could not unlink: %s"), path
);
4207 if (safe_create_leading_directories(path
)) {
4208 result
= error(_("unable to create leading directories of %s"),
4213 if (hold_lock_file_for_update(&lock
, path
, 0) < 0) {
4214 result
= error(_("another 'rebase' process appears to be running; "
4215 "'%s.lock' already exists"),
4220 fp
= fdopen_lock_file(&lock
, "w");
4222 result
= error_errno(_("could not open '%s' for writing"), path
);
4223 rollback_lock_file(&lock
);
4227 for_each_string_list_item(item
, refs_to_oids
) {
4228 struct update_ref_record
*rec
= item
->util
;
4229 fprintf(fp
, "%s\n%s\n%s\n", item
->string
,
4230 oid_to_hex(&rec
->before
), oid_to_hex(&rec
->after
));
4233 result
= commit_lock_file(&lock
);
4241 * Parse the update-refs file for the current rebase, then remove the
4242 * refs that do not appear in the todo_list (and have not had updated
4243 * values stored) and add refs that are in the todo_list but not
4244 * represented in the update-refs file.
4246 * If there are changes to the update-refs list, then write the new state
4249 void todo_list_filter_update_refs(struct repository
*r
,
4250 struct todo_list
*todo_list
)
4254 struct string_list update_refs
= STRING_LIST_INIT_DUP
;
4256 sequencer_get_update_refs_state(r
->gitdir
, &update_refs
);
4259 * For each item in the update_refs list, if it has no updated
4260 * value and does not appear in the todo_list, then remove it
4261 * from the update_refs list.
4263 for (i
= 0; i
< update_refs
.nr
; i
++) {
4266 const char *ref
= update_refs
.items
[i
].string
;
4267 size_t reflen
= strlen(ref
);
4268 struct update_ref_record
*rec
= update_refs
.items
[i
].util
;
4270 /* OID already stored as updated. */
4271 if (!is_null_oid(&rec
->after
))
4274 for (j
= 0; !found
&& j
< todo_list
->total_nr
; j
++) {
4275 struct todo_item
*item
= &todo_list
->items
[j
];
4276 const char *arg
= todo_list
->buf
.buf
+ item
->arg_offset
;
4278 if (item
->command
!= TODO_UPDATE_REF
)
4281 if (item
->arg_len
!= reflen
||
4282 strncmp(arg
, ref
, reflen
))
4289 free(update_refs
.items
[i
].string
);
4290 free(update_refs
.items
[i
].util
);
4293 MOVE_ARRAY(update_refs
.items
+ i
, update_refs
.items
+ i
+ 1, update_refs
.nr
- i
);
4301 * For each todo_item, check if its ref is in the update_refs list.
4302 * If not, then add it as an un-updated ref.
4304 for (i
= 0; i
< todo_list
->total_nr
; i
++) {
4305 struct todo_item
*item
= &todo_list
->items
[i
];
4306 const char *arg
= todo_list
->buf
.buf
+ item
->arg_offset
;
4309 if (item
->command
!= TODO_UPDATE_REF
)
4312 for (j
= 0; !found
&& j
< update_refs
.nr
; j
++) {
4313 const char *ref
= update_refs
.items
[j
].string
;
4315 found
= strlen(ref
) == item
->arg_len
&&
4316 !strncmp(ref
, arg
, item
->arg_len
);
4320 struct string_list_item
*inserted
;
4321 struct strbuf argref
= STRBUF_INIT
;
4323 strbuf_add(&argref
, arg
, item
->arg_len
);
4324 inserted
= string_list_insert(&update_refs
, argref
.buf
);
4325 inserted
->util
= init_update_ref_record(argref
.buf
);
4326 strbuf_release(&argref
);
4332 write_update_refs_state(&update_refs
);
4333 string_list_clear(&update_refs
, 1);
4336 static int do_update_ref(struct repository
*r
, const char *refname
)
4338 struct string_list_item
*item
;
4339 struct string_list list
= STRING_LIST_INIT_DUP
;
4341 if (sequencer_get_update_refs_state(r
->gitdir
, &list
))
4344 for_each_string_list_item(item
, &list
) {
4345 if (!strcmp(item
->string
, refname
)) {
4346 struct update_ref_record
*rec
= item
->util
;
4347 if (read_ref("HEAD", &rec
->after
))
4353 write_update_refs_state(&list
);
4354 string_list_clear(&list
, 1);
4358 static int do_update_refs(struct repository
*r
, int quiet
)
4361 struct string_list_item
*item
;
4362 struct string_list refs_to_oids
= STRING_LIST_INIT_DUP
;
4363 struct ref_store
*refs
= get_main_ref_store(r
);
4364 struct strbuf update_msg
= STRBUF_INIT
;
4365 struct strbuf error_msg
= STRBUF_INIT
;
4367 if ((res
= sequencer_get_update_refs_state(r
->gitdir
, &refs_to_oids
)))
4370 for_each_string_list_item(item
, &refs_to_oids
) {
4371 struct update_ref_record
*rec
= item
->util
;
4374 loop_res
= refs_update_ref(refs
, "rewritten during rebase",
4376 &rec
->after
, &rec
->before
,
4377 0, UPDATE_REFS_MSG_ON_ERR
);
4384 strbuf_addf(&error_msg
, "\t%s\n", item
->string
);
4386 strbuf_addf(&update_msg
, "\t%s\n", item
->string
);
4390 (update_msg
.len
|| error_msg
.len
)) {
4392 _("Updated the following refs with %s:\n%s"),
4398 _("Failed to update the following refs with %s:\n%s"),
4403 string_list_clear(&refs_to_oids
, 1);
4404 strbuf_release(&update_msg
);
4405 strbuf_release(&error_msg
);
4409 static int is_final_fixup(struct todo_list
*todo_list
)
4411 int i
= todo_list
->current
;
4413 if (!is_fixup(todo_list
->items
[i
].command
))
4416 while (++i
< todo_list
->nr
)
4417 if (is_fixup(todo_list
->items
[i
].command
))
4419 else if (!is_noop(todo_list
->items
[i
].command
))
4424 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
4428 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
4429 if (!is_noop(todo_list
->items
[i
].command
))
4430 return todo_list
->items
[i
].command
;
4435 void create_autostash(struct repository
*r
, const char *path
)
4437 struct strbuf buf
= STRBUF_INIT
;
4438 struct lock_file lock_file
= LOCK_INIT
;
4441 fd
= repo_hold_locked_index(r
, &lock_file
, 0);
4442 refresh_index(r
->index
, REFRESH_QUIET
, NULL
, NULL
, NULL
);
4444 repo_update_index_if_able(r
, &lock_file
);
4445 rollback_lock_file(&lock_file
);
4447 if (has_unstaged_changes(r
, 1) ||
4448 has_uncommitted_changes(r
, 1)) {
4449 struct child_process stash
= CHILD_PROCESS_INIT
;
4450 struct reset_head_opts ropts
= { .flags
= RESET_HEAD_HARD
};
4451 struct object_id oid
;
4453 strvec_pushl(&stash
.args
,
4454 "stash", "create", "autostash", NULL
);
4458 if (capture_command(&stash
, &buf
, GIT_MAX_HEXSZ
))
4459 die(_("Cannot autostash"));
4460 strbuf_trim_trailing_newline(&buf
);
4461 if (get_oid(buf
.buf
, &oid
))
4462 die(_("Unexpected stash response: '%s'"),
4465 strbuf_add_unique_abbrev(&buf
, &oid
, DEFAULT_ABBREV
);
4467 if (safe_create_leading_directories_const(path
))
4468 die(_("Could not create directory for '%s'"),
4470 write_file(path
, "%s", oid_to_hex(&oid
));
4471 printf(_("Created autostash: %s\n"), buf
.buf
);
4472 if (reset_head(r
, &ropts
) < 0)
4473 die(_("could not reset --hard"));
4474 discard_index(r
->index
);
4475 if (repo_read_index(r
) < 0)
4476 die(_("could not read index"));
4478 strbuf_release(&buf
);
4481 static int apply_save_autostash_oid(const char *stash_oid
, int attempt_apply
)
4483 struct child_process child
= CHILD_PROCESS_INIT
;
4486 if (attempt_apply
) {
4488 child
.no_stdout
= 1;
4489 child
.no_stderr
= 1;
4490 strvec_push(&child
.args
, "stash");
4491 strvec_push(&child
.args
, "apply");
4492 strvec_push(&child
.args
, stash_oid
);
4493 ret
= run_command(&child
);
4496 if (attempt_apply
&& !ret
)
4497 fprintf(stderr
, _("Applied autostash.\n"));
4499 struct child_process store
= CHILD_PROCESS_INIT
;
4502 strvec_push(&store
.args
, "stash");
4503 strvec_push(&store
.args
, "store");
4504 strvec_push(&store
.args
, "-m");
4505 strvec_push(&store
.args
, "autostash");
4506 strvec_push(&store
.args
, "-q");
4507 strvec_push(&store
.args
, stash_oid
);
4508 if (run_command(&store
))
4509 ret
= error(_("cannot store %s"), stash_oid
);
4513 "Your changes are safe in the stash.\n"
4514 "You can run \"git stash pop\" or"
4515 " \"git stash drop\" at any time.\n"),
4517 _("Applying autostash resulted in conflicts.") :
4518 _("Autostash exists; creating a new stash entry."));
4524 static int apply_save_autostash(const char *path
, int attempt_apply
)
4526 struct strbuf stash_oid
= STRBUF_INIT
;
4529 if (!read_oneliner(&stash_oid
, path
,
4530 READ_ONELINER_SKIP_IF_EMPTY
)) {
4531 strbuf_release(&stash_oid
);
4534 strbuf_trim(&stash_oid
);
4536 ret
= apply_save_autostash_oid(stash_oid
.buf
, attempt_apply
);
4539 strbuf_release(&stash_oid
);
4543 int save_autostash(const char *path
)
4545 return apply_save_autostash(path
, 0);
4548 int apply_autostash(const char *path
)
4550 return apply_save_autostash(path
, 1);
4553 int apply_autostash_oid(const char *stash_oid
)
4555 return apply_save_autostash_oid(stash_oid
, 1);
4558 static int checkout_onto(struct repository
*r
, struct replay_opts
*opts
,
4559 const char *onto_name
, const struct object_id
*onto
,
4560 const struct object_id
*orig_head
)
4562 struct reset_head_opts ropts
= {
4564 .orig_head
= orig_head
,
4565 .flags
= RESET_HEAD_DETACH
| RESET_ORIG_HEAD
|
4566 RESET_HEAD_RUN_POST_CHECKOUT_HOOK
,
4567 .head_msg
= reflog_message(opts
, "start", "checkout %s",
4569 .default_reflog_action
= sequencer_reflog_action(opts
)
4571 if (reset_head(r
, &ropts
)) {
4572 apply_autostash(rebase_path_autostash());
4573 sequencer_remove_state(opts
);
4574 return error(_("could not detach HEAD"));
4580 static int stopped_at_head(struct repository
*r
)
4582 struct object_id head
;
4583 struct commit
*commit
;
4584 struct commit_message message
;
4586 if (get_oid("HEAD", &head
) ||
4587 !(commit
= lookup_commit(r
, &head
)) ||
4588 parse_commit(commit
) || get_message(commit
, &message
))
4589 fprintf(stderr
, _("Stopped at HEAD\n"));
4591 fprintf(stderr
, _("Stopped at %s\n"), message
.label
);
4592 free_message(commit
, &message
);
4598 static int reread_todo_if_changed(struct repository
*r
,
4599 struct todo_list
*todo_list
,
4600 struct replay_opts
*opts
)
4603 struct strbuf buf
= STRBUF_INIT
;
4605 if (strbuf_read_file_or_whine(&buf
, get_todo_path(opts
)) < 0)
4607 offset
= get_item_line_offset(todo_list
, todo_list
->current
+ 1);
4608 if (buf
.len
!= todo_list
->buf
.len
- offset
||
4609 memcmp(buf
.buf
, todo_list
->buf
.buf
+ offset
, buf
.len
)) {
4610 /* Reread the todo file if it has changed. */
4611 todo_list_release(todo_list
);
4612 if (read_populate_todo(r
, todo_list
, opts
))
4613 return -1; /* message was printed */
4614 /* `current` will be incremented on return */
4615 todo_list
->current
= -1;
4617 strbuf_release(&buf
);
4622 static const char rescheduled_advice
[] =
4623 N_("Could not execute the todo command\n"
4627 "It has been rescheduled; To edit the command before continuing, please\n"
4628 "edit the todo list first:\n"
4630 " git rebase --edit-todo\n"
4631 " git rebase --continue\n");
4633 static int pick_commits(struct repository
*r
,
4634 struct todo_list
*todo_list
,
4635 struct replay_opts
*opts
)
4637 int res
= 0, reschedule
= 0;
4639 opts
->reflog_message
= sequencer_reflog_action(opts
);
4641 assert(!(opts
->signoff
|| opts
->no_commit
||
4642 opts
->record_origin
|| should_edit(opts
) ||
4643 opts
->committer_date_is_author_date
||
4644 opts
->ignore_date
));
4645 if (read_and_refresh_cache(r
, opts
))
4648 while (todo_list
->current
< todo_list
->nr
) {
4649 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
4650 const char *arg
= todo_item_get_arg(todo_list
, item
);
4653 if (save_todo(todo_list
, opts
))
4655 if (is_rebase_i(opts
)) {
4656 if (item
->command
!= TODO_COMMENT
) {
4657 FILE *f
= fopen(rebase_path_msgnum(), "w");
4659 todo_list
->done_nr
++;
4662 fprintf(f
, "%d\n", todo_list
->done_nr
);
4666 fprintf(stderr
, _("Rebasing (%d/%d)%s"),
4668 todo_list
->total_nr
,
4669 opts
->verbose
? "\n" : "\r");
4671 unlink(rebase_path_message());
4672 unlink(rebase_path_author_script());
4673 unlink(rebase_path_stopped_sha());
4674 unlink(rebase_path_amend());
4675 unlink(git_path_merge_head(r
));
4676 unlink(git_path_auto_merge(r
));
4677 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
4679 if (item
->command
== TODO_BREAK
) {
4682 return stopped_at_head(r
);
4685 if (item
->command
<= TODO_SQUASH
) {
4686 if (is_rebase_i(opts
))
4687 opts
->reflog_message
= reflog_message(opts
,
4688 command_to_string(item
->command
), NULL
);
4690 res
= do_pick_commit(r
, item
, opts
,
4691 is_final_fixup(todo_list
),
4693 if (is_rebase_i(opts
) && res
< 0) {
4695 advise(_(rescheduled_advice
),
4696 get_item_line_length(todo_list
,
4697 todo_list
->current
),
4698 get_item_line(todo_list
,
4699 todo_list
->current
));
4700 todo_list
->current
--;
4701 if (save_todo(todo_list
, opts
))
4704 if (item
->command
== TODO_EDIT
) {
4705 struct commit
*commit
= item
->commit
;
4710 _("Stopped at %s... %.*s\n"),
4711 short_commit_name(commit
),
4712 item
->arg_len
, arg
);
4714 return error_with_patch(r
, commit
,
4715 arg
, item
->arg_len
, opts
, res
, !res
);
4717 if (is_rebase_i(opts
) && !res
)
4718 record_in_rewritten(&item
->commit
->object
.oid
,
4719 peek_command(todo_list
, 1));
4720 if (res
&& is_fixup(item
->command
)) {
4723 return error_failed_squash(r
, item
->commit
, opts
,
4724 item
->arg_len
, arg
);
4725 } else if (res
&& is_rebase_i(opts
) && item
->commit
) {
4727 struct object_id oid
;
4730 * If we are rewording and have either
4731 * fast-forwarded already, or are about to
4732 * create a new root commit, we want to amend,
4733 * otherwise we do not.
4735 if (item
->command
== TODO_REWORD
&&
4736 !get_oid("HEAD", &oid
) &&
4737 (oideq(&item
->commit
->object
.oid
, &oid
) ||
4738 (opts
->have_squash_onto
&&
4739 oideq(&opts
->squash_onto
, &oid
))))
4742 return res
| error_with_patch(r
, item
->commit
,
4743 arg
, item
->arg_len
, opts
,
4746 } else if (item
->command
== TODO_EXEC
) {
4747 char *end_of_arg
= (char *)(arg
+ item
->arg_len
);
4748 int saved
= *end_of_arg
;
4753 res
= do_exec(r
, arg
);
4754 *end_of_arg
= saved
;
4757 if (opts
->reschedule_failed_exec
)
4761 } else if (item
->command
== TODO_LABEL
) {
4762 if ((res
= do_label(r
, arg
, item
->arg_len
)))
4764 } else if (item
->command
== TODO_RESET
) {
4765 if ((res
= do_reset(r
, arg
, item
->arg_len
, opts
)))
4767 } else if (item
->command
== TODO_MERGE
) {
4768 if ((res
= do_merge(r
, item
->commit
, arg
, item
->arg_len
,
4769 item
->flags
, &check_todo
, opts
)) < 0)
4771 else if (item
->commit
)
4772 record_in_rewritten(&item
->commit
->object
.oid
,
4773 peek_command(todo_list
, 1));
4775 /* failed with merge conflicts */
4776 return error_with_patch(r
, item
->commit
,
4779 } else if (item
->command
== TODO_UPDATE_REF
) {
4780 struct strbuf ref
= STRBUF_INIT
;
4781 strbuf_add(&ref
, arg
, item
->arg_len
);
4782 if ((res
= do_update_ref(r
, ref
.buf
)))
4784 strbuf_release(&ref
);
4785 } else if (!is_noop(item
->command
))
4786 return error(_("unknown command %d"), item
->command
);
4789 advise(_(rescheduled_advice
),
4790 get_item_line_length(todo_list
,
4791 todo_list
->current
),
4792 get_item_line(todo_list
, todo_list
->current
));
4793 todo_list
->current
--;
4794 if (save_todo(todo_list
, opts
))
4797 return error_with_patch(r
,
4801 } else if (is_rebase_i(opts
) && check_todo
&& !res
&&
4802 reread_todo_if_changed(r
, todo_list
, opts
)) {
4806 todo_list
->current
++;
4811 if (is_rebase_i(opts
)) {
4812 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
4815 /* Stopped in the middle, as planned? */
4816 if (todo_list
->current
< todo_list
->nr
)
4819 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
4820 starts_with(head_ref
.buf
, "refs/")) {
4822 struct object_id head
, orig
;
4825 if (get_oid("HEAD", &head
)) {
4826 res
= error(_("cannot read HEAD"));
4828 strbuf_release(&head_ref
);
4829 strbuf_release(&buf
);
4832 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
4833 get_oid_hex(buf
.buf
, &orig
)) {
4834 res
= error(_("could not read orig-head"));
4835 goto cleanup_head_ref
;
4838 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
4839 res
= error(_("could not read 'onto'"));
4840 goto cleanup_head_ref
;
4842 msg
= reflog_message(opts
, "finish", "%s onto %s",
4843 head_ref
.buf
, buf
.buf
);
4844 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
4845 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
4846 res
= error(_("could not update %s"),
4848 goto cleanup_head_ref
;
4850 msg
= reflog_message(opts
, "finish", "returning to %s",
4852 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
4853 res
= error(_("could not update HEAD to %s"),
4855 goto cleanup_head_ref
;
4860 if (opts
->verbose
) {
4861 struct rev_info log_tree_opt
;
4862 struct object_id orig
, head
;
4864 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
4865 repo_init_revisions(r
, &log_tree_opt
, NULL
);
4866 log_tree_opt
.diff
= 1;
4867 log_tree_opt
.diffopt
.output_format
=
4868 DIFF_FORMAT_DIFFSTAT
;
4869 log_tree_opt
.disable_stdin
= 1;
4871 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
4872 !get_oid(buf
.buf
, &orig
) &&
4873 !get_oid("HEAD", &head
)) {
4874 diff_tree_oid(&orig
, &head
, "",
4875 &log_tree_opt
.diffopt
);
4876 log_tree_diff_flush(&log_tree_opt
);
4878 release_revisions(&log_tree_opt
);
4880 flush_rewritten_pending();
4881 if (!stat(rebase_path_rewritten_list(), &st
) &&
4883 struct child_process child
= CHILD_PROCESS_INIT
;
4884 struct run_hooks_opt hook_opt
= RUN_HOOKS_OPT_INIT
;
4886 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
4888 strvec_push(&child
.args
, "notes");
4889 strvec_push(&child
.args
, "copy");
4890 strvec_push(&child
.args
, "--for-rewrite=rebase");
4891 /* we don't care if this copying failed */
4892 run_command(&child
);
4894 hook_opt
.path_to_stdin
= rebase_path_rewritten_list();
4895 strvec_push(&hook_opt
.args
, "rebase");
4896 run_hooks_opt("post-rewrite", &hook_opt
);
4898 apply_autostash(rebase_path_autostash());
4904 _("Successfully rebased and updated %s.\n"),
4908 strbuf_release(&buf
);
4909 strbuf_release(&head_ref
);
4911 if (do_update_refs(r
, opts
->quiet
))
4916 * Sequence of picks finished successfully; cleanup by
4917 * removing the .git/sequencer directory
4919 return sequencer_remove_state(opts
);
4922 static int continue_single_pick(struct repository
*r
, struct replay_opts
*opts
)
4924 struct child_process cmd
= CHILD_PROCESS_INIT
;
4926 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
4927 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
4928 return error(_("no cherry-pick or revert in progress"));
4931 strvec_push(&cmd
.args
, "commit");
4934 * continue_single_pick() handles the case of recovering from a
4935 * conflict. should_edit() doesn't handle that case; for a conflict,
4936 * we want to edit if the user asked for it, or if they didn't specify
4937 * and stdin is a tty.
4939 if (!opts
->edit
|| (opts
->edit
< 0 && !isatty(0)))
4941 * Include --cleanup=strip as well because we don't want the
4942 * "# Conflicts:" messages.
4944 strvec_pushl(&cmd
.args
, "--no-edit", "--cleanup=strip", NULL
);
4946 return run_command(&cmd
);
4949 static int commit_staged_changes(struct repository
*r
,
4950 struct replay_opts
*opts
,
4951 struct todo_list
*todo_list
)
4953 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
4954 unsigned int final_fixup
= 0, is_clean
;
4956 if (has_unstaged_changes(r
, 1))
4957 return error(_("cannot rebase: You have unstaged changes."));
4959 is_clean
= !has_uncommitted_changes(r
, 0);
4961 if (file_exists(rebase_path_amend())) {
4962 struct strbuf rev
= STRBUF_INIT
;
4963 struct object_id head
, to_amend
;
4965 if (get_oid("HEAD", &head
))
4966 return error(_("cannot amend non-existing commit"));
4967 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
4968 return error(_("invalid file: '%s'"), rebase_path_amend());
4969 if (get_oid_hex(rev
.buf
, &to_amend
))
4970 return error(_("invalid contents: '%s'"),
4971 rebase_path_amend());
4972 if (!is_clean
&& !oideq(&head
, &to_amend
))
4973 return error(_("\nYou have uncommitted changes in your "
4974 "working tree. Please, commit them\n"
4975 "first and then run 'git rebase "
4976 "--continue' again."));
4978 * When skipping a failed fixup/squash, we need to edit the
4979 * commit message, the current fixup list and count, and if it
4980 * was the last fixup/squash in the chain, we need to clean up
4981 * the commit message and if there was a squash, let the user
4984 if (!is_clean
|| !opts
->current_fixup_count
)
4985 ; /* this is not the final fixup */
4986 else if (!oideq(&head
, &to_amend
) ||
4987 !file_exists(rebase_path_stopped_sha())) {
4988 /* was a final fixup or squash done manually? */
4989 if (!is_fixup(peek_command(todo_list
, 0))) {
4990 unlink(rebase_path_fixup_msg());
4991 unlink(rebase_path_squash_msg());
4992 unlink(rebase_path_current_fixups());
4993 strbuf_reset(&opts
->current_fixups
);
4994 opts
->current_fixup_count
= 0;
4997 /* we are in a fixup/squash chain */
4998 const char *p
= opts
->current_fixups
.buf
;
4999 int len
= opts
->current_fixups
.len
;
5001 opts
->current_fixup_count
--;
5003 BUG("Incorrect current_fixups:\n%s", p
);
5004 while (len
&& p
[len
- 1] != '\n')
5006 strbuf_setlen(&opts
->current_fixups
, len
);
5007 if (write_message(p
, len
, rebase_path_current_fixups(),
5009 return error(_("could not write file: '%s'"),
5010 rebase_path_current_fixups());
5013 * If a fixup/squash in a fixup/squash chain failed, the
5014 * commit message is already correct, no need to commit
5017 * Only if it is the final command in the fixup/squash
5018 * chain, and only if the chain is longer than a single
5019 * fixup/squash command (which was just skipped), do we
5020 * actually need to re-commit with a cleaned up commit
5023 if (opts
->current_fixup_count
> 0 &&
5024 !is_fixup(peek_command(todo_list
, 0))) {
5027 * If there was not a single "squash" in the
5028 * chain, we only need to clean up the commit
5029 * message, no need to bother the user with
5030 * opening the commit message in the editor.
5032 if (!starts_with(p
, "squash ") &&
5033 !strstr(p
, "\nsquash "))
5034 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
5035 } else if (is_fixup(peek_command(todo_list
, 0))) {
5037 * We need to update the squash message to skip
5038 * the latest commit message.
5040 struct commit
*commit
;
5041 const char *path
= rebase_path_squash_msg();
5042 const char *encoding
= get_commit_output_encoding();
5044 if (parse_head(r
, &commit
) ||
5045 !(p
= logmsg_reencode(commit
, NULL
, encoding
)) ||
5046 write_message(p
, strlen(p
), path
, 0)) {
5047 unuse_commit_buffer(commit
, p
);
5048 return error(_("could not write file: "
5051 unuse_commit_buffer(commit
, p
);
5055 strbuf_release(&rev
);
5060 if (refs_ref_exists(get_main_ref_store(r
),
5061 "CHERRY_PICK_HEAD") &&
5062 refs_delete_ref(get_main_ref_store(r
), "",
5063 "CHERRY_PICK_HEAD", NULL
, 0))
5064 return error(_("could not remove CHERRY_PICK_HEAD"));
5065 if (unlink(git_path_merge_msg(r
)) && errno
!= ENOENT
)
5066 return error_errno(_("could not remove '%s'"),
5067 git_path_merge_msg(r
));
5072 if (run_git_commit(final_fixup
? NULL
: rebase_path_message(),
5074 return error(_("could not commit staged changes."));
5075 unlink(rebase_path_amend());
5076 unlink(git_path_merge_head(r
));
5077 unlink(git_path_auto_merge(r
));
5079 unlink(rebase_path_fixup_msg());
5080 unlink(rebase_path_squash_msg());
5082 if (opts
->current_fixup_count
> 0) {
5084 * Whether final fixup or not, we just cleaned up the commit
5087 unlink(rebase_path_current_fixups());
5088 strbuf_reset(&opts
->current_fixups
);
5089 opts
->current_fixup_count
= 0;
5094 int sequencer_continue(struct repository
*r
, struct replay_opts
*opts
)
5096 struct todo_list todo_list
= TODO_LIST_INIT
;
5099 if (read_and_refresh_cache(r
, opts
))
5102 if (read_populate_opts(opts
))
5104 if (is_rebase_i(opts
)) {
5105 if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
5106 goto release_todo_list
;
5108 if (file_exists(rebase_path_dropped())) {
5109 if ((res
= todo_list_check_against_backup(r
, &todo_list
)))
5110 goto release_todo_list
;
5112 unlink(rebase_path_dropped());
5115 opts
->reflog_message
= reflog_message(opts
, "continue", NULL
);
5116 if (commit_staged_changes(r
, opts
, &todo_list
)) {
5118 goto release_todo_list
;
5120 } else if (!file_exists(get_todo_path(opts
)))
5121 return continue_single_pick(r
, opts
);
5122 else if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
5123 goto release_todo_list
;
5125 if (!is_rebase_i(opts
)) {
5126 /* Verify that the conflict has been resolved */
5127 if (refs_ref_exists(get_main_ref_store(r
),
5128 "CHERRY_PICK_HEAD") ||
5129 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
5130 res
= continue_single_pick(r
, opts
);
5132 goto release_todo_list
;
5134 if (index_differs_from(r
, "HEAD", NULL
, 0)) {
5135 res
= error_dirty_index(r
, opts
);
5136 goto release_todo_list
;
5138 todo_list
.current
++;
5139 } else if (file_exists(rebase_path_stopped_sha())) {
5140 struct strbuf buf
= STRBUF_INIT
;
5141 struct object_id oid
;
5143 if (read_oneliner(&buf
, rebase_path_stopped_sha(),
5144 READ_ONELINER_SKIP_IF_EMPTY
) &&
5145 !get_oid_hex(buf
.buf
, &oid
))
5146 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
5147 strbuf_release(&buf
);
5150 res
= pick_commits(r
, &todo_list
, opts
);
5152 todo_list_release(&todo_list
);
5156 static int single_pick(struct repository
*r
,
5157 struct commit
*cmit
,
5158 struct replay_opts
*opts
)
5161 struct todo_item item
;
5163 item
.command
= opts
->action
== REPLAY_PICK
?
5164 TODO_PICK
: TODO_REVERT
;
5167 opts
->reflog_message
= sequencer_reflog_action(opts
);
5168 return do_pick_commit(r
, &item
, opts
, 0, &check_todo
);
5171 int sequencer_pick_revisions(struct repository
*r
,
5172 struct replay_opts
*opts
)
5174 struct todo_list todo_list
= TODO_LIST_INIT
;
5175 struct object_id oid
;
5179 if (read_and_refresh_cache(r
, opts
))
5182 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
5183 struct object_id oid
;
5184 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
5186 /* This happens when using --stdin. */
5190 if (!get_oid(name
, &oid
)) {
5191 if (!lookup_commit_reference_gently(r
, &oid
, 1)) {
5192 enum object_type type
= oid_object_info(r
,
5195 return error(_("%s: can't cherry-pick a %s"),
5196 name
, type_name(type
));
5199 return error(_("%s: bad revision"), name
);
5203 * If we were called as "git cherry-pick <commit>", just
5204 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
5205 * REVERT_HEAD, and don't touch the sequencer state.
5206 * This means it is possible to cherry-pick in the middle
5207 * of a cherry-pick sequence.
5209 if (opts
->revs
->cmdline
.nr
== 1 &&
5210 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
5211 opts
->revs
->no_walk
&&
5212 !opts
->revs
->cmdline
.rev
->flags
) {
5213 struct commit
*cmit
;
5214 if (prepare_revision_walk(opts
->revs
))
5215 return error(_("revision walk setup failed"));
5216 cmit
= get_revision(opts
->revs
);
5218 return error(_("empty commit set passed"));
5219 if (get_revision(opts
->revs
))
5220 BUG("unexpected extra commit from walk");
5221 return single_pick(r
, cmit
, opts
);
5225 * Start a new cherry-pick/ revert sequence; but
5226 * first, make sure that an existing one isn't in
5230 if (walk_revs_populate_todo(&todo_list
, opts
) ||
5231 create_seq_dir(r
) < 0)
5233 if (get_oid("HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
5234 return error(_("can't revert as initial commit"));
5235 if (save_head(oid_to_hex(&oid
)))
5237 if (save_opts(opts
))
5239 update_abort_safety_file();
5240 res
= pick_commits(r
, &todo_list
, opts
);
5241 todo_list_release(&todo_list
);
5245 void append_signoff(struct strbuf
*msgbuf
, size_t ignore_footer
, unsigned flag
)
5247 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
5248 struct strbuf sob
= STRBUF_INIT
;
5251 strbuf_addstr(&sob
, sign_off_header
);
5252 strbuf_addstr(&sob
, fmt_name(WANT_COMMITTER_IDENT
));
5253 strbuf_addch(&sob
, '\n');
5256 strbuf_complete_line(msgbuf
);
5259 * If the whole message buffer is equal to the sob, pretend that we
5260 * found a conforming footer with a matching sob
5262 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
5263 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
5266 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
5269 const char *append_newlines
= NULL
;
5270 size_t len
= msgbuf
->len
- ignore_footer
;
5274 * The buffer is completely empty. Leave foom for
5275 * the title and body to be filled in by the user.
5277 append_newlines
= "\n\n";
5278 } else if (len
== 1) {
5280 * Buffer contains a single newline. Add another
5281 * so that we leave room for the title and body.
5283 append_newlines
= "\n";
5284 } else if (msgbuf
->buf
[len
- 2] != '\n') {
5286 * Buffer ends with a single newline. Add another
5287 * so that there is an empty line between the message
5290 append_newlines
= "\n";
5291 } /* else, the buffer already ends with two newlines. */
5293 if (append_newlines
)
5294 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
5295 append_newlines
, strlen(append_newlines
));
5298 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
5299 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
5302 strbuf_release(&sob
);
5305 struct labels_entry
{
5306 struct hashmap_entry entry
;
5307 char label
[FLEX_ARRAY
];
5310 static int labels_cmp(const void *fndata UNUSED
,
5311 const struct hashmap_entry
*eptr
,
5312 const struct hashmap_entry
*entry_or_key
, const void *key
)
5314 const struct labels_entry
*a
, *b
;
5316 a
= container_of(eptr
, const struct labels_entry
, entry
);
5317 b
= container_of(entry_or_key
, const struct labels_entry
, entry
);
5319 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
5322 struct string_entry
{
5323 struct oidmap_entry entry
;
5324 char string
[FLEX_ARRAY
];
5327 struct label_state
{
5328 struct oidmap commit2label
;
5329 struct hashmap labels
;
5333 static const char *label_oid(struct object_id
*oid
, const char *label
,
5334 struct label_state
*state
)
5336 struct labels_entry
*labels_entry
;
5337 struct string_entry
*string_entry
;
5338 struct object_id dummy
;
5341 string_entry
= oidmap_get(&state
->commit2label
, oid
);
5343 return string_entry
->string
;
5346 * For "uninteresting" commits, i.e. commits that are not to be
5347 * rebased, and which can therefore not be labeled, we use a unique
5348 * abbreviation of the commit name. This is slightly more complicated
5349 * than calling find_unique_abbrev() because we also need to make
5350 * sure that the abbreviation does not conflict with any other
5353 * We disallow "interesting" commits to be labeled by a string that
5354 * is a valid full-length hash, to ensure that we always can find an
5355 * abbreviation for any uninteresting commit's names that does not
5356 * clash with any other label.
5358 strbuf_reset(&state
->buf
);
5362 strbuf_grow(&state
->buf
, GIT_MAX_HEXSZ
);
5363 label
= p
= state
->buf
.buf
;
5365 find_unique_abbrev_r(p
, oid
, default_abbrev
);
5368 * We may need to extend the abbreviated hash so that there is
5369 * no conflicting label.
5371 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
5372 size_t i
= strlen(p
) + 1;
5374 oid_to_hex_r(p
, oid
);
5375 for (; i
< the_hash_algo
->hexsz
; i
++) {
5378 if (!hashmap_get_from_hash(&state
->labels
,
5385 struct strbuf
*buf
= &state
->buf
;
5388 * Sanitize labels by replacing non-alpha-numeric characters
5389 * (including white-space ones) by dashes, as they might be
5390 * illegal in file names (and hence in ref names).
5392 * Note that we retain non-ASCII UTF-8 characters (identified
5393 * via the most significant bit). They should be all acceptable
5394 * in file names. We do not validate the UTF-8 here, that's not
5395 * the job of this function.
5397 for (; *label
; label
++)
5398 if ((*label
& 0x80) || isalnum(*label
))
5399 strbuf_addch(buf
, *label
);
5400 /* avoid leading dash and double-dashes */
5401 else if (buf
->len
&& buf
->buf
[buf
->len
- 1] != '-')
5402 strbuf_addch(buf
, '-');
5404 strbuf_addstr(buf
, "rev-");
5405 strbuf_add_unique_abbrev(buf
, oid
, default_abbrev
);
5409 if ((buf
->len
== the_hash_algo
->hexsz
&&
5410 !get_oid_hex(label
, &dummy
)) ||
5411 (buf
->len
== 1 && *label
== '#') ||
5412 hashmap_get_from_hash(&state
->labels
,
5413 strihash(label
), label
)) {
5415 * If the label already exists, or if the label is a
5416 * valid full OID, or the label is a '#' (which we use
5417 * as a separator between merge heads and oneline), we
5418 * append a dash and a number to make it unique.
5420 size_t len
= buf
->len
;
5422 for (i
= 2; ; i
++) {
5423 strbuf_setlen(buf
, len
);
5424 strbuf_addf(buf
, "-%d", i
);
5425 if (!hashmap_get_from_hash(&state
->labels
,
5435 FLEX_ALLOC_STR(labels_entry
, label
, label
);
5436 hashmap_entry_init(&labels_entry
->entry
, strihash(label
));
5437 hashmap_add(&state
->labels
, &labels_entry
->entry
);
5439 FLEX_ALLOC_STR(string_entry
, string
, label
);
5440 oidcpy(&string_entry
->entry
.oid
, oid
);
5441 oidmap_put(&state
->commit2label
, string_entry
);
5443 return string_entry
->string
;
5446 static int make_script_with_merges(struct pretty_print_context
*pp
,
5447 struct rev_info
*revs
, struct strbuf
*out
,
5450 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5451 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
5452 int root_with_onto
= flags
& TODO_LIST_ROOT_WITH_ONTO
;
5453 int skipped_commit
= 0;
5454 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
5455 struct strbuf label
= STRBUF_INIT
;
5456 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
5457 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
5458 struct commit
*commit
;
5459 struct oidmap commit2todo
= OIDMAP_INIT
;
5460 struct string_entry
*entry
;
5461 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
5462 shown
= OIDSET_INIT
;
5463 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
5465 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
5466 const char *cmd_pick
= abbr
? "p" : "pick",
5467 *cmd_label
= abbr
? "l" : "label",
5468 *cmd_reset
= abbr
? "t" : "reset",
5469 *cmd_merge
= abbr
? "m" : "merge";
5471 oidmap_init(&commit2todo
, 0);
5472 oidmap_init(&state
.commit2label
, 0);
5473 hashmap_init(&state
.labels
, labels_cmp
, NULL
, 0);
5474 strbuf_init(&state
.buf
, 32);
5476 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
5477 struct labels_entry
*onto_label_entry
;
5478 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
5479 FLEX_ALLOC_STR(entry
, string
, "onto");
5480 oidcpy(&entry
->entry
.oid
, oid
);
5481 oidmap_put(&state
.commit2label
, entry
);
5483 FLEX_ALLOC_STR(onto_label_entry
, label
, "onto");
5484 hashmap_entry_init(&onto_label_entry
->entry
, strihash("onto"));
5485 hashmap_add(&state
.labels
, &onto_label_entry
->entry
);
5490 * - get onelines for all commits
5491 * - gather all branch tips (i.e. 2nd or later parents of merges)
5492 * - label all branch tips
5494 while ((commit
= get_revision(revs
))) {
5495 struct commit_list
*to_merge
;
5496 const char *p1
, *p2
;
5497 struct object_id
*oid
;
5500 tail
= &commit_list_insert(commit
, tail
)->next
;
5501 oidset_insert(&interesting
, &commit
->object
.oid
);
5503 is_empty
= is_original_commit_empty(commit
);
5504 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5505 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5506 warning(_("skipped previously applied commit %s"),
5507 short_commit_name(commit
));
5511 if (is_empty
&& !keep_empty
)
5514 strbuf_reset(&oneline
);
5515 pretty_print_commit(pp
, commit
, &oneline
);
5517 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
5519 /* non-merge commit: easy case */
5521 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
5522 oid_to_hex(&commit
->object
.oid
),
5525 strbuf_addf(&buf
, " %c empty",
5528 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5529 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5530 oidmap_put(&commit2todo
, entry
);
5535 /* Create a label */
5536 strbuf_reset(&label
);
5537 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
5538 (p1
= strchr(p1
, '\'')) &&
5539 (p2
= strchr(++p1
, '\'')))
5540 strbuf_add(&label
, p1
, p2
- p1
);
5541 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
5543 (p1
= strstr(p1
, " from ")))
5544 strbuf_addstr(&label
, p1
+ strlen(" from "));
5546 strbuf_addbuf(&label
, &oneline
);
5549 strbuf_addf(&buf
, "%s -C %s",
5550 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
5552 /* label the tips of merged branches */
5553 for (; to_merge
; to_merge
= to_merge
->next
) {
5554 oid
= &to_merge
->item
->object
.oid
;
5555 strbuf_addch(&buf
, ' ');
5557 if (!oidset_contains(&interesting
, oid
)) {
5558 strbuf_addstr(&buf
, label_oid(oid
, NULL
,
5563 tips_tail
= &commit_list_insert(to_merge
->item
,
5566 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
5568 strbuf_addf(&buf
, " # %s", oneline
.buf
);
5570 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5571 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5572 oidmap_put(&commit2todo
, entry
);
5575 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5576 _("use --reapply-cherry-picks to include skipped commits"));
5580 * - label branch points
5581 * - add HEAD to the branch tips
5583 for (iter
= commits
; iter
; iter
= iter
->next
) {
5584 struct commit_list
*parent
= iter
->item
->parents
;
5585 for (; parent
; parent
= parent
->next
) {
5586 struct object_id
*oid
= &parent
->item
->object
.oid
;
5587 if (!oidset_contains(&interesting
, oid
))
5589 if (oidset_insert(&child_seen
, oid
))
5590 label_oid(oid
, "branch-point", &state
);
5593 /* Add HEAD as implicit "tip of branch" */
5595 tips_tail
= &commit_list_insert(iter
->item
,
5600 * Third phase: output the todo list. This is a bit tricky, as we
5601 * want to avoid jumping back and forth between revisions. To
5602 * accomplish that goal, we walk backwards from the branch tips,
5603 * gathering commits not yet shown, reversing the list on the fly,
5604 * then outputting that list (labeling revisions as needed).
5606 strbuf_addf(out
, "%s onto\n", cmd_label
);
5607 for (iter
= tips
; iter
; iter
= iter
->next
) {
5608 struct commit_list
*list
= NULL
, *iter2
;
5610 commit
= iter
->item
;
5611 if (oidset_contains(&shown
, &commit
->object
.oid
))
5613 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
5616 strbuf_addf(out
, "\n%c Branch %s\n", comment_line_char
, entry
->string
);
5618 strbuf_addch(out
, '\n');
5620 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
5621 !oidset_contains(&shown
, &commit
->object
.oid
)) {
5622 commit_list_insert(commit
, &list
);
5623 if (!commit
->parents
) {
5627 commit
= commit
->parents
->item
;
5631 strbuf_addf(out
, "%s %s\n", cmd_reset
,
5632 rebase_cousins
|| root_with_onto
?
5633 "onto" : "[new root]");
5635 const char *to
= NULL
;
5637 entry
= oidmap_get(&state
.commit2label
,
5638 &commit
->object
.oid
);
5641 else if (!rebase_cousins
)
5642 to
= label_oid(&commit
->object
.oid
, NULL
,
5645 if (!to
|| !strcmp(to
, "onto"))
5646 strbuf_addf(out
, "%s onto\n", cmd_reset
);
5648 strbuf_reset(&oneline
);
5649 pretty_print_commit(pp
, commit
, &oneline
);
5650 strbuf_addf(out
, "%s %s # %s\n",
5651 cmd_reset
, to
, oneline
.buf
);
5655 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
5656 struct object_id
*oid
= &iter2
->item
->object
.oid
;
5657 entry
= oidmap_get(&commit2todo
, oid
);
5658 /* only show if not already upstream */
5660 strbuf_addf(out
, "%s\n", entry
->string
);
5661 entry
= oidmap_get(&state
.commit2label
, oid
);
5663 strbuf_addf(out
, "%s %s\n",
5664 cmd_label
, entry
->string
);
5665 oidset_insert(&shown
, oid
);
5668 free_commit_list(list
);
5671 free_commit_list(commits
);
5672 free_commit_list(tips
);
5674 strbuf_release(&label
);
5675 strbuf_release(&oneline
);
5676 strbuf_release(&buf
);
5678 oidmap_free(&commit2todo
, 1);
5679 oidmap_free(&state
.commit2label
, 1);
5680 hashmap_clear_and_free(&state
.labels
, struct labels_entry
, entry
);
5681 strbuf_release(&state
.buf
);
5686 int sequencer_make_script(struct repository
*r
, struct strbuf
*out
, int argc
,
5687 const char **argv
, unsigned flags
)
5689 char *format
= NULL
;
5690 struct pretty_print_context pp
= {0};
5691 struct rev_info revs
;
5692 struct commit
*commit
;
5693 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5694 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
5695 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
5696 int reapply_cherry_picks
= flags
& TODO_LIST_REAPPLY_CHERRY_PICKS
;
5697 int skipped_commit
= 0;
5700 repo_init_revisions(r
, &revs
, NULL
);
5701 revs
.verbose_header
= 1;
5703 revs
.max_parents
= 1;
5704 revs
.cherry_mark
= !reapply_cherry_picks
;
5707 revs
.right_only
= 1;
5708 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
5709 revs
.topo_order
= 1;
5711 revs
.pretty_given
= 1;
5712 git_config_get_string("rebase.instructionFormat", &format
);
5713 if (!format
|| !*format
) {
5715 format
= xstrdup("%s");
5717 get_commit_format(format
, &revs
);
5719 pp
.fmt
= revs
.commit_format
;
5720 pp
.output_encoding
= get_log_output_encoding();
5722 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1) {
5723 ret
= error(_("make_script: unhandled options"));
5727 if (prepare_revision_walk(&revs
) < 0) {
5728 ret
= error(_("make_script: error preparing revisions"));
5732 if (rebase_merges
) {
5733 ret
= make_script_with_merges(&pp
, &revs
, out
, flags
);
5737 while ((commit
= get_revision(&revs
))) {
5738 int is_empty
= is_original_commit_empty(commit
);
5740 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5741 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5742 warning(_("skipped previously applied commit %s"),
5743 short_commit_name(commit
));
5747 if (is_empty
&& !keep_empty
)
5749 strbuf_addf(out
, "%s %s ", insn
,
5750 oid_to_hex(&commit
->object
.oid
));
5751 pretty_print_commit(&pp
, commit
, out
);
5753 strbuf_addf(out
, " %c empty", comment_line_char
);
5754 strbuf_addch(out
, '\n');
5757 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5758 _("use --reapply-cherry-picks to include skipped commits"));
5760 release_revisions(&revs
);
5765 * Add commands after pick and (series of) squash/fixup commands
5768 static void todo_list_add_exec_commands(struct todo_list
*todo_list
,
5769 struct string_list
*commands
)
5771 struct strbuf
*buf
= &todo_list
->buf
;
5772 size_t base_offset
= buf
->len
;
5773 int i
, insert
, nr
= 0, alloc
= 0;
5774 struct todo_item
*items
= NULL
, *base_items
= NULL
;
5776 CALLOC_ARRAY(base_items
, commands
->nr
);
5777 for (i
= 0; i
< commands
->nr
; i
++) {
5778 size_t command_len
= strlen(commands
->items
[i
].string
);
5780 strbuf_addstr(buf
, commands
->items
[i
].string
);
5781 strbuf_addch(buf
, '\n');
5783 base_items
[i
].command
= TODO_EXEC
;
5784 base_items
[i
].offset_in_buf
= base_offset
;
5785 base_items
[i
].arg_offset
= base_offset
;
5786 base_items
[i
].arg_len
= command_len
;
5788 base_offset
+= command_len
+ 1;
5792 * Insert <commands> after every pick. Here, fixup/squash chains
5793 * are considered part of the pick, so we insert the commands *after*
5794 * those chains if there are any.
5796 * As we insert the exec commands immediately after rearranging
5797 * any fixups and before the user edits the list, a fixup chain
5798 * can never contain comments (any comments are empty picks that
5799 * have been commented out because the user did not specify
5800 * --keep-empty). So, it is safe to insert an exec command
5801 * without looking at the command following a comment.
5804 for (i
= 0; i
< todo_list
->nr
; i
++) {
5805 enum todo_command command
= todo_list
->items
[i
].command
;
5806 if (insert
&& !is_fixup(command
)) {
5807 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5808 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5814 ALLOC_GROW(items
, nr
+ 1, alloc
);
5815 items
[nr
++] = todo_list
->items
[i
];
5817 if (command
== TODO_PICK
|| command
== TODO_MERGE
)
5821 /* insert or append final <commands> */
5823 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5824 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5829 FREE_AND_NULL(todo_list
->items
);
5830 todo_list
->items
= items
;
5832 todo_list
->alloc
= alloc
;
5835 static void todo_list_to_strbuf(struct repository
*r
, struct todo_list
*todo_list
,
5836 struct strbuf
*buf
, int num
, unsigned flags
)
5838 struct todo_item
*item
;
5839 int i
, max
= todo_list
->nr
;
5841 if (num
> 0 && num
< max
)
5844 for (item
= todo_list
->items
, i
= 0; i
< max
; i
++, item
++) {
5847 /* if the item is not a command write it and continue */
5848 if (item
->command
>= TODO_COMMENT
) {
5849 strbuf_addf(buf
, "%.*s\n", item
->arg_len
,
5850 todo_item_get_arg(todo_list
, item
));
5854 /* add command to the buffer */
5855 cmd
= command_to_char(item
->command
);
5856 if ((flags
& TODO_LIST_ABBREVIATE_CMDS
) && cmd
)
5857 strbuf_addch(buf
, cmd
);
5859 strbuf_addstr(buf
, command_to_string(item
->command
));
5863 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
5864 short_commit_name(item
->commit
) :
5865 oid_to_hex(&item
->commit
->object
.oid
);
5867 if (item
->command
== TODO_FIXUP
) {
5868 if (item
->flags
& TODO_EDIT_FIXUP_MSG
)
5869 strbuf_addstr(buf
, " -c");
5870 else if (item
->flags
& TODO_REPLACE_FIXUP_MSG
) {
5871 strbuf_addstr(buf
, " -C");
5875 if (item
->command
== TODO_MERGE
) {
5876 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
5877 strbuf_addstr(buf
, " -c");
5879 strbuf_addstr(buf
, " -C");
5882 strbuf_addf(buf
, " %s", oid
);
5885 /* add all the rest */
5887 strbuf_addch(buf
, '\n');
5889 strbuf_addf(buf
, " %.*s\n", item
->arg_len
,
5890 todo_item_get_arg(todo_list
, item
));
5894 int todo_list_write_to_file(struct repository
*r
, struct todo_list
*todo_list
,
5895 const char *file
, const char *shortrevisions
,
5896 const char *shortonto
, int num
, unsigned flags
)
5899 struct strbuf buf
= STRBUF_INIT
;
5901 todo_list_to_strbuf(r
, todo_list
, &buf
, num
, flags
);
5902 if (flags
& TODO_LIST_APPEND_TODO_HELP
)
5903 append_todo_help(count_commands(todo_list
),
5904 shortrevisions
, shortonto
, &buf
);
5906 res
= write_message(buf
.buf
, buf
.len
, file
, 0);
5907 strbuf_release(&buf
);
5912 /* skip picking commits whose parents are unchanged */
5913 static int skip_unnecessary_picks(struct repository
*r
,
5914 struct todo_list
*todo_list
,
5915 struct object_id
*base_oid
)
5917 struct object_id
*parent_oid
;
5920 for (i
= 0; i
< todo_list
->nr
; i
++) {
5921 struct todo_item
*item
= todo_list
->items
+ i
;
5923 if (item
->command
>= TODO_NOOP
)
5925 if (item
->command
!= TODO_PICK
)
5927 if (parse_commit(item
->commit
)) {
5928 return error(_("could not parse commit '%s'"),
5929 oid_to_hex(&item
->commit
->object
.oid
));
5931 if (!item
->commit
->parents
)
5932 break; /* root commit */
5933 if (item
->commit
->parents
->next
)
5934 break; /* merge commit */
5935 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
5936 if (!oideq(parent_oid
, base_oid
))
5938 oidcpy(base_oid
, &item
->commit
->object
.oid
);
5941 const char *done_path
= rebase_path_done();
5943 if (todo_list_write_to_file(r
, todo_list
, done_path
, NULL
, NULL
, i
, 0)) {
5944 error_errno(_("could not write to '%s'"), done_path
);
5948 MOVE_ARRAY(todo_list
->items
, todo_list
->items
+ i
, todo_list
->nr
- i
);
5950 todo_list
->current
= 0;
5951 todo_list
->done_nr
+= i
;
5953 if (is_fixup(peek_command(todo_list
, 0)))
5954 record_in_rewritten(base_oid
, peek_command(todo_list
, 0));
5960 struct todo_add_branch_context
{
5961 struct todo_item
*items
;
5965 struct commit
*commit
;
5966 struct string_list refs_to_oids
;
5969 static int add_decorations_to_list(const struct commit
*commit
,
5970 struct todo_add_branch_context
*ctx
)
5972 const struct name_decoration
*decoration
= get_name_decoration(&commit
->object
);
5973 const char *head_ref
= resolve_ref_unsafe("HEAD",
5974 RESOLVE_REF_READING
,
5978 while (decoration
) {
5979 struct todo_item
*item
;
5981 size_t base_offset
= ctx
->buf
->len
;
5984 * If the branch is the current HEAD, then it will be
5985 * updated by the default rebase behavior.
5987 if (head_ref
&& !strcmp(head_ref
, decoration
->name
)) {
5988 decoration
= decoration
->next
;
5992 ALLOC_GROW(ctx
->items
,
5995 item
= &ctx
->items
[ctx
->items_nr
];
5996 memset(item
, 0, sizeof(*item
));
5998 /* If the branch is checked out, then leave a comment instead. */
5999 if ((path
= branch_checked_out(decoration
->name
))) {
6000 item
->command
= TODO_COMMENT
;
6001 strbuf_addf(ctx
->buf
, "# Ref %s checked out at '%s'\n",
6002 decoration
->name
, path
);
6004 struct string_list_item
*sti
;
6005 item
->command
= TODO_UPDATE_REF
;
6006 strbuf_addf(ctx
->buf
, "%s\n", decoration
->name
);
6008 sti
= string_list_insert(&ctx
->refs_to_oids
,
6010 sti
->util
= init_update_ref_record(decoration
->name
);
6013 item
->offset_in_buf
= base_offset
;
6014 item
->arg_offset
= base_offset
;
6015 item
->arg_len
= ctx
->buf
->len
- base_offset
;
6018 decoration
= decoration
->next
;
6025 * For each 'pick' command, find out if the commit has a decoration in
6026 * refs/heads/. If so, then add a 'label for-update-refs/' command.
6028 static int todo_list_add_update_ref_commands(struct todo_list
*todo_list
)
6031 static struct string_list decorate_refs_exclude
= STRING_LIST_INIT_NODUP
;
6032 static struct string_list decorate_refs_exclude_config
= STRING_LIST_INIT_NODUP
;
6033 static struct string_list decorate_refs_include
= STRING_LIST_INIT_NODUP
;
6034 struct decoration_filter decoration_filter
= {
6035 .include_ref_pattern
= &decorate_refs_include
,
6036 .exclude_ref_pattern
= &decorate_refs_exclude
,
6037 .exclude_ref_config_pattern
= &decorate_refs_exclude_config
,
6039 struct todo_add_branch_context ctx
= {
6040 .buf
= &todo_list
->buf
,
6041 .refs_to_oids
= STRING_LIST_INIT_DUP
,
6044 ctx
.items_alloc
= 2 * todo_list
->nr
+ 1;
6045 ALLOC_ARRAY(ctx
.items
, ctx
.items_alloc
);
6047 string_list_append(&decorate_refs_include
, "refs/heads/");
6048 load_ref_decorations(&decoration_filter
, 0);
6050 for (i
= 0; i
< todo_list
->nr
; ) {
6051 struct todo_item
*item
= &todo_list
->items
[i
];
6053 /* insert ith item into new list */
6054 ALLOC_GROW(ctx
.items
,
6058 ctx
.items
[ctx
.items_nr
++] = todo_list
->items
[i
++];
6061 ctx
.commit
= item
->commit
;
6062 add_decorations_to_list(item
->commit
, &ctx
);
6066 res
= write_update_refs_state(&ctx
.refs_to_oids
);
6068 string_list_clear(&ctx
.refs_to_oids
, 1);
6071 /* we failed, so clean up the new list. */
6076 free(todo_list
->items
);
6077 todo_list
->items
= ctx
.items
;
6078 todo_list
->nr
= ctx
.items_nr
;
6079 todo_list
->alloc
= ctx
.items_alloc
;
6084 int complete_action(struct repository
*r
, struct replay_opts
*opts
, unsigned flags
,
6085 const char *shortrevisions
, const char *onto_name
,
6086 struct commit
*onto
, const struct object_id
*orig_head
,
6087 struct string_list
*commands
, unsigned autosquash
,
6088 unsigned update_refs
,
6089 struct todo_list
*todo_list
)
6091 char shortonto
[GIT_MAX_HEXSZ
+ 1];
6092 const char *todo_file
= rebase_path_todo();
6093 struct todo_list new_todo
= TODO_LIST_INIT
;
6094 struct strbuf
*buf
= &todo_list
->buf
, buf2
= STRBUF_INIT
;
6095 struct object_id oid
= onto
->object
.oid
;
6098 find_unique_abbrev_r(shortonto
, &oid
, DEFAULT_ABBREV
);
6100 if (buf
->len
== 0) {
6101 struct todo_item
*item
= append_new_todo(todo_list
);
6102 item
->command
= TODO_NOOP
;
6103 item
->commit
= NULL
;
6104 item
->arg_len
= item
->arg_offset
= item
->flags
= item
->offset_in_buf
= 0;
6107 if (update_refs
&& todo_list_add_update_ref_commands(todo_list
))
6110 if (autosquash
&& todo_list_rearrange_squash(todo_list
))
6114 todo_list_add_exec_commands(todo_list
, commands
);
6116 if (count_commands(todo_list
) == 0) {
6117 apply_autostash(rebase_path_autostash());
6118 sequencer_remove_state(opts
);
6120 return error(_("nothing to do"));
6123 res
= edit_todo_list(r
, todo_list
, &new_todo
, shortrevisions
,
6127 else if (res
== -2) {
6128 apply_autostash(rebase_path_autostash());
6129 sequencer_remove_state(opts
);
6132 } else if (res
== -3) {
6133 apply_autostash(rebase_path_autostash());
6134 sequencer_remove_state(opts
);
6135 todo_list_release(&new_todo
);
6137 return error(_("nothing to do"));
6138 } else if (res
== -4) {
6139 checkout_onto(r
, opts
, onto_name
, &onto
->object
.oid
, orig_head
);
6140 todo_list_release(&new_todo
);
6145 /* Expand the commit IDs */
6146 todo_list_to_strbuf(r
, &new_todo
, &buf2
, -1, 0);
6147 strbuf_swap(&new_todo
.buf
, &buf2
);
6148 strbuf_release(&buf2
);
6149 new_todo
.total_nr
-= new_todo
.nr
;
6150 if (todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
) < 0)
6151 BUG("invalid todo list after expanding IDs:\n%s",
6154 if (opts
->allow_ff
&& skip_unnecessary_picks(r
, &new_todo
, &oid
)) {
6155 todo_list_release(&new_todo
);
6156 return error(_("could not skip unnecessary pick commands"));
6159 if (todo_list_write_to_file(r
, &new_todo
, todo_file
, NULL
, NULL
, -1,
6160 flags
& ~(TODO_LIST_SHORTEN_IDS
))) {
6161 todo_list_release(&new_todo
);
6162 return error_errno(_("could not write '%s'"), todo_file
);
6167 if (checkout_onto(r
, opts
, onto_name
, &oid
, orig_head
))
6170 if (require_clean_work_tree(r
, "rebase", "", 1, 1))
6173 todo_list_write_total_nr(&new_todo
);
6174 res
= pick_commits(r
, &new_todo
, opts
);
6177 todo_list_release(&new_todo
);
6182 struct subject2item_entry
{
6183 struct hashmap_entry entry
;
6185 char subject
[FLEX_ARRAY
];
6188 static int subject2item_cmp(const void *fndata UNUSED
,
6189 const struct hashmap_entry
*eptr
,
6190 const struct hashmap_entry
*entry_or_key
,
6193 const struct subject2item_entry
*a
, *b
;
6195 a
= container_of(eptr
, const struct subject2item_entry
, entry
);
6196 b
= container_of(entry_or_key
, const struct subject2item_entry
, entry
);
6198 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
6201 define_commit_slab(commit_todo_item
, struct todo_item
*);
6203 static int skip_fixupish(const char *subject
, const char **p
) {
6204 return skip_prefix(subject
, "fixup! ", p
) ||
6205 skip_prefix(subject
, "amend! ", p
) ||
6206 skip_prefix(subject
, "squash! ", p
);
6210 * Rearrange the todo list that has both "pick commit-id msg" and "pick
6211 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
6212 * after the former, and change "pick" to "fixup"/"squash".
6214 * Note that if the config has specified a custom instruction format, each log
6215 * message will have to be retrieved from the commit (as the oneline in the
6216 * script cannot be trusted) in order to normalize the autosquash arrangement.
6218 int todo_list_rearrange_squash(struct todo_list
*todo_list
)
6220 struct hashmap subject2item
;
6221 int rearranged
= 0, *next
, *tail
, i
, nr
= 0, alloc
= 0;
6223 struct commit_todo_item commit_todo
;
6224 struct todo_item
*items
= NULL
;
6226 init_commit_todo_item(&commit_todo
);
6228 * The hashmap maps onelines to the respective todo list index.
6230 * If any items need to be rearranged, the next[i] value will indicate
6231 * which item was moved directly after the i'th.
6233 * In that case, last[i] will indicate the index of the latest item to
6234 * be moved to appear after the i'th.
6236 hashmap_init(&subject2item
, subject2item_cmp
, NULL
, todo_list
->nr
);
6237 ALLOC_ARRAY(next
, todo_list
->nr
);
6238 ALLOC_ARRAY(tail
, todo_list
->nr
);
6239 ALLOC_ARRAY(subjects
, todo_list
->nr
);
6240 for (i
= 0; i
< todo_list
->nr
; i
++) {
6241 struct strbuf buf
= STRBUF_INIT
;
6242 struct todo_item
*item
= todo_list
->items
+ i
;
6243 const char *commit_buffer
, *subject
, *p
;
6246 struct subject2item_entry
*entry
;
6248 next
[i
] = tail
[i
] = -1;
6249 if (!item
->commit
|| item
->command
== TODO_DROP
) {
6254 if (is_fixup(item
->command
)) {
6255 clear_commit_todo_item(&commit_todo
);
6256 return error(_("the script was already rearranged."));
6259 parse_commit(item
->commit
);
6260 commit_buffer
= logmsg_reencode(item
->commit
, NULL
, "UTF-8");
6261 find_commit_subject(commit_buffer
, &subject
);
6262 format_subject(&buf
, subject
, " ");
6263 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
6264 unuse_commit_buffer(item
->commit
, commit_buffer
);
6265 if (skip_fixupish(subject
, &p
)) {
6266 struct commit
*commit2
;
6271 if (!skip_fixupish(p
, &p
))
6275 entry
= hashmap_get_entry_from_hash(&subject2item
,
6277 struct subject2item_entry
,
6280 /* found by title */
6282 else if (!strchr(p
, ' ') &&
6284 lookup_commit_reference_by_name(p
)) &&
6285 *commit_todo_item_at(&commit_todo
, commit2
))
6286 /* found by commit name */
6287 i2
= *commit_todo_item_at(&commit_todo
, commit2
)
6290 /* copy can be a prefix of the commit subject */
6291 for (i2
= 0; i2
< i
; i2
++)
6293 starts_with(subjects
[i2
], p
))
6301 if (starts_with(subject
, "fixup!")) {
6302 todo_list
->items
[i
].command
= TODO_FIXUP
;
6303 } else if (starts_with(subject
, "amend!")) {
6304 todo_list
->items
[i
].command
= TODO_FIXUP
;
6305 todo_list
->items
[i
].flags
= TODO_REPLACE_FIXUP_MSG
;
6307 todo_list
->items
[i
].command
= TODO_SQUASH
;
6313 next
[i
] = next
[tail
[i2
]];
6317 } else if (!hashmap_get_from_hash(&subject2item
,
6318 strhash(subject
), subject
)) {
6319 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
6321 hashmap_entry_init(&entry
->entry
,
6322 strhash(entry
->subject
));
6323 hashmap_put(&subject2item
, &entry
->entry
);
6326 *commit_todo_item_at(&commit_todo
, item
->commit
) = item
;
6330 for (i
= 0; i
< todo_list
->nr
; i
++) {
6331 enum todo_command command
= todo_list
->items
[i
].command
;
6335 * Initially, all commands are 'pick's. If it is a
6336 * fixup or a squash now, we have rearranged it.
6338 if (is_fixup(command
))
6342 ALLOC_GROW(items
, nr
+ 1, alloc
);
6343 items
[nr
++] = todo_list
->items
[cur
];
6348 FREE_AND_NULL(todo_list
->items
);
6349 todo_list
->items
= items
;
6351 todo_list
->alloc
= alloc
;
6356 for (i
= 0; i
< todo_list
->nr
; i
++)
6359 hashmap_clear_and_free(&subject2item
, struct subject2item_entry
, entry
);
6361 clear_commit_todo_item(&commit_todo
);
6366 int sequencer_determine_whence(struct repository
*r
, enum commit_whence
*whence
)
6368 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
6369 struct object_id cherry_pick_head
, rebase_head
;
6371 if (file_exists(git_path_seq_dir()))
6372 *whence
= FROM_CHERRY_PICK_MULTI
;
6373 if (file_exists(rebase_path()) &&
6374 !get_oid("REBASE_HEAD", &rebase_head
) &&
6375 !get_oid("CHERRY_PICK_HEAD", &cherry_pick_head
) &&
6376 oideq(&rebase_head
, &cherry_pick_head
))
6377 *whence
= FROM_REBASE_PICK
;
6379 *whence
= FROM_CHERRY_PICK_SINGLE
;
6387 int sequencer_get_update_refs_state(const char *wt_dir
,
6388 struct string_list
*refs
)
6392 struct strbuf ref
= STRBUF_INIT
;
6393 struct strbuf hash
= STRBUF_INIT
;
6394 struct update_ref_record
*rec
= NULL
;
6396 char *path
= rebase_path_update_refs(wt_dir
);
6398 fp
= fopen(path
, "r");
6402 while (strbuf_getline(&ref
, fp
) != EOF
) {
6403 struct string_list_item
*item
;
6405 CALLOC_ARRAY(rec
, 1);
6407 if (strbuf_getline(&hash
, fp
) == EOF
||
6408 get_oid_hex(hash
.buf
, &rec
->before
)) {
6409 warning(_("update-refs file at '%s' is invalid"),
6415 if (strbuf_getline(&hash
, fp
) == EOF
||
6416 get_oid_hex(hash
.buf
, &rec
->after
)) {
6417 warning(_("update-refs file at '%s' is invalid"),
6423 item
= string_list_insert(refs
, ref
.buf
);
6433 strbuf_release(&ref
);
6434 strbuf_release(&hash
);