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"
41 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
43 static const char sign_off_header
[] = "Signed-off-by: ";
44 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
46 GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
48 static GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
50 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
51 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
52 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
53 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
55 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
57 * The file containing rebase commands, comments, and empty lines.
58 * This file is created by "git rebase -i" then edited by the user. As
59 * the lines are processed, they are removed from the front of this
60 * file and written to the tail of 'done'.
62 GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
63 GIT_PATH_FUNC(rebase_path_todo_backup
, "rebase-merge/git-rebase-todo.backup")
65 GIT_PATH_FUNC(rebase_path_dropped
, "rebase-merge/dropped")
68 * The rebase command lines that have already been processed. A line
69 * is moved here when it is first handled, before any associated user
72 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
74 * The file to keep track of how many commands were already processed (e.g.
77 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum")
79 * The file to keep track of how many commands are to be processed in total
80 * (e.g. for the prompt).
82 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end")
84 * The commit message that is planned to be used for any changes that
85 * need to be committed following a user interaction.
87 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
89 * The file into which is accumulated the suggested commit message for
90 * squash/fixup commands. When the first of a series of squash/fixups
91 * is seen, the file is created and the commit message from the
92 * previous commit and from the first squash/fixup commit are written
93 * to it. The commit message for each subsequent squash/fixup commit
94 * is appended to the file as it is processed.
96 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
98 * If the current series of squash/fixups has not yet included a squash
99 * command, then this file exists and holds the commit message of the
100 * original "pick" commit. (If the series ends without a "squash"
101 * command, then this can be used as the commit message of the combined
102 * commit without opening the editor.)
104 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
106 * This file contains the list fixup/squash commands that have been
107 * accumulated into message-fixup or message-squash so far.
109 static GIT_PATH_FUNC(rebase_path_current_fixups
, "rebase-merge/current-fixups")
111 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
112 * GIT_AUTHOR_DATE that will be used for the commit that is currently
115 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
117 * When an "edit" rebase command is being processed, the SHA1 of the
118 * commit to be edited is recorded in this file. When "git rebase
119 * --continue" is executed, if there are any staged changes then they
120 * will be amended to the HEAD commit, but only provided the HEAD
121 * commit is still the commit to be edited. When any other rebase
122 * command is processed, this file is deleted.
124 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
126 * When we stop at a given patch via the "edit" command, this file contains
127 * the commit object name of the corresponding patch.
129 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
131 * For the post-rewrite hook, we make a list of rewritten commits and
132 * their new sha1s. The rewritten-pending list keeps the sha1s of
133 * commits that have been processed, but not committed yet,
134 * e.g. because they are waiting for a 'squash' command.
136 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
137 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
138 "rebase-merge/rewritten-pending")
141 * The path of the file containing the OID of the "squash onto" commit, i.e.
142 * the dummy commit used for `reset [new root]`.
144 static GIT_PATH_FUNC(rebase_path_squash_onto
, "rebase-merge/squash-onto")
147 * The path of the file listing refs that need to be deleted after the rebase
148 * finishes. This is used by the `label` command to record the need for cleanup.
150 static GIT_PATH_FUNC(rebase_path_refs_to_delete
, "rebase-merge/refs-to-delete")
153 * The update-refs file stores a list of refs that will be updated at the end
154 * of the rebase sequence. The 'update-ref <ref>' commands in the todo file
155 * update the OIDs for the refs in this file, but the refs are not updated
156 * until the end of the rebase sequence.
158 * rebase_path_update_refs() returns the path to this file for a given
159 * worktree directory. For the current worktree, pass the_repository->gitdir.
161 static char *rebase_path_update_refs(const char *wt_git_dir
)
163 return xstrfmt("%s/rebase-merge/update-refs", wt_git_dir
);
167 * The following files are written by git-rebase just after parsing the
170 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
171 static GIT_PATH_FUNC(rebase_path_cdate_is_adate
, "rebase-merge/cdate_is_adate")
172 static GIT_PATH_FUNC(rebase_path_ignore_date
, "rebase-merge/ignore_date")
173 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
174 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
175 static GIT_PATH_FUNC(rebase_path_quiet
, "rebase-merge/quiet")
176 static GIT_PATH_FUNC(rebase_path_signoff
, "rebase-merge/signoff")
177 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
178 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
179 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
180 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
181 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
182 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
183 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec
, "rebase-merge/reschedule-failed-exec")
184 static GIT_PATH_FUNC(rebase_path_no_reschedule_failed_exec
, "rebase-merge/no-reschedule-failed-exec")
185 static GIT_PATH_FUNC(rebase_path_drop_redundant_commits
, "rebase-merge/drop_redundant_commits")
186 static GIT_PATH_FUNC(rebase_path_keep_redundant_commits
, "rebase-merge/keep_redundant_commits")
189 * A 'struct update_refs_record' represents a value in the update-refs
190 * list. We use a string_list to map refs to these (before, after) pairs.
192 struct update_ref_record
{
193 struct object_id before
;
194 struct object_id after
;
197 static struct update_ref_record
*init_update_ref_record(const char *ref
)
199 struct update_ref_record
*rec
;
201 CALLOC_ARRAY(rec
, 1);
203 oidcpy(&rec
->before
, null_oid());
204 oidcpy(&rec
->after
, null_oid());
206 /* This may fail, but that's fine, we will keep the null OID. */
207 read_ref(ref
, &rec
->before
);
212 static int git_sequencer_config(const char *k
, const char *v
, void *cb
)
214 struct replay_opts
*opts
= cb
;
217 if (!strcmp(k
, "commit.cleanup")) {
220 status
= git_config_string(&s
, k
, v
);
224 if (!strcmp(s
, "verbatim")) {
225 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
226 opts
->explicit_cleanup
= 1;
227 } else if (!strcmp(s
, "whitespace")) {
228 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
229 opts
->explicit_cleanup
= 1;
230 } else if (!strcmp(s
, "strip")) {
231 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_ALL
;
232 opts
->explicit_cleanup
= 1;
233 } else if (!strcmp(s
, "scissors")) {
234 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SCISSORS
;
235 opts
->explicit_cleanup
= 1;
237 warning(_("invalid commit message cleanup mode '%s'"),
245 if (!strcmp(k
, "commit.gpgsign")) {
246 opts
->gpg_sign
= git_config_bool(k
, v
) ? xstrdup("") : NULL
;
250 if (!opts
->default_strategy
&& !strcmp(k
, "pull.twohead")) {
251 int ret
= git_config_string((const char**)&opts
->default_strategy
, k
, v
);
254 * pull.twohead is allowed to be multi-valued; we only
255 * care about the first value.
257 char *tmp
= strchr(opts
->default_strategy
, ' ');
264 if (opts
->action
== REPLAY_REVERT
&& !strcmp(k
, "revert.reference"))
265 opts
->commit_use_reference
= git_config_bool(k
, v
);
267 status
= git_gpg_config(k
, v
, NULL
);
271 return git_diff_basic_config(k
, v
, NULL
);
274 void sequencer_init_config(struct replay_opts
*opts
)
276 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
277 git_config(git_sequencer_config
, opts
);
280 static inline int is_rebase_i(const struct replay_opts
*opts
)
282 return opts
->action
== REPLAY_INTERACTIVE_REBASE
;
285 static const char *get_dir(const struct replay_opts
*opts
)
287 if (is_rebase_i(opts
))
288 return rebase_path();
289 return git_path_seq_dir();
292 static const char *get_todo_path(const struct replay_opts
*opts
)
294 if (is_rebase_i(opts
))
295 return rebase_path_todo();
296 return git_path_todo_file();
300 * Returns 0 for non-conforming footer
301 * Returns 1 for conforming footer
302 * Returns 2 when sob exists within conforming footer
303 * Returns 3 when sob exists within conforming footer as last entry
305 static int has_conforming_footer(struct strbuf
*sb
, struct strbuf
*sob
,
306 size_t ignore_footer
)
308 struct process_trailer_options opts
= PROCESS_TRAILER_OPTIONS_INIT
;
309 struct trailer_info info
;
311 int found_sob
= 0, found_sob_last
= 0;
317 saved_char
= sb
->buf
[sb
->len
- ignore_footer
];
318 sb
->buf
[sb
->len
- ignore_footer
] = '\0';
321 trailer_info_get(&info
, sb
->buf
, &opts
);
324 sb
->buf
[sb
->len
- ignore_footer
] = saved_char
;
326 if (info
.trailer_start
== info
.trailer_end
)
329 for (i
= 0; i
< info
.trailer_nr
; i
++)
330 if (sob
&& !strncmp(info
.trailers
[i
], sob
->buf
, sob
->len
)) {
332 if (i
== info
.trailer_nr
- 1)
336 trailer_info_release(&info
);
345 static const char *gpg_sign_opt_quoted(struct replay_opts
*opts
)
347 static struct strbuf buf
= STRBUF_INIT
;
351 sq_quotef(&buf
, "-S%s", opts
->gpg_sign
);
355 int sequencer_remove_state(struct replay_opts
*opts
)
357 struct strbuf buf
= STRBUF_INIT
;
360 if (is_rebase_i(opts
) &&
361 strbuf_read_file(&buf
, rebase_path_refs_to_delete(), 0) > 0) {
364 char *eol
= strchr(p
, '\n');
367 if (delete_ref("(rebase) cleanup", p
, NULL
, 0) < 0) {
368 warning(_("could not delete '%s'"), p
);
377 free(opts
->gpg_sign
);
378 free(opts
->reflog_action
);
379 free(opts
->default_strategy
);
380 free(opts
->strategy
);
381 for (i
= 0; i
< opts
->xopts_nr
; i
++)
382 free(opts
->xopts
[i
]);
384 strbuf_release(&opts
->current_fixups
);
387 strbuf_addstr(&buf
, get_dir(opts
));
388 if (remove_dir_recursively(&buf
, 0))
389 ret
= error(_("could not remove '%s'"), buf
.buf
);
390 strbuf_release(&buf
);
395 static const char *action_name(const struct replay_opts
*opts
)
397 switch (opts
->action
) {
401 return N_("cherry-pick");
402 case REPLAY_INTERACTIVE_REBASE
:
405 die(_("unknown action: %d"), opts
->action
);
408 struct commit_message
{
415 static const char *short_commit_name(struct commit
*commit
)
417 return find_unique_abbrev(&commit
->object
.oid
, DEFAULT_ABBREV
);
420 static int get_message(struct commit
*commit
, struct commit_message
*out
)
422 const char *abbrev
, *subject
;
425 out
->message
= logmsg_reencode(commit
, NULL
, get_commit_output_encoding());
426 abbrev
= short_commit_name(commit
);
428 subject_len
= find_commit_subject(out
->message
, &subject
);
430 out
->subject
= xmemdupz(subject
, subject_len
);
431 out
->label
= xstrfmt("%s (%s)", abbrev
, out
->subject
);
432 out
->parent_label
= xstrfmt("parent of %s", out
->label
);
437 static void free_message(struct commit
*commit
, struct commit_message
*msg
)
439 free(msg
->parent_label
);
442 unuse_commit_buffer(commit
, msg
->message
);
445 static void print_advice(struct repository
*r
, int show_hint
,
446 struct replay_opts
*opts
)
448 char *msg
= getenv("GIT_CHERRY_PICK_HELP");
453 * A conflict has occurred but the porcelain
454 * (typically rebase --interactive) wants to take care
455 * of the commit itself so remove CHERRY_PICK_HEAD
457 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
464 advise(_("after resolving the conflicts, mark the corrected paths\n"
465 "with 'git add <paths>' or 'git rm <paths>'"));
466 else if (opts
->action
== REPLAY_PICK
)
467 advise(_("After resolving the conflicts, mark them with\n"
468 "\"git add/rm <pathspec>\", then run\n"
469 "\"git cherry-pick --continue\".\n"
470 "You can instead skip this commit with \"git cherry-pick --skip\".\n"
471 "To abort and get back to the state before \"git cherry-pick\",\n"
472 "run \"git cherry-pick --abort\"."));
473 else if (opts
->action
== REPLAY_REVERT
)
474 advise(_("After resolving the conflicts, mark them with\n"
475 "\"git add/rm <pathspec>\", then run\n"
476 "\"git revert --continue\".\n"
477 "You can instead skip this commit with \"git revert --skip\".\n"
478 "To abort and get back to the state before \"git revert\",\n"
479 "run \"git revert --abort\"."));
481 BUG("unexpected pick action in print_advice()");
485 static int write_message(const void *buf
, size_t len
, const char *filename
,
488 struct lock_file msg_file
= LOCK_INIT
;
490 int msg_fd
= hold_lock_file_for_update(&msg_file
, filename
, 0);
492 return error_errno(_("could not lock '%s'"), filename
);
493 if (write_in_full(msg_fd
, buf
, len
) < 0) {
494 error_errno(_("could not write to '%s'"), filename
);
495 rollback_lock_file(&msg_file
);
498 if (append_eol
&& write(msg_fd
, "\n", 1) < 0) {
499 error_errno(_("could not write eol to '%s'"), filename
);
500 rollback_lock_file(&msg_file
);
503 if (commit_lock_file(&msg_file
) < 0)
504 return error(_("failed to finalize '%s'"), filename
);
509 int read_oneliner(struct strbuf
*buf
,
510 const char *path
, unsigned flags
)
512 int orig_len
= buf
->len
;
514 if (strbuf_read_file(buf
, path
, 0) < 0) {
515 if ((flags
& READ_ONELINER_WARN_MISSING
) ||
516 (errno
!= ENOENT
&& errno
!= ENOTDIR
))
517 warning_errno(_("could not read '%s'"), path
);
521 if (buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\n') {
522 if (--buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\r')
524 buf
->buf
[buf
->len
] = '\0';
527 if ((flags
& READ_ONELINER_SKIP_IF_EMPTY
) && buf
->len
== orig_len
)
533 static struct tree
*empty_tree(struct repository
*r
)
535 return lookup_tree(r
, the_hash_algo
->empty_tree
);
538 static int error_dirty_index(struct repository
*repo
, struct replay_opts
*opts
)
540 if (repo_read_index_unmerged(repo
))
541 return error_resolve_conflict(action_name(opts
));
543 error(_("your local changes would be overwritten by %s."),
544 _(action_name(opts
)));
546 if (advice_enabled(ADVICE_COMMIT_BEFORE_MERGE
))
547 advise(_("commit your changes or stash them to proceed."));
551 static void update_abort_safety_file(void)
553 struct object_id head
;
555 /* Do nothing on a single-pick */
556 if (!file_exists(git_path_seq_dir()))
559 if (!get_oid("HEAD", &head
))
560 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head
));
562 write_file(git_path_abort_safety_file(), "%s", "");
565 static int fast_forward_to(struct repository
*r
,
566 const struct object_id
*to
,
567 const struct object_id
*from
,
569 struct replay_opts
*opts
)
571 struct ref_transaction
*transaction
;
572 struct strbuf sb
= STRBUF_INIT
;
573 struct strbuf err
= STRBUF_INIT
;
576 if (checkout_fast_forward(r
, from
, to
, 1))
577 return -1; /* the callee should have complained already */
579 strbuf_addf(&sb
, "%s: fast-forward", action_name(opts
));
581 transaction
= ref_transaction_begin(&err
);
583 ref_transaction_update(transaction
, "HEAD",
584 to
, unborn
&& !is_rebase_i(opts
) ?
587 ref_transaction_commit(transaction
, &err
)) {
588 ref_transaction_free(transaction
);
589 error("%s", err
.buf
);
591 strbuf_release(&err
);
596 strbuf_release(&err
);
597 ref_transaction_free(transaction
);
598 update_abort_safety_file();
602 enum commit_msg_cleanup_mode
get_cleanup_mode(const char *cleanup_arg
,
605 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
606 return use_editor
? COMMIT_MSG_CLEANUP_ALL
:
607 COMMIT_MSG_CLEANUP_SPACE
;
608 else if (!strcmp(cleanup_arg
, "verbatim"))
609 return COMMIT_MSG_CLEANUP_NONE
;
610 else if (!strcmp(cleanup_arg
, "whitespace"))
611 return COMMIT_MSG_CLEANUP_SPACE
;
612 else if (!strcmp(cleanup_arg
, "strip"))
613 return COMMIT_MSG_CLEANUP_ALL
;
614 else if (!strcmp(cleanup_arg
, "scissors"))
615 return use_editor
? COMMIT_MSG_CLEANUP_SCISSORS
:
616 COMMIT_MSG_CLEANUP_SPACE
;
618 die(_("Invalid cleanup mode %s"), cleanup_arg
);
622 * NB using int rather than enum cleanup_mode to stop clang's
623 * -Wtautological-constant-out-of-range-compare complaining that the comparison
626 static const char *describe_cleanup_mode(int cleanup_mode
)
628 static const char *modes
[] = { "whitespace",
633 if (cleanup_mode
< ARRAY_SIZE(modes
))
634 return modes
[cleanup_mode
];
636 BUG("invalid cleanup_mode provided (%d)", cleanup_mode
);
639 void append_conflicts_hint(struct index_state
*istate
,
640 struct strbuf
*msgbuf
, enum commit_msg_cleanup_mode cleanup_mode
)
644 if (cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
) {
645 strbuf_addch(msgbuf
, '\n');
646 wt_status_append_cut_line(msgbuf
);
647 strbuf_addch(msgbuf
, comment_line_char
);
650 strbuf_addch(msgbuf
, '\n');
651 strbuf_commented_addf(msgbuf
, "Conflicts:\n");
652 for (i
= 0; i
< istate
->cache_nr
;) {
653 const struct cache_entry
*ce
= istate
->cache
[i
++];
655 strbuf_commented_addf(msgbuf
, "\t%s\n", ce
->name
);
656 while (i
< istate
->cache_nr
&&
657 !strcmp(ce
->name
, istate
->cache
[i
]->name
))
663 static int do_recursive_merge(struct repository
*r
,
664 struct commit
*base
, struct commit
*next
,
665 const char *base_label
, const char *next_label
,
666 struct object_id
*head
, struct strbuf
*msgbuf
,
667 struct replay_opts
*opts
)
669 struct merge_options o
;
670 struct merge_result result
;
671 struct tree
*next_tree
, *base_tree
, *head_tree
;
672 int clean
, show_output
;
674 struct lock_file index_lock
= LOCK_INIT
;
676 if (repo_hold_locked_index(r
, &index_lock
, LOCK_REPORT_ON_ERROR
) < 0)
681 init_merge_options(&o
, r
);
682 o
.ancestor
= base
? base_label
: "(empty tree)";
684 o
.branch2
= next
? next_label
: "(empty tree)";
685 if (is_rebase_i(opts
))
687 o
.show_rename_progress
= 1;
689 head_tree
= parse_tree_indirect(head
);
690 next_tree
= next
? get_commit_tree(next
) : empty_tree(r
);
691 base_tree
= base
? get_commit_tree(base
) : empty_tree(r
);
693 for (i
= 0; i
< opts
->xopts_nr
; i
++)
694 parse_merge_opt(&o
, opts
->xopts
[i
]);
696 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
697 memset(&result
, 0, sizeof(result
));
698 merge_incore_nonrecursive(&o
, base_tree
, head_tree
, next_tree
,
700 show_output
= !is_rebase_i(opts
) || !result
.clean
;
702 * TODO: merge_switch_to_result will update index/working tree;
703 * we only really want to do that if !result.clean || this is
704 * the final patch to be picked. But determining this is the
705 * final patch would take some work, and "head_tree" would need
706 * to be replace with the tree the index matched before we
707 * started doing any picks.
709 merge_switch_to_result(&o
, head_tree
, &result
, 1, show_output
);
710 clean
= result
.clean
;
712 ensure_full_index(r
->index
);
713 clean
= merge_trees(&o
, head_tree
, next_tree
, base_tree
);
714 if (is_rebase_i(opts
) && clean
<= 0)
715 fputs(o
.obuf
.buf
, stdout
);
716 strbuf_release(&o
.obuf
);
719 rollback_lock_file(&index_lock
);
723 if (write_locked_index(r
->index
, &index_lock
,
724 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
726 * TRANSLATORS: %s will be "revert", "cherry-pick" or
729 return error(_("%s: Unable to write new index file"),
730 _(action_name(opts
)));
733 append_conflicts_hint(r
->index
, msgbuf
,
734 opts
->default_msg_cleanup
);
739 static struct object_id
*get_cache_tree_oid(struct index_state
*istate
)
741 if (!cache_tree_fully_valid(istate
->cache_tree
))
742 if (cache_tree_update(istate
, 0)) {
743 error(_("unable to update cache tree"));
747 return &istate
->cache_tree
->oid
;
750 static int is_index_unchanged(struct repository
*r
)
752 struct object_id head_oid
, *cache_tree_oid
;
753 struct commit
*head_commit
;
754 struct index_state
*istate
= r
->index
;
756 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
757 return error(_("could not resolve HEAD commit"));
759 head_commit
= lookup_commit(r
, &head_oid
);
762 * If head_commit is NULL, check_commit, called from
763 * lookup_commit, would have indicated that head_commit is not
764 * a commit object already. parse_commit() will return failure
765 * without further complaints in such a case. Otherwise, if
766 * the commit is invalid, parse_commit() will complain. So
767 * there is nothing for us to say here. Just return failure.
769 if (parse_commit(head_commit
))
772 if (!(cache_tree_oid
= get_cache_tree_oid(istate
)))
775 return oideq(cache_tree_oid
, get_commit_tree_oid(head_commit
));
778 static int write_author_script(const char *message
)
780 struct strbuf buf
= STRBUF_INIT
;
785 if (!*message
|| starts_with(message
, "\n")) {
787 /* Missing 'author' line? */
788 unlink(rebase_path_author_script());
790 } else if (skip_prefix(message
, "author ", &message
))
792 else if ((eol
= strchr(message
, '\n')))
797 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
798 while (*message
&& *message
!= '\n' && *message
!= '\r')
799 if (skip_prefix(message
, " <", &message
))
801 else if (*message
!= '\'')
802 strbuf_addch(&buf
, *(message
++));
804 strbuf_addf(&buf
, "'\\%c'", *(message
++));
805 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
806 while (*message
&& *message
!= '\n' && *message
!= '\r')
807 if (skip_prefix(message
, "> ", &message
))
809 else if (*message
!= '\'')
810 strbuf_addch(&buf
, *(message
++));
812 strbuf_addf(&buf
, "'\\%c'", *(message
++));
813 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
814 while (*message
&& *message
!= '\n' && *message
!= '\r')
815 if (*message
!= '\'')
816 strbuf_addch(&buf
, *(message
++));
818 strbuf_addf(&buf
, "'\\%c'", *(message
++));
819 strbuf_addch(&buf
, '\'');
820 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
821 strbuf_release(&buf
);
826 * Take a series of KEY='VALUE' lines where VALUE part is
827 * sq-quoted, and append <KEY, VALUE> at the end of the string list
829 static int parse_key_value_squoted(char *buf
, struct string_list
*list
)
832 struct string_list_item
*item
;
834 char *cp
= strchr(buf
, '=');
836 np
= strchrnul(buf
, '\n');
837 return error(_("no key present in '%.*s'"),
838 (int) (np
- buf
), buf
);
840 np
= strchrnul(cp
, '\n');
842 item
= string_list_append(list
, buf
);
844 buf
= np
+ (*np
== '\n');
848 return error(_("unable to dequote value of '%s'"),
850 item
->util
= xstrdup(cp
);
856 * Reads and parses the state directory's "author-script" file, and sets name,
857 * email and date accordingly.
858 * Returns 0 on success, -1 if the file could not be parsed.
860 * The author script is of the format:
862 * GIT_AUTHOR_NAME='$author_name'
863 * GIT_AUTHOR_EMAIL='$author_email'
864 * GIT_AUTHOR_DATE='$author_date'
866 * where $author_name, $author_email and $author_date are quoted. We are strict
867 * with our parsing, as the file was meant to be eval'd in the now-removed
868 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
869 * from what this function expects, it is better to bail out than to do
870 * something that the user does not expect.
872 int read_author_script(const char *path
, char **name
, char **email
, char **date
,
875 struct strbuf buf
= STRBUF_INIT
;
876 struct string_list kv
= STRING_LIST_INIT_DUP
;
877 int retval
= -1; /* assume failure */
878 int i
, name_i
= -2, email_i
= -2, date_i
= -2, err
= 0;
880 if (strbuf_read_file(&buf
, path
, 256) <= 0) {
881 strbuf_release(&buf
);
882 if (errno
== ENOENT
&& allow_missing
)
885 return error_errno(_("could not open '%s' for reading"),
889 if (parse_key_value_squoted(buf
.buf
, &kv
))
892 for (i
= 0; i
< kv
.nr
; i
++) {
893 if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_NAME")) {
895 name_i
= error(_("'GIT_AUTHOR_NAME' already given"));
898 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_EMAIL")) {
900 email_i
= error(_("'GIT_AUTHOR_EMAIL' already given"));
903 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_DATE")) {
905 date_i
= error(_("'GIT_AUTHOR_DATE' already given"));
909 err
= error(_("unknown variable '%s'"),
914 error(_("missing 'GIT_AUTHOR_NAME'"));
916 error(_("missing 'GIT_AUTHOR_EMAIL'"));
918 error(_("missing 'GIT_AUTHOR_DATE'"));
919 if (name_i
< 0 || email_i
< 0 || date_i
< 0 || err
)
921 *name
= kv
.items
[name_i
].util
;
922 *email
= kv
.items
[email_i
].util
;
923 *date
= kv
.items
[date_i
].util
;
926 string_list_clear(&kv
, !!retval
);
927 strbuf_release(&buf
);
932 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
933 * file with shell quoting into struct strvec. Returns -1 on
934 * error, 0 otherwise.
936 static int read_env_script(struct strvec
*env
)
938 char *name
, *email
, *date
;
940 if (read_author_script(rebase_path_author_script(),
941 &name
, &email
, &date
, 0))
944 strvec_pushf(env
, "GIT_AUTHOR_NAME=%s", name
);
945 strvec_pushf(env
, "GIT_AUTHOR_EMAIL=%s", email
);
946 strvec_pushf(env
, "GIT_AUTHOR_DATE=%s", date
);
954 static char *get_author(const char *message
)
959 a
= find_commit_header(message
, "author", &len
);
961 return xmemdupz(a
, len
);
966 static const char *author_date_from_env(const struct strvec
*env
)
971 for (i
= 0; i
< env
->nr
; i
++)
972 if (skip_prefix(env
->v
[i
],
973 "GIT_AUTHOR_DATE=", &date
))
976 * If GIT_AUTHOR_DATE is missing we should have already errored out when
979 BUG("GIT_AUTHOR_DATE missing from author script");
982 static const char staged_changes_advice
[] =
983 N_("you have staged changes in your working tree\n"
984 "If these changes are meant to be squashed into the previous commit, run:\n"
986 " git commit --amend %s\n"
988 "If they are meant to go into a new commit, run:\n"
992 "In both cases, once you're done, continue with:\n"
994 " git rebase --continue\n");
996 #define ALLOW_EMPTY (1<<0)
997 #define EDIT_MSG (1<<1)
998 #define AMEND_MSG (1<<2)
999 #define CLEANUP_MSG (1<<3)
1000 #define VERIFY_MSG (1<<4)
1001 #define CREATE_ROOT_COMMIT (1<<5)
1002 #define VERBATIM_MSG (1<<6)
1004 static int run_command_silent_on_success(struct child_process
*cmd
)
1006 struct strbuf buf
= STRBUF_INIT
;
1009 cmd
->stdout_to_stderr
= 1;
1010 rc
= pipe_command(cmd
,
1016 fputs(buf
.buf
, stderr
);
1017 strbuf_release(&buf
);
1022 * If we are cherry-pick, and if the merge did not result in
1023 * hand-editing, we will hit this commit and inherit the original
1024 * author date and name.
1026 * If we are revert, or if our cherry-pick results in a hand merge,
1027 * we had better say that the current user is responsible for that.
1029 * An exception is when run_git_commit() is called during an
1030 * interactive rebase: in that case, we will want to retain the
1033 static int run_git_commit(const char *defmsg
,
1034 struct replay_opts
*opts
,
1037 struct child_process cmd
= CHILD_PROCESS_INIT
;
1039 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1040 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1044 if (is_rebase_i(opts
) &&
1045 ((opts
->committer_date_is_author_date
&& !opts
->ignore_date
) ||
1046 !(!defmsg
&& (flags
& AMEND_MSG
))) &&
1047 read_env_script(&cmd
.env
)) {
1048 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
1050 return error(_(staged_changes_advice
),
1054 strvec_pushf(&cmd
.env
, GIT_REFLOG_ACTION
"=%s", opts
->reflog_message
);
1056 if (opts
->committer_date_is_author_date
)
1057 strvec_pushf(&cmd
.env
, "GIT_COMMITTER_DATE=%s",
1060 author_date_from_env(&cmd
.env
));
1061 if (opts
->ignore_date
)
1062 strvec_push(&cmd
.env
, "GIT_AUTHOR_DATE=");
1064 strvec_push(&cmd
.args
, "commit");
1066 if (!(flags
& VERIFY_MSG
))
1067 strvec_push(&cmd
.args
, "-n");
1068 if ((flags
& AMEND_MSG
))
1069 strvec_push(&cmd
.args
, "--amend");
1071 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
1073 strvec_push(&cmd
.args
, "--no-gpg-sign");
1075 strvec_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
1076 else if (!(flags
& EDIT_MSG
))
1077 strvec_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
1078 if ((flags
& CLEANUP_MSG
))
1079 strvec_push(&cmd
.args
, "--cleanup=strip");
1080 if ((flags
& VERBATIM_MSG
))
1081 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1082 if ((flags
& EDIT_MSG
))
1083 strvec_push(&cmd
.args
, "-e");
1084 else if (!(flags
& CLEANUP_MSG
) &&
1085 !opts
->signoff
&& !opts
->record_origin
&&
1086 !opts
->explicit_cleanup
)
1087 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1089 if ((flags
& ALLOW_EMPTY
))
1090 strvec_push(&cmd
.args
, "--allow-empty");
1092 if (!(flags
& EDIT_MSG
))
1093 strvec_push(&cmd
.args
, "--allow-empty-message");
1095 if (is_rebase_i(opts
) && !(flags
& EDIT_MSG
))
1096 return run_command_silent_on_success(&cmd
);
1098 return run_command(&cmd
);
1101 static int rest_is_empty(const struct strbuf
*sb
, int start
)
1106 /* Check if the rest is just whitespace and Signed-off-by's. */
1107 for (i
= start
; i
< sb
->len
; i
++) {
1108 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1114 if (strlen(sign_off_header
) <= eol
- i
&&
1115 starts_with(sb
->buf
+ i
, sign_off_header
)) {
1120 if (!isspace(sb
->buf
[i
++]))
1127 void cleanup_message(struct strbuf
*msgbuf
,
1128 enum commit_msg_cleanup_mode cleanup_mode
, int verbose
)
1130 if (verbose
|| /* Truncate the message just before the diff, if any. */
1131 cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
1132 strbuf_setlen(msgbuf
, wt_status_locate_end(msgbuf
->buf
, msgbuf
->len
));
1133 if (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
)
1134 strbuf_stripspace(msgbuf
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1138 * Find out if the message in the strbuf contains only whitespace and
1139 * Signed-off-by lines.
1141 int message_is_empty(const struct strbuf
*sb
,
1142 enum commit_msg_cleanup_mode cleanup_mode
)
1144 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1146 return rest_is_empty(sb
, 0);
1150 * See if the user edited the message in the editor or left what
1151 * was in the template intact
1153 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
1154 enum commit_msg_cleanup_mode cleanup_mode
)
1156 struct strbuf tmpl
= STRBUF_INIT
;
1159 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1162 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
1165 strbuf_stripspace(&tmpl
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1166 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
1168 strbuf_release(&tmpl
);
1169 return rest_is_empty(sb
, start
- sb
->buf
);
1172 int update_head_with_reflog(const struct commit
*old_head
,
1173 const struct object_id
*new_head
,
1174 const char *action
, const struct strbuf
*msg
,
1177 struct ref_transaction
*transaction
;
1178 struct strbuf sb
= STRBUF_INIT
;
1183 strbuf_addstr(&sb
, action
);
1184 strbuf_addstr(&sb
, ": ");
1187 nl
= strchr(msg
->buf
, '\n');
1189 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
1191 strbuf_addbuf(&sb
, msg
);
1192 strbuf_addch(&sb
, '\n');
1195 transaction
= ref_transaction_begin(err
);
1197 ref_transaction_update(transaction
, "HEAD", new_head
,
1198 old_head
? &old_head
->object
.oid
: null_oid(),
1200 ref_transaction_commit(transaction
, err
)) {
1203 ref_transaction_free(transaction
);
1204 strbuf_release(&sb
);
1209 static int run_rewrite_hook(const struct object_id
*oldoid
,
1210 const struct object_id
*newoid
)
1212 struct child_process proc
= CHILD_PROCESS_INIT
;
1214 struct strbuf sb
= STRBUF_INIT
;
1215 const char *hook_path
= find_hook("post-rewrite");
1220 strvec_pushl(&proc
.args
, hook_path
, "amend", NULL
);
1222 proc
.stdout_to_stderr
= 1;
1223 proc
.trace2_hook_name
= "post-rewrite";
1225 code
= start_command(&proc
);
1228 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
1229 sigchain_push(SIGPIPE
, SIG_IGN
);
1230 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
1232 strbuf_release(&sb
);
1233 sigchain_pop(SIGPIPE
);
1234 return finish_command(&proc
);
1237 void commit_post_rewrite(struct repository
*r
,
1238 const struct commit
*old_head
,
1239 const struct object_id
*new_head
)
1241 struct notes_rewrite_cfg
*cfg
;
1243 cfg
= init_copy_notes_for_rewrite("amend");
1245 /* we are amending, so old_head is not NULL */
1246 copy_note_for_rewrite(cfg
, &old_head
->object
.oid
, new_head
);
1247 finish_copy_notes_for_rewrite(r
, cfg
, "Notes added by 'git commit --amend'");
1249 run_rewrite_hook(&old_head
->object
.oid
, new_head
);
1252 static int run_prepare_commit_msg_hook(struct repository
*r
,
1257 const char *name
, *arg1
= NULL
, *arg2
= NULL
;
1259 name
= git_path_commit_editmsg();
1260 if (write_message(msg
->buf
, msg
->len
, name
, 0))
1269 if (run_commit_hook(0, r
->index_file
, NULL
, "prepare-commit-msg", name
,
1271 ret
= error(_("'prepare-commit-msg' hook failed"));
1276 static const char implicit_ident_advice_noconfig
[] =
1277 N_("Your name and email address were configured automatically based\n"
1278 "on your username and hostname. Please check that they are accurate.\n"
1279 "You can suppress this message by setting them explicitly. Run the\n"
1280 "following command and follow the instructions in your editor to edit\n"
1281 "your configuration file:\n"
1283 " git config --global --edit\n"
1285 "After doing this, you may fix the identity used for this commit with:\n"
1287 " git commit --amend --reset-author\n");
1289 static const char implicit_ident_advice_config
[] =
1290 N_("Your name and email address were configured automatically based\n"
1291 "on your username and hostname. Please check that they are accurate.\n"
1292 "You can suppress this message by setting them explicitly:\n"
1294 " git config --global user.name \"Your Name\"\n"
1295 " git config --global user.email you@example.com\n"
1297 "After doing this, you may fix the identity used for this commit with:\n"
1299 " git commit --amend --reset-author\n");
1301 static const char *implicit_ident_advice(void)
1303 char *user_config
= interpolate_path("~/.gitconfig", 0);
1304 char *xdg_config
= xdg_config_home("config");
1305 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1311 return _(implicit_ident_advice_config
);
1313 return _(implicit_ident_advice_noconfig
);
1317 void print_commit_summary(struct repository
*r
,
1319 const struct object_id
*oid
,
1322 struct rev_info rev
;
1323 struct commit
*commit
;
1324 struct strbuf format
= STRBUF_INIT
;
1326 struct pretty_print_context pctx
= {0};
1327 struct strbuf author_ident
= STRBUF_INIT
;
1328 struct strbuf committer_ident
= STRBUF_INIT
;
1329 struct ref_store
*refs
;
1331 commit
= lookup_commit(r
, oid
);
1333 die(_("couldn't look up newly created commit"));
1334 if (parse_commit(commit
))
1335 die(_("could not parse newly created commit"));
1337 strbuf_addstr(&format
, "format:%h] %s");
1339 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1340 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1341 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1342 strbuf_addstr(&format
, "\n Author: ");
1343 strbuf_addbuf_percentquote(&format
, &author_ident
);
1345 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
1346 struct strbuf date
= STRBUF_INIT
;
1348 format_commit_message(commit
, "%ad", &date
, &pctx
);
1349 strbuf_addstr(&format
, "\n Date: ");
1350 strbuf_addbuf_percentquote(&format
, &date
);
1351 strbuf_release(&date
);
1353 if (!committer_ident_sufficiently_given()) {
1354 strbuf_addstr(&format
, "\n Committer: ");
1355 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1356 if (advice_enabled(ADVICE_IMPLICIT_IDENTITY
)) {
1357 strbuf_addch(&format
, '\n');
1358 strbuf_addstr(&format
, implicit_ident_advice());
1361 strbuf_release(&author_ident
);
1362 strbuf_release(&committer_ident
);
1364 repo_init_revisions(r
, &rev
, prefix
);
1365 setup_revisions(0, NULL
, &rev
, NULL
);
1368 rev
.diffopt
.output_format
=
1369 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1371 rev
.verbose_header
= 1;
1372 rev
.show_root_diff
= 1;
1373 get_commit_format(format
.buf
, &rev
);
1374 rev
.always_show_header
= 0;
1375 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1376 diff_setup_done(&rev
.diffopt
);
1378 refs
= get_main_ref_store(the_repository
);
1379 head
= refs_resolve_ref_unsafe(refs
, "HEAD", 0, NULL
, NULL
);
1381 die(_("unable to resolve HEAD after creating commit"));
1382 if (!strcmp(head
, "HEAD"))
1383 head
= _("detached HEAD");
1385 skip_prefix(head
, "refs/heads/", &head
);
1386 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1387 _(" (root-commit)") : "");
1389 if (!log_tree_commit(&rev
, commit
)) {
1390 rev
.always_show_header
= 1;
1391 rev
.use_terminator
= 1;
1392 log_tree_commit(&rev
, commit
);
1395 release_revisions(&rev
);
1396 strbuf_release(&format
);
1399 static int parse_head(struct repository
*r
, struct commit
**head
)
1401 struct commit
*current_head
;
1402 struct object_id oid
;
1404 if (get_oid("HEAD", &oid
)) {
1405 current_head
= NULL
;
1407 current_head
= lookup_commit_reference(r
, &oid
);
1409 return error(_("could not parse HEAD"));
1410 if (!oideq(&oid
, ¤t_head
->object
.oid
)) {
1411 warning(_("HEAD %s is not a commit!"),
1414 if (parse_commit(current_head
))
1415 return error(_("could not parse HEAD commit"));
1417 *head
= current_head
;
1423 * Try to commit without forking 'git commit'. In some cases we need
1424 * to run 'git commit' to display an error message
1427 * -1 - error unable to commit
1429 * 1 - run 'git commit'
1431 static int try_to_commit(struct repository
*r
,
1432 struct strbuf
*msg
, const char *author
,
1433 struct replay_opts
*opts
, unsigned int flags
,
1434 struct object_id
*oid
)
1436 struct object_id tree
;
1437 struct commit
*current_head
= NULL
;
1438 struct commit_list
*parents
= NULL
;
1439 struct commit_extra_header
*extra
= NULL
;
1440 struct strbuf err
= STRBUF_INIT
;
1441 struct strbuf commit_msg
= STRBUF_INIT
;
1442 char *amend_author
= NULL
;
1443 const char *committer
= NULL
;
1444 const char *hook_commit
= NULL
;
1445 enum commit_msg_cleanup_mode cleanup
;
1448 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1449 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1451 if (parse_head(r
, ¤t_head
))
1454 if (flags
& AMEND_MSG
) {
1455 const char *exclude_gpgsig
[] = { "gpgsig", "gpgsig-sha256", NULL
};
1456 const char *out_enc
= get_commit_output_encoding();
1457 const char *message
= logmsg_reencode(current_head
, NULL
,
1461 const char *orig_message
= NULL
;
1463 find_commit_subject(message
, &orig_message
);
1465 strbuf_addstr(msg
, orig_message
);
1466 hook_commit
= "HEAD";
1468 author
= amend_author
= get_author(message
);
1469 unuse_commit_buffer(current_head
, message
);
1471 res
= error(_("unable to parse commit author"));
1474 parents
= copy_commit_list(current_head
->parents
);
1475 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1476 } else if (current_head
&&
1477 (!(flags
& CREATE_ROOT_COMMIT
) || (flags
& AMEND_MSG
))) {
1478 commit_list_insert(current_head
, &parents
);
1481 if (write_index_as_tree(&tree
, r
->index
, r
->index_file
, 0, NULL
)) {
1482 res
= error(_("git write-tree failed to write a tree"));
1486 if (!(flags
& ALLOW_EMPTY
)) {
1487 struct commit
*first_parent
= current_head
;
1489 if (flags
& AMEND_MSG
) {
1490 if (current_head
->parents
) {
1491 first_parent
= current_head
->parents
->item
;
1492 if (repo_parse_commit(r
, first_parent
)) {
1493 res
= error(_("could not parse HEAD commit"));
1497 first_parent
= NULL
;
1500 if (oideq(first_parent
1501 ? get_commit_tree_oid(first_parent
)
1502 : the_hash_algo
->empty_tree
,
1504 res
= 1; /* run 'git commit' to display error message */
1509 if (hook_exists("prepare-commit-msg")) {
1510 res
= run_prepare_commit_msg_hook(r
, msg
, hook_commit
);
1513 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1515 res
= error_errno(_("unable to read commit message "
1517 git_path_commit_editmsg());
1523 if (flags
& CLEANUP_MSG
)
1524 cleanup
= COMMIT_MSG_CLEANUP_ALL
;
1525 else if (flags
& VERBATIM_MSG
)
1526 cleanup
= COMMIT_MSG_CLEANUP_NONE
;
1527 else if ((opts
->signoff
|| opts
->record_origin
) &&
1528 !opts
->explicit_cleanup
)
1529 cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
1531 cleanup
= opts
->default_msg_cleanup
;
1533 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1534 strbuf_stripspace(msg
, cleanup
== COMMIT_MSG_CLEANUP_ALL
);
1535 if ((flags
& EDIT_MSG
) && message_is_empty(msg
, cleanup
)) {
1536 res
= 1; /* run 'git commit' to display error message */
1540 if (opts
->committer_date_is_author_date
) {
1541 struct ident_split id
;
1542 struct strbuf date
= STRBUF_INIT
;
1544 if (!opts
->ignore_date
) {
1545 if (split_ident_line(&id
, author
, (int)strlen(author
)) < 0) {
1546 res
= error(_("invalid author identity '%s'"),
1550 if (!id
.date_begin
) {
1552 "corrupt author: missing date information"));
1555 strbuf_addf(&date
, "@%.*s %.*s",
1556 (int)(id
.date_end
- id
.date_begin
),
1558 (int)(id
.tz_end
- id
.tz_begin
),
1563 committer
= fmt_ident(getenv("GIT_COMMITTER_NAME"),
1564 getenv("GIT_COMMITTER_EMAIL"),
1565 WANT_COMMITTER_IDENT
,
1566 opts
->ignore_date
? NULL
: date
.buf
,
1568 strbuf_release(&date
);
1573 if (opts
->ignore_date
) {
1574 struct ident_split id
;
1577 if (split_ident_line(&id
, author
, strlen(author
)) < 0) {
1578 error(_("invalid author identity '%s'"), author
);
1581 name
= xmemdupz(id
.name_begin
, id
.name_end
- id
.name_begin
);
1582 email
= xmemdupz(id
.mail_begin
, id
.mail_end
- id
.mail_begin
);
1583 author
= fmt_ident(name
, email
, WANT_AUTHOR_IDENT
, NULL
,
1589 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
, oid
,
1590 author
, committer
, opts
->gpg_sign
, extra
)) {
1591 res
= error(_("failed to write commit object"));
1595 if (update_head_with_reflog(current_head
, oid
, opts
->reflog_message
,
1597 res
= error("%s", err
.buf
);
1601 run_commit_hook(0, r
->index_file
, NULL
, "post-commit", NULL
);
1602 if (flags
& AMEND_MSG
)
1603 commit_post_rewrite(r
, current_head
, oid
);
1606 free_commit_extra_headers(extra
);
1607 strbuf_release(&err
);
1608 strbuf_release(&commit_msg
);
1614 static int write_rebase_head(struct object_id
*oid
)
1616 if (update_ref("rebase", "REBASE_HEAD", oid
,
1617 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1618 return error(_("could not update %s"), "REBASE_HEAD");
1623 static int do_commit(struct repository
*r
,
1624 const char *msg_file
, const char *author
,
1625 struct replay_opts
*opts
, unsigned int flags
,
1626 struct object_id
*oid
)
1630 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
)) {
1631 struct object_id oid
;
1632 struct strbuf sb
= STRBUF_INIT
;
1634 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1635 return error_errno(_("unable to read commit message "
1639 res
= try_to_commit(r
, msg_file
? &sb
: NULL
,
1640 author
, opts
, flags
, &oid
);
1641 strbuf_release(&sb
);
1643 refs_delete_ref(get_main_ref_store(r
), "",
1644 "CHERRY_PICK_HEAD", NULL
, 0);
1645 unlink(git_path_merge_msg(r
));
1646 if (!is_rebase_i(opts
))
1647 print_commit_summary(r
, NULL
, &oid
,
1648 SUMMARY_SHOW_AUTHOR_DATE
);
1653 if (is_rebase_i(opts
) && oid
)
1654 if (write_rebase_head(oid
))
1656 return run_git_commit(msg_file
, opts
, flags
);
1662 static int is_original_commit_empty(struct commit
*commit
)
1664 const struct object_id
*ptree_oid
;
1666 if (parse_commit(commit
))
1667 return error(_("could not parse commit %s"),
1668 oid_to_hex(&commit
->object
.oid
));
1669 if (commit
->parents
) {
1670 struct commit
*parent
= commit
->parents
->item
;
1671 if (parse_commit(parent
))
1672 return error(_("could not parse parent commit %s"),
1673 oid_to_hex(&parent
->object
.oid
));
1674 ptree_oid
= get_commit_tree_oid(parent
);
1676 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1679 return oideq(ptree_oid
, get_commit_tree_oid(commit
));
1683 * Should empty commits be allowed? Return status:
1684 * <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1685 * 0: Halt on empty commit
1686 * 1: Allow empty commit
1687 * 2: Drop empty commit
1689 static int allow_empty(struct repository
*r
,
1690 struct replay_opts
*opts
,
1691 struct commit
*commit
)
1693 int index_unchanged
, originally_empty
;
1698 * (1) we do not allow empty at all and error out.
1700 * (2) we allow ones that were initially empty, and
1701 * just drop the ones that become empty
1703 * (3) we allow ones that were initially empty, but
1704 * halt for the ones that become empty;
1706 * (4) we allow both.
1708 if (!opts
->allow_empty
)
1709 return 0; /* let "git commit" barf as necessary */
1711 index_unchanged
= is_index_unchanged(r
);
1712 if (index_unchanged
< 0)
1713 return index_unchanged
;
1714 if (!index_unchanged
)
1715 return 0; /* we do not have to say --allow-empty */
1717 if (opts
->keep_redundant_commits
)
1720 originally_empty
= is_original_commit_empty(commit
);
1721 if (originally_empty
< 0)
1722 return originally_empty
;
1723 if (originally_empty
)
1725 else if (opts
->drop_redundant_commits
)
1734 } todo_command_info
[] = {
1735 [TODO_PICK
] = { 'p', "pick" },
1736 [TODO_REVERT
] = { 0, "revert" },
1737 [TODO_EDIT
] = { 'e', "edit" },
1738 [TODO_REWORD
] = { 'r', "reword" },
1739 [TODO_FIXUP
] = { 'f', "fixup" },
1740 [TODO_SQUASH
] = { 's', "squash" },
1741 [TODO_EXEC
] = { 'x', "exec" },
1742 [TODO_BREAK
] = { 'b', "break" },
1743 [TODO_LABEL
] = { 'l', "label" },
1744 [TODO_RESET
] = { 't', "reset" },
1745 [TODO_MERGE
] = { 'm', "merge" },
1746 [TODO_UPDATE_REF
] = { 'u', "update-ref" },
1747 [TODO_NOOP
] = { 0, "noop" },
1748 [TODO_DROP
] = { 'd', "drop" },
1749 [TODO_COMMENT
] = { 0, NULL
},
1752 static const char *command_to_string(const enum todo_command command
)
1754 if (command
< TODO_COMMENT
)
1755 return todo_command_info
[command
].str
;
1756 die(_("unknown command: %d"), command
);
1759 static char command_to_char(const enum todo_command command
)
1761 if (command
< TODO_COMMENT
)
1762 return todo_command_info
[command
].c
;
1763 return comment_line_char
;
1766 static int is_noop(const enum todo_command command
)
1768 return TODO_NOOP
<= command
;
1771 static int is_fixup(enum todo_command command
)
1773 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1776 /* Does this command create a (non-merge) commit? */
1777 static int is_pick_or_similar(enum todo_command command
)
1792 enum todo_item_flags
{
1793 TODO_EDIT_MERGE_MSG
= (1 << 0),
1794 TODO_REPLACE_FIXUP_MSG
= (1 << 1),
1795 TODO_EDIT_FIXUP_MSG
= (1 << 2),
1798 static const char first_commit_msg_str
[] = N_("This is the 1st commit message:");
1799 static const char nth_commit_msg_fmt
[] = N_("This is the commit message #%d:");
1800 static const char skip_first_commit_msg_str
[] = N_("The 1st commit message will be skipped:");
1801 static const char skip_nth_commit_msg_fmt
[] = N_("The commit message #%d will be skipped:");
1802 static const char combined_commit_msg_fmt
[] = N_("This is a combination of %d commits.");
1804 static int is_fixup_flag(enum todo_command command
, unsigned flag
)
1806 return command
== TODO_FIXUP
&& ((flag
& TODO_REPLACE_FIXUP_MSG
) ||
1807 (flag
& TODO_EDIT_FIXUP_MSG
));
1811 * Wrapper around strbuf_add_commented_lines() which avoids double
1812 * commenting commit subjects.
1814 static void add_commented_lines(struct strbuf
*buf
, const void *str
, size_t len
)
1816 const char *s
= str
;
1817 while (len
> 0 && s
[0] == comment_line_char
) {
1819 const char *n
= memchr(s
, '\n', len
);
1824 strbuf_add(buf
, s
, count
);
1828 strbuf_add_commented_lines(buf
, s
, len
);
1831 /* Does the current fixup chain contain a squash command? */
1832 static int seen_squash(struct replay_opts
*opts
)
1834 return starts_with(opts
->current_fixups
.buf
, "squash") ||
1835 strstr(opts
->current_fixups
.buf
, "\nsquash");
1838 static void update_comment_bufs(struct strbuf
*buf1
, struct strbuf
*buf2
, int n
)
1840 strbuf_setlen(buf1
, 2);
1841 strbuf_addf(buf1
, _(nth_commit_msg_fmt
), n
);
1842 strbuf_addch(buf1
, '\n');
1843 strbuf_setlen(buf2
, 2);
1844 strbuf_addf(buf2
, _(skip_nth_commit_msg_fmt
), n
);
1845 strbuf_addch(buf2
, '\n');
1849 * Comment out any un-commented commit messages, updating the message comments
1850 * to say they will be skipped but do not comment out the empty lines that
1851 * surround commit messages and their comments.
1853 static void update_squash_message_for_fixup(struct strbuf
*msg
)
1855 void (*copy_lines
)(struct strbuf
*, const void *, size_t) = strbuf_add
;
1856 struct strbuf buf1
= STRBUF_INIT
, buf2
= STRBUF_INIT
;
1857 const char *s
, *start
;
1859 size_t orig_msg_len
;
1862 strbuf_addf(&buf1
, "# %s\n", _(first_commit_msg_str
));
1863 strbuf_addf(&buf2
, "# %s\n", _(skip_first_commit_msg_str
));
1864 s
= start
= orig_msg
= strbuf_detach(msg
, &orig_msg_len
);
1868 if (skip_prefix(s
, buf1
.buf
, &next
)) {
1870 * Copy the last message, preserving the blank line
1871 * preceding the current line
1873 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1874 copy_lines(msg
, start
, s
- start
- off
);
1876 strbuf_addch(msg
, '\n');
1878 * The next message needs to be commented out but the
1879 * message header is already commented out so just copy
1880 * it and the blank line that follows it.
1882 strbuf_addbuf(msg
, &buf2
);
1884 strbuf_addch(msg
, *next
++);
1886 copy_lines
= add_commented_lines
;
1887 update_comment_bufs(&buf1
, &buf2
, ++i
);
1888 } else if (skip_prefix(s
, buf2
.buf
, &next
)) {
1889 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1890 copy_lines(msg
, start
, s
- start
- off
);
1893 copy_lines
= strbuf_add
;
1894 update_comment_bufs(&buf1
, &buf2
, ++i
);
1896 s
= strchr(s
, '\n');
1901 copy_lines(msg
, start
, orig_msg_len
- (start
- orig_msg
));
1903 strbuf_release(&buf1
);
1904 strbuf_release(&buf2
);
1907 static int append_squash_message(struct strbuf
*buf
, const char *body
,
1908 enum todo_command command
, struct replay_opts
*opts
,
1911 const char *fixup_msg
;
1912 size_t commented_len
= 0, fixup_off
;
1914 * amend is non-interactive and not normally used with fixup!
1915 * or squash! commits, so only comment out those subjects when
1916 * squashing commit messages.
1918 if (starts_with(body
, "amend!") ||
1919 ((command
== TODO_SQUASH
|| seen_squash(opts
)) &&
1920 (starts_with(body
, "squash!") || starts_with(body
, "fixup!"))))
1921 commented_len
= commit_subject_length(body
);
1923 strbuf_addf(buf
, "\n%c ", comment_line_char
);
1924 strbuf_addf(buf
, _(nth_commit_msg_fmt
),
1925 ++opts
->current_fixup_count
+ 1);
1926 strbuf_addstr(buf
, "\n\n");
1927 strbuf_add_commented_lines(buf
, body
, commented_len
);
1928 /* buf->buf may be reallocated so store an offset into the buffer */
1929 fixup_off
= buf
->len
;
1930 strbuf_addstr(buf
, body
+ commented_len
);
1932 /* fixup -C after squash behaves like squash */
1933 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
)) {
1935 * We're replacing the commit message so we need to
1936 * append the Signed-off-by: trailer if the user
1937 * requested '--signoff'.
1940 append_signoff(buf
, 0, 0);
1942 if ((command
== TODO_FIXUP
) &&
1943 (flag
& TODO_REPLACE_FIXUP_MSG
) &&
1944 (file_exists(rebase_path_fixup_msg()) ||
1945 !file_exists(rebase_path_squash_msg()))) {
1946 fixup_msg
= skip_blank_lines(buf
->buf
+ fixup_off
);
1947 if (write_message(fixup_msg
, strlen(fixup_msg
),
1948 rebase_path_fixup_msg(), 0) < 0)
1949 return error(_("cannot write '%s'"),
1950 rebase_path_fixup_msg());
1952 unlink(rebase_path_fixup_msg());
1955 unlink(rebase_path_fixup_msg());
1961 static int update_squash_messages(struct repository
*r
,
1962 enum todo_command command
,
1963 struct commit
*commit
,
1964 struct replay_opts
*opts
,
1967 struct strbuf buf
= STRBUF_INIT
;
1969 const char *message
, *body
;
1970 const char *encoding
= get_commit_output_encoding();
1972 if (opts
->current_fixup_count
> 0) {
1973 struct strbuf header
= STRBUF_INIT
;
1976 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
1977 return error(_("could not read '%s'"),
1978 rebase_path_squash_msg());
1980 eol
= buf
.buf
[0] != comment_line_char
?
1981 buf
.buf
: strchrnul(buf
.buf
, '\n');
1983 strbuf_addf(&header
, "%c ", comment_line_char
);
1984 strbuf_addf(&header
, _(combined_commit_msg_fmt
),
1985 opts
->current_fixup_count
+ 2);
1986 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
1987 strbuf_release(&header
);
1988 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
))
1989 update_squash_message_for_fixup(&buf
);
1991 struct object_id head
;
1992 struct commit
*head_commit
;
1993 const char *head_message
, *body
;
1995 if (get_oid("HEAD", &head
))
1996 return error(_("need a HEAD to fixup"));
1997 if (!(head_commit
= lookup_commit_reference(r
, &head
)))
1998 return error(_("could not read HEAD"));
1999 if (!(head_message
= logmsg_reencode(head_commit
, NULL
, encoding
)))
2000 return error(_("could not read HEAD's commit message"));
2002 find_commit_subject(head_message
, &body
);
2003 if (command
== TODO_FIXUP
&& !flag
&& write_message(body
, strlen(body
),
2004 rebase_path_fixup_msg(), 0) < 0) {
2005 unuse_commit_buffer(head_commit
, head_message
);
2006 return error(_("cannot write '%s'"), rebase_path_fixup_msg());
2008 strbuf_addf(&buf
, "%c ", comment_line_char
);
2009 strbuf_addf(&buf
, _(combined_commit_msg_fmt
), 2);
2010 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
2011 strbuf_addstr(&buf
, is_fixup_flag(command
, flag
) ?
2012 _(skip_first_commit_msg_str
) :
2013 _(first_commit_msg_str
));
2014 strbuf_addstr(&buf
, "\n\n");
2015 if (is_fixup_flag(command
, flag
))
2016 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
2018 strbuf_addstr(&buf
, body
);
2020 unuse_commit_buffer(head_commit
, head_message
);
2023 if (!(message
= logmsg_reencode(commit
, NULL
, encoding
)))
2024 return error(_("could not read commit message of %s"),
2025 oid_to_hex(&commit
->object
.oid
));
2026 find_commit_subject(message
, &body
);
2028 if (command
== TODO_SQUASH
|| is_fixup_flag(command
, flag
)) {
2029 res
= append_squash_message(&buf
, body
, command
, opts
, flag
);
2030 } else if (command
== TODO_FIXUP
) {
2031 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
2032 strbuf_addf(&buf
, _(skip_nth_commit_msg_fmt
),
2033 ++opts
->current_fixup_count
+ 1);
2034 strbuf_addstr(&buf
, "\n\n");
2035 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
2037 return error(_("unknown command: %d"), command
);
2038 unuse_commit_buffer(commit
, message
);
2041 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(),
2043 strbuf_release(&buf
);
2046 strbuf_addf(&opts
->current_fixups
, "%s%s %s",
2047 opts
->current_fixups
.len
? "\n" : "",
2048 command_to_string(command
),
2049 oid_to_hex(&commit
->object
.oid
));
2050 res
= write_message(opts
->current_fixups
.buf
,
2051 opts
->current_fixups
.len
,
2052 rebase_path_current_fixups(), 0);
2058 static void flush_rewritten_pending(void)
2060 struct strbuf buf
= STRBUF_INIT
;
2061 struct object_id newoid
;
2064 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
2065 !get_oid("HEAD", &newoid
) &&
2066 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
2067 char *bol
= buf
.buf
, *eol
;
2070 eol
= strchrnul(bol
, '\n');
2071 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
2072 bol
, oid_to_hex(&newoid
));
2078 unlink(rebase_path_rewritten_pending());
2080 strbuf_release(&buf
);
2083 static void record_in_rewritten(struct object_id
*oid
,
2084 enum todo_command next_command
)
2086 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
2091 fprintf(out
, "%s\n", oid_to_hex(oid
));
2094 if (!is_fixup(next_command
))
2095 flush_rewritten_pending();
2098 static int should_edit(struct replay_opts
*opts
) {
2101 * Note that we only handle the case of non-conflicted
2102 * commits; continue_single_pick() handles the conflicted
2103 * commits itself instead of calling this function.
2105 return (opts
->action
== REPLAY_REVERT
&& isatty(0)) ? 1 : 0;
2109 static void refer_to_commit(struct replay_opts
*opts
,
2110 struct strbuf
*msgbuf
, struct commit
*commit
)
2112 if (opts
->commit_use_reference
) {
2113 struct pretty_print_context ctx
= {
2114 .abbrev
= DEFAULT_ABBREV
,
2115 .date_mode
.type
= DATE_SHORT
,
2117 format_commit_message(commit
, "%h (%s, %ad)", msgbuf
, &ctx
);
2119 strbuf_addstr(msgbuf
, oid_to_hex(&commit
->object
.oid
));
2123 static int do_pick_commit(struct repository
*r
,
2124 struct todo_item
*item
,
2125 struct replay_opts
*opts
,
2126 int final_fixup
, int *check_todo
)
2128 unsigned int flags
= should_edit(opts
) ? EDIT_MSG
: 0;
2129 const char *msg_file
= should_edit(opts
) ? NULL
: git_path_merge_msg(r
);
2130 struct object_id head
;
2131 struct commit
*base
, *next
, *parent
;
2132 const char *base_label
, *next_label
;
2133 char *author
= NULL
;
2134 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
2135 struct strbuf msgbuf
= STRBUF_INIT
;
2136 int res
, unborn
= 0, reword
= 0, allow
, drop_commit
;
2137 enum todo_command command
= item
->command
;
2138 struct commit
*commit
= item
->commit
;
2140 if (opts
->no_commit
) {
2142 * We do not intend to commit immediately. We just want to
2143 * merge the differences in, so let's compute the tree
2144 * that represents the "current" state for the merge machinery
2147 if (write_index_as_tree(&head
, r
->index
, r
->index_file
, 0, NULL
))
2148 return error(_("your index file is unmerged."));
2150 unborn
= get_oid("HEAD", &head
);
2151 /* Do we want to generate a root commit? */
2152 if (is_pick_or_similar(command
) && opts
->have_squash_onto
&&
2153 oideq(&head
, &opts
->squash_onto
)) {
2154 if (is_fixup(command
))
2155 return error(_("cannot fixup root commit"));
2156 flags
|= CREATE_ROOT_COMMIT
;
2159 oidcpy(&head
, the_hash_algo
->empty_tree
);
2160 if (index_differs_from(r
, unborn
? empty_tree_oid_hex() : "HEAD",
2162 return error_dirty_index(r
, opts
);
2164 discard_index(r
->index
);
2166 if (!commit
->parents
)
2168 else if (commit
->parents
->next
) {
2169 /* Reverting or cherry-picking a merge commit */
2171 struct commit_list
*p
;
2173 if (!opts
->mainline
)
2174 return error(_("commit %s is a merge but no -m option was given."),
2175 oid_to_hex(&commit
->object
.oid
));
2177 for (cnt
= 1, p
= commit
->parents
;
2178 cnt
!= opts
->mainline
&& p
;
2181 if (cnt
!= opts
->mainline
|| !p
)
2182 return error(_("commit %s does not have parent %d"),
2183 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2185 } else if (1 < opts
->mainline
)
2187 * Non-first parent explicitly specified as mainline for
2190 return error(_("commit %s does not have parent %d"),
2191 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2193 parent
= commit
->parents
->item
;
2195 if (get_message(commit
, &msg
) != 0)
2196 return error(_("cannot get commit message for %s"),
2197 oid_to_hex(&commit
->object
.oid
));
2199 if (opts
->allow_ff
&& !is_fixup(command
) &&
2200 ((parent
&& oideq(&parent
->object
.oid
, &head
)) ||
2201 (!parent
&& unborn
))) {
2202 if (is_rebase_i(opts
))
2203 write_author_script(msg
.message
);
2204 res
= fast_forward_to(r
, &commit
->object
.oid
, &head
, unborn
,
2206 if (res
|| command
!= TODO_REWORD
)
2210 goto fast_forward_edit
;
2212 if (parent
&& parse_commit(parent
) < 0)
2213 /* TRANSLATORS: The first %s will be a "todo" command like
2214 "revert" or "pick", the second %s a SHA1. */
2215 return error(_("%s: cannot parse parent commit %s"),
2216 command_to_string(command
),
2217 oid_to_hex(&parent
->object
.oid
));
2220 * "commit" is an existing commit. We would want to apply
2221 * the difference it introduces since its first parent "prev"
2222 * on top of the current HEAD if we are cherry-pick. Or the
2223 * reverse of it if we are revert.
2226 if (command
== TODO_REVERT
) {
2228 base_label
= msg
.label
;
2230 next_label
= msg
.parent_label
;
2231 if (opts
->commit_use_reference
) {
2232 strbuf_addstr(&msgbuf
,
2233 "# *** SAY WHY WE ARE REVERTING ON THE TITLE LINE ***");
2235 strbuf_addstr(&msgbuf
, "Revert \"");
2236 strbuf_addstr(&msgbuf
, msg
.subject
);
2237 strbuf_addstr(&msgbuf
, "\"");
2239 strbuf_addstr(&msgbuf
, "\n\nThis reverts commit ");
2240 refer_to_commit(opts
, &msgbuf
, commit
);
2242 if (commit
->parents
&& commit
->parents
->next
) {
2243 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
2244 refer_to_commit(opts
, &msgbuf
, parent
);
2246 strbuf_addstr(&msgbuf
, ".\n");
2251 base_label
= msg
.parent_label
;
2253 next_label
= msg
.label
;
2255 /* Append the commit log message to msgbuf. */
2256 if (find_commit_subject(msg
.message
, &p
))
2257 strbuf_addstr(&msgbuf
, p
);
2259 if (opts
->record_origin
) {
2260 strbuf_complete_line(&msgbuf
);
2261 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
2262 strbuf_addch(&msgbuf
, '\n');
2263 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
2264 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
2265 strbuf_addstr(&msgbuf
, ")\n");
2267 if (!is_fixup(command
))
2268 author
= get_author(msg
.message
);
2271 if (command
== TODO_REWORD
)
2273 else if (is_fixup(command
)) {
2274 if (update_squash_messages(r
, command
, commit
,
2279 msg_file
= rebase_path_squash_msg();
2280 else if (file_exists(rebase_path_fixup_msg())) {
2281 flags
|= VERBATIM_MSG
;
2282 msg_file
= rebase_path_fixup_msg();
2284 const char *dest
= git_path_squash_msg(r
);
2286 if (copy_file(dest
, rebase_path_squash_msg(), 0666))
2287 return error(_("could not rename '%s' to '%s'"),
2288 rebase_path_squash_msg(), dest
);
2289 unlink(git_path_merge_msg(r
));
2295 if (opts
->signoff
&& !is_fixup(command
))
2296 append_signoff(&msgbuf
, 0, 0);
2298 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
2300 else if (!opts
->strategy
||
2301 !strcmp(opts
->strategy
, "recursive") ||
2302 !strcmp(opts
->strategy
, "ort") ||
2303 command
== TODO_REVERT
) {
2304 res
= do_recursive_merge(r
, base
, next
, base_label
, next_label
,
2305 &head
, &msgbuf
, opts
);
2309 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
2310 git_path_merge_msg(r
), 0);
2312 struct commit_list
*common
= NULL
;
2313 struct commit_list
*remotes
= NULL
;
2315 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
2316 git_path_merge_msg(r
), 0);
2318 commit_list_insert(base
, &common
);
2319 commit_list_insert(next
, &remotes
);
2320 res
|= try_merge_command(r
, opts
->strategy
,
2321 opts
->xopts_nr
, (const char **)opts
->xopts
,
2322 common
, oid_to_hex(&head
), remotes
);
2323 free_commit_list(common
);
2324 free_commit_list(remotes
);
2326 strbuf_release(&msgbuf
);
2329 * If the merge was clean or if it failed due to conflict, we write
2330 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
2331 * However, if the merge did not even start, then we don't want to
2334 if ((command
== TODO_PICK
|| command
== TODO_REWORD
||
2335 command
== TODO_EDIT
) && !opts
->no_commit
&&
2336 (res
== 0 || res
== 1) &&
2337 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
2338 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2340 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
2341 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
2342 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2346 error(command
== TODO_REVERT
2347 ? _("could not revert %s... %s")
2348 : _("could not apply %s... %s"),
2349 short_commit_name(commit
), msg
.subject
);
2350 print_advice(r
, res
== 1, opts
);
2351 repo_rerere(r
, opts
->allow_rerere_auto
);
2356 allow
= allow_empty(r
, opts
, commit
);
2360 } else if (allow
== 1) {
2361 flags
|= ALLOW_EMPTY
;
2362 } else if (allow
== 2) {
2364 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
2366 unlink(git_path_merge_msg(r
));
2367 unlink(git_path_auto_merge(r
));
2369 _("dropping %s %s -- patch contents already upstream\n"),
2370 oid_to_hex(&commit
->object
.oid
), msg
.subject
);
2371 } /* else allow == 0 and there's nothing special to do */
2372 if (!opts
->no_commit
&& !drop_commit
) {
2373 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
2374 res
= do_commit(r
, msg_file
, author
, opts
, flags
,
2375 commit
? &commit
->object
.oid
: NULL
);
2377 res
= error(_("unable to parse commit author"));
2378 *check_todo
= !!(flags
& EDIT_MSG
);
2379 if (!res
&& reword
) {
2381 res
= run_git_commit(NULL
, opts
, EDIT_MSG
|
2382 VERIFY_MSG
| AMEND_MSG
|
2383 (flags
& ALLOW_EMPTY
));
2389 if (!res
&& final_fixup
) {
2390 unlink(rebase_path_fixup_msg());
2391 unlink(rebase_path_squash_msg());
2392 unlink(rebase_path_current_fixups());
2393 strbuf_reset(&opts
->current_fixups
);
2394 opts
->current_fixup_count
= 0;
2398 free_message(commit
, &msg
);
2400 update_abort_safety_file();
2405 static int prepare_revs(struct replay_opts
*opts
)
2408 * picking (but not reverting) ranges (but not individual revisions)
2409 * should be done in reverse
2411 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
2412 opts
->revs
->reverse
^= 1;
2414 if (prepare_revision_walk(opts
->revs
))
2415 return error(_("revision walk setup failed"));
2420 static int read_and_refresh_cache(struct repository
*r
,
2421 struct replay_opts
*opts
)
2423 struct lock_file index_lock
= LOCK_INIT
;
2424 int index_fd
= repo_hold_locked_index(r
, &index_lock
, 0);
2425 if (repo_read_index(r
) < 0) {
2426 rollback_lock_file(&index_lock
);
2427 return error(_("git %s: failed to read the index"),
2430 refresh_index(r
->index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
2432 if (index_fd
>= 0) {
2433 if (write_locked_index(r
->index
, &index_lock
,
2434 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
2435 return error(_("git %s: failed to refresh the index"),
2441 * If we are resolving merges in any way other than "ort", then
2442 * expand the sparse index.
2444 if (opts
->strategy
&& strcmp(opts
->strategy
, "ort"))
2445 ensure_full_index(r
->index
);
2449 void todo_list_release(struct todo_list
*todo_list
)
2451 strbuf_release(&todo_list
->buf
);
2452 FREE_AND_NULL(todo_list
->items
);
2453 todo_list
->nr
= todo_list
->alloc
= 0;
2456 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
2458 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
2459 todo_list
->total_nr
++;
2460 return todo_list
->items
+ todo_list
->nr
++;
2463 const char *todo_item_get_arg(struct todo_list
*todo_list
,
2464 struct todo_item
*item
)
2466 return todo_list
->buf
.buf
+ item
->arg_offset
;
2469 static int is_command(enum todo_command command
, const char **bol
)
2471 const char *str
= todo_command_info
[command
].str
;
2472 const char nick
= todo_command_info
[command
].c
;
2473 const char *p
= *bol
+ 1;
2475 return skip_prefix(*bol
, str
, bol
) ||
2476 ((nick
&& **bol
== nick
) &&
2477 (*p
== ' ' || *p
== '\t' || *p
== '\n' || *p
== '\r' || !*p
) &&
2481 static int parse_insn_line(struct repository
*r
, struct todo_item
*item
,
2482 const char *buf
, const char *bol
, char *eol
)
2484 struct object_id commit_oid
;
2485 char *end_of_object_name
;
2486 int i
, saved
, status
, padding
;
2491 bol
+= strspn(bol
, " \t");
2493 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
2494 item
->command
= TODO_COMMENT
;
2495 item
->commit
= NULL
;
2496 item
->arg_offset
= bol
- buf
;
2497 item
->arg_len
= eol
- bol
;
2501 for (i
= 0; i
< TODO_COMMENT
; i
++)
2502 if (is_command(i
, &bol
)) {
2506 if (i
>= TODO_COMMENT
)
2509 /* Eat up extra spaces/ tabs before object name */
2510 padding
= strspn(bol
, " \t");
2513 if (item
->command
== TODO_NOOP
|| item
->command
== TODO_BREAK
) {
2515 return error(_("%s does not accept arguments: '%s'"),
2516 command_to_string(item
->command
), bol
);
2517 item
->commit
= NULL
;
2518 item
->arg_offset
= bol
- buf
;
2519 item
->arg_len
= eol
- bol
;
2524 return error(_("missing arguments for %s"),
2525 command_to_string(item
->command
));
2527 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
2528 item
->command
== TODO_RESET
|| item
->command
== TODO_UPDATE_REF
) {
2529 item
->commit
= NULL
;
2530 item
->arg_offset
= bol
- buf
;
2531 item
->arg_len
= (int)(eol
- bol
);
2535 if (item
->command
== TODO_FIXUP
) {
2536 if (skip_prefix(bol
, "-C", &bol
) &&
2537 (*bol
== ' ' || *bol
== '\t')) {
2538 bol
+= strspn(bol
, " \t");
2539 item
->flags
|= TODO_REPLACE_FIXUP_MSG
;
2540 } else if (skip_prefix(bol
, "-c", &bol
) &&
2541 (*bol
== ' ' || *bol
== '\t')) {
2542 bol
+= strspn(bol
, " \t");
2543 item
->flags
|= TODO_EDIT_FIXUP_MSG
;
2547 if (item
->command
== TODO_MERGE
) {
2548 if (skip_prefix(bol
, "-C", &bol
))
2549 bol
+= strspn(bol
, " \t");
2550 else if (skip_prefix(bol
, "-c", &bol
)) {
2551 bol
+= strspn(bol
, " \t");
2552 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2554 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2555 item
->commit
= NULL
;
2556 item
->arg_offset
= bol
- buf
;
2557 item
->arg_len
= (int)(eol
- bol
);
2562 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
2563 saved
= *end_of_object_name
;
2564 *end_of_object_name
= '\0';
2565 status
= get_oid(bol
, &commit_oid
);
2567 error(_("could not parse '%s'"), bol
); /* return later */
2568 *end_of_object_name
= saved
;
2570 bol
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2571 item
->arg_offset
= bol
- buf
;
2572 item
->arg_len
= (int)(eol
- bol
);
2577 item
->commit
= lookup_commit_reference(r
, &commit_oid
);
2578 return item
->commit
? 0 : -1;
2581 int sequencer_get_last_command(struct repository
*r
, enum replay_action
*action
)
2583 const char *todo_file
, *bol
;
2584 struct strbuf buf
= STRBUF_INIT
;
2587 todo_file
= git_path_todo_file();
2588 if (strbuf_read_file(&buf
, todo_file
, 0) < 0) {
2589 if (errno
== ENOENT
|| errno
== ENOTDIR
)
2592 return error_errno("unable to open '%s'", todo_file
);
2594 bol
= buf
.buf
+ strspn(buf
.buf
, " \t\r\n");
2595 if (is_command(TODO_PICK
, &bol
) && (*bol
== ' ' || *bol
== '\t'))
2596 *action
= REPLAY_PICK
;
2597 else if (is_command(TODO_REVERT
, &bol
) &&
2598 (*bol
== ' ' || *bol
== '\t'))
2599 *action
= REPLAY_REVERT
;
2603 strbuf_release(&buf
);
2608 int todo_list_parse_insn_buffer(struct repository
*r
, char *buf
,
2609 struct todo_list
*todo_list
)
2611 struct todo_item
*item
;
2612 char *p
= buf
, *next_p
;
2613 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2615 todo_list
->current
= todo_list
->nr
= 0;
2617 for (i
= 1; *p
; i
++, p
= next_p
) {
2618 char *eol
= strchrnul(p
, '\n');
2620 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2622 if (p
!= eol
&& eol
[-1] == '\r')
2623 eol
--; /* strip Carriage Return */
2625 item
= append_new_todo(todo_list
);
2626 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2627 if (parse_insn_line(r
, item
, buf
, p
, eol
)) {
2628 res
= error(_("invalid line %d: %.*s"),
2629 i
, (int)(eol
- p
), p
);
2630 item
->command
= TODO_COMMENT
+ 1;
2631 item
->arg_offset
= p
- buf
;
2632 item
->arg_len
= (int)(eol
- p
);
2633 item
->commit
= NULL
;
2638 else if (is_fixup(item
->command
))
2639 return error(_("cannot '%s' without a previous commit"),
2640 command_to_string(item
->command
));
2641 else if (!is_noop(item
->command
))
2648 static int count_commands(struct todo_list
*todo_list
)
2652 for (i
= 0; i
< todo_list
->nr
; i
++)
2653 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2659 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2661 return index
< todo_list
->nr
?
2662 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2665 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2667 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2670 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2672 return get_item_line_offset(todo_list
, index
+ 1)
2673 - get_item_line_offset(todo_list
, index
);
2676 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2681 fd
= open(path
, O_RDONLY
);
2683 return error_errno(_("could not open '%s'"), path
);
2684 len
= strbuf_read(sb
, fd
, 0);
2687 return error(_("could not read '%s'."), path
);
2691 static int have_finished_the_last_pick(void)
2693 struct strbuf buf
= STRBUF_INIT
;
2695 const char *todo_path
= git_path_todo_file();
2698 if (strbuf_read_file(&buf
, todo_path
, 0) < 0) {
2699 if (errno
== ENOENT
) {
2702 error_errno("unable to open '%s'", todo_path
);
2706 /* If there is only one line then we are done */
2707 eol
= strchr(buf
.buf
, '\n');
2708 if (!eol
|| !eol
[1])
2711 strbuf_release(&buf
);
2716 void sequencer_post_commit_cleanup(struct repository
*r
, int verbose
)
2718 struct replay_opts opts
= REPLAY_OPTS_INIT
;
2719 int need_cleanup
= 0;
2721 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
2722 if (!refs_delete_ref(get_main_ref_store(r
), "",
2723 "CHERRY_PICK_HEAD", NULL
, 0) &&
2725 warning(_("cancelling a cherry picking in progress"));
2726 opts
.action
= REPLAY_PICK
;
2730 if (refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
2731 if (!refs_delete_ref(get_main_ref_store(r
), "", "REVERT_HEAD",
2734 warning(_("cancelling a revert in progress"));
2735 opts
.action
= REPLAY_REVERT
;
2739 unlink(git_path_auto_merge(r
));
2744 if (!have_finished_the_last_pick())
2747 sequencer_remove_state(&opts
);
2750 static void todo_list_write_total_nr(struct todo_list
*todo_list
)
2752 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2755 fprintf(f
, "%d\n", todo_list
->total_nr
);
2760 static int read_populate_todo(struct repository
*r
,
2761 struct todo_list
*todo_list
,
2762 struct replay_opts
*opts
)
2764 const char *todo_file
= get_todo_path(opts
);
2767 strbuf_reset(&todo_list
->buf
);
2768 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2771 res
= todo_list_parse_insn_buffer(r
, todo_list
->buf
.buf
, todo_list
);
2773 if (is_rebase_i(opts
))
2774 return error(_("please fix this using "
2775 "'git rebase --edit-todo'."));
2776 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2779 if (!todo_list
->nr
&&
2780 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2781 return error(_("no commits parsed."));
2783 if (!is_rebase_i(opts
)) {
2784 enum todo_command valid
=
2785 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2788 for (i
= 0; i
< todo_list
->nr
; i
++)
2789 if (valid
== todo_list
->items
[i
].command
)
2791 else if (valid
== TODO_PICK
)
2792 return error(_("cannot cherry-pick during a revert."));
2794 return error(_("cannot revert during a cherry-pick."));
2797 if (is_rebase_i(opts
)) {
2798 struct todo_list done
= TODO_LIST_INIT
;
2800 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2801 !todo_list_parse_insn_buffer(r
, done
.buf
.buf
, &done
))
2802 todo_list
->done_nr
= count_commands(&done
);
2804 todo_list
->done_nr
= 0;
2806 todo_list
->total_nr
= todo_list
->done_nr
2807 + count_commands(todo_list
);
2808 todo_list_release(&done
);
2810 todo_list_write_total_nr(todo_list
);
2816 static int git_config_string_dup(char **dest
,
2817 const char *var
, const char *value
)
2820 return config_error_nonbool(var
);
2822 *dest
= xstrdup(value
);
2826 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
2828 struct replay_opts
*opts
= data
;
2833 else if (!strcmp(key
, "options.no-commit"))
2834 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
2835 else if (!strcmp(key
, "options.edit"))
2836 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
2837 else if (!strcmp(key
, "options.allow-empty"))
2839 git_config_bool_or_int(key
, value
, &error_flag
);
2840 else if (!strcmp(key
, "options.allow-empty-message"))
2841 opts
->allow_empty_message
=
2842 git_config_bool_or_int(key
, value
, &error_flag
);
2843 else if (!strcmp(key
, "options.keep-redundant-commits"))
2844 opts
->keep_redundant_commits
=
2845 git_config_bool_or_int(key
, value
, &error_flag
);
2846 else if (!strcmp(key
, "options.signoff"))
2847 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
2848 else if (!strcmp(key
, "options.record-origin"))
2849 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
2850 else if (!strcmp(key
, "options.allow-ff"))
2851 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
2852 else if (!strcmp(key
, "options.mainline"))
2853 opts
->mainline
= git_config_int(key
, value
);
2854 else if (!strcmp(key
, "options.strategy"))
2855 git_config_string_dup(&opts
->strategy
, key
, value
);
2856 else if (!strcmp(key
, "options.gpg-sign"))
2857 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
2858 else if (!strcmp(key
, "options.strategy-option")) {
2859 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
2860 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(value
);
2861 } else if (!strcmp(key
, "options.allow-rerere-auto"))
2862 opts
->allow_rerere_auto
=
2863 git_config_bool_or_int(key
, value
, &error_flag
) ?
2864 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
2865 else if (!strcmp(key
, "options.default-msg-cleanup")) {
2866 opts
->explicit_cleanup
= 1;
2867 opts
->default_msg_cleanup
= get_cleanup_mode(value
, 1);
2869 return error(_("invalid key: %s"), key
);
2872 return error(_("invalid value for '%s': '%s'"), key
, value
);
2877 void parse_strategy_opts(struct replay_opts
*opts
, char *raw_opts
)
2880 char *strategy_opts_string
= raw_opts
;
2882 if (*strategy_opts_string
== ' ')
2883 strategy_opts_string
++;
2885 opts
->xopts_nr
= split_cmdline(strategy_opts_string
,
2886 (const char ***)&opts
->xopts
);
2887 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
2888 const char *arg
= opts
->xopts
[i
];
2890 skip_prefix(arg
, "--", &arg
);
2891 opts
->xopts
[i
] = xstrdup(arg
);
2895 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2898 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2900 free(opts
->strategy
);
2901 opts
->strategy
= strbuf_detach(buf
, NULL
);
2902 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2905 parse_strategy_opts(opts
, buf
->buf
);
2908 static int read_populate_opts(struct replay_opts
*opts
)
2910 if (is_rebase_i(opts
)) {
2911 struct strbuf buf
= STRBUF_INIT
;
2914 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(),
2915 READ_ONELINER_SKIP_IF_EMPTY
)) {
2916 if (!starts_with(buf
.buf
, "-S"))
2919 free(opts
->gpg_sign
);
2920 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2925 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(),
2926 READ_ONELINER_SKIP_IF_EMPTY
)) {
2927 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2928 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2929 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2930 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2934 if (file_exists(rebase_path_verbose()))
2937 if (file_exists(rebase_path_quiet()))
2940 if (file_exists(rebase_path_signoff())) {
2945 if (file_exists(rebase_path_cdate_is_adate())) {
2947 opts
->committer_date_is_author_date
= 1;
2950 if (file_exists(rebase_path_ignore_date())) {
2952 opts
->ignore_date
= 1;
2955 if (file_exists(rebase_path_reschedule_failed_exec()))
2956 opts
->reschedule_failed_exec
= 1;
2957 else if (file_exists(rebase_path_no_reschedule_failed_exec()))
2958 opts
->reschedule_failed_exec
= 0;
2960 if (file_exists(rebase_path_drop_redundant_commits()))
2961 opts
->drop_redundant_commits
= 1;
2963 if (file_exists(rebase_path_keep_redundant_commits()))
2964 opts
->keep_redundant_commits
= 1;
2966 read_strategy_opts(opts
, &buf
);
2969 if (read_oneliner(&opts
->current_fixups
,
2970 rebase_path_current_fixups(),
2971 READ_ONELINER_SKIP_IF_EMPTY
)) {
2972 const char *p
= opts
->current_fixups
.buf
;
2973 opts
->current_fixup_count
= 1;
2974 while ((p
= strchr(p
, '\n'))) {
2975 opts
->current_fixup_count
++;
2980 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
2981 if (get_oid_committish(buf
.buf
, &opts
->squash_onto
) < 0) {
2982 ret
= error(_("unusable squash-onto"));
2985 opts
->have_squash_onto
= 1;
2989 strbuf_release(&buf
);
2993 if (!file_exists(git_path_opts_file()))
2996 * The function git_parse_source(), called from git_config_from_file(),
2997 * may die() in case of a syntactically incorrect file. We do not care
2998 * about this case, though, because we wrote that file ourselves, so we
2999 * are pretty certain that it is syntactically correct.
3001 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
3002 return error(_("malformed options sheet: '%s'"),
3003 git_path_opts_file());
3007 static void write_strategy_opts(struct replay_opts
*opts
)
3010 struct strbuf buf
= STRBUF_INIT
;
3012 for (i
= 0; i
< opts
->xopts_nr
; ++i
)
3013 strbuf_addf(&buf
, " --%s", opts
->xopts
[i
]);
3015 write_file(rebase_path_strategy_opts(), "%s\n", buf
.buf
);
3016 strbuf_release(&buf
);
3019 int write_basic_state(struct replay_opts
*opts
, const char *head_name
,
3020 struct commit
*onto
, const struct object_id
*orig_head
)
3023 write_file(rebase_path_head_name(), "%s\n", head_name
);
3025 write_file(rebase_path_onto(), "%s\n",
3026 oid_to_hex(&onto
->object
.oid
));
3028 write_file(rebase_path_orig_head(), "%s\n",
3029 oid_to_hex(orig_head
));
3032 write_file(rebase_path_quiet(), "%s", "");
3034 write_file(rebase_path_verbose(), "%s", "");
3036 write_file(rebase_path_strategy(), "%s\n", opts
->strategy
);
3037 if (opts
->xopts_nr
> 0)
3038 write_strategy_opts(opts
);
3040 if (opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
)
3041 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
3042 else if (opts
->allow_rerere_auto
== RERERE_NOAUTOUPDATE
)
3043 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
3046 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts
->gpg_sign
);
3048 write_file(rebase_path_signoff(), "--signoff\n");
3049 if (opts
->drop_redundant_commits
)
3050 write_file(rebase_path_drop_redundant_commits(), "%s", "");
3051 if (opts
->keep_redundant_commits
)
3052 write_file(rebase_path_keep_redundant_commits(), "%s", "");
3053 if (opts
->committer_date_is_author_date
)
3054 write_file(rebase_path_cdate_is_adate(), "%s", "");
3055 if (opts
->ignore_date
)
3056 write_file(rebase_path_ignore_date(), "%s", "");
3057 if (opts
->reschedule_failed_exec
)
3058 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
3060 write_file(rebase_path_no_reschedule_failed_exec(), "%s", "");
3065 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
3066 struct replay_opts
*opts
)
3068 enum todo_command command
= opts
->action
== REPLAY_PICK
?
3069 TODO_PICK
: TODO_REVERT
;
3070 const char *command_string
= todo_command_info
[command
].str
;
3071 const char *encoding
;
3072 struct commit
*commit
;
3074 if (prepare_revs(opts
))
3077 encoding
= get_log_output_encoding();
3079 while ((commit
= get_revision(opts
->revs
))) {
3080 struct todo_item
*item
= append_new_todo(todo_list
);
3081 const char *commit_buffer
= logmsg_reencode(commit
, NULL
, encoding
);
3082 const char *subject
;
3085 item
->command
= command
;
3086 item
->commit
= commit
;
3087 item
->arg_offset
= 0;
3089 item
->offset_in_buf
= todo_list
->buf
.len
;
3090 subject_len
= find_commit_subject(commit_buffer
, &subject
);
3091 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
3092 short_commit_name(commit
), subject_len
, subject
);
3093 unuse_commit_buffer(commit
, commit_buffer
);
3097 return error(_("empty commit set passed"));
3102 static int create_seq_dir(struct repository
*r
)
3104 enum replay_action action
;
3105 const char *in_progress_error
= NULL
;
3106 const char *in_progress_advice
= NULL
;
3107 unsigned int advise_skip
=
3108 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD") ||
3109 refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD");
3111 if (!sequencer_get_last_command(r
, &action
)) {
3114 in_progress_error
= _("revert is already in progress");
3115 in_progress_advice
=
3116 _("try \"git revert (--continue | %s--abort | --quit)\"");
3119 in_progress_error
= _("cherry-pick is already in progress");
3120 in_progress_advice
=
3121 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
3124 BUG("unexpected action in create_seq_dir");
3127 if (in_progress_error
) {
3128 error("%s", in_progress_error
);
3129 if (advice_enabled(ADVICE_SEQUENCER_IN_USE
))
3130 advise(in_progress_advice
,
3131 advise_skip
? "--skip | " : "");
3134 if (mkdir(git_path_seq_dir(), 0777) < 0)
3135 return error_errno(_("could not create sequencer directory '%s'"),
3136 git_path_seq_dir());
3141 static int save_head(const char *head
)
3143 struct lock_file head_lock
= LOCK_INIT
;
3144 struct strbuf buf
= STRBUF_INIT
;
3148 fd
= hold_lock_file_for_update(&head_lock
, git_path_head_file(), 0);
3150 return error_errno(_("could not lock HEAD"));
3151 strbuf_addf(&buf
, "%s\n", head
);
3152 written
= write_in_full(fd
, buf
.buf
, buf
.len
);
3153 strbuf_release(&buf
);
3155 error_errno(_("could not write to '%s'"), git_path_head_file());
3156 rollback_lock_file(&head_lock
);
3159 if (commit_lock_file(&head_lock
) < 0)
3160 return error(_("failed to finalize '%s'"), git_path_head_file());
3164 static int rollback_is_safe(void)
3166 struct strbuf sb
= STRBUF_INIT
;
3167 struct object_id expected_head
, actual_head
;
3169 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
3171 if (get_oid_hex(sb
.buf
, &expected_head
)) {
3172 strbuf_release(&sb
);
3173 die(_("could not parse %s"), git_path_abort_safety_file());
3175 strbuf_release(&sb
);
3177 else if (errno
== ENOENT
)
3178 oidclr(&expected_head
);
3180 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
3182 if (get_oid("HEAD", &actual_head
))
3183 oidclr(&actual_head
);
3185 return oideq(&actual_head
, &expected_head
);
3188 static int reset_merge(const struct object_id
*oid
)
3190 struct child_process cmd
= CHILD_PROCESS_INIT
;
3193 strvec_pushl(&cmd
.args
, "reset", "--merge", NULL
);
3195 if (!is_null_oid(oid
))
3196 strvec_push(&cmd
.args
, oid_to_hex(oid
));
3198 return run_command(&cmd
);
3201 static int rollback_single_pick(struct repository
*r
)
3203 struct object_id head_oid
;
3205 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
3206 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
3207 return error(_("no cherry-pick or revert in progress"));
3208 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
3209 return error(_("cannot resolve HEAD"));
3210 if (is_null_oid(&head_oid
))
3211 return error(_("cannot abort from a branch yet to be born"));
3212 return reset_merge(&head_oid
);
3215 static int skip_single_pick(void)
3217 struct object_id head
;
3219 if (read_ref_full("HEAD", 0, &head
, NULL
))
3220 return error(_("cannot resolve HEAD"));
3221 return reset_merge(&head
);
3224 int sequencer_rollback(struct repository
*r
, struct replay_opts
*opts
)
3227 struct object_id oid
;
3228 struct strbuf buf
= STRBUF_INIT
;
3231 f
= fopen(git_path_head_file(), "r");
3232 if (!f
&& errno
== ENOENT
) {
3234 * There is no multiple-cherry-pick in progress.
3235 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
3236 * a single-cherry-pick in progress, abort that.
3238 return rollback_single_pick(r
);
3241 return error_errno(_("cannot open '%s'"), git_path_head_file());
3242 if (strbuf_getline_lf(&buf
, f
)) {
3243 error(_("cannot read '%s': %s"), git_path_head_file(),
3244 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
3249 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
3250 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
3251 git_path_head_file());
3254 if (is_null_oid(&oid
)) {
3255 error(_("cannot abort from a branch yet to be born"));
3259 if (!rollback_is_safe()) {
3260 /* Do not error, just do not rollback */
3261 warning(_("You seem to have moved HEAD. "
3262 "Not rewinding, check your HEAD!"));
3264 if (reset_merge(&oid
))
3266 strbuf_release(&buf
);
3267 return sequencer_remove_state(opts
);
3269 strbuf_release(&buf
);
3273 int sequencer_skip(struct repository
*r
, struct replay_opts
*opts
)
3275 enum replay_action action
= -1;
3276 sequencer_get_last_command(r
, &action
);
3279 * Check whether the subcommand requested to skip the commit is actually
3280 * in progress and that it's safe to skip the commit.
3282 * opts->action tells us which subcommand requested to skip the commit.
3283 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
3284 * action is in progress and we can skip the commit.
3286 * Otherwise we check that the last instruction was related to the
3287 * particular subcommand we're trying to execute and barf if that's not
3290 * Finally we check that the rollback is "safe", i.e., has the HEAD
3291 * moved? In this case, it doesn't make sense to "reset the merge" and
3292 * "skip the commit" as the user already handled this by committing. But
3293 * we'd not want to barf here, instead give advice on how to proceed. We
3294 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
3295 * it gets removed when the user commits, so if it still exists we're
3296 * sure the user can't have committed before.
3298 switch (opts
->action
) {
3300 if (!refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
3301 if (action
!= REPLAY_REVERT
)
3302 return error(_("no revert in progress"));
3303 if (!rollback_is_safe())
3308 if (!refs_ref_exists(get_main_ref_store(r
),
3309 "CHERRY_PICK_HEAD")) {
3310 if (action
!= REPLAY_PICK
)
3311 return error(_("no cherry-pick in progress"));
3312 if (!rollback_is_safe())
3317 BUG("unexpected action in sequencer_skip");
3320 if (skip_single_pick())
3321 return error(_("failed to skip the commit"));
3322 if (!is_directory(git_path_seq_dir()))
3325 return sequencer_continue(r
, opts
);
3328 error(_("there is nothing to skip"));
3330 if (advice_enabled(ADVICE_RESOLVE_CONFLICT
)) {
3331 advise(_("have you committed already?\n"
3332 "try \"git %s --continue\""),
3333 action
== REPLAY_REVERT
? "revert" : "cherry-pick");
3338 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
3340 struct lock_file todo_lock
= LOCK_INIT
;
3341 const char *todo_path
= get_todo_path(opts
);
3342 int next
= todo_list
->current
, offset
, fd
;
3345 * rebase -i writes "git-rebase-todo" without the currently executing
3346 * command, appending it to "done" instead.
3348 if (is_rebase_i(opts
))
3351 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
3353 return error_errno(_("could not lock '%s'"), todo_path
);
3354 offset
= get_item_line_offset(todo_list
, next
);
3355 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
3356 todo_list
->buf
.len
- offset
) < 0)
3357 return error_errno(_("could not write to '%s'"), todo_path
);
3358 if (commit_lock_file(&todo_lock
) < 0)
3359 return error(_("failed to finalize '%s'"), todo_path
);
3361 if (is_rebase_i(opts
) && next
> 0) {
3362 const char *done
= rebase_path_done();
3363 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
3368 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
3369 get_item_line_length(todo_list
, next
- 1))
3371 ret
= error_errno(_("could not write to '%s'"), done
);
3373 ret
= error_errno(_("failed to finalize '%s'"), done
);
3379 static int save_opts(struct replay_opts
*opts
)
3381 const char *opts_file
= git_path_opts_file();
3384 if (opts
->no_commit
)
3385 res
|= git_config_set_in_file_gently(opts_file
,
3386 "options.no-commit", "true");
3387 if (opts
->edit
>= 0)
3388 res
|= git_config_set_in_file_gently(opts_file
, "options.edit",
3389 opts
->edit
? "true" : "false");
3390 if (opts
->allow_empty
)
3391 res
|= git_config_set_in_file_gently(opts_file
,
3392 "options.allow-empty", "true");
3393 if (opts
->allow_empty_message
)
3394 res
|= git_config_set_in_file_gently(opts_file
,
3395 "options.allow-empty-message", "true");
3396 if (opts
->keep_redundant_commits
)
3397 res
|= git_config_set_in_file_gently(opts_file
,
3398 "options.keep-redundant-commits", "true");
3400 res
|= git_config_set_in_file_gently(opts_file
,
3401 "options.signoff", "true");
3402 if (opts
->record_origin
)
3403 res
|= git_config_set_in_file_gently(opts_file
,
3404 "options.record-origin", "true");
3406 res
|= git_config_set_in_file_gently(opts_file
,
3407 "options.allow-ff", "true");
3408 if (opts
->mainline
) {
3409 struct strbuf buf
= STRBUF_INIT
;
3410 strbuf_addf(&buf
, "%d", opts
->mainline
);
3411 res
|= git_config_set_in_file_gently(opts_file
,
3412 "options.mainline", buf
.buf
);
3413 strbuf_release(&buf
);
3416 res
|= git_config_set_in_file_gently(opts_file
,
3417 "options.strategy", opts
->strategy
);
3419 res
|= git_config_set_in_file_gently(opts_file
,
3420 "options.gpg-sign", opts
->gpg_sign
);
3423 for (i
= 0; i
< opts
->xopts_nr
; i
++)
3424 res
|= git_config_set_multivar_in_file_gently(opts_file
,
3425 "options.strategy-option",
3426 opts
->xopts
[i
], "^$", 0);
3428 if (opts
->allow_rerere_auto
)
3429 res
|= git_config_set_in_file_gently(opts_file
,
3430 "options.allow-rerere-auto",
3431 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
3434 if (opts
->explicit_cleanup
)
3435 res
|= git_config_set_in_file_gently(opts_file
,
3436 "options.default-msg-cleanup",
3437 describe_cleanup_mode(opts
->default_msg_cleanup
));
3441 static int make_patch(struct repository
*r
,
3442 struct commit
*commit
,
3443 struct replay_opts
*opts
)
3445 struct strbuf buf
= STRBUF_INIT
;
3446 struct rev_info log_tree_opt
;
3447 const char *subject
;
3448 char hex
[GIT_MAX_HEXSZ
+ 1];
3451 oid_to_hex_r(hex
, &commit
->object
.oid
);
3452 if (write_message(hex
, strlen(hex
), rebase_path_stopped_sha(), 1) < 0)
3454 res
|= write_rebase_head(&commit
->object
.oid
);
3456 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
3457 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3458 repo_init_revisions(r
, &log_tree_opt
, NULL
);
3459 log_tree_opt
.abbrev
= 0;
3460 log_tree_opt
.diff
= 1;
3461 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
3462 log_tree_opt
.disable_stdin
= 1;
3463 log_tree_opt
.no_commit_id
= 1;
3464 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
3465 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
3466 if (!log_tree_opt
.diffopt
.file
)
3467 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
3469 res
|= log_tree_commit(&log_tree_opt
, commit
);
3470 fclose(log_tree_opt
.diffopt
.file
);
3474 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
3475 if (!file_exists(buf
.buf
)) {
3476 const char *encoding
= get_commit_output_encoding();
3477 const char *commit_buffer
= logmsg_reencode(commit
, NULL
, encoding
);
3478 find_commit_subject(commit_buffer
, &subject
);
3479 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
3480 unuse_commit_buffer(commit
, commit_buffer
);
3482 strbuf_release(&buf
);
3483 release_revisions(&log_tree_opt
);
3488 static int intend_to_amend(void)
3490 struct object_id head
;
3493 if (get_oid("HEAD", &head
))
3494 return error(_("cannot read HEAD"));
3496 p
= oid_to_hex(&head
);
3497 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
3500 static int error_with_patch(struct repository
*r
,
3501 struct commit
*commit
,
3502 const char *subject
, int subject_len
,
3503 struct replay_opts
*opts
,
3504 int exit_code
, int to_amend
)
3507 if (make_patch(r
, commit
, opts
))
3509 } else if (copy_file(rebase_path_message(),
3510 git_path_merge_msg(r
), 0666))
3511 return error(_("unable to copy '%s' to '%s'"),
3512 git_path_merge_msg(r
), rebase_path_message());
3515 if (intend_to_amend())
3519 _("You can amend the commit now, with\n"
3521 " git commit --amend %s\n"
3523 "Once you are satisfied with your changes, run\n"
3525 " git rebase --continue\n"),
3526 gpg_sign_opt_quoted(opts
));
3527 } else if (exit_code
) {
3529 fprintf_ln(stderr
, _("Could not apply %s... %.*s"),
3530 short_commit_name(commit
), subject_len
, subject
);
3533 * We don't have the hash of the parent so
3534 * just print the line from the todo file.
3536 fprintf_ln(stderr
, _("Could not merge %.*s"),
3537 subject_len
, subject
);
3543 static int error_failed_squash(struct repository
*r
,
3544 struct commit
*commit
,
3545 struct replay_opts
*opts
,
3547 const char *subject
)
3549 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3550 return error(_("could not copy '%s' to '%s'"),
3551 rebase_path_squash_msg(), rebase_path_message());
3552 unlink(git_path_merge_msg(r
));
3553 if (copy_file(git_path_merge_msg(r
), rebase_path_message(), 0666))
3554 return error(_("could not copy '%s' to '%s'"),
3555 rebase_path_message(),
3556 git_path_merge_msg(r
));
3557 return error_with_patch(r
, commit
, subject
, subject_len
, opts
, 1, 0);
3560 static int do_exec(struct repository
*r
, const char *command_line
)
3562 struct child_process cmd
= CHILD_PROCESS_INIT
;
3565 fprintf(stderr
, _("Executing: %s\n"), command_line
);
3567 strvec_push(&cmd
.args
, command_line
);
3568 status
= run_command(&cmd
);
3570 /* force re-reading of the cache */
3571 discard_index(r
->index
);
3572 if (repo_read_index(r
) < 0)
3573 return error(_("could not read index"));
3575 dirty
= require_clean_work_tree(r
, "rebase", NULL
, 1, 1);
3578 warning(_("execution failed: %s\n%s"
3579 "You can fix the problem, and then run\n"
3581 " git rebase --continue\n"
3584 dirty
? N_("and made changes to the index and/or the "
3585 "working tree\n") : "");
3587 /* command not found */
3590 warning(_("execution succeeded: %s\nbut "
3591 "left changes to the index and/or the working tree\n"
3592 "Commit or stash your changes, and then run\n"
3594 " git rebase --continue\n"
3595 "\n"), command_line
);
3602 __attribute__((format (printf
, 2, 3)))
3603 static int safe_append(const char *filename
, const char *fmt
, ...)
3606 struct lock_file lock
= LOCK_INIT
;
3607 int fd
= hold_lock_file_for_update(&lock
, filename
,
3608 LOCK_REPORT_ON_ERROR
);
3609 struct strbuf buf
= STRBUF_INIT
;
3614 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
3615 error_errno(_("could not read '%s'"), filename
);
3616 rollback_lock_file(&lock
);
3619 strbuf_complete(&buf
, '\n');
3621 strbuf_vaddf(&buf
, fmt
, ap
);
3624 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
3625 error_errno(_("could not write to '%s'"), filename
);
3626 strbuf_release(&buf
);
3627 rollback_lock_file(&lock
);
3630 if (commit_lock_file(&lock
) < 0) {
3631 strbuf_release(&buf
);
3632 rollback_lock_file(&lock
);
3633 return error(_("failed to finalize '%s'"), filename
);
3636 strbuf_release(&buf
);
3640 static int do_label(struct repository
*r
, const char *name
, int len
)
3642 struct ref_store
*refs
= get_main_ref_store(r
);
3643 struct ref_transaction
*transaction
;
3644 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
3645 struct strbuf msg
= STRBUF_INIT
;
3647 struct object_id head_oid
;
3649 if (len
== 1 && *name
== '#')
3650 return error(_("illegal label name: '%.*s'"), len
, name
);
3652 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3653 strbuf_addf(&msg
, "rebase (label) '%.*s'", len
, name
);
3655 transaction
= ref_store_transaction_begin(refs
, &err
);
3657 error("%s", err
.buf
);
3659 } else if (get_oid("HEAD", &head_oid
)) {
3660 error(_("could not read HEAD"));
3662 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
3663 NULL
, 0, msg
.buf
, &err
) < 0 ||
3664 ref_transaction_commit(transaction
, &err
)) {
3665 error("%s", err
.buf
);
3668 ref_transaction_free(transaction
);
3669 strbuf_release(&err
);
3670 strbuf_release(&msg
);
3673 ret
= safe_append(rebase_path_refs_to_delete(),
3674 "%s\n", ref_name
.buf
);
3675 strbuf_release(&ref_name
);
3680 static const char *sequencer_reflog_action(struct replay_opts
*opts
)
3682 if (!opts
->reflog_action
) {
3683 opts
->reflog_action
= getenv(GIT_REFLOG_ACTION
);
3684 opts
->reflog_action
=
3685 xstrdup(opts
->reflog_action
? opts
->reflog_action
3686 : action_name(opts
));
3689 return opts
->reflog_action
;
3692 __attribute__((format (printf
, 3, 4)))
3693 static const char *reflog_message(struct replay_opts
*opts
,
3694 const char *sub_action
, const char *fmt
, ...)
3697 static struct strbuf buf
= STRBUF_INIT
;
3701 strbuf_addstr(&buf
, sequencer_reflog_action(opts
));
3703 strbuf_addf(&buf
, " (%s)", sub_action
);
3705 strbuf_addstr(&buf
, ": ");
3706 strbuf_vaddf(&buf
, fmt
, ap
);
3713 static struct commit
*lookup_label(struct repository
*r
, const char *label
,
3714 int len
, struct strbuf
*buf
)
3716 struct commit
*commit
;
3717 struct object_id oid
;
3720 strbuf_addf(buf
, "refs/rewritten/%.*s", len
, label
);
3721 if (!read_ref(buf
->buf
, &oid
)) {
3722 commit
= lookup_commit_object(r
, &oid
);
3724 /* fall back to non-rewritten ref or commit */
3725 strbuf_splice(buf
, 0, strlen("refs/rewritten/"), "", 0);
3726 commit
= lookup_commit_reference_by_name(buf
->buf
);
3730 error(_("could not resolve '%s'"), buf
->buf
);
3735 static int do_reset(struct repository
*r
,
3736 const char *name
, int len
,
3737 struct replay_opts
*opts
)
3739 struct strbuf ref_name
= STRBUF_INIT
;
3740 struct object_id oid
;
3741 struct lock_file lock
= LOCK_INIT
;
3742 struct tree_desc desc
= { 0 };
3744 struct unpack_trees_options unpack_tree_opts
= { 0 };
3747 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0)
3750 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
3751 if (!opts
->have_squash_onto
) {
3753 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
3754 NULL
, &opts
->squash_onto
,
3756 return error(_("writing fake root commit"));
3757 opts
->have_squash_onto
= 1;
3758 hex
= oid_to_hex(&opts
->squash_onto
);
3759 if (write_message(hex
, strlen(hex
),
3760 rebase_path_squash_onto(), 0))
3761 return error(_("writing squash-onto"));
3763 oidcpy(&oid
, &opts
->squash_onto
);
3766 struct commit
*commit
;
3768 /* Determine the length of the label */
3769 for (i
= 0; i
< len
; i
++)
3770 if (isspace(name
[i
]))
3774 commit
= lookup_label(r
, name
, len
, &ref_name
);
3779 oid
= commit
->object
.oid
;
3782 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
3783 unpack_tree_opts
.head_idx
= 1;
3784 unpack_tree_opts
.src_index
= r
->index
;
3785 unpack_tree_opts
.dst_index
= r
->index
;
3786 unpack_tree_opts
.fn
= oneway_merge
;
3787 unpack_tree_opts
.merge
= 1;
3788 unpack_tree_opts
.update
= 1;
3789 unpack_tree_opts
.preserve_ignored
= 0; /* FIXME: !overwrite_ignore */
3790 unpack_tree_opts
.skip_cache_tree_update
= 1;
3791 init_checkout_metadata(&unpack_tree_opts
.meta
, name
, &oid
, NULL
);
3793 if (repo_read_index_unmerged(r
)) {
3794 ret
= error_resolve_conflict(action_name(opts
));
3798 if (!fill_tree_descriptor(r
, &desc
, &oid
)) {
3799 ret
= error(_("failed to find tree of %s"), oid_to_hex(&oid
));
3803 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
3808 tree
= parse_tree_indirect(&oid
);
3809 prime_cache_tree(r
, r
->index
, tree
);
3811 if (write_locked_index(r
->index
, &lock
, COMMIT_LOCK
) < 0)
3812 ret
= error(_("could not write index"));
3815 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
3816 len
, name
), "HEAD", &oid
,
3817 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3819 free((void *)desc
.buffer
);
3821 rollback_lock_file(&lock
);
3822 strbuf_release(&ref_name
);
3823 clear_unpack_trees_porcelain(&unpack_tree_opts
);
3827 static int do_merge(struct repository
*r
,
3828 struct commit
*commit
,
3829 const char *arg
, int arg_len
,
3830 int flags
, int *check_todo
, struct replay_opts
*opts
)
3832 int run_commit_flags
= 0;
3833 struct strbuf ref_name
= STRBUF_INIT
;
3834 struct commit
*head_commit
, *merge_commit
, *i
;
3835 struct commit_list
*bases
, *j
;
3836 struct commit_list
*to_merge
= NULL
, **tail
= &to_merge
;
3837 const char *strategy
= !opts
->xopts_nr
&&
3839 !strcmp(opts
->strategy
, "recursive") ||
3840 !strcmp(opts
->strategy
, "ort")) ?
3841 NULL
: opts
->strategy
;
3842 struct merge_options o
;
3843 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
, k
;
3844 static struct lock_file lock
;
3847 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0) {
3852 head_commit
= lookup_commit_reference_by_name("HEAD");
3854 ret
= error(_("cannot merge without a current revision"));
3859 * For octopus merges, the arg starts with the list of revisions to be
3860 * merged. The list is optionally followed by '#' and the oneline.
3862 merge_arg_len
= oneline_offset
= arg_len
;
3863 for (p
= arg
; p
- arg
< arg_len
; p
+= strspn(p
, " \t\n")) {
3866 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
3867 p
+= 1 + strspn(p
+ 1, " \t\n");
3868 oneline_offset
= p
- arg
;
3871 k
= strcspn(p
, " \t\n");
3874 merge_commit
= lookup_label(r
, p
, k
, &ref_name
);
3875 if (!merge_commit
) {
3876 ret
= error(_("unable to parse '%.*s'"), k
, p
);
3879 tail
= &commit_list_insert(merge_commit
, tail
)->next
;
3881 merge_arg_len
= p
- arg
;
3885 ret
= error(_("nothing to merge: '%.*s'"), arg_len
, arg
);
3889 if (opts
->have_squash_onto
&&
3890 oideq(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
3892 * When the user tells us to "merge" something into a
3893 * "[new root]", let's simply fast-forward to the merge head.
3895 rollback_lock_file(&lock
);
3897 ret
= error(_("octopus merge cannot be executed on "
3898 "top of a [new root]"));
3900 ret
= fast_forward_to(r
, &to_merge
->item
->object
.oid
,
3901 &head_commit
->object
.oid
, 0,
3907 * If HEAD is not identical to the first parent of the original merge
3908 * commit, we cannot fast-forward.
3910 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
3911 oideq(&commit
->parents
->item
->object
.oid
,
3912 &head_commit
->object
.oid
);
3915 * If any merge head is different from the original one, we cannot
3918 if (can_fast_forward
) {
3919 struct commit_list
*p
= commit
->parents
->next
;
3921 for (j
= to_merge
; j
&& p
; j
= j
->next
, p
= p
->next
)
3922 if (!oideq(&j
->item
->object
.oid
,
3923 &p
->item
->object
.oid
)) {
3924 can_fast_forward
= 0;
3928 * If the number of merge heads differs from the original merge
3929 * commit, we cannot fast-forward.
3932 can_fast_forward
= 0;
3935 if (can_fast_forward
) {
3936 rollback_lock_file(&lock
);
3937 ret
= fast_forward_to(r
, &commit
->object
.oid
,
3938 &head_commit
->object
.oid
, 0, opts
);
3939 if (flags
& TODO_EDIT_MERGE_MSG
)
3940 goto fast_forward_edit
;
3946 const char *encoding
= get_commit_output_encoding();
3947 const char *message
= logmsg_reencode(commit
, NULL
, encoding
);
3952 ret
= error(_("could not get commit message of '%s'"),
3953 oid_to_hex(&commit
->object
.oid
));
3956 write_author_script(message
);
3957 find_commit_subject(message
, &body
);
3959 ret
= write_message(body
, len
, git_path_merge_msg(r
), 0);
3960 unuse_commit_buffer(commit
, message
);
3962 error_errno(_("could not write '%s'"),
3963 git_path_merge_msg(r
));
3967 struct strbuf buf
= STRBUF_INIT
;
3970 strbuf_addf(&buf
, "author %s", git_author_info(0));
3971 write_author_script(buf
.buf
);
3974 if (oneline_offset
< arg_len
) {
3975 p
= arg
+ oneline_offset
;
3976 len
= arg_len
- oneline_offset
;
3978 strbuf_addf(&buf
, "Merge %s '%.*s'",
3979 to_merge
->next
? "branches" : "branch",
3980 merge_arg_len
, arg
);
3985 ret
= write_message(p
, len
, git_path_merge_msg(r
), 0);
3986 strbuf_release(&buf
);
3988 error_errno(_("could not write '%s'"),
3989 git_path_merge_msg(r
));
3994 if (strategy
|| to_merge
->next
) {
3996 struct child_process cmd
= CHILD_PROCESS_INIT
;
3998 if (read_env_script(&cmd
.env
)) {
3999 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
4001 ret
= error(_(staged_changes_advice
), gpg_opt
, gpg_opt
);
4005 if (opts
->committer_date_is_author_date
)
4006 strvec_pushf(&cmd
.env
, "GIT_COMMITTER_DATE=%s",
4009 author_date_from_env(&cmd
.env
));
4010 if (opts
->ignore_date
)
4011 strvec_push(&cmd
.env
, "GIT_AUTHOR_DATE=");
4014 strvec_push(&cmd
.args
, "merge");
4015 strvec_push(&cmd
.args
, "-s");
4017 strvec_push(&cmd
.args
, "octopus");
4019 strvec_push(&cmd
.args
, strategy
);
4020 for (k
= 0; k
< opts
->xopts_nr
; k
++)
4021 strvec_pushf(&cmd
.args
,
4022 "-X%s", opts
->xopts
[k
]);
4024 if (!(flags
& TODO_EDIT_MERGE_MSG
))
4025 strvec_push(&cmd
.args
, "--no-edit");
4027 strvec_push(&cmd
.args
, "--edit");
4028 strvec_push(&cmd
.args
, "--no-ff");
4029 strvec_push(&cmd
.args
, "--no-log");
4030 strvec_push(&cmd
.args
, "--no-stat");
4031 strvec_push(&cmd
.args
, "-F");
4032 strvec_push(&cmd
.args
, git_path_merge_msg(r
));
4034 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
4036 strvec_push(&cmd
.args
, "--no-gpg-sign");
4038 /* Add the tips to be merged */
4039 for (j
= to_merge
; j
; j
= j
->next
)
4040 strvec_push(&cmd
.args
,
4041 oid_to_hex(&j
->item
->object
.oid
));
4043 strbuf_release(&ref_name
);
4044 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
4046 rollback_lock_file(&lock
);
4048 ret
= run_command(&cmd
);
4050 /* force re-reading of the cache */
4052 discard_index(r
->index
);
4053 if (repo_read_index(r
) < 0)
4054 ret
= error(_("could not read index"));
4059 merge_commit
= to_merge
->item
;
4060 bases
= get_merge_bases(head_commit
, merge_commit
);
4061 if (bases
&& oideq(&merge_commit
->object
.oid
,
4062 &bases
->item
->object
.oid
)) {
4064 /* skip merging an ancestor of HEAD */
4068 write_message(oid_to_hex(&merge_commit
->object
.oid
), the_hash_algo
->hexsz
,
4069 git_path_merge_head(r
), 0);
4070 write_message("no-ff", 5, git_path_merge_mode(r
), 0);
4072 bases
= reverse_commit_list(bases
);
4075 init_merge_options(&o
, r
);
4077 o
.branch2
= ref_name
.buf
;
4078 o
.buffer_output
= 2;
4080 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
4082 * TODO: Should use merge_incore_recursive() and
4083 * merge_switch_to_result(), skipping the call to
4084 * merge_switch_to_result() when we don't actually need to
4085 * update the index and working copy immediately.
4087 ret
= merge_ort_recursive(&o
,
4088 head_commit
, merge_commit
, bases
,
4091 ret
= merge_recursive(&o
, head_commit
, merge_commit
, bases
,
4095 fputs(o
.obuf
.buf
, stdout
);
4096 strbuf_release(&o
.obuf
);
4098 error(_("could not even attempt to merge '%.*s'"),
4099 merge_arg_len
, arg
);
4103 * The return value of merge_recursive() is 1 on clean, and 0 on
4106 * Let's reverse that, so that do_merge() returns 0 upon success and
4107 * 1 upon failed merge (keeping the return value -1 for the cases where
4108 * we will want to reschedule the `merge` command).
4112 if (r
->index
->cache_changed
&&
4113 write_locked_index(r
->index
, &lock
, COMMIT_LOCK
)) {
4114 ret
= error(_("merge: Unable to write new index file"));
4118 rollback_lock_file(&lock
);
4120 repo_rerere(r
, opts
->allow_rerere_auto
);
4123 * In case of problems, we now want to return a positive
4124 * value (a negative one would indicate that the `merge`
4125 * command needs to be rescheduled).
4127 ret
= !!run_git_commit(git_path_merge_msg(r
), opts
,
4130 if (!ret
&& flags
& TODO_EDIT_MERGE_MSG
) {
4133 run_commit_flags
|= AMEND_MSG
| EDIT_MSG
| VERIFY_MSG
;
4134 ret
= !!run_git_commit(NULL
, opts
, run_commit_flags
);
4139 strbuf_release(&ref_name
);
4140 rollback_lock_file(&lock
);
4141 free_commit_list(to_merge
);
4145 static int write_update_refs_state(struct string_list
*refs_to_oids
)
4148 struct lock_file lock
= LOCK_INIT
;
4150 struct string_list_item
*item
;
4153 path
= rebase_path_update_refs(the_repository
->gitdir
);
4155 if (!refs_to_oids
->nr
) {
4156 if (unlink(path
) && errno
!= ENOENT
)
4157 result
= error_errno(_("could not unlink: %s"), path
);
4161 if (safe_create_leading_directories(path
)) {
4162 result
= error(_("unable to create leading directories of %s"),
4167 if (hold_lock_file_for_update(&lock
, path
, 0) < 0) {
4168 result
= error(_("another 'rebase' process appears to be running; "
4169 "'%s.lock' already exists"),
4174 fp
= fdopen_lock_file(&lock
, "w");
4176 result
= error_errno(_("could not open '%s' for writing"), path
);
4177 rollback_lock_file(&lock
);
4181 for_each_string_list_item(item
, refs_to_oids
) {
4182 struct update_ref_record
*rec
= item
->util
;
4183 fprintf(fp
, "%s\n%s\n%s\n", item
->string
,
4184 oid_to_hex(&rec
->before
), oid_to_hex(&rec
->after
));
4187 result
= commit_lock_file(&lock
);
4195 * Parse the update-refs file for the current rebase, then remove the
4196 * refs that do not appear in the todo_list (and have not had updated
4197 * values stored) and add refs that are in the todo_list but not
4198 * represented in the update-refs file.
4200 * If there are changes to the update-refs list, then write the new state
4203 void todo_list_filter_update_refs(struct repository
*r
,
4204 struct todo_list
*todo_list
)
4208 struct string_list update_refs
= STRING_LIST_INIT_DUP
;
4210 sequencer_get_update_refs_state(r
->gitdir
, &update_refs
);
4213 * For each item in the update_refs list, if it has no updated
4214 * value and does not appear in the todo_list, then remove it
4215 * from the update_refs list.
4217 for (i
= 0; i
< update_refs
.nr
; i
++) {
4220 const char *ref
= update_refs
.items
[i
].string
;
4221 size_t reflen
= strlen(ref
);
4222 struct update_ref_record
*rec
= update_refs
.items
[i
].util
;
4224 /* OID already stored as updated. */
4225 if (!is_null_oid(&rec
->after
))
4228 for (j
= 0; !found
&& j
< todo_list
->total_nr
; j
++) {
4229 struct todo_item
*item
= &todo_list
->items
[j
];
4230 const char *arg
= todo_list
->buf
.buf
+ item
->arg_offset
;
4232 if (item
->command
!= TODO_UPDATE_REF
)
4235 if (item
->arg_len
!= reflen
||
4236 strncmp(arg
, ref
, reflen
))
4243 free(update_refs
.items
[i
].string
);
4244 free(update_refs
.items
[i
].util
);
4247 MOVE_ARRAY(update_refs
.items
+ i
, update_refs
.items
+ i
+ 1, update_refs
.nr
- i
);
4255 * For each todo_item, check if its ref is in the update_refs list.
4256 * If not, then add it as an un-updated ref.
4258 for (i
= 0; i
< todo_list
->total_nr
; i
++) {
4259 struct todo_item
*item
= &todo_list
->items
[i
];
4260 const char *arg
= todo_list
->buf
.buf
+ item
->arg_offset
;
4263 if (item
->command
!= TODO_UPDATE_REF
)
4266 for (j
= 0; !found
&& j
< update_refs
.nr
; j
++) {
4267 const char *ref
= update_refs
.items
[j
].string
;
4269 found
= strlen(ref
) == item
->arg_len
&&
4270 !strncmp(ref
, arg
, item
->arg_len
);
4274 struct string_list_item
*inserted
;
4275 struct strbuf argref
= STRBUF_INIT
;
4277 strbuf_add(&argref
, arg
, item
->arg_len
);
4278 inserted
= string_list_insert(&update_refs
, argref
.buf
);
4279 inserted
->util
= init_update_ref_record(argref
.buf
);
4280 strbuf_release(&argref
);
4286 write_update_refs_state(&update_refs
);
4287 string_list_clear(&update_refs
, 1);
4290 static int do_update_ref(struct repository
*r
, const char *refname
)
4292 struct string_list_item
*item
;
4293 struct string_list list
= STRING_LIST_INIT_DUP
;
4295 if (sequencer_get_update_refs_state(r
->gitdir
, &list
))
4298 for_each_string_list_item(item
, &list
) {
4299 if (!strcmp(item
->string
, refname
)) {
4300 struct update_ref_record
*rec
= item
->util
;
4301 if (read_ref("HEAD", &rec
->after
))
4307 write_update_refs_state(&list
);
4308 string_list_clear(&list
, 1);
4312 static int do_update_refs(struct repository
*r
, int quiet
)
4315 struct string_list_item
*item
;
4316 struct string_list refs_to_oids
= STRING_LIST_INIT_DUP
;
4317 struct ref_store
*refs
= get_main_ref_store(r
);
4318 struct strbuf update_msg
= STRBUF_INIT
;
4319 struct strbuf error_msg
= STRBUF_INIT
;
4321 if ((res
= sequencer_get_update_refs_state(r
->gitdir
, &refs_to_oids
)))
4324 for_each_string_list_item(item
, &refs_to_oids
) {
4325 struct update_ref_record
*rec
= item
->util
;
4328 loop_res
= refs_update_ref(refs
, "rewritten during rebase",
4330 &rec
->after
, &rec
->before
,
4331 0, UPDATE_REFS_MSG_ON_ERR
);
4338 strbuf_addf(&error_msg
, "\t%s\n", item
->string
);
4340 strbuf_addf(&update_msg
, "\t%s\n", item
->string
);
4344 (update_msg
.len
|| error_msg
.len
)) {
4346 _("Updated the following refs with %s:\n%s"),
4352 _("Failed to update the following refs with %s:\n%s"),
4357 string_list_clear(&refs_to_oids
, 1);
4358 strbuf_release(&update_msg
);
4359 strbuf_release(&error_msg
);
4363 static int is_final_fixup(struct todo_list
*todo_list
)
4365 int i
= todo_list
->current
;
4367 if (!is_fixup(todo_list
->items
[i
].command
))
4370 while (++i
< todo_list
->nr
)
4371 if (is_fixup(todo_list
->items
[i
].command
))
4373 else if (!is_noop(todo_list
->items
[i
].command
))
4378 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
4382 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
4383 if (!is_noop(todo_list
->items
[i
].command
))
4384 return todo_list
->items
[i
].command
;
4389 void create_autostash(struct repository
*r
, const char *path
)
4391 struct strbuf buf
= STRBUF_INIT
;
4392 struct lock_file lock_file
= LOCK_INIT
;
4395 fd
= repo_hold_locked_index(r
, &lock_file
, 0);
4396 refresh_index(r
->index
, REFRESH_QUIET
, NULL
, NULL
, NULL
);
4398 repo_update_index_if_able(r
, &lock_file
);
4399 rollback_lock_file(&lock_file
);
4401 if (has_unstaged_changes(r
, 1) ||
4402 has_uncommitted_changes(r
, 1)) {
4403 struct child_process stash
= CHILD_PROCESS_INIT
;
4404 struct reset_head_opts ropts
= { .flags
= RESET_HEAD_HARD
};
4405 struct object_id oid
;
4407 strvec_pushl(&stash
.args
,
4408 "stash", "create", "autostash", NULL
);
4412 if (capture_command(&stash
, &buf
, GIT_MAX_HEXSZ
))
4413 die(_("Cannot autostash"));
4414 strbuf_trim_trailing_newline(&buf
);
4415 if (get_oid(buf
.buf
, &oid
))
4416 die(_("Unexpected stash response: '%s'"),
4419 strbuf_add_unique_abbrev(&buf
, &oid
, DEFAULT_ABBREV
);
4421 if (safe_create_leading_directories_const(path
))
4422 die(_("Could not create directory for '%s'"),
4424 write_file(path
, "%s", oid_to_hex(&oid
));
4425 printf(_("Created autostash: %s\n"), buf
.buf
);
4426 if (reset_head(r
, &ropts
) < 0)
4427 die(_("could not reset --hard"));
4428 discard_index(r
->index
);
4429 if (repo_read_index(r
) < 0)
4430 die(_("could not read index"));
4432 strbuf_release(&buf
);
4435 static int apply_save_autostash_oid(const char *stash_oid
, int attempt_apply
)
4437 struct child_process child
= CHILD_PROCESS_INIT
;
4440 if (attempt_apply
) {
4442 child
.no_stdout
= 1;
4443 child
.no_stderr
= 1;
4444 strvec_push(&child
.args
, "stash");
4445 strvec_push(&child
.args
, "apply");
4446 strvec_push(&child
.args
, stash_oid
);
4447 ret
= run_command(&child
);
4450 if (attempt_apply
&& !ret
)
4451 fprintf(stderr
, _("Applied autostash.\n"));
4453 struct child_process store
= CHILD_PROCESS_INIT
;
4456 strvec_push(&store
.args
, "stash");
4457 strvec_push(&store
.args
, "store");
4458 strvec_push(&store
.args
, "-m");
4459 strvec_push(&store
.args
, "autostash");
4460 strvec_push(&store
.args
, "-q");
4461 strvec_push(&store
.args
, stash_oid
);
4462 if (run_command(&store
))
4463 ret
= error(_("cannot store %s"), stash_oid
);
4467 "Your changes are safe in the stash.\n"
4468 "You can run \"git stash pop\" or"
4469 " \"git stash drop\" at any time.\n"),
4471 _("Applying autostash resulted in conflicts.") :
4472 _("Autostash exists; creating a new stash entry."));
4478 static int apply_save_autostash(const char *path
, int attempt_apply
)
4480 struct strbuf stash_oid
= STRBUF_INIT
;
4483 if (!read_oneliner(&stash_oid
, path
,
4484 READ_ONELINER_SKIP_IF_EMPTY
)) {
4485 strbuf_release(&stash_oid
);
4488 strbuf_trim(&stash_oid
);
4490 ret
= apply_save_autostash_oid(stash_oid
.buf
, attempt_apply
);
4493 strbuf_release(&stash_oid
);
4497 int save_autostash(const char *path
)
4499 return apply_save_autostash(path
, 0);
4502 int apply_autostash(const char *path
)
4504 return apply_save_autostash(path
, 1);
4507 int apply_autostash_oid(const char *stash_oid
)
4509 return apply_save_autostash_oid(stash_oid
, 1);
4512 static int checkout_onto(struct repository
*r
, struct replay_opts
*opts
,
4513 const char *onto_name
, const struct object_id
*onto
,
4514 const struct object_id
*orig_head
)
4516 struct reset_head_opts ropts
= {
4518 .orig_head
= orig_head
,
4519 .flags
= RESET_HEAD_DETACH
| RESET_ORIG_HEAD
|
4520 RESET_HEAD_RUN_POST_CHECKOUT_HOOK
,
4521 .head_msg
= reflog_message(opts
, "start", "checkout %s",
4523 .default_reflog_action
= sequencer_reflog_action(opts
)
4525 if (reset_head(r
, &ropts
)) {
4526 apply_autostash(rebase_path_autostash());
4527 sequencer_remove_state(opts
);
4528 return error(_("could not detach HEAD"));
4534 static int stopped_at_head(struct repository
*r
)
4536 struct object_id head
;
4537 struct commit
*commit
;
4538 struct commit_message message
;
4540 if (get_oid("HEAD", &head
) ||
4541 !(commit
= lookup_commit(r
, &head
)) ||
4542 parse_commit(commit
) || get_message(commit
, &message
))
4543 fprintf(stderr
, _("Stopped at HEAD\n"));
4545 fprintf(stderr
, _("Stopped at %s\n"), message
.label
);
4546 free_message(commit
, &message
);
4552 static int reread_todo_if_changed(struct repository
*r
,
4553 struct todo_list
*todo_list
,
4554 struct replay_opts
*opts
)
4557 struct strbuf buf
= STRBUF_INIT
;
4559 if (strbuf_read_file_or_whine(&buf
, get_todo_path(opts
)) < 0)
4561 offset
= get_item_line_offset(todo_list
, todo_list
->current
+ 1);
4562 if (buf
.len
!= todo_list
->buf
.len
- offset
||
4563 memcmp(buf
.buf
, todo_list
->buf
.buf
+ offset
, buf
.len
)) {
4564 /* Reread the todo file if it has changed. */
4565 todo_list_release(todo_list
);
4566 if (read_populate_todo(r
, todo_list
, opts
))
4567 return -1; /* message was printed */
4568 /* `current` will be incremented on return */
4569 todo_list
->current
= -1;
4571 strbuf_release(&buf
);
4576 static const char rescheduled_advice
[] =
4577 N_("Could not execute the todo command\n"
4581 "It has been rescheduled; To edit the command before continuing, please\n"
4582 "edit the todo list first:\n"
4584 " git rebase --edit-todo\n"
4585 " git rebase --continue\n");
4587 static int pick_commits(struct repository
*r
,
4588 struct todo_list
*todo_list
,
4589 struct replay_opts
*opts
)
4591 int res
= 0, reschedule
= 0;
4593 opts
->reflog_message
= sequencer_reflog_action(opts
);
4595 assert(!(opts
->signoff
|| opts
->no_commit
||
4596 opts
->record_origin
|| should_edit(opts
) ||
4597 opts
->committer_date_is_author_date
||
4598 opts
->ignore_date
));
4599 if (read_and_refresh_cache(r
, opts
))
4602 while (todo_list
->current
< todo_list
->nr
) {
4603 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
4604 const char *arg
= todo_item_get_arg(todo_list
, item
);
4607 if (save_todo(todo_list
, opts
))
4609 if (is_rebase_i(opts
)) {
4610 if (item
->command
!= TODO_COMMENT
) {
4611 FILE *f
= fopen(rebase_path_msgnum(), "w");
4613 todo_list
->done_nr
++;
4616 fprintf(f
, "%d\n", todo_list
->done_nr
);
4620 fprintf(stderr
, _("Rebasing (%d/%d)%s"),
4622 todo_list
->total_nr
,
4623 opts
->verbose
? "\n" : "\r");
4625 unlink(rebase_path_message());
4626 unlink(rebase_path_author_script());
4627 unlink(rebase_path_stopped_sha());
4628 unlink(rebase_path_amend());
4629 unlink(git_path_merge_head(r
));
4630 unlink(git_path_auto_merge(r
));
4631 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
4633 if (item
->command
== TODO_BREAK
) {
4636 return stopped_at_head(r
);
4639 if (item
->command
<= TODO_SQUASH
) {
4640 if (is_rebase_i(opts
))
4641 opts
->reflog_message
= reflog_message(opts
,
4642 command_to_string(item
->command
), NULL
);
4644 res
= do_pick_commit(r
, item
, opts
,
4645 is_final_fixup(todo_list
),
4647 if (is_rebase_i(opts
) && res
< 0) {
4649 advise(_(rescheduled_advice
),
4650 get_item_line_length(todo_list
,
4651 todo_list
->current
),
4652 get_item_line(todo_list
,
4653 todo_list
->current
));
4654 todo_list
->current
--;
4655 if (save_todo(todo_list
, opts
))
4658 if (item
->command
== TODO_EDIT
) {
4659 struct commit
*commit
= item
->commit
;
4664 _("Stopped at %s... %.*s\n"),
4665 short_commit_name(commit
),
4666 item
->arg_len
, arg
);
4668 return error_with_patch(r
, commit
,
4669 arg
, item
->arg_len
, opts
, res
, !res
);
4671 if (is_rebase_i(opts
) && !res
)
4672 record_in_rewritten(&item
->commit
->object
.oid
,
4673 peek_command(todo_list
, 1));
4674 if (res
&& is_fixup(item
->command
)) {
4677 return error_failed_squash(r
, item
->commit
, opts
,
4678 item
->arg_len
, arg
);
4679 } else if (res
&& is_rebase_i(opts
) && item
->commit
) {
4681 struct object_id oid
;
4684 * If we are rewording and have either
4685 * fast-forwarded already, or are about to
4686 * create a new root commit, we want to amend,
4687 * otherwise we do not.
4689 if (item
->command
== TODO_REWORD
&&
4690 !get_oid("HEAD", &oid
) &&
4691 (oideq(&item
->commit
->object
.oid
, &oid
) ||
4692 (opts
->have_squash_onto
&&
4693 oideq(&opts
->squash_onto
, &oid
))))
4696 return res
| error_with_patch(r
, item
->commit
,
4697 arg
, item
->arg_len
, opts
,
4700 } else if (item
->command
== TODO_EXEC
) {
4701 char *end_of_arg
= (char *)(arg
+ item
->arg_len
);
4702 int saved
= *end_of_arg
;
4707 res
= do_exec(r
, arg
);
4708 *end_of_arg
= saved
;
4711 if (opts
->reschedule_failed_exec
)
4715 } else if (item
->command
== TODO_LABEL
) {
4716 if ((res
= do_label(r
, arg
, item
->arg_len
)))
4718 } else if (item
->command
== TODO_RESET
) {
4719 if ((res
= do_reset(r
, arg
, item
->arg_len
, opts
)))
4721 } else if (item
->command
== TODO_MERGE
) {
4722 if ((res
= do_merge(r
, item
->commit
, arg
, item
->arg_len
,
4723 item
->flags
, &check_todo
, opts
)) < 0)
4725 else if (item
->commit
)
4726 record_in_rewritten(&item
->commit
->object
.oid
,
4727 peek_command(todo_list
, 1));
4729 /* failed with merge conflicts */
4730 return error_with_patch(r
, item
->commit
,
4733 } else if (item
->command
== TODO_UPDATE_REF
) {
4734 struct strbuf ref
= STRBUF_INIT
;
4735 strbuf_add(&ref
, arg
, item
->arg_len
);
4736 if ((res
= do_update_ref(r
, ref
.buf
)))
4738 strbuf_release(&ref
);
4739 } else if (!is_noop(item
->command
))
4740 return error(_("unknown command %d"), item
->command
);
4743 advise(_(rescheduled_advice
),
4744 get_item_line_length(todo_list
,
4745 todo_list
->current
),
4746 get_item_line(todo_list
, todo_list
->current
));
4747 todo_list
->current
--;
4748 if (save_todo(todo_list
, opts
))
4751 return error_with_patch(r
,
4755 } else if (is_rebase_i(opts
) && check_todo
&& !res
&&
4756 reread_todo_if_changed(r
, todo_list
, opts
)) {
4760 todo_list
->current
++;
4765 if (is_rebase_i(opts
)) {
4766 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
4769 /* Stopped in the middle, as planned? */
4770 if (todo_list
->current
< todo_list
->nr
)
4773 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
4774 starts_with(head_ref
.buf
, "refs/")) {
4776 struct object_id head
, orig
;
4779 if (get_oid("HEAD", &head
)) {
4780 res
= error(_("cannot read HEAD"));
4782 strbuf_release(&head_ref
);
4783 strbuf_release(&buf
);
4786 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
4787 get_oid_hex(buf
.buf
, &orig
)) {
4788 res
= error(_("could not read orig-head"));
4789 goto cleanup_head_ref
;
4792 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
4793 res
= error(_("could not read 'onto'"));
4794 goto cleanup_head_ref
;
4796 msg
= reflog_message(opts
, "finish", "%s onto %s",
4797 head_ref
.buf
, buf
.buf
);
4798 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
4799 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
4800 res
= error(_("could not update %s"),
4802 goto cleanup_head_ref
;
4804 msg
= reflog_message(opts
, "finish", "returning to %s",
4806 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
4807 res
= error(_("could not update HEAD to %s"),
4809 goto cleanup_head_ref
;
4814 if (opts
->verbose
) {
4815 struct rev_info log_tree_opt
;
4816 struct object_id orig
, head
;
4818 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
4819 repo_init_revisions(r
, &log_tree_opt
, NULL
);
4820 log_tree_opt
.diff
= 1;
4821 log_tree_opt
.diffopt
.output_format
=
4822 DIFF_FORMAT_DIFFSTAT
;
4823 log_tree_opt
.disable_stdin
= 1;
4825 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
4826 !get_oid(buf
.buf
, &orig
) &&
4827 !get_oid("HEAD", &head
)) {
4828 diff_tree_oid(&orig
, &head
, "",
4829 &log_tree_opt
.diffopt
);
4830 log_tree_diff_flush(&log_tree_opt
);
4832 release_revisions(&log_tree_opt
);
4834 flush_rewritten_pending();
4835 if (!stat(rebase_path_rewritten_list(), &st
) &&
4837 struct child_process child
= CHILD_PROCESS_INIT
;
4838 const char *post_rewrite_hook
=
4839 find_hook("post-rewrite");
4841 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
4843 strvec_push(&child
.args
, "notes");
4844 strvec_push(&child
.args
, "copy");
4845 strvec_push(&child
.args
, "--for-rewrite=rebase");
4846 /* we don't care if this copying failed */
4847 run_command(&child
);
4849 if (post_rewrite_hook
) {
4850 struct child_process hook
= CHILD_PROCESS_INIT
;
4852 hook
.in
= open(rebase_path_rewritten_list(),
4854 hook
.stdout_to_stderr
= 1;
4855 hook
.trace2_hook_name
= "post-rewrite";
4856 strvec_push(&hook
.args
, post_rewrite_hook
);
4857 strvec_push(&hook
.args
, "rebase");
4858 /* we don't care if this hook failed */
4862 apply_autostash(rebase_path_autostash());
4868 _("Successfully rebased and updated %s.\n"),
4872 strbuf_release(&buf
);
4873 strbuf_release(&head_ref
);
4875 if (do_update_refs(r
, opts
->quiet
))
4880 * Sequence of picks finished successfully; cleanup by
4881 * removing the .git/sequencer directory
4883 return sequencer_remove_state(opts
);
4886 static int continue_single_pick(struct repository
*r
, struct replay_opts
*opts
)
4888 struct child_process cmd
= CHILD_PROCESS_INIT
;
4890 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
4891 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
4892 return error(_("no cherry-pick or revert in progress"));
4895 strvec_push(&cmd
.args
, "commit");
4898 * continue_single_pick() handles the case of recovering from a
4899 * conflict. should_edit() doesn't handle that case; for a conflict,
4900 * we want to edit if the user asked for it, or if they didn't specify
4901 * and stdin is a tty.
4903 if (!opts
->edit
|| (opts
->edit
< 0 && !isatty(0)))
4905 * Include --cleanup=strip as well because we don't want the
4906 * "# Conflicts:" messages.
4908 strvec_pushl(&cmd
.args
, "--no-edit", "--cleanup=strip", NULL
);
4910 return run_command(&cmd
);
4913 static int commit_staged_changes(struct repository
*r
,
4914 struct replay_opts
*opts
,
4915 struct todo_list
*todo_list
)
4917 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
4918 unsigned int final_fixup
= 0, is_clean
;
4920 if (has_unstaged_changes(r
, 1))
4921 return error(_("cannot rebase: You have unstaged changes."));
4923 is_clean
= !has_uncommitted_changes(r
, 0);
4925 if (file_exists(rebase_path_amend())) {
4926 struct strbuf rev
= STRBUF_INIT
;
4927 struct object_id head
, to_amend
;
4929 if (get_oid("HEAD", &head
))
4930 return error(_("cannot amend non-existing commit"));
4931 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
4932 return error(_("invalid file: '%s'"), rebase_path_amend());
4933 if (get_oid_hex(rev
.buf
, &to_amend
))
4934 return error(_("invalid contents: '%s'"),
4935 rebase_path_amend());
4936 if (!is_clean
&& !oideq(&head
, &to_amend
))
4937 return error(_("\nYou have uncommitted changes in your "
4938 "working tree. Please, commit them\n"
4939 "first and then run 'git rebase "
4940 "--continue' again."));
4942 * When skipping a failed fixup/squash, we need to edit the
4943 * commit message, the current fixup list and count, and if it
4944 * was the last fixup/squash in the chain, we need to clean up
4945 * the commit message and if there was a squash, let the user
4948 if (!is_clean
|| !opts
->current_fixup_count
)
4949 ; /* this is not the final fixup */
4950 else if (!oideq(&head
, &to_amend
) ||
4951 !file_exists(rebase_path_stopped_sha())) {
4952 /* was a final fixup or squash done manually? */
4953 if (!is_fixup(peek_command(todo_list
, 0))) {
4954 unlink(rebase_path_fixup_msg());
4955 unlink(rebase_path_squash_msg());
4956 unlink(rebase_path_current_fixups());
4957 strbuf_reset(&opts
->current_fixups
);
4958 opts
->current_fixup_count
= 0;
4961 /* we are in a fixup/squash chain */
4962 const char *p
= opts
->current_fixups
.buf
;
4963 int len
= opts
->current_fixups
.len
;
4965 opts
->current_fixup_count
--;
4967 BUG("Incorrect current_fixups:\n%s", p
);
4968 while (len
&& p
[len
- 1] != '\n')
4970 strbuf_setlen(&opts
->current_fixups
, len
);
4971 if (write_message(p
, len
, rebase_path_current_fixups(),
4973 return error(_("could not write file: '%s'"),
4974 rebase_path_current_fixups());
4977 * If a fixup/squash in a fixup/squash chain failed, the
4978 * commit message is already correct, no need to commit
4981 * Only if it is the final command in the fixup/squash
4982 * chain, and only if the chain is longer than a single
4983 * fixup/squash command (which was just skipped), do we
4984 * actually need to re-commit with a cleaned up commit
4987 if (opts
->current_fixup_count
> 0 &&
4988 !is_fixup(peek_command(todo_list
, 0))) {
4991 * If there was not a single "squash" in the
4992 * chain, we only need to clean up the commit
4993 * message, no need to bother the user with
4994 * opening the commit message in the editor.
4996 if (!starts_with(p
, "squash ") &&
4997 !strstr(p
, "\nsquash "))
4998 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
4999 } else if (is_fixup(peek_command(todo_list
, 0))) {
5001 * We need to update the squash message to skip
5002 * the latest commit message.
5004 struct commit
*commit
;
5005 const char *path
= rebase_path_squash_msg();
5006 const char *encoding
= get_commit_output_encoding();
5008 if (parse_head(r
, &commit
) ||
5009 !(p
= logmsg_reencode(commit
, NULL
, encoding
)) ||
5010 write_message(p
, strlen(p
), path
, 0)) {
5011 unuse_commit_buffer(commit
, p
);
5012 return error(_("could not write file: "
5015 unuse_commit_buffer(commit
, p
);
5019 strbuf_release(&rev
);
5024 if (refs_ref_exists(get_main_ref_store(r
),
5025 "CHERRY_PICK_HEAD") &&
5026 refs_delete_ref(get_main_ref_store(r
), "",
5027 "CHERRY_PICK_HEAD", NULL
, 0))
5028 return error(_("could not remove CHERRY_PICK_HEAD"));
5029 if (unlink(git_path_merge_msg(r
)) && errno
!= ENOENT
)
5030 return error_errno(_("could not remove '%s'"),
5031 git_path_merge_msg(r
));
5036 if (run_git_commit(final_fixup
? NULL
: rebase_path_message(),
5038 return error(_("could not commit staged changes."));
5039 unlink(rebase_path_amend());
5040 unlink(git_path_merge_head(r
));
5041 unlink(git_path_auto_merge(r
));
5043 unlink(rebase_path_fixup_msg());
5044 unlink(rebase_path_squash_msg());
5046 if (opts
->current_fixup_count
> 0) {
5048 * Whether final fixup or not, we just cleaned up the commit
5051 unlink(rebase_path_current_fixups());
5052 strbuf_reset(&opts
->current_fixups
);
5053 opts
->current_fixup_count
= 0;
5058 int sequencer_continue(struct repository
*r
, struct replay_opts
*opts
)
5060 struct todo_list todo_list
= TODO_LIST_INIT
;
5063 if (read_and_refresh_cache(r
, opts
))
5066 if (read_populate_opts(opts
))
5068 if (is_rebase_i(opts
)) {
5069 if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
5070 goto release_todo_list
;
5072 if (file_exists(rebase_path_dropped())) {
5073 if ((res
= todo_list_check_against_backup(r
, &todo_list
)))
5074 goto release_todo_list
;
5076 unlink(rebase_path_dropped());
5079 opts
->reflog_message
= reflog_message(opts
, "continue", NULL
);
5080 if (commit_staged_changes(r
, opts
, &todo_list
)) {
5082 goto release_todo_list
;
5084 } else if (!file_exists(get_todo_path(opts
)))
5085 return continue_single_pick(r
, opts
);
5086 else if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
5087 goto release_todo_list
;
5089 if (!is_rebase_i(opts
)) {
5090 /* Verify that the conflict has been resolved */
5091 if (refs_ref_exists(get_main_ref_store(r
),
5092 "CHERRY_PICK_HEAD") ||
5093 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
5094 res
= continue_single_pick(r
, opts
);
5096 goto release_todo_list
;
5098 if (index_differs_from(r
, "HEAD", NULL
, 0)) {
5099 res
= error_dirty_index(r
, opts
);
5100 goto release_todo_list
;
5102 todo_list
.current
++;
5103 } else if (file_exists(rebase_path_stopped_sha())) {
5104 struct strbuf buf
= STRBUF_INIT
;
5105 struct object_id oid
;
5107 if (read_oneliner(&buf
, rebase_path_stopped_sha(),
5108 READ_ONELINER_SKIP_IF_EMPTY
) &&
5109 !get_oid_hex(buf
.buf
, &oid
))
5110 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
5111 strbuf_release(&buf
);
5114 res
= pick_commits(r
, &todo_list
, opts
);
5116 todo_list_release(&todo_list
);
5120 static int single_pick(struct repository
*r
,
5121 struct commit
*cmit
,
5122 struct replay_opts
*opts
)
5125 struct todo_item item
;
5127 item
.command
= opts
->action
== REPLAY_PICK
?
5128 TODO_PICK
: TODO_REVERT
;
5131 opts
->reflog_message
= sequencer_reflog_action(opts
);
5132 return do_pick_commit(r
, &item
, opts
, 0, &check_todo
);
5135 int sequencer_pick_revisions(struct repository
*r
,
5136 struct replay_opts
*opts
)
5138 struct todo_list todo_list
= TODO_LIST_INIT
;
5139 struct object_id oid
;
5143 if (read_and_refresh_cache(r
, opts
))
5146 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
5147 struct object_id oid
;
5148 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
5150 /* This happens when using --stdin. */
5154 if (!get_oid(name
, &oid
)) {
5155 if (!lookup_commit_reference_gently(r
, &oid
, 1)) {
5156 enum object_type type
= oid_object_info(r
,
5159 return error(_("%s: can't cherry-pick a %s"),
5160 name
, type_name(type
));
5163 return error(_("%s: bad revision"), name
);
5167 * If we were called as "git cherry-pick <commit>", just
5168 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
5169 * REVERT_HEAD, and don't touch the sequencer state.
5170 * This means it is possible to cherry-pick in the middle
5171 * of a cherry-pick sequence.
5173 if (opts
->revs
->cmdline
.nr
== 1 &&
5174 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
5175 opts
->revs
->no_walk
&&
5176 !opts
->revs
->cmdline
.rev
->flags
) {
5177 struct commit
*cmit
;
5178 if (prepare_revision_walk(opts
->revs
))
5179 return error(_("revision walk setup failed"));
5180 cmit
= get_revision(opts
->revs
);
5182 return error(_("empty commit set passed"));
5183 if (get_revision(opts
->revs
))
5184 BUG("unexpected extra commit from walk");
5185 return single_pick(r
, cmit
, opts
);
5189 * Start a new cherry-pick/ revert sequence; but
5190 * first, make sure that an existing one isn't in
5194 if (walk_revs_populate_todo(&todo_list
, opts
) ||
5195 create_seq_dir(r
) < 0)
5197 if (get_oid("HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
5198 return error(_("can't revert as initial commit"));
5199 if (save_head(oid_to_hex(&oid
)))
5201 if (save_opts(opts
))
5203 update_abort_safety_file();
5204 res
= pick_commits(r
, &todo_list
, opts
);
5205 todo_list_release(&todo_list
);
5209 void append_signoff(struct strbuf
*msgbuf
, size_t ignore_footer
, unsigned flag
)
5211 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
5212 struct strbuf sob
= STRBUF_INIT
;
5215 strbuf_addstr(&sob
, sign_off_header
);
5216 strbuf_addstr(&sob
, fmt_name(WANT_COMMITTER_IDENT
));
5217 strbuf_addch(&sob
, '\n');
5220 strbuf_complete_line(msgbuf
);
5223 * If the whole message buffer is equal to the sob, pretend that we
5224 * found a conforming footer with a matching sob
5226 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
5227 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
5230 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
5233 const char *append_newlines
= NULL
;
5234 size_t len
= msgbuf
->len
- ignore_footer
;
5238 * The buffer is completely empty. Leave foom for
5239 * the title and body to be filled in by the user.
5241 append_newlines
= "\n\n";
5242 } else if (len
== 1) {
5244 * Buffer contains a single newline. Add another
5245 * so that we leave room for the title and body.
5247 append_newlines
= "\n";
5248 } else if (msgbuf
->buf
[len
- 2] != '\n') {
5250 * Buffer ends with a single newline. Add another
5251 * so that there is an empty line between the message
5254 append_newlines
= "\n";
5255 } /* else, the buffer already ends with two newlines. */
5257 if (append_newlines
)
5258 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
5259 append_newlines
, strlen(append_newlines
));
5262 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
5263 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
5266 strbuf_release(&sob
);
5269 struct labels_entry
{
5270 struct hashmap_entry entry
;
5271 char label
[FLEX_ARRAY
];
5274 static int labels_cmp(const void *fndata UNUSED
,
5275 const struct hashmap_entry
*eptr
,
5276 const struct hashmap_entry
*entry_or_key
, const void *key
)
5278 const struct labels_entry
*a
, *b
;
5280 a
= container_of(eptr
, const struct labels_entry
, entry
);
5281 b
= container_of(entry_or_key
, const struct labels_entry
, entry
);
5283 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
5286 struct string_entry
{
5287 struct oidmap_entry entry
;
5288 char string
[FLEX_ARRAY
];
5291 struct label_state
{
5292 struct oidmap commit2label
;
5293 struct hashmap labels
;
5297 static const char *label_oid(struct object_id
*oid
, const char *label
,
5298 struct label_state
*state
)
5300 struct labels_entry
*labels_entry
;
5301 struct string_entry
*string_entry
;
5302 struct object_id dummy
;
5305 string_entry
= oidmap_get(&state
->commit2label
, oid
);
5307 return string_entry
->string
;
5310 * For "uninteresting" commits, i.e. commits that are not to be
5311 * rebased, and which can therefore not be labeled, we use a unique
5312 * abbreviation of the commit name. This is slightly more complicated
5313 * than calling find_unique_abbrev() because we also need to make
5314 * sure that the abbreviation does not conflict with any other
5317 * We disallow "interesting" commits to be labeled by a string that
5318 * is a valid full-length hash, to ensure that we always can find an
5319 * abbreviation for any uninteresting commit's names that does not
5320 * clash with any other label.
5322 strbuf_reset(&state
->buf
);
5326 strbuf_grow(&state
->buf
, GIT_MAX_HEXSZ
);
5327 label
= p
= state
->buf
.buf
;
5329 find_unique_abbrev_r(p
, oid
, default_abbrev
);
5332 * We may need to extend the abbreviated hash so that there is
5333 * no conflicting label.
5335 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
5336 size_t i
= strlen(p
) + 1;
5338 oid_to_hex_r(p
, oid
);
5339 for (; i
< the_hash_algo
->hexsz
; i
++) {
5342 if (!hashmap_get_from_hash(&state
->labels
,
5349 struct strbuf
*buf
= &state
->buf
;
5352 * Sanitize labels by replacing non-alpha-numeric characters
5353 * (including white-space ones) by dashes, as they might be
5354 * illegal in file names (and hence in ref names).
5356 * Note that we retain non-ASCII UTF-8 characters (identified
5357 * via the most significant bit). They should be all acceptable
5358 * in file names. We do not validate the UTF-8 here, that's not
5359 * the job of this function.
5361 for (; *label
; label
++)
5362 if ((*label
& 0x80) || isalnum(*label
))
5363 strbuf_addch(buf
, *label
);
5364 /* avoid leading dash and double-dashes */
5365 else if (buf
->len
&& buf
->buf
[buf
->len
- 1] != '-')
5366 strbuf_addch(buf
, '-');
5368 strbuf_addstr(buf
, "rev-");
5369 strbuf_add_unique_abbrev(buf
, oid
, default_abbrev
);
5373 if ((buf
->len
== the_hash_algo
->hexsz
&&
5374 !get_oid_hex(label
, &dummy
)) ||
5375 (buf
->len
== 1 && *label
== '#') ||
5376 hashmap_get_from_hash(&state
->labels
,
5377 strihash(label
), label
)) {
5379 * If the label already exists, or if the label is a
5380 * valid full OID, or the label is a '#' (which we use
5381 * as a separator between merge heads and oneline), we
5382 * append a dash and a number to make it unique.
5384 size_t len
= buf
->len
;
5386 for (i
= 2; ; i
++) {
5387 strbuf_setlen(buf
, len
);
5388 strbuf_addf(buf
, "-%d", i
);
5389 if (!hashmap_get_from_hash(&state
->labels
,
5399 FLEX_ALLOC_STR(labels_entry
, label
, label
);
5400 hashmap_entry_init(&labels_entry
->entry
, strihash(label
));
5401 hashmap_add(&state
->labels
, &labels_entry
->entry
);
5403 FLEX_ALLOC_STR(string_entry
, string
, label
);
5404 oidcpy(&string_entry
->entry
.oid
, oid
);
5405 oidmap_put(&state
->commit2label
, string_entry
);
5407 return string_entry
->string
;
5410 static int make_script_with_merges(struct pretty_print_context
*pp
,
5411 struct rev_info
*revs
, struct strbuf
*out
,
5414 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5415 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
5416 int root_with_onto
= flags
& TODO_LIST_ROOT_WITH_ONTO
;
5417 int skipped_commit
= 0;
5418 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
5419 struct strbuf label
= STRBUF_INIT
;
5420 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
5421 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
5422 struct commit
*commit
;
5423 struct oidmap commit2todo
= OIDMAP_INIT
;
5424 struct string_entry
*entry
;
5425 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
5426 shown
= OIDSET_INIT
;
5427 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
5429 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
5430 const char *cmd_pick
= abbr
? "p" : "pick",
5431 *cmd_label
= abbr
? "l" : "label",
5432 *cmd_reset
= abbr
? "t" : "reset",
5433 *cmd_merge
= abbr
? "m" : "merge";
5435 oidmap_init(&commit2todo
, 0);
5436 oidmap_init(&state
.commit2label
, 0);
5437 hashmap_init(&state
.labels
, labels_cmp
, NULL
, 0);
5438 strbuf_init(&state
.buf
, 32);
5440 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
5441 struct labels_entry
*onto_label_entry
;
5442 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
5443 FLEX_ALLOC_STR(entry
, string
, "onto");
5444 oidcpy(&entry
->entry
.oid
, oid
);
5445 oidmap_put(&state
.commit2label
, entry
);
5447 FLEX_ALLOC_STR(onto_label_entry
, label
, "onto");
5448 hashmap_entry_init(&onto_label_entry
->entry
, strihash("onto"));
5449 hashmap_add(&state
.labels
, &onto_label_entry
->entry
);
5454 * - get onelines for all commits
5455 * - gather all branch tips (i.e. 2nd or later parents of merges)
5456 * - label all branch tips
5458 while ((commit
= get_revision(revs
))) {
5459 struct commit_list
*to_merge
;
5460 const char *p1
, *p2
;
5461 struct object_id
*oid
;
5464 tail
= &commit_list_insert(commit
, tail
)->next
;
5465 oidset_insert(&interesting
, &commit
->object
.oid
);
5467 is_empty
= is_original_commit_empty(commit
);
5468 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5469 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5470 warning(_("skipped previously applied commit %s"),
5471 short_commit_name(commit
));
5475 if (is_empty
&& !keep_empty
)
5478 strbuf_reset(&oneline
);
5479 pretty_print_commit(pp
, commit
, &oneline
);
5481 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
5483 /* non-merge commit: easy case */
5485 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
5486 oid_to_hex(&commit
->object
.oid
),
5489 strbuf_addf(&buf
, " %c empty",
5492 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5493 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5494 oidmap_put(&commit2todo
, entry
);
5499 /* Create a label */
5500 strbuf_reset(&label
);
5501 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
5502 (p1
= strchr(p1
, '\'')) &&
5503 (p2
= strchr(++p1
, '\'')))
5504 strbuf_add(&label
, p1
, p2
- p1
);
5505 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
5507 (p1
= strstr(p1
, " from ")))
5508 strbuf_addstr(&label
, p1
+ strlen(" from "));
5510 strbuf_addbuf(&label
, &oneline
);
5513 strbuf_addf(&buf
, "%s -C %s",
5514 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
5516 /* label the tips of merged branches */
5517 for (; to_merge
; to_merge
= to_merge
->next
) {
5518 oid
= &to_merge
->item
->object
.oid
;
5519 strbuf_addch(&buf
, ' ');
5521 if (!oidset_contains(&interesting
, oid
)) {
5522 strbuf_addstr(&buf
, label_oid(oid
, NULL
,
5527 tips_tail
= &commit_list_insert(to_merge
->item
,
5530 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
5532 strbuf_addf(&buf
, " # %s", oneline
.buf
);
5534 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5535 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5536 oidmap_put(&commit2todo
, entry
);
5539 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5540 _("use --reapply-cherry-picks to include skipped commits"));
5544 * - label branch points
5545 * - add HEAD to the branch tips
5547 for (iter
= commits
; iter
; iter
= iter
->next
) {
5548 struct commit_list
*parent
= iter
->item
->parents
;
5549 for (; parent
; parent
= parent
->next
) {
5550 struct object_id
*oid
= &parent
->item
->object
.oid
;
5551 if (!oidset_contains(&interesting
, oid
))
5553 if (oidset_insert(&child_seen
, oid
))
5554 label_oid(oid
, "branch-point", &state
);
5557 /* Add HEAD as implicit "tip of branch" */
5559 tips_tail
= &commit_list_insert(iter
->item
,
5564 * Third phase: output the todo list. This is a bit tricky, as we
5565 * want to avoid jumping back and forth between revisions. To
5566 * accomplish that goal, we walk backwards from the branch tips,
5567 * gathering commits not yet shown, reversing the list on the fly,
5568 * then outputting that list (labeling revisions as needed).
5570 strbuf_addf(out
, "%s onto\n", cmd_label
);
5571 for (iter
= tips
; iter
; iter
= iter
->next
) {
5572 struct commit_list
*list
= NULL
, *iter2
;
5574 commit
= iter
->item
;
5575 if (oidset_contains(&shown
, &commit
->object
.oid
))
5577 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
5580 strbuf_addf(out
, "\n%c Branch %s\n", comment_line_char
, entry
->string
);
5582 strbuf_addch(out
, '\n');
5584 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
5585 !oidset_contains(&shown
, &commit
->object
.oid
)) {
5586 commit_list_insert(commit
, &list
);
5587 if (!commit
->parents
) {
5591 commit
= commit
->parents
->item
;
5595 strbuf_addf(out
, "%s %s\n", cmd_reset
,
5596 rebase_cousins
|| root_with_onto
?
5597 "onto" : "[new root]");
5599 const char *to
= NULL
;
5601 entry
= oidmap_get(&state
.commit2label
,
5602 &commit
->object
.oid
);
5605 else if (!rebase_cousins
)
5606 to
= label_oid(&commit
->object
.oid
, NULL
,
5609 if (!to
|| !strcmp(to
, "onto"))
5610 strbuf_addf(out
, "%s onto\n", cmd_reset
);
5612 strbuf_reset(&oneline
);
5613 pretty_print_commit(pp
, commit
, &oneline
);
5614 strbuf_addf(out
, "%s %s # %s\n",
5615 cmd_reset
, to
, oneline
.buf
);
5619 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
5620 struct object_id
*oid
= &iter2
->item
->object
.oid
;
5621 entry
= oidmap_get(&commit2todo
, oid
);
5622 /* only show if not already upstream */
5624 strbuf_addf(out
, "%s\n", entry
->string
);
5625 entry
= oidmap_get(&state
.commit2label
, oid
);
5627 strbuf_addf(out
, "%s %s\n",
5628 cmd_label
, entry
->string
);
5629 oidset_insert(&shown
, oid
);
5632 free_commit_list(list
);
5635 free_commit_list(commits
);
5636 free_commit_list(tips
);
5638 strbuf_release(&label
);
5639 strbuf_release(&oneline
);
5640 strbuf_release(&buf
);
5642 oidmap_free(&commit2todo
, 1);
5643 oidmap_free(&state
.commit2label
, 1);
5644 hashmap_clear_and_free(&state
.labels
, struct labels_entry
, entry
);
5645 strbuf_release(&state
.buf
);
5650 int sequencer_make_script(struct repository
*r
, struct strbuf
*out
, int argc
,
5651 const char **argv
, unsigned flags
)
5653 char *format
= NULL
;
5654 struct pretty_print_context pp
= {0};
5655 struct rev_info revs
;
5656 struct commit
*commit
;
5657 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5658 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
5659 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
5660 int reapply_cherry_picks
= flags
& TODO_LIST_REAPPLY_CHERRY_PICKS
;
5661 int skipped_commit
= 0;
5664 repo_init_revisions(r
, &revs
, NULL
);
5665 revs
.verbose_header
= 1;
5667 revs
.max_parents
= 1;
5668 revs
.cherry_mark
= !reapply_cherry_picks
;
5671 revs
.right_only
= 1;
5672 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
5673 revs
.topo_order
= 1;
5675 revs
.pretty_given
= 1;
5676 git_config_get_string("rebase.instructionFormat", &format
);
5677 if (!format
|| !*format
) {
5679 format
= xstrdup("%s");
5681 get_commit_format(format
, &revs
);
5683 pp
.fmt
= revs
.commit_format
;
5684 pp
.output_encoding
= get_log_output_encoding();
5686 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1) {
5687 ret
= error(_("make_script: unhandled options"));
5691 if (prepare_revision_walk(&revs
) < 0) {
5692 ret
= error(_("make_script: error preparing revisions"));
5696 if (rebase_merges
) {
5697 ret
= make_script_with_merges(&pp
, &revs
, out
, flags
);
5701 while ((commit
= get_revision(&revs
))) {
5702 int is_empty
= is_original_commit_empty(commit
);
5704 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5705 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5706 warning(_("skipped previously applied commit %s"),
5707 short_commit_name(commit
));
5711 if (is_empty
&& !keep_empty
)
5713 strbuf_addf(out
, "%s %s ", insn
,
5714 oid_to_hex(&commit
->object
.oid
));
5715 pretty_print_commit(&pp
, commit
, out
);
5717 strbuf_addf(out
, " %c empty", comment_line_char
);
5718 strbuf_addch(out
, '\n');
5721 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5722 _("use --reapply-cherry-picks to include skipped commits"));
5724 release_revisions(&revs
);
5729 * Add commands after pick and (series of) squash/fixup commands
5732 static void todo_list_add_exec_commands(struct todo_list
*todo_list
,
5733 struct string_list
*commands
)
5735 struct strbuf
*buf
= &todo_list
->buf
;
5736 size_t base_offset
= buf
->len
;
5737 int i
, insert
, nr
= 0, alloc
= 0;
5738 struct todo_item
*items
= NULL
, *base_items
= NULL
;
5740 CALLOC_ARRAY(base_items
, commands
->nr
);
5741 for (i
= 0; i
< commands
->nr
; i
++) {
5742 size_t command_len
= strlen(commands
->items
[i
].string
);
5744 strbuf_addstr(buf
, commands
->items
[i
].string
);
5745 strbuf_addch(buf
, '\n');
5747 base_items
[i
].command
= TODO_EXEC
;
5748 base_items
[i
].offset_in_buf
= base_offset
;
5749 base_items
[i
].arg_offset
= base_offset
+ strlen("exec ");
5750 base_items
[i
].arg_len
= command_len
- strlen("exec ");
5752 base_offset
+= command_len
+ 1;
5756 * Insert <commands> after every pick. Here, fixup/squash chains
5757 * are considered part of the pick, so we insert the commands *after*
5758 * those chains if there are any.
5760 * As we insert the exec commands immediately after rearranging
5761 * any fixups and before the user edits the list, a fixup chain
5762 * can never contain comments (any comments are empty picks that
5763 * have been commented out because the user did not specify
5764 * --keep-empty). So, it is safe to insert an exec command
5765 * without looking at the command following a comment.
5768 for (i
= 0; i
< todo_list
->nr
; i
++) {
5769 enum todo_command command
= todo_list
->items
[i
].command
;
5770 if (insert
&& !is_fixup(command
)) {
5771 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5772 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5778 ALLOC_GROW(items
, nr
+ 1, alloc
);
5779 items
[nr
++] = todo_list
->items
[i
];
5781 if (command
== TODO_PICK
|| command
== TODO_MERGE
)
5785 /* insert or append final <commands> */
5787 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5788 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5793 FREE_AND_NULL(todo_list
->items
);
5794 todo_list
->items
= items
;
5796 todo_list
->alloc
= alloc
;
5799 static void todo_list_to_strbuf(struct repository
*r
, struct todo_list
*todo_list
,
5800 struct strbuf
*buf
, int num
, unsigned flags
)
5802 struct todo_item
*item
;
5803 int i
, max
= todo_list
->nr
;
5805 if (num
> 0 && num
< max
)
5808 for (item
= todo_list
->items
, i
= 0; i
< max
; i
++, item
++) {
5811 /* if the item is not a command write it and continue */
5812 if (item
->command
>= TODO_COMMENT
) {
5813 strbuf_addf(buf
, "%.*s\n", item
->arg_len
,
5814 todo_item_get_arg(todo_list
, item
));
5818 /* add command to the buffer */
5819 cmd
= command_to_char(item
->command
);
5820 if ((flags
& TODO_LIST_ABBREVIATE_CMDS
) && cmd
)
5821 strbuf_addch(buf
, cmd
);
5823 strbuf_addstr(buf
, command_to_string(item
->command
));
5827 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
5828 short_commit_name(item
->commit
) :
5829 oid_to_hex(&item
->commit
->object
.oid
);
5831 if (item
->command
== TODO_FIXUP
) {
5832 if (item
->flags
& TODO_EDIT_FIXUP_MSG
)
5833 strbuf_addstr(buf
, " -c");
5834 else if (item
->flags
& TODO_REPLACE_FIXUP_MSG
) {
5835 strbuf_addstr(buf
, " -C");
5839 if (item
->command
== TODO_MERGE
) {
5840 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
5841 strbuf_addstr(buf
, " -c");
5843 strbuf_addstr(buf
, " -C");
5846 strbuf_addf(buf
, " %s", oid
);
5849 /* add all the rest */
5851 strbuf_addch(buf
, '\n');
5853 strbuf_addf(buf
, " %.*s\n", item
->arg_len
,
5854 todo_item_get_arg(todo_list
, item
));
5858 int todo_list_write_to_file(struct repository
*r
, struct todo_list
*todo_list
,
5859 const char *file
, const char *shortrevisions
,
5860 const char *shortonto
, int num
, unsigned flags
)
5863 struct strbuf buf
= STRBUF_INIT
;
5865 todo_list_to_strbuf(r
, todo_list
, &buf
, num
, flags
);
5866 if (flags
& TODO_LIST_APPEND_TODO_HELP
)
5867 append_todo_help(count_commands(todo_list
),
5868 shortrevisions
, shortonto
, &buf
);
5870 res
= write_message(buf
.buf
, buf
.len
, file
, 0);
5871 strbuf_release(&buf
);
5876 /* skip picking commits whose parents are unchanged */
5877 static int skip_unnecessary_picks(struct repository
*r
,
5878 struct todo_list
*todo_list
,
5879 struct object_id
*base_oid
)
5881 struct object_id
*parent_oid
;
5884 for (i
= 0; i
< todo_list
->nr
; i
++) {
5885 struct todo_item
*item
= todo_list
->items
+ i
;
5887 if (item
->command
>= TODO_NOOP
)
5889 if (item
->command
!= TODO_PICK
)
5891 if (parse_commit(item
->commit
)) {
5892 return error(_("could not parse commit '%s'"),
5893 oid_to_hex(&item
->commit
->object
.oid
));
5895 if (!item
->commit
->parents
)
5896 break; /* root commit */
5897 if (item
->commit
->parents
->next
)
5898 break; /* merge commit */
5899 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
5900 if (!oideq(parent_oid
, base_oid
))
5902 oidcpy(base_oid
, &item
->commit
->object
.oid
);
5905 const char *done_path
= rebase_path_done();
5907 if (todo_list_write_to_file(r
, todo_list
, done_path
, NULL
, NULL
, i
, 0)) {
5908 error_errno(_("could not write to '%s'"), done_path
);
5912 MOVE_ARRAY(todo_list
->items
, todo_list
->items
+ i
, todo_list
->nr
- i
);
5914 todo_list
->current
= 0;
5915 todo_list
->done_nr
+= i
;
5917 if (is_fixup(peek_command(todo_list
, 0)))
5918 record_in_rewritten(base_oid
, peek_command(todo_list
, 0));
5924 struct todo_add_branch_context
{
5925 struct todo_item
*items
;
5929 struct commit
*commit
;
5930 struct string_list refs_to_oids
;
5933 static int add_decorations_to_list(const struct commit
*commit
,
5934 struct todo_add_branch_context
*ctx
)
5936 const struct name_decoration
*decoration
= get_name_decoration(&commit
->object
);
5937 const char *head_ref
= resolve_ref_unsafe("HEAD",
5938 RESOLVE_REF_READING
,
5942 while (decoration
) {
5943 struct todo_item
*item
;
5945 size_t base_offset
= ctx
->buf
->len
;
5948 * If the branch is the current HEAD, then it will be
5949 * updated by the default rebase behavior.
5951 if (head_ref
&& !strcmp(head_ref
, decoration
->name
)) {
5952 decoration
= decoration
->next
;
5956 ALLOC_GROW(ctx
->items
,
5959 item
= &ctx
->items
[ctx
->items_nr
];
5960 memset(item
, 0, sizeof(*item
));
5962 /* If the branch is checked out, then leave a comment instead. */
5963 if ((path
= branch_checked_out(decoration
->name
))) {
5964 item
->command
= TODO_COMMENT
;
5965 strbuf_addf(ctx
->buf
, "# Ref %s checked out at '%s'\n",
5966 decoration
->name
, path
);
5968 struct string_list_item
*sti
;
5969 item
->command
= TODO_UPDATE_REF
;
5970 strbuf_addf(ctx
->buf
, "%s\n", decoration
->name
);
5972 sti
= string_list_insert(&ctx
->refs_to_oids
,
5974 sti
->util
= init_update_ref_record(decoration
->name
);
5977 item
->offset_in_buf
= base_offset
;
5978 item
->arg_offset
= base_offset
;
5979 item
->arg_len
= ctx
->buf
->len
- base_offset
;
5982 decoration
= decoration
->next
;
5989 * For each 'pick' command, find out if the commit has a decoration in
5990 * refs/heads/. If so, then add a 'label for-update-refs/' command.
5992 static int todo_list_add_update_ref_commands(struct todo_list
*todo_list
)
5995 static struct string_list decorate_refs_exclude
= STRING_LIST_INIT_NODUP
;
5996 static struct string_list decorate_refs_exclude_config
= STRING_LIST_INIT_NODUP
;
5997 static struct string_list decorate_refs_include
= STRING_LIST_INIT_NODUP
;
5998 struct decoration_filter decoration_filter
= {
5999 .include_ref_pattern
= &decorate_refs_include
,
6000 .exclude_ref_pattern
= &decorate_refs_exclude
,
6001 .exclude_ref_config_pattern
= &decorate_refs_exclude_config
,
6003 struct todo_add_branch_context ctx
= {
6004 .buf
= &todo_list
->buf
,
6005 .refs_to_oids
= STRING_LIST_INIT_DUP
,
6008 ctx
.items_alloc
= 2 * todo_list
->nr
+ 1;
6009 ALLOC_ARRAY(ctx
.items
, ctx
.items_alloc
);
6011 string_list_append(&decorate_refs_include
, "refs/heads/");
6012 load_ref_decorations(&decoration_filter
, 0);
6014 for (i
= 0; i
< todo_list
->nr
; ) {
6015 struct todo_item
*item
= &todo_list
->items
[i
];
6017 /* insert ith item into new list */
6018 ALLOC_GROW(ctx
.items
,
6022 ctx
.items
[ctx
.items_nr
++] = todo_list
->items
[i
++];
6025 ctx
.commit
= item
->commit
;
6026 add_decorations_to_list(item
->commit
, &ctx
);
6030 res
= write_update_refs_state(&ctx
.refs_to_oids
);
6032 string_list_clear(&ctx
.refs_to_oids
, 1);
6035 /* we failed, so clean up the new list. */
6040 free(todo_list
->items
);
6041 todo_list
->items
= ctx
.items
;
6042 todo_list
->nr
= ctx
.items_nr
;
6043 todo_list
->alloc
= ctx
.items_alloc
;
6048 int complete_action(struct repository
*r
, struct replay_opts
*opts
, unsigned flags
,
6049 const char *shortrevisions
, const char *onto_name
,
6050 struct commit
*onto
, const struct object_id
*orig_head
,
6051 struct string_list
*commands
, unsigned autosquash
,
6052 unsigned update_refs
,
6053 struct todo_list
*todo_list
)
6055 char shortonto
[GIT_MAX_HEXSZ
+ 1];
6056 const char *todo_file
= rebase_path_todo();
6057 struct todo_list new_todo
= TODO_LIST_INIT
;
6058 struct strbuf
*buf
= &todo_list
->buf
, buf2
= STRBUF_INIT
;
6059 struct object_id oid
= onto
->object
.oid
;
6062 find_unique_abbrev_r(shortonto
, &oid
, DEFAULT_ABBREV
);
6064 if (buf
->len
== 0) {
6065 struct todo_item
*item
= append_new_todo(todo_list
);
6066 item
->command
= TODO_NOOP
;
6067 item
->commit
= NULL
;
6068 item
->arg_len
= item
->arg_offset
= item
->flags
= item
->offset_in_buf
= 0;
6071 if (update_refs
&& todo_list_add_update_ref_commands(todo_list
))
6074 if (autosquash
&& todo_list_rearrange_squash(todo_list
))
6078 todo_list_add_exec_commands(todo_list
, commands
);
6080 if (count_commands(todo_list
) == 0) {
6081 apply_autostash(rebase_path_autostash());
6082 sequencer_remove_state(opts
);
6084 return error(_("nothing to do"));
6087 res
= edit_todo_list(r
, todo_list
, &new_todo
, shortrevisions
,
6091 else if (res
== -2) {
6092 apply_autostash(rebase_path_autostash());
6093 sequencer_remove_state(opts
);
6096 } else if (res
== -3) {
6097 apply_autostash(rebase_path_autostash());
6098 sequencer_remove_state(opts
);
6099 todo_list_release(&new_todo
);
6101 return error(_("nothing to do"));
6102 } else if (res
== -4) {
6103 checkout_onto(r
, opts
, onto_name
, &onto
->object
.oid
, orig_head
);
6104 todo_list_release(&new_todo
);
6109 /* Expand the commit IDs */
6110 todo_list_to_strbuf(r
, &new_todo
, &buf2
, -1, 0);
6111 strbuf_swap(&new_todo
.buf
, &buf2
);
6112 strbuf_release(&buf2
);
6113 new_todo
.total_nr
-= new_todo
.nr
;
6114 if (todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
) < 0)
6115 BUG("invalid todo list after expanding IDs:\n%s",
6118 if (opts
->allow_ff
&& skip_unnecessary_picks(r
, &new_todo
, &oid
)) {
6119 todo_list_release(&new_todo
);
6120 return error(_("could not skip unnecessary pick commands"));
6123 if (todo_list_write_to_file(r
, &new_todo
, todo_file
, NULL
, NULL
, -1,
6124 flags
& ~(TODO_LIST_SHORTEN_IDS
))) {
6125 todo_list_release(&new_todo
);
6126 return error_errno(_("could not write '%s'"), todo_file
);
6131 if (checkout_onto(r
, opts
, onto_name
, &oid
, orig_head
))
6134 if (require_clean_work_tree(r
, "rebase", "", 1, 1))
6137 todo_list_write_total_nr(&new_todo
);
6138 res
= pick_commits(r
, &new_todo
, opts
);
6141 todo_list_release(&new_todo
);
6146 struct subject2item_entry
{
6147 struct hashmap_entry entry
;
6149 char subject
[FLEX_ARRAY
];
6152 static int subject2item_cmp(const void *fndata UNUSED
,
6153 const struct hashmap_entry
*eptr
,
6154 const struct hashmap_entry
*entry_or_key
,
6157 const struct subject2item_entry
*a
, *b
;
6159 a
= container_of(eptr
, const struct subject2item_entry
, entry
);
6160 b
= container_of(entry_or_key
, const struct subject2item_entry
, entry
);
6162 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
6165 define_commit_slab(commit_todo_item
, struct todo_item
*);
6167 static int skip_fixupish(const char *subject
, const char **p
) {
6168 return skip_prefix(subject
, "fixup! ", p
) ||
6169 skip_prefix(subject
, "amend! ", p
) ||
6170 skip_prefix(subject
, "squash! ", p
);
6174 * Rearrange the todo list that has both "pick commit-id msg" and "pick
6175 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
6176 * after the former, and change "pick" to "fixup"/"squash".
6178 * Note that if the config has specified a custom instruction format, each log
6179 * message will have to be retrieved from the commit (as the oneline in the
6180 * script cannot be trusted) in order to normalize the autosquash arrangement.
6182 int todo_list_rearrange_squash(struct todo_list
*todo_list
)
6184 struct hashmap subject2item
;
6185 int rearranged
= 0, *next
, *tail
, i
, nr
= 0, alloc
= 0;
6187 struct commit_todo_item commit_todo
;
6188 struct todo_item
*items
= NULL
;
6190 init_commit_todo_item(&commit_todo
);
6192 * The hashmap maps onelines to the respective todo list index.
6194 * If any items need to be rearranged, the next[i] value will indicate
6195 * which item was moved directly after the i'th.
6197 * In that case, last[i] will indicate the index of the latest item to
6198 * be moved to appear after the i'th.
6200 hashmap_init(&subject2item
, subject2item_cmp
, NULL
, todo_list
->nr
);
6201 ALLOC_ARRAY(next
, todo_list
->nr
);
6202 ALLOC_ARRAY(tail
, todo_list
->nr
);
6203 ALLOC_ARRAY(subjects
, todo_list
->nr
);
6204 for (i
= 0; i
< todo_list
->nr
; i
++) {
6205 struct strbuf buf
= STRBUF_INIT
;
6206 struct todo_item
*item
= todo_list
->items
+ i
;
6207 const char *commit_buffer
, *subject
, *p
;
6210 struct subject2item_entry
*entry
;
6212 next
[i
] = tail
[i
] = -1;
6213 if (!item
->commit
|| item
->command
== TODO_DROP
) {
6218 if (is_fixup(item
->command
)) {
6219 clear_commit_todo_item(&commit_todo
);
6220 return error(_("the script was already rearranged."));
6223 parse_commit(item
->commit
);
6224 commit_buffer
= logmsg_reencode(item
->commit
, NULL
, "UTF-8");
6225 find_commit_subject(commit_buffer
, &subject
);
6226 format_subject(&buf
, subject
, " ");
6227 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
6228 unuse_commit_buffer(item
->commit
, commit_buffer
);
6229 if (skip_fixupish(subject
, &p
)) {
6230 struct commit
*commit2
;
6235 if (!skip_fixupish(p
, &p
))
6239 entry
= hashmap_get_entry_from_hash(&subject2item
,
6241 struct subject2item_entry
,
6244 /* found by title */
6246 else if (!strchr(p
, ' ') &&
6248 lookup_commit_reference_by_name(p
)) &&
6249 *commit_todo_item_at(&commit_todo
, commit2
))
6250 /* found by commit name */
6251 i2
= *commit_todo_item_at(&commit_todo
, commit2
)
6254 /* copy can be a prefix of the commit subject */
6255 for (i2
= 0; i2
< i
; i2
++)
6257 starts_with(subjects
[i2
], p
))
6265 if (starts_with(subject
, "fixup!")) {
6266 todo_list
->items
[i
].command
= TODO_FIXUP
;
6267 } else if (starts_with(subject
, "amend!")) {
6268 todo_list
->items
[i
].command
= TODO_FIXUP
;
6269 todo_list
->items
[i
].flags
= TODO_REPLACE_FIXUP_MSG
;
6271 todo_list
->items
[i
].command
= TODO_SQUASH
;
6277 next
[i
] = next
[tail
[i2
]];
6281 } else if (!hashmap_get_from_hash(&subject2item
,
6282 strhash(subject
), subject
)) {
6283 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
6285 hashmap_entry_init(&entry
->entry
,
6286 strhash(entry
->subject
));
6287 hashmap_put(&subject2item
, &entry
->entry
);
6290 *commit_todo_item_at(&commit_todo
, item
->commit
) = item
;
6294 for (i
= 0; i
< todo_list
->nr
; i
++) {
6295 enum todo_command command
= todo_list
->items
[i
].command
;
6299 * Initially, all commands are 'pick's. If it is a
6300 * fixup or a squash now, we have rearranged it.
6302 if (is_fixup(command
))
6306 ALLOC_GROW(items
, nr
+ 1, alloc
);
6307 items
[nr
++] = todo_list
->items
[cur
];
6312 FREE_AND_NULL(todo_list
->items
);
6313 todo_list
->items
= items
;
6315 todo_list
->alloc
= alloc
;
6320 for (i
= 0; i
< todo_list
->nr
; i
++)
6323 hashmap_clear_and_free(&subject2item
, struct subject2item_entry
, entry
);
6325 clear_commit_todo_item(&commit_todo
);
6330 int sequencer_determine_whence(struct repository
*r
, enum commit_whence
*whence
)
6332 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
6333 struct object_id cherry_pick_head
, rebase_head
;
6335 if (file_exists(git_path_seq_dir()))
6336 *whence
= FROM_CHERRY_PICK_MULTI
;
6337 if (file_exists(rebase_path()) &&
6338 !get_oid("REBASE_HEAD", &rebase_head
) &&
6339 !get_oid("CHERRY_PICK_HEAD", &cherry_pick_head
) &&
6340 oideq(&rebase_head
, &cherry_pick_head
))
6341 *whence
= FROM_REBASE_PICK
;
6343 *whence
= FROM_CHERRY_PICK_SINGLE
;
6351 int sequencer_get_update_refs_state(const char *wt_dir
,
6352 struct string_list
*refs
)
6356 struct strbuf ref
= STRBUF_INIT
;
6357 struct strbuf hash
= STRBUF_INIT
;
6358 struct update_ref_record
*rec
= NULL
;
6360 char *path
= rebase_path_update_refs(wt_dir
);
6362 fp
= fopen(path
, "r");
6366 while (strbuf_getline(&ref
, fp
) != EOF
) {
6367 struct string_list_item
*item
;
6369 CALLOC_ARRAY(rec
, 1);
6371 if (strbuf_getline(&hash
, fp
) == EOF
||
6372 get_oid_hex(hash
.buf
, &rec
->before
)) {
6373 warning(_("update-refs file at '%s' is invalid"),
6379 if (strbuf_getline(&hash
, fp
) == EOF
||
6380 get_oid_hex(hash
.buf
, &rec
->after
)) {
6381 warning(_("update-refs file at '%s' is invalid"),
6387 item
= string_list_insert(refs
, ref
.buf
);
6397 strbuf_release(&ref
);
6398 strbuf_release(&hash
);