7 #include "environment.h"
12 #include "object-file.h"
13 #include "object-name.h"
14 #include "object-store.h"
18 #include "sequencer.h"
20 #include "run-command.h"
24 #include "cache-tree.h"
28 #include "merge-ort.h"
29 #include "merge-ort-wrappers.h"
35 #include "wt-status.h"
37 #include "notes-utils.h"
39 #include "unpack-trees.h"
43 #include "commit-slab.h"
45 #include "commit-reach.h"
46 #include "rebase-interactive.h"
51 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
53 static const char sign_off_header
[] = "Signed-off-by: ";
54 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
56 GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
58 static GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
60 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
61 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
62 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
63 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
65 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
67 * The file containing rebase commands, comments, and empty lines.
68 * This file is created by "git rebase -i" then edited by the user. As
69 * the lines are processed, they are removed from the front of this
70 * file and written to the tail of 'done'.
72 GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
73 GIT_PATH_FUNC(rebase_path_todo_backup
, "rebase-merge/git-rebase-todo.backup")
75 GIT_PATH_FUNC(rebase_path_dropped
, "rebase-merge/dropped")
78 * The rebase command lines that have already been processed. A line
79 * is moved here when it is first handled, before any associated user
82 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
84 * The file to keep track of how many commands were already processed (e.g.
87 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum")
89 * The file to keep track of how many commands are to be processed in total
90 * (e.g. for the prompt).
92 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end")
94 * The commit message that is planned to be used for any changes that
95 * need to be committed following a user interaction.
97 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
99 * The file into which is accumulated the suggested commit message for
100 * squash/fixup commands. When the first of a series of squash/fixups
101 * is seen, the file is created and the commit message from the
102 * previous commit and from the first squash/fixup commit are written
103 * to it. The commit message for each subsequent squash/fixup commit
104 * is appended to the file as it is processed.
106 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
108 * If the current series of squash/fixups has not yet included a squash
109 * command, then this file exists and holds the commit message of the
110 * original "pick" commit. (If the series ends without a "squash"
111 * command, then this can be used as the commit message of the combined
112 * commit without opening the editor.)
114 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
116 * This file contains the list fixup/squash commands that have been
117 * accumulated into message-fixup or message-squash so far.
119 static GIT_PATH_FUNC(rebase_path_current_fixups
, "rebase-merge/current-fixups")
121 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
122 * GIT_AUTHOR_DATE that will be used for the commit that is currently
125 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
127 * When an "edit" rebase command is being processed, the SHA1 of the
128 * commit to be edited is recorded in this file. When "git rebase
129 * --continue" is executed, if there are any staged changes then they
130 * will be amended to the HEAD commit, but only provided the HEAD
131 * commit is still the commit to be edited. When any other rebase
132 * command is processed, this file is deleted.
134 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
136 * When we stop at a given patch via the "edit" command, this file contains
137 * the commit object name of the corresponding patch.
139 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
141 * For the post-rewrite hook, we make a list of rewritten commits and
142 * their new sha1s. The rewritten-pending list keeps the sha1s of
143 * commits that have been processed, but not committed yet,
144 * e.g. because they are waiting for a 'squash' command.
146 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
147 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
148 "rebase-merge/rewritten-pending")
151 * The path of the file containing the OID of the "squash onto" commit, i.e.
152 * the dummy commit used for `reset [new root]`.
154 static GIT_PATH_FUNC(rebase_path_squash_onto
, "rebase-merge/squash-onto")
157 * The path of the file listing refs that need to be deleted after the rebase
158 * finishes. This is used by the `label` command to record the need for cleanup.
160 static GIT_PATH_FUNC(rebase_path_refs_to_delete
, "rebase-merge/refs-to-delete")
163 * The update-refs file stores a list of refs that will be updated at the end
164 * of the rebase sequence. The 'update-ref <ref>' commands in the todo file
165 * update the OIDs for the refs in this file, but the refs are not updated
166 * until the end of the rebase sequence.
168 * rebase_path_update_refs() returns the path to this file for a given
169 * worktree directory. For the current worktree, pass the_repository->gitdir.
171 static char *rebase_path_update_refs(const char *wt_git_dir
)
173 return xstrfmt("%s/rebase-merge/update-refs", wt_git_dir
);
177 * The following files are written by git-rebase just after parsing the
180 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
181 static GIT_PATH_FUNC(rebase_path_cdate_is_adate
, "rebase-merge/cdate_is_adate")
182 static GIT_PATH_FUNC(rebase_path_ignore_date
, "rebase-merge/ignore_date")
183 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
184 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
185 static GIT_PATH_FUNC(rebase_path_quiet
, "rebase-merge/quiet")
186 static GIT_PATH_FUNC(rebase_path_signoff
, "rebase-merge/signoff")
187 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
188 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
189 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
190 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
191 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
192 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
193 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec
, "rebase-merge/reschedule-failed-exec")
194 static GIT_PATH_FUNC(rebase_path_no_reschedule_failed_exec
, "rebase-merge/no-reschedule-failed-exec")
195 static GIT_PATH_FUNC(rebase_path_drop_redundant_commits
, "rebase-merge/drop_redundant_commits")
196 static GIT_PATH_FUNC(rebase_path_keep_redundant_commits
, "rebase-merge/keep_redundant_commits")
199 * A 'struct update_refs_record' represents a value in the update-refs
200 * list. We use a string_list to map refs to these (before, after) pairs.
202 struct update_ref_record
{
203 struct object_id before
;
204 struct object_id after
;
207 static struct update_ref_record
*init_update_ref_record(const char *ref
)
209 struct update_ref_record
*rec
;
211 CALLOC_ARRAY(rec
, 1);
213 oidcpy(&rec
->before
, null_oid());
214 oidcpy(&rec
->after
, null_oid());
216 /* This may fail, but that's fine, we will keep the null OID. */
217 read_ref(ref
, &rec
->before
);
222 static int git_sequencer_config(const char *k
, const char *v
, void *cb
)
224 struct replay_opts
*opts
= cb
;
227 if (!strcmp(k
, "commit.cleanup")) {
230 status
= git_config_string(&s
, k
, v
);
234 if (!strcmp(s
, "verbatim")) {
235 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
236 opts
->explicit_cleanup
= 1;
237 } else if (!strcmp(s
, "whitespace")) {
238 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
239 opts
->explicit_cleanup
= 1;
240 } else if (!strcmp(s
, "strip")) {
241 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_ALL
;
242 opts
->explicit_cleanup
= 1;
243 } else if (!strcmp(s
, "scissors")) {
244 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SCISSORS
;
245 opts
->explicit_cleanup
= 1;
247 warning(_("invalid commit message cleanup mode '%s'"),
255 if (!strcmp(k
, "commit.gpgsign")) {
256 opts
->gpg_sign
= git_config_bool(k
, v
) ? xstrdup("") : NULL
;
260 if (!opts
->default_strategy
&& !strcmp(k
, "pull.twohead")) {
261 int ret
= git_config_string((const char**)&opts
->default_strategy
, k
, v
);
264 * pull.twohead is allowed to be multi-valued; we only
265 * care about the first value.
267 char *tmp
= strchr(opts
->default_strategy
, ' ');
274 if (opts
->action
== REPLAY_REVERT
&& !strcmp(k
, "revert.reference"))
275 opts
->commit_use_reference
= git_config_bool(k
, v
);
277 return git_diff_basic_config(k
, v
, NULL
);
280 void sequencer_init_config(struct replay_opts
*opts
)
282 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
283 git_config(git_sequencer_config
, opts
);
286 static inline int is_rebase_i(const struct replay_opts
*opts
)
288 return opts
->action
== REPLAY_INTERACTIVE_REBASE
;
291 static const char *get_dir(const struct replay_opts
*opts
)
293 if (is_rebase_i(opts
))
294 return rebase_path();
295 return git_path_seq_dir();
298 static const char *get_todo_path(const struct replay_opts
*opts
)
300 if (is_rebase_i(opts
))
301 return rebase_path_todo();
302 return git_path_todo_file();
306 * Returns 0 for non-conforming footer
307 * Returns 1 for conforming footer
308 * Returns 2 when sob exists within conforming footer
309 * Returns 3 when sob exists within conforming footer as last entry
311 static int has_conforming_footer(struct strbuf
*sb
, struct strbuf
*sob
,
312 size_t ignore_footer
)
314 struct process_trailer_options opts
= PROCESS_TRAILER_OPTIONS_INIT
;
315 struct trailer_info info
;
317 int found_sob
= 0, found_sob_last
= 0;
323 saved_char
= sb
->buf
[sb
->len
- ignore_footer
];
324 sb
->buf
[sb
->len
- ignore_footer
] = '\0';
327 trailer_info_get(&info
, sb
->buf
, &opts
);
330 sb
->buf
[sb
->len
- ignore_footer
] = saved_char
;
332 if (info
.trailer_start
== info
.trailer_end
)
335 for (i
= 0; i
< info
.trailer_nr
; i
++)
336 if (sob
&& !strncmp(info
.trailers
[i
], sob
->buf
, sob
->len
)) {
338 if (i
== info
.trailer_nr
- 1)
342 trailer_info_release(&info
);
351 static const char *gpg_sign_opt_quoted(struct replay_opts
*opts
)
353 static struct strbuf buf
= STRBUF_INIT
;
357 sq_quotef(&buf
, "-S%s", opts
->gpg_sign
);
361 void replay_opts_release(struct replay_opts
*opts
)
363 free(opts
->gpg_sign
);
364 free(opts
->reflog_action
);
365 free(opts
->default_strategy
);
366 free(opts
->strategy
);
367 strvec_clear (&opts
->xopts
);
368 strbuf_release(&opts
->current_fixups
);
370 release_revisions(opts
->revs
);
374 int sequencer_remove_state(struct replay_opts
*opts
)
376 struct strbuf buf
= STRBUF_INIT
;
379 if (is_rebase_i(opts
) &&
380 strbuf_read_file(&buf
, rebase_path_refs_to_delete(), 0) > 0) {
383 char *eol
= strchr(p
, '\n');
386 if (delete_ref("(rebase) cleanup", p
, NULL
, 0) < 0) {
387 warning(_("could not delete '%s'"), p
);
397 strbuf_addstr(&buf
, get_dir(opts
));
398 if (remove_dir_recursively(&buf
, 0))
399 ret
= error(_("could not remove '%s'"), buf
.buf
);
400 strbuf_release(&buf
);
405 static const char *action_name(const struct replay_opts
*opts
)
407 switch (opts
->action
) {
411 return N_("cherry-pick");
412 case REPLAY_INTERACTIVE_REBASE
:
415 die(_("unknown action: %d"), opts
->action
);
418 struct commit_message
{
425 static const char *short_commit_name(struct commit
*commit
)
427 return repo_find_unique_abbrev(the_repository
, &commit
->object
.oid
,
431 static int get_message(struct commit
*commit
, struct commit_message
*out
)
433 const char *abbrev
, *subject
;
436 out
->message
= repo_logmsg_reencode(the_repository
, commit
, NULL
,
437 get_commit_output_encoding());
438 abbrev
= short_commit_name(commit
);
440 subject_len
= find_commit_subject(out
->message
, &subject
);
442 out
->subject
= xmemdupz(subject
, subject_len
);
443 out
->label
= xstrfmt("%s (%s)", abbrev
, out
->subject
);
444 out
->parent_label
= xstrfmt("parent of %s", out
->label
);
449 static void free_message(struct commit
*commit
, struct commit_message
*msg
)
451 free(msg
->parent_label
);
454 repo_unuse_commit_buffer(the_repository
, commit
, msg
->message
);
457 static void print_advice(struct repository
*r
, int show_hint
,
458 struct replay_opts
*opts
)
460 char *msg
= getenv("GIT_CHERRY_PICK_HELP");
465 * A conflict has occurred but the porcelain
466 * (typically rebase --interactive) wants to take care
467 * of the commit itself so remove CHERRY_PICK_HEAD
469 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
476 advise(_("after resolving the conflicts, mark the corrected paths\n"
477 "with 'git add <paths>' or 'git rm <paths>'"));
478 else if (opts
->action
== REPLAY_PICK
)
479 advise(_("After resolving the conflicts, mark them with\n"
480 "\"git add/rm <pathspec>\", then run\n"
481 "\"git cherry-pick --continue\".\n"
482 "You can instead skip this commit with \"git cherry-pick --skip\".\n"
483 "To abort and get back to the state before \"git cherry-pick\",\n"
484 "run \"git cherry-pick --abort\"."));
485 else if (opts
->action
== REPLAY_REVERT
)
486 advise(_("After resolving the conflicts, mark them with\n"
487 "\"git add/rm <pathspec>\", then run\n"
488 "\"git revert --continue\".\n"
489 "You can instead skip this commit with \"git revert --skip\".\n"
490 "To abort and get back to the state before \"git revert\",\n"
491 "run \"git revert --abort\"."));
493 BUG("unexpected pick action in print_advice()");
497 static int write_message(const void *buf
, size_t len
, const char *filename
,
500 struct lock_file msg_file
= LOCK_INIT
;
502 int msg_fd
= hold_lock_file_for_update(&msg_file
, filename
, 0);
504 return error_errno(_("could not lock '%s'"), filename
);
505 if (write_in_full(msg_fd
, buf
, len
) < 0) {
506 error_errno(_("could not write to '%s'"), filename
);
507 rollback_lock_file(&msg_file
);
510 if (append_eol
&& write(msg_fd
, "\n", 1) < 0) {
511 error_errno(_("could not write eol to '%s'"), filename
);
512 rollback_lock_file(&msg_file
);
515 if (commit_lock_file(&msg_file
) < 0)
516 return error(_("failed to finalize '%s'"), filename
);
521 int read_oneliner(struct strbuf
*buf
,
522 const char *path
, unsigned flags
)
524 int orig_len
= buf
->len
;
526 if (strbuf_read_file(buf
, path
, 0) < 0) {
527 if ((flags
& READ_ONELINER_WARN_MISSING
) ||
528 (errno
!= ENOENT
&& errno
!= ENOTDIR
))
529 warning_errno(_("could not read '%s'"), path
);
533 if (buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\n') {
534 if (--buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\r')
536 buf
->buf
[buf
->len
] = '\0';
539 if ((flags
& READ_ONELINER_SKIP_IF_EMPTY
) && buf
->len
== orig_len
)
545 static struct tree
*empty_tree(struct repository
*r
)
547 return lookup_tree(r
, the_hash_algo
->empty_tree
);
550 static int error_dirty_index(struct repository
*repo
, struct replay_opts
*opts
)
552 if (repo_read_index_unmerged(repo
))
553 return error_resolve_conflict(action_name(opts
));
555 error(_("your local changes would be overwritten by %s."),
556 _(action_name(opts
)));
558 if (advice_enabled(ADVICE_COMMIT_BEFORE_MERGE
))
559 advise(_("commit your changes or stash them to proceed."));
563 static void update_abort_safety_file(void)
565 struct object_id head
;
567 /* Do nothing on a single-pick */
568 if (!file_exists(git_path_seq_dir()))
571 if (!repo_get_oid(the_repository
, "HEAD", &head
))
572 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head
));
574 write_file(git_path_abort_safety_file(), "%s", "");
577 static int fast_forward_to(struct repository
*r
,
578 const struct object_id
*to
,
579 const struct object_id
*from
,
581 struct replay_opts
*opts
)
583 struct ref_transaction
*transaction
;
584 struct strbuf sb
= STRBUF_INIT
;
585 struct strbuf err
= STRBUF_INIT
;
588 if (checkout_fast_forward(r
, from
, to
, 1))
589 return -1; /* the callee should have complained already */
591 strbuf_addf(&sb
, "%s: fast-forward", action_name(opts
));
593 transaction
= ref_transaction_begin(&err
);
595 ref_transaction_update(transaction
, "HEAD",
596 to
, unborn
&& !is_rebase_i(opts
) ?
599 ref_transaction_commit(transaction
, &err
)) {
600 ref_transaction_free(transaction
);
601 error("%s", err
.buf
);
603 strbuf_release(&err
);
608 strbuf_release(&err
);
609 ref_transaction_free(transaction
);
610 update_abort_safety_file();
614 enum commit_msg_cleanup_mode
get_cleanup_mode(const char *cleanup_arg
,
617 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
618 return use_editor
? COMMIT_MSG_CLEANUP_ALL
:
619 COMMIT_MSG_CLEANUP_SPACE
;
620 else if (!strcmp(cleanup_arg
, "verbatim"))
621 return COMMIT_MSG_CLEANUP_NONE
;
622 else if (!strcmp(cleanup_arg
, "whitespace"))
623 return COMMIT_MSG_CLEANUP_SPACE
;
624 else if (!strcmp(cleanup_arg
, "strip"))
625 return COMMIT_MSG_CLEANUP_ALL
;
626 else if (!strcmp(cleanup_arg
, "scissors"))
627 return use_editor
? COMMIT_MSG_CLEANUP_SCISSORS
:
628 COMMIT_MSG_CLEANUP_SPACE
;
630 die(_("Invalid cleanup mode %s"), cleanup_arg
);
634 * NB using int rather than enum cleanup_mode to stop clang's
635 * -Wtautological-constant-out-of-range-compare complaining that the comparison
638 static const char *describe_cleanup_mode(int cleanup_mode
)
640 static const char *modes
[] = { "whitespace",
645 if (cleanup_mode
< ARRAY_SIZE(modes
))
646 return modes
[cleanup_mode
];
648 BUG("invalid cleanup_mode provided (%d)", cleanup_mode
);
651 void append_conflicts_hint(struct index_state
*istate
,
652 struct strbuf
*msgbuf
, enum commit_msg_cleanup_mode cleanup_mode
)
656 if (cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
) {
657 strbuf_addch(msgbuf
, '\n');
658 wt_status_append_cut_line(msgbuf
);
659 strbuf_addch(msgbuf
, comment_line_char
);
662 strbuf_addch(msgbuf
, '\n');
663 strbuf_commented_addf(msgbuf
, "Conflicts:\n");
664 for (i
= 0; i
< istate
->cache_nr
;) {
665 const struct cache_entry
*ce
= istate
->cache
[i
++];
667 strbuf_commented_addf(msgbuf
, "\t%s\n", ce
->name
);
668 while (i
< istate
->cache_nr
&&
669 !strcmp(ce
->name
, istate
->cache
[i
]->name
))
675 static int do_recursive_merge(struct repository
*r
,
676 struct commit
*base
, struct commit
*next
,
677 const char *base_label
, const char *next_label
,
678 struct object_id
*head
, struct strbuf
*msgbuf
,
679 struct replay_opts
*opts
)
681 struct merge_options o
;
682 struct merge_result result
;
683 struct tree
*next_tree
, *base_tree
, *head_tree
;
684 int clean
, show_output
;
686 struct lock_file index_lock
= LOCK_INIT
;
688 if (repo_hold_locked_index(r
, &index_lock
, LOCK_REPORT_ON_ERROR
) < 0)
693 init_merge_options(&o
, r
);
694 o
.ancestor
= base
? base_label
: "(empty tree)";
696 o
.branch2
= next
? next_label
: "(empty tree)";
697 if (is_rebase_i(opts
))
699 o
.show_rename_progress
= 1;
701 head_tree
= parse_tree_indirect(head
);
702 next_tree
= next
? repo_get_commit_tree(r
, next
) : empty_tree(r
);
703 base_tree
= base
? repo_get_commit_tree(r
, base
) : empty_tree(r
);
705 for (i
= 0; i
< opts
->xopts
.nr
; i
++)
706 parse_merge_opt(&o
, opts
->xopts
.v
[i
]);
708 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
709 memset(&result
, 0, sizeof(result
));
710 merge_incore_nonrecursive(&o
, base_tree
, head_tree
, next_tree
,
712 show_output
= !is_rebase_i(opts
) || !result
.clean
;
714 * TODO: merge_switch_to_result will update index/working tree;
715 * we only really want to do that if !result.clean || this is
716 * the final patch to be picked. But determining this is the
717 * final patch would take some work, and "head_tree" would need
718 * to be replace with the tree the index matched before we
719 * started doing any picks.
721 merge_switch_to_result(&o
, head_tree
, &result
, 1, show_output
);
722 clean
= result
.clean
;
724 ensure_full_index(r
->index
);
725 clean
= merge_trees(&o
, head_tree
, next_tree
, base_tree
);
726 if (is_rebase_i(opts
) && clean
<= 0)
727 fputs(o
.obuf
.buf
, stdout
);
728 strbuf_release(&o
.obuf
);
731 rollback_lock_file(&index_lock
);
735 if (write_locked_index(r
->index
, &index_lock
,
736 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
738 * TRANSLATORS: %s will be "revert", "cherry-pick" or
741 return error(_("%s: Unable to write new index file"),
742 _(action_name(opts
)));
745 append_conflicts_hint(r
->index
, msgbuf
,
746 opts
->default_msg_cleanup
);
751 static struct object_id
*get_cache_tree_oid(struct index_state
*istate
)
753 if (!cache_tree_fully_valid(istate
->cache_tree
))
754 if (cache_tree_update(istate
, 0)) {
755 error(_("unable to update cache tree"));
759 return &istate
->cache_tree
->oid
;
762 static int is_index_unchanged(struct repository
*r
)
764 struct object_id head_oid
, *cache_tree_oid
;
765 struct commit
*head_commit
;
766 struct index_state
*istate
= r
->index
;
768 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
769 return error(_("could not resolve HEAD commit"));
771 head_commit
= lookup_commit(r
, &head_oid
);
774 * If head_commit is NULL, check_commit, called from
775 * lookup_commit, would have indicated that head_commit is not
776 * a commit object already. repo_parse_commit() will return failure
777 * without further complaints in such a case. Otherwise, if
778 * the commit is invalid, repo_parse_commit() will complain. So
779 * there is nothing for us to say here. Just return failure.
781 if (repo_parse_commit(r
, head_commit
))
784 if (!(cache_tree_oid
= get_cache_tree_oid(istate
)))
787 return oideq(cache_tree_oid
, get_commit_tree_oid(head_commit
));
790 static int write_author_script(const char *message
)
792 struct strbuf buf
= STRBUF_INIT
;
797 if (!*message
|| starts_with(message
, "\n")) {
799 /* Missing 'author' line? */
800 unlink(rebase_path_author_script());
802 } else if (skip_prefix(message
, "author ", &message
))
804 else if ((eol
= strchr(message
, '\n')))
809 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
810 while (*message
&& *message
!= '\n' && *message
!= '\r')
811 if (skip_prefix(message
, " <", &message
))
813 else if (*message
!= '\'')
814 strbuf_addch(&buf
, *(message
++));
816 strbuf_addf(&buf
, "'\\%c'", *(message
++));
817 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
818 while (*message
&& *message
!= '\n' && *message
!= '\r')
819 if (skip_prefix(message
, "> ", &message
))
821 else if (*message
!= '\'')
822 strbuf_addch(&buf
, *(message
++));
824 strbuf_addf(&buf
, "'\\%c'", *(message
++));
825 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
826 while (*message
&& *message
!= '\n' && *message
!= '\r')
827 if (*message
!= '\'')
828 strbuf_addch(&buf
, *(message
++));
830 strbuf_addf(&buf
, "'\\%c'", *(message
++));
831 strbuf_addch(&buf
, '\'');
832 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
833 strbuf_release(&buf
);
838 * Take a series of KEY='VALUE' lines where VALUE part is
839 * sq-quoted, and append <KEY, VALUE> at the end of the string list
841 static int parse_key_value_squoted(char *buf
, struct string_list
*list
)
844 struct string_list_item
*item
;
846 char *cp
= strchr(buf
, '=');
848 np
= strchrnul(buf
, '\n');
849 return error(_("no key present in '%.*s'"),
850 (int) (np
- buf
), buf
);
852 np
= strchrnul(cp
, '\n');
854 item
= string_list_append(list
, buf
);
856 buf
= np
+ (*np
== '\n');
860 return error(_("unable to dequote value of '%s'"),
862 item
->util
= xstrdup(cp
);
868 * Reads and parses the state directory's "author-script" file, and sets name,
869 * email and date accordingly.
870 * Returns 0 on success, -1 if the file could not be parsed.
872 * The author script is of the format:
874 * GIT_AUTHOR_NAME='$author_name'
875 * GIT_AUTHOR_EMAIL='$author_email'
876 * GIT_AUTHOR_DATE='$author_date'
878 * where $author_name, $author_email and $author_date are quoted. We are strict
879 * with our parsing, as the file was meant to be eval'd in the now-removed
880 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
881 * from what this function expects, it is better to bail out than to do
882 * something that the user does not expect.
884 int read_author_script(const char *path
, char **name
, char **email
, char **date
,
887 struct strbuf buf
= STRBUF_INIT
;
888 struct string_list kv
= STRING_LIST_INIT_DUP
;
889 int retval
= -1; /* assume failure */
890 int i
, name_i
= -2, email_i
= -2, date_i
= -2, err
= 0;
892 if (strbuf_read_file(&buf
, path
, 256) <= 0) {
893 strbuf_release(&buf
);
894 if (errno
== ENOENT
&& allow_missing
)
897 return error_errno(_("could not open '%s' for reading"),
901 if (parse_key_value_squoted(buf
.buf
, &kv
))
904 for (i
= 0; i
< kv
.nr
; i
++) {
905 if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_NAME")) {
907 name_i
= error(_("'GIT_AUTHOR_NAME' already given"));
910 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_EMAIL")) {
912 email_i
= error(_("'GIT_AUTHOR_EMAIL' already given"));
915 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_DATE")) {
917 date_i
= error(_("'GIT_AUTHOR_DATE' already given"));
921 err
= error(_("unknown variable '%s'"),
926 error(_("missing 'GIT_AUTHOR_NAME'"));
928 error(_("missing 'GIT_AUTHOR_EMAIL'"));
930 error(_("missing 'GIT_AUTHOR_DATE'"));
931 if (name_i
< 0 || email_i
< 0 || date_i
< 0 || err
)
933 *name
= kv
.items
[name_i
].util
;
934 *email
= kv
.items
[email_i
].util
;
935 *date
= kv
.items
[date_i
].util
;
938 string_list_clear(&kv
, !!retval
);
939 strbuf_release(&buf
);
944 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
945 * file with shell quoting into struct strvec. Returns -1 on
946 * error, 0 otherwise.
948 static int read_env_script(struct strvec
*env
)
950 char *name
, *email
, *date
;
952 if (read_author_script(rebase_path_author_script(),
953 &name
, &email
, &date
, 0))
956 strvec_pushf(env
, "GIT_AUTHOR_NAME=%s", name
);
957 strvec_pushf(env
, "GIT_AUTHOR_EMAIL=%s", email
);
958 strvec_pushf(env
, "GIT_AUTHOR_DATE=%s", date
);
966 static char *get_author(const char *message
)
971 a
= find_commit_header(message
, "author", &len
);
973 return xmemdupz(a
, len
);
978 static const char *author_date_from_env(const struct strvec
*env
)
983 for (i
= 0; i
< env
->nr
; i
++)
984 if (skip_prefix(env
->v
[i
],
985 "GIT_AUTHOR_DATE=", &date
))
988 * If GIT_AUTHOR_DATE is missing we should have already errored out when
991 BUG("GIT_AUTHOR_DATE missing from author script");
994 static const char staged_changes_advice
[] =
995 N_("you have staged changes in your working tree\n"
996 "If these changes are meant to be squashed into the previous commit, run:\n"
998 " git commit --amend %s\n"
1000 "If they are meant to go into a new commit, run:\n"
1004 "In both cases, once you're done, continue with:\n"
1006 " git rebase --continue\n");
1008 #define ALLOW_EMPTY (1<<0)
1009 #define EDIT_MSG (1<<1)
1010 #define AMEND_MSG (1<<2)
1011 #define CLEANUP_MSG (1<<3)
1012 #define VERIFY_MSG (1<<4)
1013 #define CREATE_ROOT_COMMIT (1<<5)
1014 #define VERBATIM_MSG (1<<6)
1016 static int run_command_silent_on_success(struct child_process
*cmd
)
1018 struct strbuf buf
= STRBUF_INIT
;
1021 cmd
->stdout_to_stderr
= 1;
1022 rc
= pipe_command(cmd
,
1028 fputs(buf
.buf
, stderr
);
1029 strbuf_release(&buf
);
1034 * If we are cherry-pick, and if the merge did not result in
1035 * hand-editing, we will hit this commit and inherit the original
1036 * author date and name.
1038 * If we are revert, or if our cherry-pick results in a hand merge,
1039 * we had better say that the current user is responsible for that.
1041 * An exception is when run_git_commit() is called during an
1042 * interactive rebase: in that case, we will want to retain the
1045 static int run_git_commit(const char *defmsg
,
1046 struct replay_opts
*opts
,
1049 struct child_process cmd
= CHILD_PROCESS_INIT
;
1051 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1052 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1056 if (is_rebase_i(opts
) &&
1057 ((opts
->committer_date_is_author_date
&& !opts
->ignore_date
) ||
1058 !(!defmsg
&& (flags
& AMEND_MSG
))) &&
1059 read_env_script(&cmd
.env
)) {
1060 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
1062 return error(_(staged_changes_advice
),
1066 strvec_pushf(&cmd
.env
, GIT_REFLOG_ACTION
"=%s", opts
->reflog_message
);
1068 if (opts
->committer_date_is_author_date
)
1069 strvec_pushf(&cmd
.env
, "GIT_COMMITTER_DATE=%s",
1072 author_date_from_env(&cmd
.env
));
1073 if (opts
->ignore_date
)
1074 strvec_push(&cmd
.env
, "GIT_AUTHOR_DATE=");
1076 strvec_push(&cmd
.args
, "commit");
1078 if (!(flags
& VERIFY_MSG
))
1079 strvec_push(&cmd
.args
, "-n");
1080 if ((flags
& AMEND_MSG
))
1081 strvec_push(&cmd
.args
, "--amend");
1083 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
1085 strvec_push(&cmd
.args
, "--no-gpg-sign");
1087 strvec_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
1088 else if (!(flags
& EDIT_MSG
))
1089 strvec_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
1090 if ((flags
& CLEANUP_MSG
))
1091 strvec_push(&cmd
.args
, "--cleanup=strip");
1092 if ((flags
& VERBATIM_MSG
))
1093 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1094 if ((flags
& EDIT_MSG
))
1095 strvec_push(&cmd
.args
, "-e");
1096 else if (!(flags
& CLEANUP_MSG
) &&
1097 !opts
->signoff
&& !opts
->record_origin
&&
1098 !opts
->explicit_cleanup
)
1099 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1101 if ((flags
& ALLOW_EMPTY
))
1102 strvec_push(&cmd
.args
, "--allow-empty");
1104 if (!(flags
& EDIT_MSG
))
1105 strvec_push(&cmd
.args
, "--allow-empty-message");
1107 if (is_rebase_i(opts
) && !(flags
& EDIT_MSG
))
1108 return run_command_silent_on_success(&cmd
);
1110 return run_command(&cmd
);
1113 static int rest_is_empty(const struct strbuf
*sb
, int start
)
1118 /* Check if the rest is just whitespace and Signed-off-by's. */
1119 for (i
= start
; i
< sb
->len
; i
++) {
1120 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1126 if (strlen(sign_off_header
) <= eol
- i
&&
1127 starts_with(sb
->buf
+ i
, sign_off_header
)) {
1132 if (!isspace(sb
->buf
[i
++]))
1139 void cleanup_message(struct strbuf
*msgbuf
,
1140 enum commit_msg_cleanup_mode cleanup_mode
, int verbose
)
1142 if (verbose
|| /* Truncate the message just before the diff, if any. */
1143 cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
1144 strbuf_setlen(msgbuf
, wt_status_locate_end(msgbuf
->buf
, msgbuf
->len
));
1145 if (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
)
1146 strbuf_stripspace(msgbuf
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1150 * Find out if the message in the strbuf contains only whitespace and
1151 * Signed-off-by lines.
1153 int message_is_empty(const struct strbuf
*sb
,
1154 enum commit_msg_cleanup_mode cleanup_mode
)
1156 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1158 return rest_is_empty(sb
, 0);
1162 * See if the user edited the message in the editor or left what
1163 * was in the template intact
1165 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
1166 enum commit_msg_cleanup_mode cleanup_mode
)
1168 struct strbuf tmpl
= STRBUF_INIT
;
1171 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1174 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
1177 strbuf_stripspace(&tmpl
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1178 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
1180 strbuf_release(&tmpl
);
1181 return rest_is_empty(sb
, start
- sb
->buf
);
1184 int update_head_with_reflog(const struct commit
*old_head
,
1185 const struct object_id
*new_head
,
1186 const char *action
, const struct strbuf
*msg
,
1189 struct ref_transaction
*transaction
;
1190 struct strbuf sb
= STRBUF_INIT
;
1195 strbuf_addstr(&sb
, action
);
1196 strbuf_addstr(&sb
, ": ");
1199 nl
= strchr(msg
->buf
, '\n');
1201 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
1203 strbuf_addbuf(&sb
, msg
);
1204 strbuf_addch(&sb
, '\n');
1207 transaction
= ref_transaction_begin(err
);
1209 ref_transaction_update(transaction
, "HEAD", new_head
,
1210 old_head
? &old_head
->object
.oid
: null_oid(),
1212 ref_transaction_commit(transaction
, err
)) {
1215 ref_transaction_free(transaction
);
1216 strbuf_release(&sb
);
1221 static int run_rewrite_hook(const struct object_id
*oldoid
,
1222 const struct object_id
*newoid
)
1224 struct child_process proc
= CHILD_PROCESS_INIT
;
1226 struct strbuf sb
= STRBUF_INIT
;
1227 const char *hook_path
= find_hook("post-rewrite");
1232 strvec_pushl(&proc
.args
, hook_path
, "amend", NULL
);
1234 proc
.stdout_to_stderr
= 1;
1235 proc
.trace2_hook_name
= "post-rewrite";
1237 code
= start_command(&proc
);
1240 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
1241 sigchain_push(SIGPIPE
, SIG_IGN
);
1242 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
1244 strbuf_release(&sb
);
1245 sigchain_pop(SIGPIPE
);
1246 return finish_command(&proc
);
1249 void commit_post_rewrite(struct repository
*r
,
1250 const struct commit
*old_head
,
1251 const struct object_id
*new_head
)
1253 struct notes_rewrite_cfg
*cfg
;
1255 cfg
= init_copy_notes_for_rewrite("amend");
1257 /* we are amending, so old_head is not NULL */
1258 copy_note_for_rewrite(cfg
, &old_head
->object
.oid
, new_head
);
1259 finish_copy_notes_for_rewrite(r
, cfg
, "Notes added by 'git commit --amend'");
1261 run_rewrite_hook(&old_head
->object
.oid
, new_head
);
1264 static int run_prepare_commit_msg_hook(struct repository
*r
,
1269 const char *name
, *arg1
= NULL
, *arg2
= NULL
;
1271 name
= git_path_commit_editmsg();
1272 if (write_message(msg
->buf
, msg
->len
, name
, 0))
1281 if (run_commit_hook(0, r
->index_file
, NULL
, "prepare-commit-msg", name
,
1283 ret
= error(_("'prepare-commit-msg' hook failed"));
1288 static const char implicit_ident_advice_noconfig
[] =
1289 N_("Your name and email address were configured automatically based\n"
1290 "on your username and hostname. Please check that they are accurate.\n"
1291 "You can suppress this message by setting them explicitly. Run the\n"
1292 "following command and follow the instructions in your editor to edit\n"
1293 "your configuration file:\n"
1295 " git config --global --edit\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_config
[] =
1302 N_("Your name and email address were configured automatically based\n"
1303 "on your username and hostname. Please check that they are accurate.\n"
1304 "You can suppress this message by setting them explicitly:\n"
1306 " git config --global user.name \"Your Name\"\n"
1307 " git config --global user.email you@example.com\n"
1309 "After doing this, you may fix the identity used for this commit with:\n"
1311 " git commit --amend --reset-author\n");
1313 static const char *implicit_ident_advice(void)
1315 char *user_config
= interpolate_path("~/.gitconfig", 0);
1316 char *xdg_config
= xdg_config_home("config");
1317 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1323 return _(implicit_ident_advice_config
);
1325 return _(implicit_ident_advice_noconfig
);
1329 void print_commit_summary(struct repository
*r
,
1331 const struct object_id
*oid
,
1334 struct rev_info rev
;
1335 struct commit
*commit
;
1336 struct strbuf format
= STRBUF_INIT
;
1338 struct pretty_print_context pctx
= {0};
1339 struct strbuf author_ident
= STRBUF_INIT
;
1340 struct strbuf committer_ident
= STRBUF_INIT
;
1341 struct ref_store
*refs
;
1343 commit
= lookup_commit(r
, oid
);
1345 die(_("couldn't look up newly created commit"));
1346 if (repo_parse_commit(r
, commit
))
1347 die(_("could not parse newly created commit"));
1349 strbuf_addstr(&format
, "format:%h] %s");
1351 repo_format_commit_message(r
, commit
, "%an <%ae>", &author_ident
,
1353 repo_format_commit_message(r
, commit
, "%cn <%ce>", &committer_ident
,
1355 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1356 strbuf_addstr(&format
, "\n Author: ");
1357 strbuf_addbuf_percentquote(&format
, &author_ident
);
1359 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
1360 struct strbuf date
= STRBUF_INIT
;
1362 repo_format_commit_message(r
, commit
, "%ad", &date
, &pctx
);
1363 strbuf_addstr(&format
, "\n Date: ");
1364 strbuf_addbuf_percentquote(&format
, &date
);
1365 strbuf_release(&date
);
1367 if (!committer_ident_sufficiently_given()) {
1368 strbuf_addstr(&format
, "\n Committer: ");
1369 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1370 if (advice_enabled(ADVICE_IMPLICIT_IDENTITY
)) {
1371 strbuf_addch(&format
, '\n');
1372 strbuf_addstr(&format
, implicit_ident_advice());
1375 strbuf_release(&author_ident
);
1376 strbuf_release(&committer_ident
);
1378 repo_init_revisions(r
, &rev
, prefix
);
1379 setup_revisions(0, NULL
, &rev
, NULL
);
1382 rev
.diffopt
.output_format
=
1383 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1385 rev
.verbose_header
= 1;
1386 rev
.show_root_diff
= 1;
1387 get_commit_format(format
.buf
, &rev
);
1388 rev
.always_show_header
= 0;
1389 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1390 diff_setup_done(&rev
.diffopt
);
1392 refs
= get_main_ref_store(r
);
1393 head
= refs_resolve_ref_unsafe(refs
, "HEAD", 0, NULL
, NULL
);
1395 die(_("unable to resolve HEAD after creating commit"));
1396 if (!strcmp(head
, "HEAD"))
1397 head
= _("detached HEAD");
1399 skip_prefix(head
, "refs/heads/", &head
);
1400 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1401 _(" (root-commit)") : "");
1403 if (!log_tree_commit(&rev
, commit
)) {
1404 rev
.always_show_header
= 1;
1405 rev
.use_terminator
= 1;
1406 log_tree_commit(&rev
, commit
);
1409 release_revisions(&rev
);
1410 strbuf_release(&format
);
1413 static int parse_head(struct repository
*r
, struct commit
**head
)
1415 struct commit
*current_head
;
1416 struct object_id oid
;
1418 if (repo_get_oid(r
, "HEAD", &oid
)) {
1419 current_head
= NULL
;
1421 current_head
= lookup_commit_reference(r
, &oid
);
1423 return error(_("could not parse HEAD"));
1424 if (!oideq(&oid
, ¤t_head
->object
.oid
)) {
1425 warning(_("HEAD %s is not a commit!"),
1428 if (repo_parse_commit(r
, current_head
))
1429 return error(_("could not parse HEAD commit"));
1431 *head
= current_head
;
1437 * Try to commit without forking 'git commit'. In some cases we need
1438 * to run 'git commit' to display an error message
1441 * -1 - error unable to commit
1443 * 1 - run 'git commit'
1445 static int try_to_commit(struct repository
*r
,
1446 struct strbuf
*msg
, const char *author
,
1447 struct replay_opts
*opts
, unsigned int flags
,
1448 struct object_id
*oid
)
1450 struct object_id tree
;
1451 struct commit
*current_head
= NULL
;
1452 struct commit_list
*parents
= NULL
;
1453 struct commit_extra_header
*extra
= NULL
;
1454 struct strbuf err
= STRBUF_INIT
;
1455 struct strbuf commit_msg
= STRBUF_INIT
;
1456 char *amend_author
= NULL
;
1457 const char *committer
= NULL
;
1458 const char *hook_commit
= NULL
;
1459 enum commit_msg_cleanup_mode cleanup
;
1462 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1463 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1465 if (parse_head(r
, ¤t_head
))
1468 if (flags
& AMEND_MSG
) {
1469 const char *exclude_gpgsig
[] = { "gpgsig", "gpgsig-sha256", NULL
};
1470 const char *out_enc
= get_commit_output_encoding();
1471 const char *message
= repo_logmsg_reencode(r
, current_head
,
1475 const char *orig_message
= NULL
;
1477 find_commit_subject(message
, &orig_message
);
1479 strbuf_addstr(msg
, orig_message
);
1480 hook_commit
= "HEAD";
1482 author
= amend_author
= get_author(message
);
1483 repo_unuse_commit_buffer(r
, current_head
,
1486 res
= error(_("unable to parse commit author"));
1489 parents
= copy_commit_list(current_head
->parents
);
1490 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1491 } else if (current_head
&&
1492 (!(flags
& CREATE_ROOT_COMMIT
) || (flags
& AMEND_MSG
))) {
1493 commit_list_insert(current_head
, &parents
);
1496 if (write_index_as_tree(&tree
, r
->index
, r
->index_file
, 0, NULL
)) {
1497 res
= error(_("git write-tree failed to write a tree"));
1501 if (!(flags
& ALLOW_EMPTY
)) {
1502 struct commit
*first_parent
= current_head
;
1504 if (flags
& AMEND_MSG
) {
1505 if (current_head
->parents
) {
1506 first_parent
= current_head
->parents
->item
;
1507 if (repo_parse_commit(r
, first_parent
)) {
1508 res
= error(_("could not parse HEAD commit"));
1512 first_parent
= NULL
;
1515 if (oideq(first_parent
1516 ? get_commit_tree_oid(first_parent
)
1517 : the_hash_algo
->empty_tree
,
1519 res
= 1; /* run 'git commit' to display error message */
1524 if (hook_exists("prepare-commit-msg")) {
1525 res
= run_prepare_commit_msg_hook(r
, msg
, hook_commit
);
1528 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1530 res
= error_errno(_("unable to read commit message "
1532 git_path_commit_editmsg());
1538 if (flags
& CLEANUP_MSG
)
1539 cleanup
= COMMIT_MSG_CLEANUP_ALL
;
1540 else if (flags
& VERBATIM_MSG
)
1541 cleanup
= COMMIT_MSG_CLEANUP_NONE
;
1542 else if ((opts
->signoff
|| opts
->record_origin
) &&
1543 !opts
->explicit_cleanup
)
1544 cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
1546 cleanup
= opts
->default_msg_cleanup
;
1548 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1549 strbuf_stripspace(msg
, cleanup
== COMMIT_MSG_CLEANUP_ALL
);
1550 if ((flags
& EDIT_MSG
) && message_is_empty(msg
, cleanup
)) {
1551 res
= 1; /* run 'git commit' to display error message */
1555 if (opts
->committer_date_is_author_date
) {
1556 struct ident_split id
;
1557 struct strbuf date
= STRBUF_INIT
;
1559 if (!opts
->ignore_date
) {
1560 if (split_ident_line(&id
, author
, (int)strlen(author
)) < 0) {
1561 res
= error(_("invalid author identity '%s'"),
1565 if (!id
.date_begin
) {
1567 "corrupt author: missing date information"));
1570 strbuf_addf(&date
, "@%.*s %.*s",
1571 (int)(id
.date_end
- id
.date_begin
),
1573 (int)(id
.tz_end
- id
.tz_begin
),
1578 committer
= fmt_ident(getenv("GIT_COMMITTER_NAME"),
1579 getenv("GIT_COMMITTER_EMAIL"),
1580 WANT_COMMITTER_IDENT
,
1581 opts
->ignore_date
? NULL
: date
.buf
,
1583 strbuf_release(&date
);
1588 if (opts
->ignore_date
) {
1589 struct ident_split id
;
1592 if (split_ident_line(&id
, author
, strlen(author
)) < 0) {
1593 error(_("invalid author identity '%s'"), author
);
1596 name
= xmemdupz(id
.name_begin
, id
.name_end
- id
.name_begin
);
1597 email
= xmemdupz(id
.mail_begin
, id
.mail_end
- id
.mail_begin
);
1598 author
= fmt_ident(name
, email
, WANT_AUTHOR_IDENT
, NULL
,
1604 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
, oid
,
1605 author
, committer
, opts
->gpg_sign
, extra
)) {
1606 res
= error(_("failed to write commit object"));
1610 if (update_head_with_reflog(current_head
, oid
, opts
->reflog_message
,
1612 res
= error("%s", err
.buf
);
1616 run_commit_hook(0, r
->index_file
, NULL
, "post-commit", NULL
);
1617 if (flags
& AMEND_MSG
)
1618 commit_post_rewrite(r
, current_head
, oid
);
1621 free_commit_extra_headers(extra
);
1622 strbuf_release(&err
);
1623 strbuf_release(&commit_msg
);
1629 static int write_rebase_head(struct object_id
*oid
)
1631 if (update_ref("rebase", "REBASE_HEAD", oid
,
1632 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1633 return error(_("could not update %s"), "REBASE_HEAD");
1638 static int do_commit(struct repository
*r
,
1639 const char *msg_file
, const char *author
,
1640 struct replay_opts
*opts
, unsigned int flags
,
1641 struct object_id
*oid
)
1645 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
)) {
1646 struct object_id oid
;
1647 struct strbuf sb
= STRBUF_INIT
;
1649 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1650 return error_errno(_("unable to read commit message "
1654 res
= try_to_commit(r
, msg_file
? &sb
: NULL
,
1655 author
, opts
, flags
, &oid
);
1656 strbuf_release(&sb
);
1658 refs_delete_ref(get_main_ref_store(r
), "",
1659 "CHERRY_PICK_HEAD", NULL
, 0);
1660 unlink(git_path_merge_msg(r
));
1661 if (!is_rebase_i(opts
))
1662 print_commit_summary(r
, NULL
, &oid
,
1663 SUMMARY_SHOW_AUTHOR_DATE
);
1668 if (is_rebase_i(opts
) && oid
)
1669 if (write_rebase_head(oid
))
1671 return run_git_commit(msg_file
, opts
, flags
);
1677 static int is_original_commit_empty(struct commit
*commit
)
1679 const struct object_id
*ptree_oid
;
1681 if (repo_parse_commit(the_repository
, commit
))
1682 return error(_("could not parse commit %s"),
1683 oid_to_hex(&commit
->object
.oid
));
1684 if (commit
->parents
) {
1685 struct commit
*parent
= commit
->parents
->item
;
1686 if (repo_parse_commit(the_repository
, parent
))
1687 return error(_("could not parse parent commit %s"),
1688 oid_to_hex(&parent
->object
.oid
));
1689 ptree_oid
= get_commit_tree_oid(parent
);
1691 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1694 return oideq(ptree_oid
, get_commit_tree_oid(commit
));
1698 * Should empty commits be allowed? Return status:
1699 * <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1700 * 0: Halt on empty commit
1701 * 1: Allow empty commit
1702 * 2: Drop empty commit
1704 static int allow_empty(struct repository
*r
,
1705 struct replay_opts
*opts
,
1706 struct commit
*commit
)
1708 int index_unchanged
, originally_empty
;
1713 * (1) we do not allow empty at all and error out.
1715 * (2) we allow ones that were initially empty, and
1716 * just drop the ones that become empty
1718 * (3) we allow ones that were initially empty, but
1719 * halt for the ones that become empty;
1721 * (4) we allow both.
1723 if (!opts
->allow_empty
)
1724 return 0; /* let "git commit" barf as necessary */
1726 index_unchanged
= is_index_unchanged(r
);
1727 if (index_unchanged
< 0)
1728 return index_unchanged
;
1729 if (!index_unchanged
)
1730 return 0; /* we do not have to say --allow-empty */
1732 if (opts
->keep_redundant_commits
)
1735 originally_empty
= is_original_commit_empty(commit
);
1736 if (originally_empty
< 0)
1737 return originally_empty
;
1738 if (originally_empty
)
1740 else if (opts
->drop_redundant_commits
)
1749 } todo_command_info
[] = {
1750 [TODO_PICK
] = { 'p', "pick" },
1751 [TODO_REVERT
] = { 0, "revert" },
1752 [TODO_EDIT
] = { 'e', "edit" },
1753 [TODO_REWORD
] = { 'r', "reword" },
1754 [TODO_FIXUP
] = { 'f', "fixup" },
1755 [TODO_SQUASH
] = { 's', "squash" },
1756 [TODO_EXEC
] = { 'x', "exec" },
1757 [TODO_BREAK
] = { 'b', "break" },
1758 [TODO_LABEL
] = { 'l', "label" },
1759 [TODO_RESET
] = { 't', "reset" },
1760 [TODO_MERGE
] = { 'm', "merge" },
1761 [TODO_UPDATE_REF
] = { 'u', "update-ref" },
1762 [TODO_NOOP
] = { 0, "noop" },
1763 [TODO_DROP
] = { 'd', "drop" },
1764 [TODO_COMMENT
] = { 0, NULL
},
1767 static const char *command_to_string(const enum todo_command command
)
1769 if (command
< TODO_COMMENT
)
1770 return todo_command_info
[command
].str
;
1771 die(_("unknown command: %d"), command
);
1774 static char command_to_char(const enum todo_command command
)
1776 if (command
< TODO_COMMENT
)
1777 return todo_command_info
[command
].c
;
1778 return comment_line_char
;
1781 static int is_noop(const enum todo_command command
)
1783 return TODO_NOOP
<= command
;
1786 static int is_fixup(enum todo_command command
)
1788 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1791 /* Does this command create a (non-merge) commit? */
1792 static int is_pick_or_similar(enum todo_command command
)
1807 enum todo_item_flags
{
1808 TODO_EDIT_MERGE_MSG
= (1 << 0),
1809 TODO_REPLACE_FIXUP_MSG
= (1 << 1),
1810 TODO_EDIT_FIXUP_MSG
= (1 << 2),
1813 static const char first_commit_msg_str
[] = N_("This is the 1st commit message:");
1814 static const char nth_commit_msg_fmt
[] = N_("This is the commit message #%d:");
1815 static const char skip_first_commit_msg_str
[] = N_("The 1st commit message will be skipped:");
1816 static const char skip_nth_commit_msg_fmt
[] = N_("The commit message #%d will be skipped:");
1817 static const char combined_commit_msg_fmt
[] = N_("This is a combination of %d commits.");
1819 static int is_fixup_flag(enum todo_command command
, unsigned flag
)
1821 return command
== TODO_FIXUP
&& ((flag
& TODO_REPLACE_FIXUP_MSG
) ||
1822 (flag
& TODO_EDIT_FIXUP_MSG
));
1826 * Wrapper around strbuf_add_commented_lines() which avoids double
1827 * commenting commit subjects.
1829 static void add_commented_lines(struct strbuf
*buf
, const void *str
, size_t len
)
1831 const char *s
= str
;
1832 while (len
> 0 && s
[0] == comment_line_char
) {
1834 const char *n
= memchr(s
, '\n', len
);
1839 strbuf_add(buf
, s
, count
);
1843 strbuf_add_commented_lines(buf
, s
, len
);
1846 /* Does the current fixup chain contain a squash command? */
1847 static int seen_squash(struct replay_opts
*opts
)
1849 return starts_with(opts
->current_fixups
.buf
, "squash") ||
1850 strstr(opts
->current_fixups
.buf
, "\nsquash");
1853 static void update_comment_bufs(struct strbuf
*buf1
, struct strbuf
*buf2
, int n
)
1855 strbuf_setlen(buf1
, 2);
1856 strbuf_addf(buf1
, _(nth_commit_msg_fmt
), n
);
1857 strbuf_addch(buf1
, '\n');
1858 strbuf_setlen(buf2
, 2);
1859 strbuf_addf(buf2
, _(skip_nth_commit_msg_fmt
), n
);
1860 strbuf_addch(buf2
, '\n');
1864 * Comment out any un-commented commit messages, updating the message comments
1865 * to say they will be skipped but do not comment out the empty lines that
1866 * surround commit messages and their comments.
1868 static void update_squash_message_for_fixup(struct strbuf
*msg
)
1870 void (*copy_lines
)(struct strbuf
*, const void *, size_t) = strbuf_add
;
1871 struct strbuf buf1
= STRBUF_INIT
, buf2
= STRBUF_INIT
;
1872 const char *s
, *start
;
1874 size_t orig_msg_len
;
1877 strbuf_addf(&buf1
, "# %s\n", _(first_commit_msg_str
));
1878 strbuf_addf(&buf2
, "# %s\n", _(skip_first_commit_msg_str
));
1879 s
= start
= orig_msg
= strbuf_detach(msg
, &orig_msg_len
);
1883 if (skip_prefix(s
, buf1
.buf
, &next
)) {
1885 * Copy the last message, preserving the blank line
1886 * preceding the current line
1888 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1889 copy_lines(msg
, start
, s
- start
- off
);
1891 strbuf_addch(msg
, '\n');
1893 * The next message needs to be commented out but the
1894 * message header is already commented out so just copy
1895 * it and the blank line that follows it.
1897 strbuf_addbuf(msg
, &buf2
);
1899 strbuf_addch(msg
, *next
++);
1901 copy_lines
= add_commented_lines
;
1902 update_comment_bufs(&buf1
, &buf2
, ++i
);
1903 } else if (skip_prefix(s
, buf2
.buf
, &next
)) {
1904 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1905 copy_lines(msg
, start
, s
- start
- off
);
1908 copy_lines
= strbuf_add
;
1909 update_comment_bufs(&buf1
, &buf2
, ++i
);
1911 s
= strchr(s
, '\n');
1916 copy_lines(msg
, start
, orig_msg_len
- (start
- orig_msg
));
1918 strbuf_release(&buf1
);
1919 strbuf_release(&buf2
);
1922 static int append_squash_message(struct strbuf
*buf
, const char *body
,
1923 enum todo_command command
, struct replay_opts
*opts
,
1926 const char *fixup_msg
;
1927 size_t commented_len
= 0, fixup_off
;
1929 * amend is non-interactive and not normally used with fixup!
1930 * or squash! commits, so only comment out those subjects when
1931 * squashing commit messages.
1933 if (starts_with(body
, "amend!") ||
1934 ((command
== TODO_SQUASH
|| seen_squash(opts
)) &&
1935 (starts_with(body
, "squash!") || starts_with(body
, "fixup!"))))
1936 commented_len
= commit_subject_length(body
);
1938 strbuf_addf(buf
, "\n%c ", comment_line_char
);
1939 strbuf_addf(buf
, _(nth_commit_msg_fmt
),
1940 ++opts
->current_fixup_count
+ 1);
1941 strbuf_addstr(buf
, "\n\n");
1942 strbuf_add_commented_lines(buf
, body
, commented_len
);
1943 /* buf->buf may be reallocated so store an offset into the buffer */
1944 fixup_off
= buf
->len
;
1945 strbuf_addstr(buf
, body
+ commented_len
);
1947 /* fixup -C after squash behaves like squash */
1948 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
)) {
1950 * We're replacing the commit message so we need to
1951 * append the Signed-off-by: trailer if the user
1952 * requested '--signoff'.
1955 append_signoff(buf
, 0, 0);
1957 if ((command
== TODO_FIXUP
) &&
1958 (flag
& TODO_REPLACE_FIXUP_MSG
) &&
1959 (file_exists(rebase_path_fixup_msg()) ||
1960 !file_exists(rebase_path_squash_msg()))) {
1961 fixup_msg
= skip_blank_lines(buf
->buf
+ fixup_off
);
1962 if (write_message(fixup_msg
, strlen(fixup_msg
),
1963 rebase_path_fixup_msg(), 0) < 0)
1964 return error(_("cannot write '%s'"),
1965 rebase_path_fixup_msg());
1967 unlink(rebase_path_fixup_msg());
1970 unlink(rebase_path_fixup_msg());
1976 static int update_squash_messages(struct repository
*r
,
1977 enum todo_command command
,
1978 struct commit
*commit
,
1979 struct replay_opts
*opts
,
1982 struct strbuf buf
= STRBUF_INIT
;
1984 const char *message
, *body
;
1985 const char *encoding
= get_commit_output_encoding();
1987 if (opts
->current_fixup_count
> 0) {
1988 struct strbuf header
= STRBUF_INIT
;
1991 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
1992 return error(_("could not read '%s'"),
1993 rebase_path_squash_msg());
1995 eol
= buf
.buf
[0] != comment_line_char
?
1996 buf
.buf
: strchrnul(buf
.buf
, '\n');
1998 strbuf_addf(&header
, "%c ", comment_line_char
);
1999 strbuf_addf(&header
, _(combined_commit_msg_fmt
),
2000 opts
->current_fixup_count
+ 2);
2001 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
2002 strbuf_release(&header
);
2003 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
))
2004 update_squash_message_for_fixup(&buf
);
2006 struct object_id head
;
2007 struct commit
*head_commit
;
2008 const char *head_message
, *body
;
2010 if (repo_get_oid(r
, "HEAD", &head
))
2011 return error(_("need a HEAD to fixup"));
2012 if (!(head_commit
= lookup_commit_reference(r
, &head
)))
2013 return error(_("could not read HEAD"));
2014 if (!(head_message
= repo_logmsg_reencode(r
, head_commit
, NULL
,
2016 return error(_("could not read HEAD's commit message"));
2018 find_commit_subject(head_message
, &body
);
2019 if (command
== TODO_FIXUP
&& !flag
&& write_message(body
, strlen(body
),
2020 rebase_path_fixup_msg(), 0) < 0) {
2021 repo_unuse_commit_buffer(r
, head_commit
, head_message
);
2022 return error(_("cannot write '%s'"), rebase_path_fixup_msg());
2024 strbuf_addf(&buf
, "%c ", comment_line_char
);
2025 strbuf_addf(&buf
, _(combined_commit_msg_fmt
), 2);
2026 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
2027 strbuf_addstr(&buf
, is_fixup_flag(command
, flag
) ?
2028 _(skip_first_commit_msg_str
) :
2029 _(first_commit_msg_str
));
2030 strbuf_addstr(&buf
, "\n\n");
2031 if (is_fixup_flag(command
, flag
))
2032 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
2034 strbuf_addstr(&buf
, body
);
2036 repo_unuse_commit_buffer(r
, head_commit
, head_message
);
2039 if (!(message
= repo_logmsg_reencode(r
, commit
, NULL
, encoding
)))
2040 return error(_("could not read commit message of %s"),
2041 oid_to_hex(&commit
->object
.oid
));
2042 find_commit_subject(message
, &body
);
2044 if (command
== TODO_SQUASH
|| is_fixup_flag(command
, flag
)) {
2045 res
= append_squash_message(&buf
, body
, command
, opts
, flag
);
2046 } else if (command
== TODO_FIXUP
) {
2047 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
2048 strbuf_addf(&buf
, _(skip_nth_commit_msg_fmt
),
2049 ++opts
->current_fixup_count
+ 1);
2050 strbuf_addstr(&buf
, "\n\n");
2051 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
2053 return error(_("unknown command: %d"), command
);
2054 repo_unuse_commit_buffer(r
, commit
, message
);
2057 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(),
2059 strbuf_release(&buf
);
2062 strbuf_addf(&opts
->current_fixups
, "%s%s %s",
2063 opts
->current_fixups
.len
? "\n" : "",
2064 command_to_string(command
),
2065 oid_to_hex(&commit
->object
.oid
));
2066 res
= write_message(opts
->current_fixups
.buf
,
2067 opts
->current_fixups
.len
,
2068 rebase_path_current_fixups(), 0);
2074 static void flush_rewritten_pending(void)
2076 struct strbuf buf
= STRBUF_INIT
;
2077 struct object_id newoid
;
2080 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
2081 !repo_get_oid(the_repository
, "HEAD", &newoid
) &&
2082 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
2083 char *bol
= buf
.buf
, *eol
;
2086 eol
= strchrnul(bol
, '\n');
2087 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
2088 bol
, oid_to_hex(&newoid
));
2094 unlink(rebase_path_rewritten_pending());
2096 strbuf_release(&buf
);
2099 static void record_in_rewritten(struct object_id
*oid
,
2100 enum todo_command next_command
)
2102 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
2107 fprintf(out
, "%s\n", oid_to_hex(oid
));
2110 if (!is_fixup(next_command
))
2111 flush_rewritten_pending();
2114 static int should_edit(struct replay_opts
*opts
) {
2117 * Note that we only handle the case of non-conflicted
2118 * commits; continue_single_pick() handles the conflicted
2119 * commits itself instead of calling this function.
2121 return (opts
->action
== REPLAY_REVERT
&& isatty(0)) ? 1 : 0;
2125 static void refer_to_commit(struct replay_opts
*opts
,
2126 struct strbuf
*msgbuf
, struct commit
*commit
)
2128 if (opts
->commit_use_reference
) {
2129 struct pretty_print_context ctx
= {
2130 .abbrev
= DEFAULT_ABBREV
,
2131 .date_mode
.type
= DATE_SHORT
,
2133 repo_format_commit_message(the_repository
, commit
,
2134 "%h (%s, %ad)", msgbuf
, &ctx
);
2136 strbuf_addstr(msgbuf
, oid_to_hex(&commit
->object
.oid
));
2140 static int do_pick_commit(struct repository
*r
,
2141 struct todo_item
*item
,
2142 struct replay_opts
*opts
,
2143 int final_fixup
, int *check_todo
)
2145 unsigned int flags
= should_edit(opts
) ? EDIT_MSG
: 0;
2146 const char *msg_file
= should_edit(opts
) ? NULL
: git_path_merge_msg(r
);
2147 struct object_id head
;
2148 struct commit
*base
, *next
, *parent
;
2149 const char *base_label
, *next_label
;
2150 char *author
= NULL
;
2151 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
2152 struct strbuf msgbuf
= STRBUF_INIT
;
2153 int res
, unborn
= 0, reword
= 0, allow
, drop_commit
;
2154 enum todo_command command
= item
->command
;
2155 struct commit
*commit
= item
->commit
;
2157 if (opts
->no_commit
) {
2159 * We do not intend to commit immediately. We just want to
2160 * merge the differences in, so let's compute the tree
2161 * that represents the "current" state for the merge machinery
2164 if (write_index_as_tree(&head
, r
->index
, r
->index_file
, 0, NULL
))
2165 return error(_("your index file is unmerged."));
2167 unborn
= repo_get_oid(r
, "HEAD", &head
);
2168 /* Do we want to generate a root commit? */
2169 if (is_pick_or_similar(command
) && opts
->have_squash_onto
&&
2170 oideq(&head
, &opts
->squash_onto
)) {
2171 if (is_fixup(command
))
2172 return error(_("cannot fixup root commit"));
2173 flags
|= CREATE_ROOT_COMMIT
;
2176 oidcpy(&head
, the_hash_algo
->empty_tree
);
2177 if (index_differs_from(r
, unborn
? empty_tree_oid_hex() : "HEAD",
2179 return error_dirty_index(r
, opts
);
2181 discard_index(r
->index
);
2183 if (!commit
->parents
)
2185 else if (commit
->parents
->next
) {
2186 /* Reverting or cherry-picking a merge commit */
2188 struct commit_list
*p
;
2190 if (!opts
->mainline
)
2191 return error(_("commit %s is a merge but no -m option was given."),
2192 oid_to_hex(&commit
->object
.oid
));
2194 for (cnt
= 1, p
= commit
->parents
;
2195 cnt
!= opts
->mainline
&& p
;
2198 if (cnt
!= opts
->mainline
|| !p
)
2199 return error(_("commit %s does not have parent %d"),
2200 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2202 } else if (1 < opts
->mainline
)
2204 * Non-first parent explicitly specified as mainline for
2207 return error(_("commit %s does not have parent %d"),
2208 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2210 parent
= commit
->parents
->item
;
2212 if (get_message(commit
, &msg
) != 0)
2213 return error(_("cannot get commit message for %s"),
2214 oid_to_hex(&commit
->object
.oid
));
2216 if (opts
->allow_ff
&& !is_fixup(command
) &&
2217 ((parent
&& oideq(&parent
->object
.oid
, &head
)) ||
2218 (!parent
&& unborn
))) {
2219 if (is_rebase_i(opts
))
2220 write_author_script(msg
.message
);
2221 res
= fast_forward_to(r
, &commit
->object
.oid
, &head
, unborn
,
2223 if (res
|| command
!= TODO_REWORD
)
2227 goto fast_forward_edit
;
2229 if (parent
&& repo_parse_commit(r
, parent
) < 0)
2230 /* TRANSLATORS: The first %s will be a "todo" command like
2231 "revert" or "pick", the second %s a SHA1. */
2232 return error(_("%s: cannot parse parent commit %s"),
2233 command_to_string(command
),
2234 oid_to_hex(&parent
->object
.oid
));
2237 * "commit" is an existing commit. We would want to apply
2238 * the difference it introduces since its first parent "prev"
2239 * on top of the current HEAD if we are cherry-pick. Or the
2240 * reverse of it if we are revert.
2243 if (command
== TODO_REVERT
) {
2245 base_label
= msg
.label
;
2247 next_label
= msg
.parent_label
;
2248 if (opts
->commit_use_reference
) {
2249 strbuf_addstr(&msgbuf
,
2250 "# *** SAY WHY WE ARE REVERTING ON THE TITLE LINE ***");
2252 strbuf_addstr(&msgbuf
, "Revert \"");
2253 strbuf_addstr(&msgbuf
, msg
.subject
);
2254 strbuf_addstr(&msgbuf
, "\"");
2256 strbuf_addstr(&msgbuf
, "\n\nThis reverts commit ");
2257 refer_to_commit(opts
, &msgbuf
, commit
);
2259 if (commit
->parents
&& commit
->parents
->next
) {
2260 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
2261 refer_to_commit(opts
, &msgbuf
, parent
);
2263 strbuf_addstr(&msgbuf
, ".\n");
2268 base_label
= msg
.parent_label
;
2270 next_label
= msg
.label
;
2272 /* Append the commit log message to msgbuf. */
2273 if (find_commit_subject(msg
.message
, &p
))
2274 strbuf_addstr(&msgbuf
, p
);
2276 if (opts
->record_origin
) {
2277 strbuf_complete_line(&msgbuf
);
2278 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
2279 strbuf_addch(&msgbuf
, '\n');
2280 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
2281 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
2282 strbuf_addstr(&msgbuf
, ")\n");
2284 if (!is_fixup(command
))
2285 author
= get_author(msg
.message
);
2288 if (command
== TODO_REWORD
)
2290 else if (is_fixup(command
)) {
2291 if (update_squash_messages(r
, command
, commit
,
2292 opts
, item
->flags
)) {
2298 msg_file
= rebase_path_squash_msg();
2299 else if (file_exists(rebase_path_fixup_msg())) {
2300 flags
|= VERBATIM_MSG
;
2301 msg_file
= rebase_path_fixup_msg();
2303 const char *dest
= git_path_squash_msg(r
);
2305 if (copy_file(dest
, rebase_path_squash_msg(), 0666)) {
2306 res
= error(_("could not rename '%s' to '%s'"),
2307 rebase_path_squash_msg(), dest
);
2310 unlink(git_path_merge_msg(r
));
2316 if (opts
->signoff
&& !is_fixup(command
))
2317 append_signoff(&msgbuf
, 0, 0);
2319 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
2321 else if (!opts
->strategy
||
2322 !strcmp(opts
->strategy
, "recursive") ||
2323 !strcmp(opts
->strategy
, "ort") ||
2324 command
== TODO_REVERT
) {
2325 res
= do_recursive_merge(r
, base
, next
, base_label
, next_label
,
2326 &head
, &msgbuf
, opts
);
2330 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
2331 git_path_merge_msg(r
), 0);
2333 struct commit_list
*common
= NULL
;
2334 struct commit_list
*remotes
= NULL
;
2336 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
2337 git_path_merge_msg(r
), 0);
2339 commit_list_insert(base
, &common
);
2340 commit_list_insert(next
, &remotes
);
2341 res
|= try_merge_command(r
, opts
->strategy
,
2342 opts
->xopts
.nr
, opts
->xopts
.v
,
2343 common
, oid_to_hex(&head
), remotes
);
2344 free_commit_list(common
);
2345 free_commit_list(remotes
);
2349 * If the merge was clean or if it failed due to conflict, we write
2350 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
2351 * However, if the merge did not even start, then we don't want to
2354 if ((command
== TODO_PICK
|| command
== TODO_REWORD
||
2355 command
== TODO_EDIT
) && !opts
->no_commit
&&
2356 (res
== 0 || res
== 1) &&
2357 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
2358 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2360 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
2361 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
2362 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2366 error(command
== TODO_REVERT
2367 ? _("could not revert %s... %s")
2368 : _("could not apply %s... %s"),
2369 short_commit_name(commit
), msg
.subject
);
2370 print_advice(r
, res
== 1, opts
);
2371 repo_rerere(r
, opts
->allow_rerere_auto
);
2376 allow
= allow_empty(r
, opts
, commit
);
2380 } else if (allow
== 1) {
2381 flags
|= ALLOW_EMPTY
;
2382 } else if (allow
== 2) {
2384 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
2386 unlink(git_path_merge_msg(r
));
2387 unlink(git_path_auto_merge(r
));
2389 _("dropping %s %s -- patch contents already upstream\n"),
2390 oid_to_hex(&commit
->object
.oid
), msg
.subject
);
2391 } /* else allow == 0 and there's nothing special to do */
2392 if (!opts
->no_commit
&& !drop_commit
) {
2393 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
2394 res
= do_commit(r
, msg_file
, author
, opts
, flags
,
2395 commit
? &commit
->object
.oid
: NULL
);
2397 res
= error(_("unable to parse commit author"));
2398 *check_todo
= !!(flags
& EDIT_MSG
);
2399 if (!res
&& reword
) {
2401 res
= run_git_commit(NULL
, opts
, EDIT_MSG
|
2402 VERIFY_MSG
| AMEND_MSG
|
2403 (flags
& ALLOW_EMPTY
));
2409 if (!res
&& final_fixup
) {
2410 unlink(rebase_path_fixup_msg());
2411 unlink(rebase_path_squash_msg());
2412 unlink(rebase_path_current_fixups());
2413 strbuf_reset(&opts
->current_fixups
);
2414 opts
->current_fixup_count
= 0;
2418 free_message(commit
, &msg
);
2420 strbuf_release(&msgbuf
);
2421 update_abort_safety_file();
2426 static int prepare_revs(struct replay_opts
*opts
)
2429 * picking (but not reverting) ranges (but not individual revisions)
2430 * should be done in reverse
2432 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
2433 opts
->revs
->reverse
^= 1;
2435 if (prepare_revision_walk(opts
->revs
))
2436 return error(_("revision walk setup failed"));
2441 static int read_and_refresh_cache(struct repository
*r
,
2442 struct replay_opts
*opts
)
2444 struct lock_file index_lock
= LOCK_INIT
;
2445 int index_fd
= repo_hold_locked_index(r
, &index_lock
, 0);
2446 if (repo_read_index(r
) < 0) {
2447 rollback_lock_file(&index_lock
);
2448 return error(_("git %s: failed to read the index"),
2451 refresh_index(r
->index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
2453 if (index_fd
>= 0) {
2454 if (write_locked_index(r
->index
, &index_lock
,
2455 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
2456 return error(_("git %s: failed to refresh the index"),
2462 * If we are resolving merges in any way other than "ort", then
2463 * expand the sparse index.
2465 if (opts
->strategy
&& strcmp(opts
->strategy
, "ort"))
2466 ensure_full_index(r
->index
);
2470 void todo_list_release(struct todo_list
*todo_list
)
2472 strbuf_release(&todo_list
->buf
);
2473 FREE_AND_NULL(todo_list
->items
);
2474 todo_list
->nr
= todo_list
->alloc
= 0;
2477 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
2479 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
2480 todo_list
->total_nr
++;
2481 return todo_list
->items
+ todo_list
->nr
++;
2484 const char *todo_item_get_arg(struct todo_list
*todo_list
,
2485 struct todo_item
*item
)
2487 return todo_list
->buf
.buf
+ item
->arg_offset
;
2490 static int is_command(enum todo_command command
, const char **bol
)
2492 const char *str
= todo_command_info
[command
].str
;
2493 const char nick
= todo_command_info
[command
].c
;
2494 const char *p
= *bol
;
2496 return (skip_prefix(p
, str
, &p
) || (nick
&& *p
++ == nick
)) &&
2497 (*p
== ' ' || *p
== '\t' || *p
== '\n' || *p
== '\r' || !*p
) &&
2501 static int check_label_or_ref_arg(enum todo_command command
, const char *arg
)
2506 * '#' is not a valid label as the merge command uses it to
2507 * separate merge parents from the commit subject.
2509 if (!strcmp(arg
, "#") ||
2510 check_refname_format(arg
, REFNAME_ALLOW_ONELEVEL
))
2511 return error(_("'%s' is not a valid label"), arg
);
2514 case TODO_UPDATE_REF
:
2515 if (check_refname_format(arg
, REFNAME_ALLOW_ONELEVEL
))
2516 return error(_("'%s' is not a valid refname"), arg
);
2517 if (check_refname_format(arg
, 0))
2518 return error(_("update-ref requires a fully qualified "
2519 "refname e.g. refs/heads/%s"), arg
);
2523 BUG("unexpected todo_command");
2529 static int parse_insn_line(struct repository
*r
, struct todo_item
*item
,
2530 const char *buf
, const char *bol
, char *eol
)
2532 struct object_id commit_oid
;
2533 char *end_of_object_name
;
2534 int i
, saved
, status
, padding
;
2539 bol
+= strspn(bol
, " \t");
2541 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
2542 item
->command
= TODO_COMMENT
;
2543 item
->commit
= NULL
;
2544 item
->arg_offset
= bol
- buf
;
2545 item
->arg_len
= eol
- bol
;
2549 for (i
= 0; i
< TODO_COMMENT
; i
++)
2550 if (is_command(i
, &bol
)) {
2554 if (i
>= TODO_COMMENT
)
2555 return error(_("invalid command '%.*s'"),
2556 (int)strcspn(bol
, " \t\r\n"), bol
);
2558 /* Eat up extra spaces/ tabs before object name */
2559 padding
= strspn(bol
, " \t");
2562 if (item
->command
== TODO_NOOP
|| item
->command
== TODO_BREAK
) {
2564 return error(_("%s does not accept arguments: '%s'"),
2565 command_to_string(item
->command
), bol
);
2566 item
->commit
= NULL
;
2567 item
->arg_offset
= bol
- buf
;
2568 item
->arg_len
= eol
- bol
;
2573 return error(_("missing arguments for %s"),
2574 command_to_string(item
->command
));
2576 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
2577 item
->command
== TODO_RESET
|| item
->command
== TODO_UPDATE_REF
) {
2580 item
->commit
= NULL
;
2581 item
->arg_offset
= bol
- buf
;
2582 item
->arg_len
= (int)(eol
- bol
);
2583 if (item
->command
== TODO_LABEL
||
2584 item
->command
== TODO_UPDATE_REF
) {
2587 ret
= check_label_or_ref_arg(item
->command
, bol
);
2593 if (item
->command
== TODO_FIXUP
) {
2594 if (skip_prefix(bol
, "-C", &bol
)) {
2595 bol
+= strspn(bol
, " \t");
2596 item
->flags
|= TODO_REPLACE_FIXUP_MSG
;
2597 } else if (skip_prefix(bol
, "-c", &bol
)) {
2598 bol
+= strspn(bol
, " \t");
2599 item
->flags
|= TODO_EDIT_FIXUP_MSG
;
2603 if (item
->command
== TODO_MERGE
) {
2604 if (skip_prefix(bol
, "-C", &bol
))
2605 bol
+= strspn(bol
, " \t");
2606 else if (skip_prefix(bol
, "-c", &bol
)) {
2607 bol
+= strspn(bol
, " \t");
2608 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2610 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2611 item
->commit
= NULL
;
2612 item
->arg_offset
= bol
- buf
;
2613 item
->arg_len
= (int)(eol
- bol
);
2618 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
2619 saved
= *end_of_object_name
;
2620 *end_of_object_name
= '\0';
2621 status
= repo_get_oid(r
, bol
, &commit_oid
);
2623 error(_("could not parse '%s'"), bol
); /* return later */
2624 *end_of_object_name
= saved
;
2626 bol
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2627 item
->arg_offset
= bol
- buf
;
2628 item
->arg_len
= (int)(eol
- bol
);
2633 item
->commit
= lookup_commit_reference(r
, &commit_oid
);
2634 return item
->commit
? 0 : -1;
2637 int sequencer_get_last_command(struct repository
*r
, enum replay_action
*action
)
2639 const char *todo_file
, *bol
;
2640 struct strbuf buf
= STRBUF_INIT
;
2643 todo_file
= git_path_todo_file();
2644 if (strbuf_read_file(&buf
, todo_file
, 0) < 0) {
2645 if (errno
== ENOENT
|| errno
== ENOTDIR
)
2648 return error_errno("unable to open '%s'", todo_file
);
2650 bol
= buf
.buf
+ strspn(buf
.buf
, " \t\r\n");
2651 if (is_command(TODO_PICK
, &bol
) && (*bol
== ' ' || *bol
== '\t'))
2652 *action
= REPLAY_PICK
;
2653 else if (is_command(TODO_REVERT
, &bol
) &&
2654 (*bol
== ' ' || *bol
== '\t'))
2655 *action
= REPLAY_REVERT
;
2659 strbuf_release(&buf
);
2664 int todo_list_parse_insn_buffer(struct repository
*r
, char *buf
,
2665 struct todo_list
*todo_list
)
2667 struct todo_item
*item
;
2668 char *p
= buf
, *next_p
;
2669 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2671 todo_list
->current
= todo_list
->nr
= 0;
2673 for (i
= 1; *p
; i
++, p
= next_p
) {
2674 char *eol
= strchrnul(p
, '\n');
2676 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2678 if (p
!= eol
&& eol
[-1] == '\r')
2679 eol
--; /* strip Carriage Return */
2681 item
= append_new_todo(todo_list
);
2682 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2683 if (parse_insn_line(r
, item
, buf
, p
, eol
)) {
2684 res
= error(_("invalid line %d: %.*s"),
2685 i
, (int)(eol
- p
), p
);
2686 item
->command
= TODO_COMMENT
+ 1;
2687 item
->arg_offset
= p
- buf
;
2688 item
->arg_len
= (int)(eol
- p
);
2689 item
->commit
= NULL
;
2694 else if (is_fixup(item
->command
))
2695 return error(_("cannot '%s' without a previous commit"),
2696 command_to_string(item
->command
));
2697 else if (!is_noop(item
->command
))
2704 static int count_commands(struct todo_list
*todo_list
)
2708 for (i
= 0; i
< todo_list
->nr
; i
++)
2709 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2715 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2717 return index
< todo_list
->nr
?
2718 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2721 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2723 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2726 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2728 return get_item_line_offset(todo_list
, index
+ 1)
2729 - get_item_line_offset(todo_list
, index
);
2732 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2737 fd
= open(path
, O_RDONLY
);
2739 return error_errno(_("could not open '%s'"), path
);
2740 len
= strbuf_read(sb
, fd
, 0);
2743 return error(_("could not read '%s'."), path
);
2747 static int have_finished_the_last_pick(void)
2749 struct strbuf buf
= STRBUF_INIT
;
2751 const char *todo_path
= git_path_todo_file();
2754 if (strbuf_read_file(&buf
, todo_path
, 0) < 0) {
2755 if (errno
== ENOENT
) {
2758 error_errno("unable to open '%s'", todo_path
);
2762 /* If there is only one line then we are done */
2763 eol
= strchr(buf
.buf
, '\n');
2764 if (!eol
|| !eol
[1])
2767 strbuf_release(&buf
);
2772 void sequencer_post_commit_cleanup(struct repository
*r
, int verbose
)
2774 struct replay_opts opts
= REPLAY_OPTS_INIT
;
2775 int need_cleanup
= 0;
2777 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
2778 if (!refs_delete_ref(get_main_ref_store(r
), "",
2779 "CHERRY_PICK_HEAD", NULL
, 0) &&
2781 warning(_("cancelling a cherry picking in progress"));
2782 opts
.action
= REPLAY_PICK
;
2786 if (refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
2787 if (!refs_delete_ref(get_main_ref_store(r
), "", "REVERT_HEAD",
2790 warning(_("cancelling a revert in progress"));
2791 opts
.action
= REPLAY_REVERT
;
2795 unlink(git_path_auto_merge(r
));
2800 if (!have_finished_the_last_pick())
2803 sequencer_remove_state(&opts
);
2806 static void todo_list_write_total_nr(struct todo_list
*todo_list
)
2808 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2811 fprintf(f
, "%d\n", todo_list
->total_nr
);
2816 static int read_populate_todo(struct repository
*r
,
2817 struct todo_list
*todo_list
,
2818 struct replay_opts
*opts
)
2820 const char *todo_file
= get_todo_path(opts
);
2823 strbuf_reset(&todo_list
->buf
);
2824 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2827 res
= todo_list_parse_insn_buffer(r
, todo_list
->buf
.buf
, todo_list
);
2829 if (is_rebase_i(opts
))
2830 return error(_("please fix this using "
2831 "'git rebase --edit-todo'."));
2832 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2835 if (!todo_list
->nr
&&
2836 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2837 return error(_("no commits parsed."));
2839 if (!is_rebase_i(opts
)) {
2840 enum todo_command valid
=
2841 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2844 for (i
= 0; i
< todo_list
->nr
; i
++)
2845 if (valid
== todo_list
->items
[i
].command
)
2847 else if (valid
== TODO_PICK
)
2848 return error(_("cannot cherry-pick during a revert."));
2850 return error(_("cannot revert during a cherry-pick."));
2853 if (is_rebase_i(opts
)) {
2854 struct todo_list done
= TODO_LIST_INIT
;
2856 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2857 !todo_list_parse_insn_buffer(r
, done
.buf
.buf
, &done
))
2858 todo_list
->done_nr
= count_commands(&done
);
2860 todo_list
->done_nr
= 0;
2862 todo_list
->total_nr
= todo_list
->done_nr
2863 + count_commands(todo_list
);
2864 todo_list_release(&done
);
2866 todo_list_write_total_nr(todo_list
);
2872 static int git_config_string_dup(char **dest
,
2873 const char *var
, const char *value
)
2876 return config_error_nonbool(var
);
2878 *dest
= xstrdup(value
);
2882 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
2884 struct replay_opts
*opts
= data
;
2889 else if (!strcmp(key
, "options.no-commit"))
2890 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
2891 else if (!strcmp(key
, "options.edit"))
2892 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
2893 else if (!strcmp(key
, "options.allow-empty"))
2895 git_config_bool_or_int(key
, value
, &error_flag
);
2896 else if (!strcmp(key
, "options.allow-empty-message"))
2897 opts
->allow_empty_message
=
2898 git_config_bool_or_int(key
, value
, &error_flag
);
2899 else if (!strcmp(key
, "options.keep-redundant-commits"))
2900 opts
->keep_redundant_commits
=
2901 git_config_bool_or_int(key
, value
, &error_flag
);
2902 else if (!strcmp(key
, "options.signoff"))
2903 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
2904 else if (!strcmp(key
, "options.record-origin"))
2905 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
2906 else if (!strcmp(key
, "options.allow-ff"))
2907 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
2908 else if (!strcmp(key
, "options.mainline"))
2909 opts
->mainline
= git_config_int(key
, value
);
2910 else if (!strcmp(key
, "options.strategy"))
2911 git_config_string_dup(&opts
->strategy
, key
, value
);
2912 else if (!strcmp(key
, "options.gpg-sign"))
2913 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
2914 else if (!strcmp(key
, "options.strategy-option")) {
2915 strvec_push(&opts
->xopts
, value
);
2916 } else if (!strcmp(key
, "options.allow-rerere-auto"))
2917 opts
->allow_rerere_auto
=
2918 git_config_bool_or_int(key
, value
, &error_flag
) ?
2919 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
2920 else if (!strcmp(key
, "options.default-msg-cleanup")) {
2921 opts
->explicit_cleanup
= 1;
2922 opts
->default_msg_cleanup
= get_cleanup_mode(value
, 1);
2924 return error(_("invalid key: %s"), key
);
2927 return error(_("invalid value for '%s': '%s'"), key
, value
);
2932 static void parse_strategy_opts(struct replay_opts
*opts
, char *raw_opts
)
2937 char *strategy_opts_string
= raw_opts
;
2939 if (*strategy_opts_string
== ' ')
2940 strategy_opts_string
++;
2942 count
= split_cmdline(strategy_opts_string
, &argv
);
2944 BUG("could not split '%s': %s", strategy_opts_string
,
2945 split_cmdline_strerror(count
));
2946 for (i
= 0; i
< count
; i
++) {
2947 const char *arg
= argv
[i
];
2949 skip_prefix(arg
, "--", &arg
);
2950 strvec_push(&opts
->xopts
, arg
);
2955 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2958 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2960 opts
->strategy
= strbuf_detach(buf
, NULL
);
2961 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2964 parse_strategy_opts(opts
, buf
->buf
);
2967 static int read_populate_opts(struct replay_opts
*opts
)
2969 if (is_rebase_i(opts
)) {
2970 struct strbuf buf
= STRBUF_INIT
;
2973 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(),
2974 READ_ONELINER_SKIP_IF_EMPTY
)) {
2975 if (!starts_with(buf
.buf
, "-S"))
2978 free(opts
->gpg_sign
);
2979 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2984 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(),
2985 READ_ONELINER_SKIP_IF_EMPTY
)) {
2986 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2987 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2988 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2989 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2993 if (file_exists(rebase_path_verbose()))
2996 if (file_exists(rebase_path_quiet()))
2999 if (file_exists(rebase_path_signoff())) {
3004 if (file_exists(rebase_path_cdate_is_adate())) {
3006 opts
->committer_date_is_author_date
= 1;
3009 if (file_exists(rebase_path_ignore_date())) {
3011 opts
->ignore_date
= 1;
3014 if (file_exists(rebase_path_reschedule_failed_exec()))
3015 opts
->reschedule_failed_exec
= 1;
3016 else if (file_exists(rebase_path_no_reschedule_failed_exec()))
3017 opts
->reschedule_failed_exec
= 0;
3019 if (file_exists(rebase_path_drop_redundant_commits()))
3020 opts
->drop_redundant_commits
= 1;
3022 if (file_exists(rebase_path_keep_redundant_commits()))
3023 opts
->keep_redundant_commits
= 1;
3025 read_strategy_opts(opts
, &buf
);
3028 if (read_oneliner(&opts
->current_fixups
,
3029 rebase_path_current_fixups(),
3030 READ_ONELINER_SKIP_IF_EMPTY
)) {
3031 const char *p
= opts
->current_fixups
.buf
;
3032 opts
->current_fixup_count
= 1;
3033 while ((p
= strchr(p
, '\n'))) {
3034 opts
->current_fixup_count
++;
3039 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
3040 if (repo_get_oid_committish(the_repository
, buf
.buf
, &opts
->squash_onto
) < 0) {
3041 ret
= error(_("unusable squash-onto"));
3044 opts
->have_squash_onto
= 1;
3048 strbuf_release(&buf
);
3052 if (!file_exists(git_path_opts_file()))
3055 * The function git_parse_source(), called from git_config_from_file(),
3056 * may die() in case of a syntactically incorrect file. We do not care
3057 * about this case, though, because we wrote that file ourselves, so we
3058 * are pretty certain that it is syntactically correct.
3060 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
3061 return error(_("malformed options sheet: '%s'"),
3062 git_path_opts_file());
3066 static void write_strategy_opts(struct replay_opts
*opts
)
3068 struct strbuf buf
= STRBUF_INIT
;
3071 * Quote strategy options so that they can be read correctly
3072 * by split_cmdline().
3074 quote_cmdline(&buf
, opts
->xopts
.v
);
3075 write_file(rebase_path_strategy_opts(), "%s\n", buf
.buf
);
3076 strbuf_release(&buf
);
3079 int write_basic_state(struct replay_opts
*opts
, const char *head_name
,
3080 struct commit
*onto
, const struct object_id
*orig_head
)
3083 write_file(rebase_path_head_name(), "%s\n", head_name
);
3085 write_file(rebase_path_onto(), "%s\n",
3086 oid_to_hex(&onto
->object
.oid
));
3088 write_file(rebase_path_orig_head(), "%s\n",
3089 oid_to_hex(orig_head
));
3092 write_file(rebase_path_quiet(), "%s", "");
3094 write_file(rebase_path_verbose(), "%s", "");
3096 write_file(rebase_path_strategy(), "%s\n", opts
->strategy
);
3097 if (opts
->xopts
.nr
> 0)
3098 write_strategy_opts(opts
);
3100 if (opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
)
3101 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
3102 else if (opts
->allow_rerere_auto
== RERERE_NOAUTOUPDATE
)
3103 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
3106 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts
->gpg_sign
);
3108 write_file(rebase_path_signoff(), "--signoff\n");
3109 if (opts
->drop_redundant_commits
)
3110 write_file(rebase_path_drop_redundant_commits(), "%s", "");
3111 if (opts
->keep_redundant_commits
)
3112 write_file(rebase_path_keep_redundant_commits(), "%s", "");
3113 if (opts
->committer_date_is_author_date
)
3114 write_file(rebase_path_cdate_is_adate(), "%s", "");
3115 if (opts
->ignore_date
)
3116 write_file(rebase_path_ignore_date(), "%s", "");
3117 if (opts
->reschedule_failed_exec
)
3118 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
3120 write_file(rebase_path_no_reschedule_failed_exec(), "%s", "");
3125 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
3126 struct replay_opts
*opts
)
3128 enum todo_command command
= opts
->action
== REPLAY_PICK
?
3129 TODO_PICK
: TODO_REVERT
;
3130 const char *command_string
= todo_command_info
[command
].str
;
3131 const char *encoding
;
3132 struct commit
*commit
;
3134 if (prepare_revs(opts
))
3137 encoding
= get_log_output_encoding();
3139 while ((commit
= get_revision(opts
->revs
))) {
3140 struct todo_item
*item
= append_new_todo(todo_list
);
3141 const char *commit_buffer
= repo_logmsg_reencode(the_repository
,
3144 const char *subject
;
3147 item
->command
= command
;
3148 item
->commit
= commit
;
3149 item
->arg_offset
= 0;
3151 item
->offset_in_buf
= todo_list
->buf
.len
;
3152 subject_len
= find_commit_subject(commit_buffer
, &subject
);
3153 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
3154 short_commit_name(commit
), subject_len
, subject
);
3155 repo_unuse_commit_buffer(the_repository
, commit
,
3160 return error(_("empty commit set passed"));
3165 static int create_seq_dir(struct repository
*r
)
3167 enum replay_action action
;
3168 const char *in_progress_error
= NULL
;
3169 const char *in_progress_advice
= NULL
;
3170 unsigned int advise_skip
=
3171 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD") ||
3172 refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD");
3174 if (!sequencer_get_last_command(r
, &action
)) {
3177 in_progress_error
= _("revert is already in progress");
3178 in_progress_advice
=
3179 _("try \"git revert (--continue | %s--abort | --quit)\"");
3182 in_progress_error
= _("cherry-pick is already in progress");
3183 in_progress_advice
=
3184 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
3187 BUG("unexpected action in create_seq_dir");
3190 if (in_progress_error
) {
3191 error("%s", in_progress_error
);
3192 if (advice_enabled(ADVICE_SEQUENCER_IN_USE
))
3193 advise(in_progress_advice
,
3194 advise_skip
? "--skip | " : "");
3197 if (mkdir(git_path_seq_dir(), 0777) < 0)
3198 return error_errno(_("could not create sequencer directory '%s'"),
3199 git_path_seq_dir());
3204 static int save_head(const char *head
)
3206 return write_message(head
, strlen(head
), git_path_head_file(), 1);
3209 static int rollback_is_safe(void)
3211 struct strbuf sb
= STRBUF_INIT
;
3212 struct object_id expected_head
, actual_head
;
3214 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
3216 if (get_oid_hex(sb
.buf
, &expected_head
)) {
3217 strbuf_release(&sb
);
3218 die(_("could not parse %s"), git_path_abort_safety_file());
3220 strbuf_release(&sb
);
3222 else if (errno
== ENOENT
)
3223 oidclr(&expected_head
);
3225 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
3227 if (repo_get_oid(the_repository
, "HEAD", &actual_head
))
3228 oidclr(&actual_head
);
3230 return oideq(&actual_head
, &expected_head
);
3233 static int reset_merge(const struct object_id
*oid
)
3235 struct child_process cmd
= CHILD_PROCESS_INIT
;
3238 strvec_pushl(&cmd
.args
, "reset", "--merge", NULL
);
3240 if (!is_null_oid(oid
))
3241 strvec_push(&cmd
.args
, oid_to_hex(oid
));
3243 return run_command(&cmd
);
3246 static int rollback_single_pick(struct repository
*r
)
3248 struct object_id head_oid
;
3250 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
3251 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
3252 return error(_("no cherry-pick or revert in progress"));
3253 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
3254 return error(_("cannot resolve HEAD"));
3255 if (is_null_oid(&head_oid
))
3256 return error(_("cannot abort from a branch yet to be born"));
3257 return reset_merge(&head_oid
);
3260 static int skip_single_pick(void)
3262 struct object_id head
;
3264 if (read_ref_full("HEAD", 0, &head
, NULL
))
3265 return error(_("cannot resolve HEAD"));
3266 return reset_merge(&head
);
3269 int sequencer_rollback(struct repository
*r
, struct replay_opts
*opts
)
3272 struct object_id oid
;
3273 struct strbuf buf
= STRBUF_INIT
;
3276 f
= fopen(git_path_head_file(), "r");
3277 if (!f
&& errno
== ENOENT
) {
3279 * There is no multiple-cherry-pick in progress.
3280 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
3281 * a single-cherry-pick in progress, abort that.
3283 return rollback_single_pick(r
);
3286 return error_errno(_("cannot open '%s'"), git_path_head_file());
3287 if (strbuf_getline_lf(&buf
, f
)) {
3288 error(_("cannot read '%s': %s"), git_path_head_file(),
3289 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
3294 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
3295 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
3296 git_path_head_file());
3299 if (is_null_oid(&oid
)) {
3300 error(_("cannot abort from a branch yet to be born"));
3304 if (!rollback_is_safe()) {
3305 /* Do not error, just do not rollback */
3306 warning(_("You seem to have moved HEAD. "
3307 "Not rewinding, check your HEAD!"));
3309 if (reset_merge(&oid
))
3311 strbuf_release(&buf
);
3312 return sequencer_remove_state(opts
);
3314 strbuf_release(&buf
);
3318 int sequencer_skip(struct repository
*r
, struct replay_opts
*opts
)
3320 enum replay_action action
= -1;
3321 sequencer_get_last_command(r
, &action
);
3324 * Check whether the subcommand requested to skip the commit is actually
3325 * in progress and that it's safe to skip the commit.
3327 * opts->action tells us which subcommand requested to skip the commit.
3328 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
3329 * action is in progress and we can skip the commit.
3331 * Otherwise we check that the last instruction was related to the
3332 * particular subcommand we're trying to execute and barf if that's not
3335 * Finally we check that the rollback is "safe", i.e., has the HEAD
3336 * moved? In this case, it doesn't make sense to "reset the merge" and
3337 * "skip the commit" as the user already handled this by committing. But
3338 * we'd not want to barf here, instead give advice on how to proceed. We
3339 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
3340 * it gets removed when the user commits, so if it still exists we're
3341 * sure the user can't have committed before.
3343 switch (opts
->action
) {
3345 if (!refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
3346 if (action
!= REPLAY_REVERT
)
3347 return error(_("no revert in progress"));
3348 if (!rollback_is_safe())
3353 if (!refs_ref_exists(get_main_ref_store(r
),
3354 "CHERRY_PICK_HEAD")) {
3355 if (action
!= REPLAY_PICK
)
3356 return error(_("no cherry-pick in progress"));
3357 if (!rollback_is_safe())
3362 BUG("unexpected action in sequencer_skip");
3365 if (skip_single_pick())
3366 return error(_("failed to skip the commit"));
3367 if (!is_directory(git_path_seq_dir()))
3370 return sequencer_continue(r
, opts
);
3373 error(_("there is nothing to skip"));
3375 if (advice_enabled(ADVICE_RESOLVE_CONFLICT
)) {
3376 advise(_("have you committed already?\n"
3377 "try \"git %s --continue\""),
3378 action
== REPLAY_REVERT
? "revert" : "cherry-pick");
3383 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
3385 struct lock_file todo_lock
= LOCK_INIT
;
3386 const char *todo_path
= get_todo_path(opts
);
3387 int next
= todo_list
->current
, offset
, fd
;
3390 * rebase -i writes "git-rebase-todo" without the currently executing
3391 * command, appending it to "done" instead.
3393 if (is_rebase_i(opts
))
3396 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
3398 return error_errno(_("could not lock '%s'"), todo_path
);
3399 offset
= get_item_line_offset(todo_list
, next
);
3400 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
3401 todo_list
->buf
.len
- offset
) < 0)
3402 return error_errno(_("could not write to '%s'"), todo_path
);
3403 if (commit_lock_file(&todo_lock
) < 0)
3404 return error(_("failed to finalize '%s'"), todo_path
);
3406 if (is_rebase_i(opts
) && next
> 0) {
3407 const char *done
= rebase_path_done();
3408 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
3413 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
3414 get_item_line_length(todo_list
, next
- 1))
3416 ret
= error_errno(_("could not write to '%s'"), done
);
3418 ret
= error_errno(_("failed to finalize '%s'"), done
);
3424 static int save_opts(struct replay_opts
*opts
)
3426 const char *opts_file
= git_path_opts_file();
3429 if (opts
->no_commit
)
3430 res
|= git_config_set_in_file_gently(opts_file
,
3431 "options.no-commit", "true");
3432 if (opts
->edit
>= 0)
3433 res
|= git_config_set_in_file_gently(opts_file
, "options.edit",
3434 opts
->edit
? "true" : "false");
3435 if (opts
->allow_empty
)
3436 res
|= git_config_set_in_file_gently(opts_file
,
3437 "options.allow-empty", "true");
3438 if (opts
->allow_empty_message
)
3439 res
|= git_config_set_in_file_gently(opts_file
,
3440 "options.allow-empty-message", "true");
3441 if (opts
->keep_redundant_commits
)
3442 res
|= git_config_set_in_file_gently(opts_file
,
3443 "options.keep-redundant-commits", "true");
3445 res
|= git_config_set_in_file_gently(opts_file
,
3446 "options.signoff", "true");
3447 if (opts
->record_origin
)
3448 res
|= git_config_set_in_file_gently(opts_file
,
3449 "options.record-origin", "true");
3451 res
|= git_config_set_in_file_gently(opts_file
,
3452 "options.allow-ff", "true");
3453 if (opts
->mainline
) {
3454 struct strbuf buf
= STRBUF_INIT
;
3455 strbuf_addf(&buf
, "%d", opts
->mainline
);
3456 res
|= git_config_set_in_file_gently(opts_file
,
3457 "options.mainline", buf
.buf
);
3458 strbuf_release(&buf
);
3461 res
|= git_config_set_in_file_gently(opts_file
,
3462 "options.strategy", opts
->strategy
);
3464 res
|= git_config_set_in_file_gently(opts_file
,
3465 "options.gpg-sign", opts
->gpg_sign
);
3466 for (size_t i
= 0; i
< opts
->xopts
.nr
; i
++)
3467 res
|= git_config_set_multivar_in_file_gently(opts_file
,
3468 "options.strategy-option",
3469 opts
->xopts
.v
[i
], "^$", 0);
3470 if (opts
->allow_rerere_auto
)
3471 res
|= git_config_set_in_file_gently(opts_file
,
3472 "options.allow-rerere-auto",
3473 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
3476 if (opts
->explicit_cleanup
)
3477 res
|= git_config_set_in_file_gently(opts_file
,
3478 "options.default-msg-cleanup",
3479 describe_cleanup_mode(opts
->default_msg_cleanup
));
3483 static int make_patch(struct repository
*r
,
3484 struct commit
*commit
,
3485 struct replay_opts
*opts
)
3487 struct strbuf buf
= STRBUF_INIT
;
3488 struct rev_info log_tree_opt
;
3489 const char *subject
;
3490 char hex
[GIT_MAX_HEXSZ
+ 1];
3493 oid_to_hex_r(hex
, &commit
->object
.oid
);
3494 if (write_message(hex
, strlen(hex
), rebase_path_stopped_sha(), 1) < 0)
3496 res
|= write_rebase_head(&commit
->object
.oid
);
3498 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
3499 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3500 repo_init_revisions(r
, &log_tree_opt
, NULL
);
3501 log_tree_opt
.abbrev
= 0;
3502 log_tree_opt
.diff
= 1;
3503 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
3504 log_tree_opt
.disable_stdin
= 1;
3505 log_tree_opt
.no_commit_id
= 1;
3506 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
3507 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
3508 if (!log_tree_opt
.diffopt
.file
)
3509 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
3511 res
|= log_tree_commit(&log_tree_opt
, commit
);
3512 fclose(log_tree_opt
.diffopt
.file
);
3516 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
3517 if (!file_exists(buf
.buf
)) {
3518 const char *encoding
= get_commit_output_encoding();
3519 const char *commit_buffer
= repo_logmsg_reencode(r
,
3522 find_commit_subject(commit_buffer
, &subject
);
3523 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
3524 repo_unuse_commit_buffer(r
, commit
,
3527 strbuf_release(&buf
);
3528 release_revisions(&log_tree_opt
);
3533 static int intend_to_amend(void)
3535 struct object_id head
;
3538 if (repo_get_oid(the_repository
, "HEAD", &head
))
3539 return error(_("cannot read HEAD"));
3541 p
= oid_to_hex(&head
);
3542 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
3545 static int error_with_patch(struct repository
*r
,
3546 struct commit
*commit
,
3547 const char *subject
, int subject_len
,
3548 struct replay_opts
*opts
,
3549 int exit_code
, int to_amend
)
3552 if (make_patch(r
, commit
, opts
))
3554 } else if (copy_file(rebase_path_message(),
3555 git_path_merge_msg(r
), 0666))
3556 return error(_("unable to copy '%s' to '%s'"),
3557 git_path_merge_msg(r
), rebase_path_message());
3560 if (intend_to_amend())
3564 _("You can amend the commit now, with\n"
3566 " git commit --amend %s\n"
3568 "Once you are satisfied with your changes, run\n"
3570 " git rebase --continue\n"),
3571 gpg_sign_opt_quoted(opts
));
3572 } else if (exit_code
) {
3574 fprintf_ln(stderr
, _("Could not apply %s... %.*s"),
3575 short_commit_name(commit
), subject_len
, subject
);
3578 * We don't have the hash of the parent so
3579 * just print the line from the todo file.
3581 fprintf_ln(stderr
, _("Could not merge %.*s"),
3582 subject_len
, subject
);
3588 static int error_failed_squash(struct repository
*r
,
3589 struct commit
*commit
,
3590 struct replay_opts
*opts
,
3592 const char *subject
)
3594 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3595 return error(_("could not copy '%s' to '%s'"),
3596 rebase_path_squash_msg(), rebase_path_message());
3597 unlink(git_path_merge_msg(r
));
3598 if (copy_file(git_path_merge_msg(r
), rebase_path_message(), 0666))
3599 return error(_("could not copy '%s' to '%s'"),
3600 rebase_path_message(),
3601 git_path_merge_msg(r
));
3602 return error_with_patch(r
, commit
, subject
, subject_len
, opts
, 1, 0);
3605 static int do_exec(struct repository
*r
, const char *command_line
)
3607 struct child_process cmd
= CHILD_PROCESS_INIT
;
3610 fprintf(stderr
, _("Executing: %s\n"), command_line
);
3612 strvec_push(&cmd
.args
, command_line
);
3613 status
= run_command(&cmd
);
3615 /* force re-reading of the cache */
3616 discard_index(r
->index
);
3617 if (repo_read_index(r
) < 0)
3618 return error(_("could not read index"));
3620 dirty
= require_clean_work_tree(r
, "rebase", NULL
, 1, 1);
3623 warning(_("execution failed: %s\n%s"
3624 "You can fix the problem, and then run\n"
3626 " git rebase --continue\n"
3629 dirty
? _("and made changes to the index and/or the "
3630 "working tree\n") : "");
3632 /* command not found */
3635 warning(_("execution succeeded: %s\nbut "
3636 "left changes to the index and/or the working tree\n"
3637 "Commit or stash your changes, and then run\n"
3639 " git rebase --continue\n"
3640 "\n"), command_line
);
3647 __attribute__((format (printf
, 2, 3)))
3648 static int safe_append(const char *filename
, const char *fmt
, ...)
3651 struct lock_file lock
= LOCK_INIT
;
3652 int fd
= hold_lock_file_for_update(&lock
, filename
,
3653 LOCK_REPORT_ON_ERROR
);
3654 struct strbuf buf
= STRBUF_INIT
;
3659 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
3660 error_errno(_("could not read '%s'"), filename
);
3661 rollback_lock_file(&lock
);
3664 strbuf_complete(&buf
, '\n');
3666 strbuf_vaddf(&buf
, fmt
, ap
);
3669 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
3670 error_errno(_("could not write to '%s'"), filename
);
3671 strbuf_release(&buf
);
3672 rollback_lock_file(&lock
);
3675 if (commit_lock_file(&lock
) < 0) {
3676 strbuf_release(&buf
);
3677 return error(_("failed to finalize '%s'"), filename
);
3680 strbuf_release(&buf
);
3684 static int do_label(struct repository
*r
, const char *name
, int len
)
3686 struct ref_store
*refs
= get_main_ref_store(r
);
3687 struct ref_transaction
*transaction
;
3688 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
3689 struct strbuf msg
= STRBUF_INIT
;
3691 struct object_id head_oid
;
3693 if (len
== 1 && *name
== '#')
3694 return error(_("illegal label name: '%.*s'"), len
, name
);
3696 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3697 strbuf_addf(&msg
, "rebase (label) '%.*s'", len
, name
);
3699 transaction
= ref_store_transaction_begin(refs
, &err
);
3701 error("%s", err
.buf
);
3703 } else if (repo_get_oid(r
, "HEAD", &head_oid
)) {
3704 error(_("could not read HEAD"));
3706 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
3707 NULL
, 0, msg
.buf
, &err
) < 0 ||
3708 ref_transaction_commit(transaction
, &err
)) {
3709 error("%s", err
.buf
);
3712 ref_transaction_free(transaction
);
3713 strbuf_release(&err
);
3714 strbuf_release(&msg
);
3717 ret
= safe_append(rebase_path_refs_to_delete(),
3718 "%s\n", ref_name
.buf
);
3719 strbuf_release(&ref_name
);
3724 static const char *sequencer_reflog_action(struct replay_opts
*opts
)
3726 if (!opts
->reflog_action
) {
3727 opts
->reflog_action
= getenv(GIT_REFLOG_ACTION
);
3728 opts
->reflog_action
=
3729 xstrdup(opts
->reflog_action
? opts
->reflog_action
3730 : action_name(opts
));
3733 return opts
->reflog_action
;
3736 __attribute__((format (printf
, 3, 4)))
3737 static const char *reflog_message(struct replay_opts
*opts
,
3738 const char *sub_action
, const char *fmt
, ...)
3741 static struct strbuf buf
= STRBUF_INIT
;
3745 strbuf_addstr(&buf
, sequencer_reflog_action(opts
));
3747 strbuf_addf(&buf
, " (%s)", sub_action
);
3749 strbuf_addstr(&buf
, ": ");
3750 strbuf_vaddf(&buf
, fmt
, ap
);
3757 static struct commit
*lookup_label(struct repository
*r
, const char *label
,
3758 int len
, struct strbuf
*buf
)
3760 struct commit
*commit
;
3761 struct object_id oid
;
3764 strbuf_addf(buf
, "refs/rewritten/%.*s", len
, label
);
3765 if (!read_ref(buf
->buf
, &oid
)) {
3766 commit
= lookup_commit_object(r
, &oid
);
3768 /* fall back to non-rewritten ref or commit */
3769 strbuf_splice(buf
, 0, strlen("refs/rewritten/"), "", 0);
3770 commit
= lookup_commit_reference_by_name(buf
->buf
);
3774 error(_("could not resolve '%s'"), buf
->buf
);
3779 static int do_reset(struct repository
*r
,
3780 const char *name
, int len
,
3781 struct replay_opts
*opts
)
3783 struct strbuf ref_name
= STRBUF_INIT
;
3784 struct object_id oid
;
3785 struct lock_file lock
= LOCK_INIT
;
3786 struct tree_desc desc
= { 0 };
3788 struct unpack_trees_options unpack_tree_opts
= { 0 };
3791 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0)
3794 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
3795 if (!opts
->have_squash_onto
) {
3797 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
3798 NULL
, &opts
->squash_onto
,
3800 return error(_("writing fake root commit"));
3801 opts
->have_squash_onto
= 1;
3802 hex
= oid_to_hex(&opts
->squash_onto
);
3803 if (write_message(hex
, strlen(hex
),
3804 rebase_path_squash_onto(), 0))
3805 return error(_("writing squash-onto"));
3807 oidcpy(&oid
, &opts
->squash_onto
);
3810 struct commit
*commit
;
3812 /* Determine the length of the label */
3813 for (i
= 0; i
< len
; i
++)
3814 if (isspace(name
[i
]))
3818 commit
= lookup_label(r
, name
, len
, &ref_name
);
3823 oid
= commit
->object
.oid
;
3826 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
3827 unpack_tree_opts
.head_idx
= 1;
3828 unpack_tree_opts
.src_index
= r
->index
;
3829 unpack_tree_opts
.dst_index
= r
->index
;
3830 unpack_tree_opts
.fn
= oneway_merge
;
3831 unpack_tree_opts
.merge
= 1;
3832 unpack_tree_opts
.update
= 1;
3833 unpack_tree_opts
.preserve_ignored
= 0; /* FIXME: !overwrite_ignore */
3834 unpack_tree_opts
.skip_cache_tree_update
= 1;
3835 init_checkout_metadata(&unpack_tree_opts
.meta
, name
, &oid
, NULL
);
3837 if (repo_read_index_unmerged(r
)) {
3838 ret
= error_resolve_conflict(action_name(opts
));
3842 if (!fill_tree_descriptor(r
, &desc
, &oid
)) {
3843 ret
= error(_("failed to find tree of %s"), oid_to_hex(&oid
));
3847 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
3852 tree
= parse_tree_indirect(&oid
);
3853 prime_cache_tree(r
, r
->index
, tree
);
3855 if (write_locked_index(r
->index
, &lock
, COMMIT_LOCK
) < 0)
3856 ret
= error(_("could not write index"));
3859 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
3860 len
, name
), "HEAD", &oid
,
3861 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3863 free((void *)desc
.buffer
);
3865 rollback_lock_file(&lock
);
3866 strbuf_release(&ref_name
);
3867 clear_unpack_trees_porcelain(&unpack_tree_opts
);
3871 static int do_merge(struct repository
*r
,
3872 struct commit
*commit
,
3873 const char *arg
, int arg_len
,
3874 int flags
, int *check_todo
, struct replay_opts
*opts
)
3876 int run_commit_flags
= 0;
3877 struct strbuf ref_name
= STRBUF_INIT
;
3878 struct commit
*head_commit
, *merge_commit
, *i
;
3879 struct commit_list
*bases
, *j
;
3880 struct commit_list
*to_merge
= NULL
, **tail
= &to_merge
;
3881 const char *strategy
= !opts
->xopts
.nr
&&
3883 !strcmp(opts
->strategy
, "recursive") ||
3884 !strcmp(opts
->strategy
, "ort")) ?
3885 NULL
: opts
->strategy
;
3886 struct merge_options o
;
3887 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
, k
;
3888 static struct lock_file lock
;
3891 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0) {
3896 head_commit
= lookup_commit_reference_by_name("HEAD");
3898 ret
= error(_("cannot merge without a current revision"));
3903 * For octopus merges, the arg starts with the list of revisions to be
3904 * merged. The list is optionally followed by '#' and the oneline.
3906 merge_arg_len
= oneline_offset
= arg_len
;
3907 for (p
= arg
; p
- arg
< arg_len
; p
+= strspn(p
, " \t\n")) {
3910 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
3911 p
+= 1 + strspn(p
+ 1, " \t\n");
3912 oneline_offset
= p
- arg
;
3915 k
= strcspn(p
, " \t\n");
3918 merge_commit
= lookup_label(r
, p
, k
, &ref_name
);
3919 if (!merge_commit
) {
3920 ret
= error(_("unable to parse '%.*s'"), k
, p
);
3923 tail
= &commit_list_insert(merge_commit
, tail
)->next
;
3925 merge_arg_len
= p
- arg
;
3929 ret
= error(_("nothing to merge: '%.*s'"), arg_len
, arg
);
3933 if (opts
->have_squash_onto
&&
3934 oideq(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
3936 * When the user tells us to "merge" something into a
3937 * "[new root]", let's simply fast-forward to the merge head.
3939 rollback_lock_file(&lock
);
3941 ret
= error(_("octopus merge cannot be executed on "
3942 "top of a [new root]"));
3944 ret
= fast_forward_to(r
, &to_merge
->item
->object
.oid
,
3945 &head_commit
->object
.oid
, 0,
3951 * If HEAD is not identical to the first parent of the original merge
3952 * commit, we cannot fast-forward.
3954 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
3955 oideq(&commit
->parents
->item
->object
.oid
,
3956 &head_commit
->object
.oid
);
3959 * If any merge head is different from the original one, we cannot
3962 if (can_fast_forward
) {
3963 struct commit_list
*p
= commit
->parents
->next
;
3965 for (j
= to_merge
; j
&& p
; j
= j
->next
, p
= p
->next
)
3966 if (!oideq(&j
->item
->object
.oid
,
3967 &p
->item
->object
.oid
)) {
3968 can_fast_forward
= 0;
3972 * If the number of merge heads differs from the original merge
3973 * commit, we cannot fast-forward.
3976 can_fast_forward
= 0;
3979 if (can_fast_forward
) {
3980 rollback_lock_file(&lock
);
3981 ret
= fast_forward_to(r
, &commit
->object
.oid
,
3982 &head_commit
->object
.oid
, 0, opts
);
3983 if (flags
& TODO_EDIT_MERGE_MSG
)
3984 goto fast_forward_edit
;
3990 const char *encoding
= get_commit_output_encoding();
3991 const char *message
= repo_logmsg_reencode(r
, commit
, NULL
,
3997 ret
= error(_("could not get commit message of '%s'"),
3998 oid_to_hex(&commit
->object
.oid
));
4001 write_author_script(message
);
4002 find_commit_subject(message
, &body
);
4004 ret
= write_message(body
, len
, git_path_merge_msg(r
), 0);
4005 repo_unuse_commit_buffer(r
, commit
, message
);
4007 error_errno(_("could not write '%s'"),
4008 git_path_merge_msg(r
));
4012 struct strbuf buf
= STRBUF_INIT
;
4015 strbuf_addf(&buf
, "author %s", git_author_info(0));
4016 write_author_script(buf
.buf
);
4019 if (oneline_offset
< arg_len
) {
4020 p
= arg
+ oneline_offset
;
4021 len
= arg_len
- oneline_offset
;
4023 strbuf_addf(&buf
, "Merge %s '%.*s'",
4024 to_merge
->next
? "branches" : "branch",
4025 merge_arg_len
, arg
);
4030 ret
= write_message(p
, len
, git_path_merge_msg(r
), 0);
4031 strbuf_release(&buf
);
4033 error_errno(_("could not write '%s'"),
4034 git_path_merge_msg(r
));
4039 if (strategy
|| to_merge
->next
) {
4041 struct child_process cmd
= CHILD_PROCESS_INIT
;
4043 if (read_env_script(&cmd
.env
)) {
4044 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
4046 ret
= error(_(staged_changes_advice
), gpg_opt
, gpg_opt
);
4050 if (opts
->committer_date_is_author_date
)
4051 strvec_pushf(&cmd
.env
, "GIT_COMMITTER_DATE=%s",
4054 author_date_from_env(&cmd
.env
));
4055 if (opts
->ignore_date
)
4056 strvec_push(&cmd
.env
, "GIT_AUTHOR_DATE=");
4059 strvec_push(&cmd
.args
, "merge");
4060 strvec_push(&cmd
.args
, "-s");
4062 strvec_push(&cmd
.args
, "octopus");
4064 strvec_push(&cmd
.args
, strategy
);
4065 for (k
= 0; k
< opts
->xopts
.nr
; k
++)
4066 strvec_pushf(&cmd
.args
,
4067 "-X%s", opts
->xopts
.v
[k
]);
4069 if (!(flags
& TODO_EDIT_MERGE_MSG
))
4070 strvec_push(&cmd
.args
, "--no-edit");
4072 strvec_push(&cmd
.args
, "--edit");
4073 strvec_push(&cmd
.args
, "--no-ff");
4074 strvec_push(&cmd
.args
, "--no-log");
4075 strvec_push(&cmd
.args
, "--no-stat");
4076 strvec_push(&cmd
.args
, "-F");
4077 strvec_push(&cmd
.args
, git_path_merge_msg(r
));
4079 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
4081 strvec_push(&cmd
.args
, "--no-gpg-sign");
4083 /* Add the tips to be merged */
4084 for (j
= to_merge
; j
; j
= j
->next
)
4085 strvec_push(&cmd
.args
,
4086 oid_to_hex(&j
->item
->object
.oid
));
4088 strbuf_release(&ref_name
);
4089 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
4091 rollback_lock_file(&lock
);
4093 ret
= run_command(&cmd
);
4095 /* force re-reading of the cache */
4097 discard_index(r
->index
);
4098 if (repo_read_index(r
) < 0)
4099 ret
= error(_("could not read index"));
4104 merge_commit
= to_merge
->item
;
4105 bases
= repo_get_merge_bases(r
, head_commit
, merge_commit
);
4106 if (bases
&& oideq(&merge_commit
->object
.oid
,
4107 &bases
->item
->object
.oid
)) {
4109 /* skip merging an ancestor of HEAD */
4113 write_message(oid_to_hex(&merge_commit
->object
.oid
), the_hash_algo
->hexsz
,
4114 git_path_merge_head(r
), 0);
4115 write_message("no-ff", 5, git_path_merge_mode(r
), 0);
4117 bases
= reverse_commit_list(bases
);
4120 init_merge_options(&o
, r
);
4122 o
.branch2
= ref_name
.buf
;
4123 o
.buffer_output
= 2;
4125 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
4127 * TODO: Should use merge_incore_recursive() and
4128 * merge_switch_to_result(), skipping the call to
4129 * merge_switch_to_result() when we don't actually need to
4130 * update the index and working copy immediately.
4132 ret
= merge_ort_recursive(&o
,
4133 head_commit
, merge_commit
, bases
,
4136 ret
= merge_recursive(&o
, head_commit
, merge_commit
, bases
,
4140 fputs(o
.obuf
.buf
, stdout
);
4141 strbuf_release(&o
.obuf
);
4143 error(_("could not even attempt to merge '%.*s'"),
4144 merge_arg_len
, arg
);
4148 * The return value of merge_recursive() is 1 on clean, and 0 on
4151 * Let's reverse that, so that do_merge() returns 0 upon success and
4152 * 1 upon failed merge (keeping the return value -1 for the cases where
4153 * we will want to reschedule the `merge` command).
4157 if (r
->index
->cache_changed
&&
4158 write_locked_index(r
->index
, &lock
, COMMIT_LOCK
)) {
4159 ret
= error(_("merge: Unable to write new index file"));
4163 rollback_lock_file(&lock
);
4165 repo_rerere(r
, opts
->allow_rerere_auto
);
4168 * In case of problems, we now want to return a positive
4169 * value (a negative one would indicate that the `merge`
4170 * command needs to be rescheduled).
4172 ret
= !!run_git_commit(git_path_merge_msg(r
), opts
,
4175 if (!ret
&& flags
& TODO_EDIT_MERGE_MSG
) {
4178 run_commit_flags
|= AMEND_MSG
| EDIT_MSG
| VERIFY_MSG
;
4179 ret
= !!run_git_commit(NULL
, opts
, run_commit_flags
);
4184 strbuf_release(&ref_name
);
4185 rollback_lock_file(&lock
);
4186 free_commit_list(to_merge
);
4190 static int write_update_refs_state(struct string_list
*refs_to_oids
)
4193 struct lock_file lock
= LOCK_INIT
;
4195 struct string_list_item
*item
;
4198 path
= rebase_path_update_refs(the_repository
->gitdir
);
4200 if (!refs_to_oids
->nr
) {
4201 if (unlink(path
) && errno
!= ENOENT
)
4202 result
= error_errno(_("could not unlink: %s"), path
);
4206 if (safe_create_leading_directories(path
)) {
4207 result
= error(_("unable to create leading directories of %s"),
4212 if (hold_lock_file_for_update(&lock
, path
, 0) < 0) {
4213 result
= error(_("another 'rebase' process appears to be running; "
4214 "'%s.lock' already exists"),
4219 fp
= fdopen_lock_file(&lock
, "w");
4221 result
= error_errno(_("could not open '%s' for writing"), path
);
4222 rollback_lock_file(&lock
);
4226 for_each_string_list_item(item
, refs_to_oids
) {
4227 struct update_ref_record
*rec
= item
->util
;
4228 fprintf(fp
, "%s\n%s\n%s\n", item
->string
,
4229 oid_to_hex(&rec
->before
), oid_to_hex(&rec
->after
));
4232 result
= commit_lock_file(&lock
);
4240 * Parse the update-refs file for the current rebase, then remove the
4241 * refs that do not appear in the todo_list (and have not had updated
4242 * values stored) and add refs that are in the todo_list but not
4243 * represented in the update-refs file.
4245 * If there are changes to the update-refs list, then write the new state
4248 void todo_list_filter_update_refs(struct repository
*r
,
4249 struct todo_list
*todo_list
)
4253 struct string_list update_refs
= STRING_LIST_INIT_DUP
;
4255 sequencer_get_update_refs_state(r
->gitdir
, &update_refs
);
4258 * For each item in the update_refs list, if it has no updated
4259 * value and does not appear in the todo_list, then remove it
4260 * from the update_refs list.
4262 for (i
= 0; i
< update_refs
.nr
; i
++) {
4265 const char *ref
= update_refs
.items
[i
].string
;
4266 size_t reflen
= strlen(ref
);
4267 struct update_ref_record
*rec
= update_refs
.items
[i
].util
;
4269 /* OID already stored as updated. */
4270 if (!is_null_oid(&rec
->after
))
4273 for (j
= 0; !found
&& j
< todo_list
->total_nr
; j
++) {
4274 struct todo_item
*item
= &todo_list
->items
[j
];
4275 const char *arg
= todo_list
->buf
.buf
+ item
->arg_offset
;
4277 if (item
->command
!= TODO_UPDATE_REF
)
4280 if (item
->arg_len
!= reflen
||
4281 strncmp(arg
, ref
, reflen
))
4288 free(update_refs
.items
[i
].string
);
4289 free(update_refs
.items
[i
].util
);
4292 MOVE_ARRAY(update_refs
.items
+ i
, update_refs
.items
+ i
+ 1, update_refs
.nr
- i
);
4300 * For each todo_item, check if its ref is in the update_refs list.
4301 * If not, then add it as an un-updated ref.
4303 for (i
= 0; i
< todo_list
->total_nr
; i
++) {
4304 struct todo_item
*item
= &todo_list
->items
[i
];
4305 const char *arg
= todo_list
->buf
.buf
+ item
->arg_offset
;
4308 if (item
->command
!= TODO_UPDATE_REF
)
4311 for (j
= 0; !found
&& j
< update_refs
.nr
; j
++) {
4312 const char *ref
= update_refs
.items
[j
].string
;
4314 found
= strlen(ref
) == item
->arg_len
&&
4315 !strncmp(ref
, arg
, item
->arg_len
);
4319 struct string_list_item
*inserted
;
4320 struct strbuf argref
= STRBUF_INIT
;
4322 strbuf_add(&argref
, arg
, item
->arg_len
);
4323 inserted
= string_list_insert(&update_refs
, argref
.buf
);
4324 inserted
->util
= init_update_ref_record(argref
.buf
);
4325 strbuf_release(&argref
);
4331 write_update_refs_state(&update_refs
);
4332 string_list_clear(&update_refs
, 1);
4335 static int do_update_ref(struct repository
*r
, const char *refname
)
4337 struct string_list_item
*item
;
4338 struct string_list list
= STRING_LIST_INIT_DUP
;
4340 if (sequencer_get_update_refs_state(r
->gitdir
, &list
))
4343 for_each_string_list_item(item
, &list
) {
4344 if (!strcmp(item
->string
, refname
)) {
4345 struct update_ref_record
*rec
= item
->util
;
4346 if (read_ref("HEAD", &rec
->after
))
4352 write_update_refs_state(&list
);
4353 string_list_clear(&list
, 1);
4357 static int do_update_refs(struct repository
*r
, int quiet
)
4360 struct string_list_item
*item
;
4361 struct string_list refs_to_oids
= STRING_LIST_INIT_DUP
;
4362 struct ref_store
*refs
= get_main_ref_store(r
);
4363 struct strbuf update_msg
= STRBUF_INIT
;
4364 struct strbuf error_msg
= STRBUF_INIT
;
4366 if ((res
= sequencer_get_update_refs_state(r
->gitdir
, &refs_to_oids
)))
4369 for_each_string_list_item(item
, &refs_to_oids
) {
4370 struct update_ref_record
*rec
= item
->util
;
4373 loop_res
= refs_update_ref(refs
, "rewritten during rebase",
4375 &rec
->after
, &rec
->before
,
4376 0, UPDATE_REFS_MSG_ON_ERR
);
4383 strbuf_addf(&error_msg
, "\t%s\n", item
->string
);
4385 strbuf_addf(&update_msg
, "\t%s\n", item
->string
);
4389 (update_msg
.len
|| error_msg
.len
)) {
4391 _("Updated the following refs with %s:\n%s"),
4397 _("Failed to update the following refs with %s:\n%s"),
4402 string_list_clear(&refs_to_oids
, 1);
4403 strbuf_release(&update_msg
);
4404 strbuf_release(&error_msg
);
4408 static int is_final_fixup(struct todo_list
*todo_list
)
4410 int i
= todo_list
->current
;
4412 if (!is_fixup(todo_list
->items
[i
].command
))
4415 while (++i
< todo_list
->nr
)
4416 if (is_fixup(todo_list
->items
[i
].command
))
4418 else if (!is_noop(todo_list
->items
[i
].command
))
4423 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
4427 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
4428 if (!is_noop(todo_list
->items
[i
].command
))
4429 return todo_list
->items
[i
].command
;
4434 void create_autostash(struct repository
*r
, const char *path
)
4436 struct strbuf buf
= STRBUF_INIT
;
4437 struct lock_file lock_file
= LOCK_INIT
;
4440 fd
= repo_hold_locked_index(r
, &lock_file
, 0);
4441 refresh_index(r
->index
, REFRESH_QUIET
, NULL
, NULL
, NULL
);
4443 repo_update_index_if_able(r
, &lock_file
);
4444 rollback_lock_file(&lock_file
);
4446 if (has_unstaged_changes(r
, 1) ||
4447 has_uncommitted_changes(r
, 1)) {
4448 struct child_process stash
= CHILD_PROCESS_INIT
;
4449 struct reset_head_opts ropts
= { .flags
= RESET_HEAD_HARD
};
4450 struct object_id oid
;
4452 strvec_pushl(&stash
.args
,
4453 "stash", "create", "autostash", NULL
);
4457 if (capture_command(&stash
, &buf
, GIT_MAX_HEXSZ
))
4458 die(_("Cannot autostash"));
4459 strbuf_trim_trailing_newline(&buf
);
4460 if (repo_get_oid(r
, buf
.buf
, &oid
))
4461 die(_("Unexpected stash response: '%s'"),
4464 strbuf_add_unique_abbrev(&buf
, &oid
, DEFAULT_ABBREV
);
4466 if (safe_create_leading_directories_const(path
))
4467 die(_("Could not create directory for '%s'"),
4469 write_file(path
, "%s", oid_to_hex(&oid
));
4470 printf(_("Created autostash: %s\n"), buf
.buf
);
4471 if (reset_head(r
, &ropts
) < 0)
4472 die(_("could not reset --hard"));
4473 discard_index(r
->index
);
4474 if (repo_read_index(r
) < 0)
4475 die(_("could not read index"));
4477 strbuf_release(&buf
);
4480 static int apply_save_autostash_oid(const char *stash_oid
, int attempt_apply
)
4482 struct child_process child
= CHILD_PROCESS_INIT
;
4485 if (attempt_apply
) {
4487 child
.no_stdout
= 1;
4488 child
.no_stderr
= 1;
4489 strvec_push(&child
.args
, "stash");
4490 strvec_push(&child
.args
, "apply");
4491 strvec_push(&child
.args
, stash_oid
);
4492 ret
= run_command(&child
);
4495 if (attempt_apply
&& !ret
)
4496 fprintf(stderr
, _("Applied autostash.\n"));
4498 struct child_process store
= CHILD_PROCESS_INIT
;
4501 strvec_push(&store
.args
, "stash");
4502 strvec_push(&store
.args
, "store");
4503 strvec_push(&store
.args
, "-m");
4504 strvec_push(&store
.args
, "autostash");
4505 strvec_push(&store
.args
, "-q");
4506 strvec_push(&store
.args
, stash_oid
);
4507 if (run_command(&store
))
4508 ret
= error(_("cannot store %s"), stash_oid
);
4512 "Your changes are safe in the stash.\n"
4513 "You can run \"git stash pop\" or"
4514 " \"git stash drop\" at any time.\n"),
4516 _("Applying autostash resulted in conflicts.") :
4517 _("Autostash exists; creating a new stash entry."));
4523 static int apply_save_autostash(const char *path
, int attempt_apply
)
4525 struct strbuf stash_oid
= STRBUF_INIT
;
4528 if (!read_oneliner(&stash_oid
, path
,
4529 READ_ONELINER_SKIP_IF_EMPTY
)) {
4530 strbuf_release(&stash_oid
);
4533 strbuf_trim(&stash_oid
);
4535 ret
= apply_save_autostash_oid(stash_oid
.buf
, attempt_apply
);
4538 strbuf_release(&stash_oid
);
4542 int save_autostash(const char *path
)
4544 return apply_save_autostash(path
, 0);
4547 int apply_autostash(const char *path
)
4549 return apply_save_autostash(path
, 1);
4552 int apply_autostash_oid(const char *stash_oid
)
4554 return apply_save_autostash_oid(stash_oid
, 1);
4557 static int checkout_onto(struct repository
*r
, struct replay_opts
*opts
,
4558 const char *onto_name
, const struct object_id
*onto
,
4559 const struct object_id
*orig_head
)
4561 struct reset_head_opts ropts
= {
4563 .orig_head
= orig_head
,
4564 .flags
= RESET_HEAD_DETACH
| RESET_ORIG_HEAD
|
4565 RESET_HEAD_RUN_POST_CHECKOUT_HOOK
,
4566 .head_msg
= reflog_message(opts
, "start", "checkout %s",
4568 .default_reflog_action
= sequencer_reflog_action(opts
)
4570 if (reset_head(r
, &ropts
)) {
4571 apply_autostash(rebase_path_autostash());
4572 sequencer_remove_state(opts
);
4573 return error(_("could not detach HEAD"));
4579 static int stopped_at_head(struct repository
*r
)
4581 struct object_id head
;
4582 struct commit
*commit
;
4583 struct commit_message message
;
4585 if (repo_get_oid(r
, "HEAD", &head
) ||
4586 !(commit
= lookup_commit(r
, &head
)) ||
4587 repo_parse_commit(r
, commit
) || get_message(commit
, &message
))
4588 fprintf(stderr
, _("Stopped at HEAD\n"));
4590 fprintf(stderr
, _("Stopped at %s\n"), message
.label
);
4591 free_message(commit
, &message
);
4597 static int reread_todo_if_changed(struct repository
*r
,
4598 struct todo_list
*todo_list
,
4599 struct replay_opts
*opts
)
4602 struct strbuf buf
= STRBUF_INIT
;
4604 if (strbuf_read_file_or_whine(&buf
, get_todo_path(opts
)) < 0)
4606 offset
= get_item_line_offset(todo_list
, todo_list
->current
+ 1);
4607 if (buf
.len
!= todo_list
->buf
.len
- offset
||
4608 memcmp(buf
.buf
, todo_list
->buf
.buf
+ offset
, buf
.len
)) {
4609 /* Reread the todo file if it has changed. */
4610 todo_list_release(todo_list
);
4611 if (read_populate_todo(r
, todo_list
, opts
))
4612 return -1; /* message was printed */
4613 /* `current` will be incremented on return */
4614 todo_list
->current
= -1;
4616 strbuf_release(&buf
);
4621 static const char rescheduled_advice
[] =
4622 N_("Could not execute the todo command\n"
4626 "It has been rescheduled; To edit the command before continuing, please\n"
4627 "edit the todo list first:\n"
4629 " git rebase --edit-todo\n"
4630 " git rebase --continue\n");
4632 static int pick_commits(struct repository
*r
,
4633 struct todo_list
*todo_list
,
4634 struct replay_opts
*opts
)
4636 int res
= 0, reschedule
= 0;
4638 opts
->reflog_message
= sequencer_reflog_action(opts
);
4640 assert(!(opts
->signoff
|| opts
->no_commit
||
4641 opts
->record_origin
|| should_edit(opts
) ||
4642 opts
->committer_date_is_author_date
||
4643 opts
->ignore_date
));
4644 if (read_and_refresh_cache(r
, opts
))
4647 while (todo_list
->current
< todo_list
->nr
) {
4648 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
4649 const char *arg
= todo_item_get_arg(todo_list
, item
);
4652 if (save_todo(todo_list
, opts
))
4654 if (is_rebase_i(opts
)) {
4655 if (item
->command
!= TODO_COMMENT
) {
4656 FILE *f
= fopen(rebase_path_msgnum(), "w");
4658 todo_list
->done_nr
++;
4661 fprintf(f
, "%d\n", todo_list
->done_nr
);
4665 fprintf(stderr
, _("Rebasing (%d/%d)%s"),
4667 todo_list
->total_nr
,
4668 opts
->verbose
? "\n" : "\r");
4670 unlink(rebase_path_message());
4671 unlink(rebase_path_author_script());
4672 unlink(rebase_path_stopped_sha());
4673 unlink(rebase_path_amend());
4674 unlink(git_path_merge_head(r
));
4675 unlink(git_path_auto_merge(r
));
4676 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
4678 if (item
->command
== TODO_BREAK
) {
4681 return stopped_at_head(r
);
4684 if (item
->command
<= TODO_SQUASH
) {
4685 if (is_rebase_i(opts
))
4686 opts
->reflog_message
= reflog_message(opts
,
4687 command_to_string(item
->command
), NULL
);
4689 res
= do_pick_commit(r
, item
, opts
,
4690 is_final_fixup(todo_list
),
4692 if (is_rebase_i(opts
) && res
< 0) {
4694 advise(_(rescheduled_advice
),
4695 get_item_line_length(todo_list
,
4696 todo_list
->current
),
4697 get_item_line(todo_list
,
4698 todo_list
->current
));
4699 todo_list
->current
--;
4700 if (save_todo(todo_list
, opts
))
4703 if (item
->command
== TODO_EDIT
) {
4704 struct commit
*commit
= item
->commit
;
4709 _("Stopped at %s... %.*s\n"),
4710 short_commit_name(commit
),
4711 item
->arg_len
, arg
);
4713 return error_with_patch(r
, commit
,
4714 arg
, item
->arg_len
, opts
, res
, !res
);
4716 if (is_rebase_i(opts
) && !res
)
4717 record_in_rewritten(&item
->commit
->object
.oid
,
4718 peek_command(todo_list
, 1));
4719 if (res
&& is_fixup(item
->command
)) {
4722 return error_failed_squash(r
, item
->commit
, opts
,
4723 item
->arg_len
, arg
);
4724 } else if (res
&& is_rebase_i(opts
) && item
->commit
) {
4726 struct object_id oid
;
4729 * If we are rewording and have either
4730 * fast-forwarded already, or are about to
4731 * create a new root commit, we want to amend,
4732 * otherwise we do not.
4734 if (item
->command
== TODO_REWORD
&&
4735 !repo_get_oid(r
, "HEAD", &oid
) &&
4736 (oideq(&item
->commit
->object
.oid
, &oid
) ||
4737 (opts
->have_squash_onto
&&
4738 oideq(&opts
->squash_onto
, &oid
))))
4741 return res
| error_with_patch(r
, item
->commit
,
4742 arg
, item
->arg_len
, opts
,
4745 } else if (item
->command
== TODO_EXEC
) {
4746 char *end_of_arg
= (char *)(arg
+ item
->arg_len
);
4747 int saved
= *end_of_arg
;
4752 res
= do_exec(r
, arg
);
4753 *end_of_arg
= saved
;
4756 if (opts
->reschedule_failed_exec
)
4760 } else if (item
->command
== TODO_LABEL
) {
4761 if ((res
= do_label(r
, arg
, item
->arg_len
)))
4763 } else if (item
->command
== TODO_RESET
) {
4764 if ((res
= do_reset(r
, arg
, item
->arg_len
, opts
)))
4766 } else if (item
->command
== TODO_MERGE
) {
4767 if ((res
= do_merge(r
, item
->commit
, arg
, item
->arg_len
,
4768 item
->flags
, &check_todo
, opts
)) < 0)
4770 else if (item
->commit
)
4771 record_in_rewritten(&item
->commit
->object
.oid
,
4772 peek_command(todo_list
, 1));
4774 /* failed with merge conflicts */
4775 return error_with_patch(r
, item
->commit
,
4778 } else if (item
->command
== TODO_UPDATE_REF
) {
4779 struct strbuf ref
= STRBUF_INIT
;
4780 strbuf_add(&ref
, arg
, item
->arg_len
);
4781 if ((res
= do_update_ref(r
, ref
.buf
)))
4783 strbuf_release(&ref
);
4784 } else if (!is_noop(item
->command
))
4785 return error(_("unknown command %d"), item
->command
);
4788 advise(_(rescheduled_advice
),
4789 get_item_line_length(todo_list
,
4790 todo_list
->current
),
4791 get_item_line(todo_list
, todo_list
->current
));
4792 todo_list
->current
--;
4793 if (save_todo(todo_list
, opts
))
4796 return error_with_patch(r
,
4800 } else if (is_rebase_i(opts
) && check_todo
&& !res
&&
4801 reread_todo_if_changed(r
, todo_list
, opts
)) {
4805 todo_list
->current
++;
4810 if (is_rebase_i(opts
)) {
4811 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
4814 /* Stopped in the middle, as planned? */
4815 if (todo_list
->current
< todo_list
->nr
)
4818 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
4819 starts_with(head_ref
.buf
, "refs/")) {
4821 struct object_id head
, orig
;
4824 if (repo_get_oid(r
, "HEAD", &head
)) {
4825 res
= error(_("cannot read HEAD"));
4827 strbuf_release(&head_ref
);
4828 strbuf_release(&buf
);
4831 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
4832 get_oid_hex(buf
.buf
, &orig
)) {
4833 res
= error(_("could not read orig-head"));
4834 goto cleanup_head_ref
;
4837 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
4838 res
= error(_("could not read 'onto'"));
4839 goto cleanup_head_ref
;
4841 msg
= reflog_message(opts
, "finish", "%s onto %s",
4842 head_ref
.buf
, buf
.buf
);
4843 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
4844 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
4845 res
= error(_("could not update %s"),
4847 goto cleanup_head_ref
;
4849 msg
= reflog_message(opts
, "finish", "returning to %s",
4851 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
4852 res
= error(_("could not update HEAD to %s"),
4854 goto cleanup_head_ref
;
4859 if (opts
->verbose
) {
4860 struct rev_info log_tree_opt
;
4861 struct object_id orig
, head
;
4863 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
4864 repo_init_revisions(r
, &log_tree_opt
, NULL
);
4865 log_tree_opt
.diff
= 1;
4866 log_tree_opt
.diffopt
.output_format
=
4867 DIFF_FORMAT_DIFFSTAT
;
4868 log_tree_opt
.disable_stdin
= 1;
4870 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
4871 !repo_get_oid(r
, buf
.buf
, &orig
) &&
4872 !repo_get_oid(r
, "HEAD", &head
)) {
4873 diff_tree_oid(&orig
, &head
, "",
4874 &log_tree_opt
.diffopt
);
4875 log_tree_diff_flush(&log_tree_opt
);
4877 release_revisions(&log_tree_opt
);
4879 flush_rewritten_pending();
4880 if (!stat(rebase_path_rewritten_list(), &st
) &&
4882 struct child_process child
= CHILD_PROCESS_INIT
;
4883 struct run_hooks_opt hook_opt
= RUN_HOOKS_OPT_INIT
;
4885 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
4887 strvec_push(&child
.args
, "notes");
4888 strvec_push(&child
.args
, "copy");
4889 strvec_push(&child
.args
, "--for-rewrite=rebase");
4890 /* we don't care if this copying failed */
4891 run_command(&child
);
4893 hook_opt
.path_to_stdin
= rebase_path_rewritten_list();
4894 strvec_push(&hook_opt
.args
, "rebase");
4895 run_hooks_opt("post-rewrite", &hook_opt
);
4897 apply_autostash(rebase_path_autostash());
4903 _("Successfully rebased and updated %s.\n"),
4907 strbuf_release(&buf
);
4908 strbuf_release(&head_ref
);
4910 if (do_update_refs(r
, opts
->quiet
))
4915 * Sequence of picks finished successfully; cleanup by
4916 * removing the .git/sequencer directory
4918 return sequencer_remove_state(opts
);
4921 static int continue_single_pick(struct repository
*r
, struct replay_opts
*opts
)
4923 struct child_process cmd
= CHILD_PROCESS_INIT
;
4925 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
4926 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
4927 return error(_("no cherry-pick or revert in progress"));
4930 strvec_push(&cmd
.args
, "commit");
4933 * continue_single_pick() handles the case of recovering from a
4934 * conflict. should_edit() doesn't handle that case; for a conflict,
4935 * we want to edit if the user asked for it, or if they didn't specify
4936 * and stdin is a tty.
4938 if (!opts
->edit
|| (opts
->edit
< 0 && !isatty(0)))
4940 * Include --cleanup=strip as well because we don't want the
4941 * "# Conflicts:" messages.
4943 strvec_pushl(&cmd
.args
, "--no-edit", "--cleanup=strip", NULL
);
4945 return run_command(&cmd
);
4948 static int commit_staged_changes(struct repository
*r
,
4949 struct replay_opts
*opts
,
4950 struct todo_list
*todo_list
)
4952 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
4953 unsigned int final_fixup
= 0, is_clean
;
4955 if (has_unstaged_changes(r
, 1))
4956 return error(_("cannot rebase: You have unstaged changes."));
4958 is_clean
= !has_uncommitted_changes(r
, 0);
4960 if (file_exists(rebase_path_amend())) {
4961 struct strbuf rev
= STRBUF_INIT
;
4962 struct object_id head
, to_amend
;
4964 if (repo_get_oid(r
, "HEAD", &head
))
4965 return error(_("cannot amend non-existing commit"));
4966 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
4967 return error(_("invalid file: '%s'"), rebase_path_amend());
4968 if (get_oid_hex(rev
.buf
, &to_amend
))
4969 return error(_("invalid contents: '%s'"),
4970 rebase_path_amend());
4971 if (!is_clean
&& !oideq(&head
, &to_amend
))
4972 return error(_("\nYou have uncommitted changes in your "
4973 "working tree. Please, commit them\n"
4974 "first and then run 'git rebase "
4975 "--continue' again."));
4977 * When skipping a failed fixup/squash, we need to edit the
4978 * commit message, the current fixup list and count, and if it
4979 * was the last fixup/squash in the chain, we need to clean up
4980 * the commit message and if there was a squash, let the user
4983 if (!is_clean
|| !opts
->current_fixup_count
)
4984 ; /* this is not the final fixup */
4985 else if (!oideq(&head
, &to_amend
) ||
4986 !file_exists(rebase_path_stopped_sha())) {
4987 /* was a final fixup or squash done manually? */
4988 if (!is_fixup(peek_command(todo_list
, 0))) {
4989 unlink(rebase_path_fixup_msg());
4990 unlink(rebase_path_squash_msg());
4991 unlink(rebase_path_current_fixups());
4992 strbuf_reset(&opts
->current_fixups
);
4993 opts
->current_fixup_count
= 0;
4996 /* we are in a fixup/squash chain */
4997 const char *p
= opts
->current_fixups
.buf
;
4998 int len
= opts
->current_fixups
.len
;
5000 opts
->current_fixup_count
--;
5002 BUG("Incorrect current_fixups:\n%s", p
);
5003 while (len
&& p
[len
- 1] != '\n')
5005 strbuf_setlen(&opts
->current_fixups
, len
);
5006 if (write_message(p
, len
, rebase_path_current_fixups(),
5008 return error(_("could not write file: '%s'"),
5009 rebase_path_current_fixups());
5012 * If a fixup/squash in a fixup/squash chain failed, the
5013 * commit message is already correct, no need to commit
5016 * Only if it is the final command in the fixup/squash
5017 * chain, and only if the chain is longer than a single
5018 * fixup/squash command (which was just skipped), do we
5019 * actually need to re-commit with a cleaned up commit
5022 if (opts
->current_fixup_count
> 0 &&
5023 !is_fixup(peek_command(todo_list
, 0))) {
5026 * If there was not a single "squash" in the
5027 * chain, we only need to clean up the commit
5028 * message, no need to bother the user with
5029 * opening the commit message in the editor.
5031 if (!starts_with(p
, "squash ") &&
5032 !strstr(p
, "\nsquash "))
5033 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
5034 } else if (is_fixup(peek_command(todo_list
, 0))) {
5036 * We need to update the squash message to skip
5037 * the latest commit message.
5039 struct commit
*commit
;
5040 const char *path
= rebase_path_squash_msg();
5041 const char *encoding
= get_commit_output_encoding();
5043 if (parse_head(r
, &commit
) ||
5044 !(p
= repo_logmsg_reencode(r
, commit
, NULL
, encoding
)) ||
5045 write_message(p
, strlen(p
), path
, 0)) {
5046 repo_unuse_commit_buffer(r
, commit
, p
);
5047 return error(_("could not write file: "
5050 repo_unuse_commit_buffer(r
,
5055 strbuf_release(&rev
);
5060 if (refs_ref_exists(get_main_ref_store(r
),
5061 "CHERRY_PICK_HEAD") &&
5062 refs_delete_ref(get_main_ref_store(r
), "",
5063 "CHERRY_PICK_HEAD", NULL
, 0))
5064 return error(_("could not remove CHERRY_PICK_HEAD"));
5065 if (unlink(git_path_merge_msg(r
)) && errno
!= ENOENT
)
5066 return error_errno(_("could not remove '%s'"),
5067 git_path_merge_msg(r
));
5072 if (run_git_commit(final_fixup
? NULL
: rebase_path_message(),
5074 return error(_("could not commit staged changes."));
5075 unlink(rebase_path_amend());
5076 unlink(git_path_merge_head(r
));
5077 unlink(git_path_auto_merge(r
));
5079 unlink(rebase_path_fixup_msg());
5080 unlink(rebase_path_squash_msg());
5082 if (opts
->current_fixup_count
> 0) {
5084 * Whether final fixup or not, we just cleaned up the commit
5087 unlink(rebase_path_current_fixups());
5088 strbuf_reset(&opts
->current_fixups
);
5089 opts
->current_fixup_count
= 0;
5094 int sequencer_continue(struct repository
*r
, struct replay_opts
*opts
)
5096 struct todo_list todo_list
= TODO_LIST_INIT
;
5099 if (read_and_refresh_cache(r
, opts
))
5102 if (read_populate_opts(opts
))
5104 if (is_rebase_i(opts
)) {
5105 if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
5106 goto release_todo_list
;
5108 if (file_exists(rebase_path_dropped())) {
5109 if ((res
= todo_list_check_against_backup(r
, &todo_list
)))
5110 goto release_todo_list
;
5112 unlink(rebase_path_dropped());
5115 opts
->reflog_message
= reflog_message(opts
, "continue", NULL
);
5116 if (commit_staged_changes(r
, opts
, &todo_list
)) {
5118 goto release_todo_list
;
5120 } else if (!file_exists(get_todo_path(opts
)))
5121 return continue_single_pick(r
, opts
);
5122 else if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
5123 goto release_todo_list
;
5125 if (!is_rebase_i(opts
)) {
5126 /* Verify that the conflict has been resolved */
5127 if (refs_ref_exists(get_main_ref_store(r
),
5128 "CHERRY_PICK_HEAD") ||
5129 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
5130 res
= continue_single_pick(r
, opts
);
5132 goto release_todo_list
;
5134 if (index_differs_from(r
, "HEAD", NULL
, 0)) {
5135 res
= error_dirty_index(r
, opts
);
5136 goto release_todo_list
;
5138 todo_list
.current
++;
5139 } else if (file_exists(rebase_path_stopped_sha())) {
5140 struct strbuf buf
= STRBUF_INIT
;
5141 struct object_id oid
;
5143 if (read_oneliner(&buf
, rebase_path_stopped_sha(),
5144 READ_ONELINER_SKIP_IF_EMPTY
) &&
5145 !get_oid_hex(buf
.buf
, &oid
))
5146 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
5147 strbuf_release(&buf
);
5150 res
= pick_commits(r
, &todo_list
, opts
);
5152 todo_list_release(&todo_list
);
5156 static int single_pick(struct repository
*r
,
5157 struct commit
*cmit
,
5158 struct replay_opts
*opts
)
5161 struct todo_item item
;
5163 item
.command
= opts
->action
== REPLAY_PICK
?
5164 TODO_PICK
: TODO_REVERT
;
5167 opts
->reflog_message
= sequencer_reflog_action(opts
);
5168 return do_pick_commit(r
, &item
, opts
, 0, &check_todo
);
5171 int sequencer_pick_revisions(struct repository
*r
,
5172 struct replay_opts
*opts
)
5174 struct todo_list todo_list
= TODO_LIST_INIT
;
5175 struct object_id oid
;
5179 if (read_and_refresh_cache(r
, opts
))
5182 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
5183 struct object_id oid
;
5184 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
5186 /* This happens when using --stdin. */
5190 if (!repo_get_oid(r
, name
, &oid
)) {
5191 if (!lookup_commit_reference_gently(r
, &oid
, 1)) {
5192 enum object_type type
= oid_object_info(r
,
5195 return error(_("%s: can't cherry-pick a %s"),
5196 name
, type_name(type
));
5199 return error(_("%s: bad revision"), name
);
5203 * If we were called as "git cherry-pick <commit>", just
5204 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
5205 * REVERT_HEAD, and don't touch the sequencer state.
5206 * This means it is possible to cherry-pick in the middle
5207 * of a cherry-pick sequence.
5209 if (opts
->revs
->cmdline
.nr
== 1 &&
5210 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
5211 opts
->revs
->no_walk
&&
5212 !opts
->revs
->cmdline
.rev
->flags
) {
5213 struct commit
*cmit
;
5214 if (prepare_revision_walk(opts
->revs
))
5215 return error(_("revision walk setup failed"));
5216 cmit
= get_revision(opts
->revs
);
5218 return error(_("empty commit set passed"));
5219 if (get_revision(opts
->revs
))
5220 BUG("unexpected extra commit from walk");
5221 return single_pick(r
, cmit
, opts
);
5225 * Start a new cherry-pick/ revert sequence; but
5226 * first, make sure that an existing one isn't in
5230 if (walk_revs_populate_todo(&todo_list
, opts
) ||
5231 create_seq_dir(r
) < 0)
5233 if (repo_get_oid(r
, "HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
5234 return error(_("can't revert as initial commit"));
5235 if (save_head(oid_to_hex(&oid
)))
5237 if (save_opts(opts
))
5239 update_abort_safety_file();
5240 res
= pick_commits(r
, &todo_list
, opts
);
5241 todo_list_release(&todo_list
);
5245 void append_signoff(struct strbuf
*msgbuf
, size_t ignore_footer
, unsigned flag
)
5247 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
5248 struct strbuf sob
= STRBUF_INIT
;
5251 strbuf_addstr(&sob
, sign_off_header
);
5252 strbuf_addstr(&sob
, fmt_name(WANT_COMMITTER_IDENT
));
5253 strbuf_addch(&sob
, '\n');
5256 strbuf_complete_line(msgbuf
);
5259 * If the whole message buffer is equal to the sob, pretend that we
5260 * found a conforming footer with a matching sob
5262 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
5263 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
5266 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
5269 const char *append_newlines
= NULL
;
5270 size_t len
= msgbuf
->len
- ignore_footer
;
5274 * The buffer is completely empty. Leave foom for
5275 * the title and body to be filled in by the user.
5277 append_newlines
= "\n\n";
5278 } else if (len
== 1) {
5280 * Buffer contains a single newline. Add another
5281 * so that we leave room for the title and body.
5283 append_newlines
= "\n";
5284 } else if (msgbuf
->buf
[len
- 2] != '\n') {
5286 * Buffer ends with a single newline. Add another
5287 * so that there is an empty line between the message
5290 append_newlines
= "\n";
5291 } /* else, the buffer already ends with two newlines. */
5293 if (append_newlines
)
5294 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
5295 append_newlines
, strlen(append_newlines
));
5298 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
5299 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
5302 strbuf_release(&sob
);
5305 struct labels_entry
{
5306 struct hashmap_entry entry
;
5307 char label
[FLEX_ARRAY
];
5310 static int labels_cmp(const void *fndata UNUSED
,
5311 const struct hashmap_entry
*eptr
,
5312 const struct hashmap_entry
*entry_or_key
, const void *key
)
5314 const struct labels_entry
*a
, *b
;
5316 a
= container_of(eptr
, const struct labels_entry
, entry
);
5317 b
= container_of(entry_or_key
, const struct labels_entry
, entry
);
5319 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
5322 struct string_entry
{
5323 struct oidmap_entry entry
;
5324 char string
[FLEX_ARRAY
];
5327 struct label_state
{
5328 struct oidmap commit2label
;
5329 struct hashmap labels
;
5333 static const char *label_oid(struct object_id
*oid
, const char *label
,
5334 struct label_state
*state
)
5336 struct labels_entry
*labels_entry
;
5337 struct string_entry
*string_entry
;
5338 struct object_id dummy
;
5341 string_entry
= oidmap_get(&state
->commit2label
, oid
);
5343 return string_entry
->string
;
5346 * For "uninteresting" commits, i.e. commits that are not to be
5347 * rebased, and which can therefore not be labeled, we use a unique
5348 * abbreviation of the commit name. This is slightly more complicated
5349 * than calling repo_find_unique_abbrev() because we also need to make
5350 * sure that the abbreviation does not conflict with any other
5353 * We disallow "interesting" commits to be labeled by a string that
5354 * is a valid full-length hash, to ensure that we always can find an
5355 * abbreviation for any uninteresting commit's names that does not
5356 * clash with any other label.
5358 strbuf_reset(&state
->buf
);
5362 strbuf_grow(&state
->buf
, GIT_MAX_HEXSZ
);
5363 label
= p
= state
->buf
.buf
;
5365 repo_find_unique_abbrev_r(the_repository
, p
, oid
,
5369 * We may need to extend the abbreviated hash so that there is
5370 * no conflicting label.
5372 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
5373 size_t i
= strlen(p
) + 1;
5375 oid_to_hex_r(p
, oid
);
5376 for (; i
< the_hash_algo
->hexsz
; i
++) {
5379 if (!hashmap_get_from_hash(&state
->labels
,
5386 struct strbuf
*buf
= &state
->buf
;
5389 * Sanitize labels by replacing non-alpha-numeric characters
5390 * (including white-space ones) by dashes, as they might be
5391 * illegal in file names (and hence in ref names).
5393 * Note that we retain non-ASCII UTF-8 characters (identified
5394 * via the most significant bit). They should be all acceptable
5395 * in file names. We do not validate the UTF-8 here, that's not
5396 * the job of this function.
5398 for (; *label
; label
++)
5399 if ((*label
& 0x80) || isalnum(*label
))
5400 strbuf_addch(buf
, *label
);
5401 /* avoid leading dash and double-dashes */
5402 else if (buf
->len
&& buf
->buf
[buf
->len
- 1] != '-')
5403 strbuf_addch(buf
, '-');
5405 strbuf_addstr(buf
, "rev-");
5406 strbuf_add_unique_abbrev(buf
, oid
, default_abbrev
);
5410 if ((buf
->len
== the_hash_algo
->hexsz
&&
5411 !get_oid_hex(label
, &dummy
)) ||
5412 (buf
->len
== 1 && *label
== '#') ||
5413 hashmap_get_from_hash(&state
->labels
,
5414 strihash(label
), label
)) {
5416 * If the label already exists, or if the label is a
5417 * valid full OID, or the label is a '#' (which we use
5418 * as a separator between merge heads and oneline), we
5419 * append a dash and a number to make it unique.
5421 size_t len
= buf
->len
;
5423 for (i
= 2; ; i
++) {
5424 strbuf_setlen(buf
, len
);
5425 strbuf_addf(buf
, "-%d", i
);
5426 if (!hashmap_get_from_hash(&state
->labels
,
5436 FLEX_ALLOC_STR(labels_entry
, label
, label
);
5437 hashmap_entry_init(&labels_entry
->entry
, strihash(label
));
5438 hashmap_add(&state
->labels
, &labels_entry
->entry
);
5440 FLEX_ALLOC_STR(string_entry
, string
, label
);
5441 oidcpy(&string_entry
->entry
.oid
, oid
);
5442 oidmap_put(&state
->commit2label
, string_entry
);
5444 return string_entry
->string
;
5447 static int make_script_with_merges(struct pretty_print_context
*pp
,
5448 struct rev_info
*revs
, struct strbuf
*out
,
5451 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5452 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
5453 int root_with_onto
= flags
& TODO_LIST_ROOT_WITH_ONTO
;
5454 int skipped_commit
= 0;
5455 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
5456 struct strbuf label
= STRBUF_INIT
;
5457 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
5458 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
5459 struct commit
*commit
;
5460 struct oidmap commit2todo
= OIDMAP_INIT
;
5461 struct string_entry
*entry
;
5462 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
5463 shown
= OIDSET_INIT
;
5464 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
5466 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
5467 const char *cmd_pick
= abbr
? "p" : "pick",
5468 *cmd_label
= abbr
? "l" : "label",
5469 *cmd_reset
= abbr
? "t" : "reset",
5470 *cmd_merge
= abbr
? "m" : "merge";
5472 oidmap_init(&commit2todo
, 0);
5473 oidmap_init(&state
.commit2label
, 0);
5474 hashmap_init(&state
.labels
, labels_cmp
, NULL
, 0);
5475 strbuf_init(&state
.buf
, 32);
5477 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
5478 struct labels_entry
*onto_label_entry
;
5479 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
5480 FLEX_ALLOC_STR(entry
, string
, "onto");
5481 oidcpy(&entry
->entry
.oid
, oid
);
5482 oidmap_put(&state
.commit2label
, entry
);
5484 FLEX_ALLOC_STR(onto_label_entry
, label
, "onto");
5485 hashmap_entry_init(&onto_label_entry
->entry
, strihash("onto"));
5486 hashmap_add(&state
.labels
, &onto_label_entry
->entry
);
5491 * - get onelines for all commits
5492 * - gather all branch tips (i.e. 2nd or later parents of merges)
5493 * - label all branch tips
5495 while ((commit
= get_revision(revs
))) {
5496 struct commit_list
*to_merge
;
5497 const char *p1
, *p2
;
5498 struct object_id
*oid
;
5501 tail
= &commit_list_insert(commit
, tail
)->next
;
5502 oidset_insert(&interesting
, &commit
->object
.oid
);
5504 is_empty
= is_original_commit_empty(commit
);
5505 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5506 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5507 warning(_("skipped previously applied commit %s"),
5508 short_commit_name(commit
));
5512 if (is_empty
&& !keep_empty
)
5515 strbuf_reset(&oneline
);
5516 pretty_print_commit(pp
, commit
, &oneline
);
5518 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
5520 /* non-merge commit: easy case */
5522 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
5523 oid_to_hex(&commit
->object
.oid
),
5526 strbuf_addf(&buf
, " %c empty",
5529 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5530 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5531 oidmap_put(&commit2todo
, entry
);
5536 /* Create a label */
5537 strbuf_reset(&label
);
5538 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
5539 (p1
= strchr(p1
, '\'')) &&
5540 (p2
= strchr(++p1
, '\'')))
5541 strbuf_add(&label
, p1
, p2
- p1
);
5542 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
5544 (p1
= strstr(p1
, " from ")))
5545 strbuf_addstr(&label
, p1
+ strlen(" from "));
5547 strbuf_addbuf(&label
, &oneline
);
5550 strbuf_addf(&buf
, "%s -C %s",
5551 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
5553 /* label the tips of merged branches */
5554 for (; to_merge
; to_merge
= to_merge
->next
) {
5555 oid
= &to_merge
->item
->object
.oid
;
5556 strbuf_addch(&buf
, ' ');
5558 if (!oidset_contains(&interesting
, oid
)) {
5559 strbuf_addstr(&buf
, label_oid(oid
, NULL
,
5564 tips_tail
= &commit_list_insert(to_merge
->item
,
5567 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
5569 strbuf_addf(&buf
, " # %s", oneline
.buf
);
5571 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5572 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5573 oidmap_put(&commit2todo
, entry
);
5576 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5577 _("use --reapply-cherry-picks to include skipped commits"));
5581 * - label branch points
5582 * - add HEAD to the branch tips
5584 for (iter
= commits
; iter
; iter
= iter
->next
) {
5585 struct commit_list
*parent
= iter
->item
->parents
;
5586 for (; parent
; parent
= parent
->next
) {
5587 struct object_id
*oid
= &parent
->item
->object
.oid
;
5588 if (!oidset_contains(&interesting
, oid
))
5590 if (oidset_insert(&child_seen
, oid
))
5591 label_oid(oid
, "branch-point", &state
);
5594 /* Add HEAD as implicit "tip of branch" */
5596 tips_tail
= &commit_list_insert(iter
->item
,
5601 * Third phase: output the todo list. This is a bit tricky, as we
5602 * want to avoid jumping back and forth between revisions. To
5603 * accomplish that goal, we walk backwards from the branch tips,
5604 * gathering commits not yet shown, reversing the list on the fly,
5605 * then outputting that list (labeling revisions as needed).
5607 strbuf_addf(out
, "%s onto\n", cmd_label
);
5608 for (iter
= tips
; iter
; iter
= iter
->next
) {
5609 struct commit_list
*list
= NULL
, *iter2
;
5611 commit
= iter
->item
;
5612 if (oidset_contains(&shown
, &commit
->object
.oid
))
5614 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
5617 strbuf_addf(out
, "\n%c Branch %s\n", comment_line_char
, entry
->string
);
5619 strbuf_addch(out
, '\n');
5621 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
5622 !oidset_contains(&shown
, &commit
->object
.oid
)) {
5623 commit_list_insert(commit
, &list
);
5624 if (!commit
->parents
) {
5628 commit
= commit
->parents
->item
;
5632 strbuf_addf(out
, "%s %s\n", cmd_reset
,
5633 rebase_cousins
|| root_with_onto
?
5634 "onto" : "[new root]");
5636 const char *to
= NULL
;
5638 entry
= oidmap_get(&state
.commit2label
,
5639 &commit
->object
.oid
);
5642 else if (!rebase_cousins
)
5643 to
= label_oid(&commit
->object
.oid
, NULL
,
5646 if (!to
|| !strcmp(to
, "onto"))
5647 strbuf_addf(out
, "%s onto\n", cmd_reset
);
5649 strbuf_reset(&oneline
);
5650 pretty_print_commit(pp
, commit
, &oneline
);
5651 strbuf_addf(out
, "%s %s # %s\n",
5652 cmd_reset
, to
, oneline
.buf
);
5656 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
5657 struct object_id
*oid
= &iter2
->item
->object
.oid
;
5658 entry
= oidmap_get(&commit2todo
, oid
);
5659 /* only show if not already upstream */
5661 strbuf_addf(out
, "%s\n", entry
->string
);
5662 entry
= oidmap_get(&state
.commit2label
, oid
);
5664 strbuf_addf(out
, "%s %s\n",
5665 cmd_label
, entry
->string
);
5666 oidset_insert(&shown
, oid
);
5669 free_commit_list(list
);
5672 free_commit_list(commits
);
5673 free_commit_list(tips
);
5675 strbuf_release(&label
);
5676 strbuf_release(&oneline
);
5677 strbuf_release(&buf
);
5679 oidmap_free(&commit2todo
, 1);
5680 oidmap_free(&state
.commit2label
, 1);
5681 hashmap_clear_and_free(&state
.labels
, struct labels_entry
, entry
);
5682 strbuf_release(&state
.buf
);
5687 int sequencer_make_script(struct repository
*r
, struct strbuf
*out
, int argc
,
5688 const char **argv
, unsigned flags
)
5690 char *format
= NULL
;
5691 struct pretty_print_context pp
= {0};
5692 struct rev_info revs
;
5693 struct commit
*commit
;
5694 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5695 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
5696 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
5697 int reapply_cherry_picks
= flags
& TODO_LIST_REAPPLY_CHERRY_PICKS
;
5698 int skipped_commit
= 0;
5701 repo_init_revisions(r
, &revs
, NULL
);
5702 revs
.verbose_header
= 1;
5704 revs
.max_parents
= 1;
5705 revs
.cherry_mark
= !reapply_cherry_picks
;
5708 revs
.right_only
= 1;
5709 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
5710 revs
.topo_order
= 1;
5712 revs
.pretty_given
= 1;
5713 git_config_get_string("rebase.instructionFormat", &format
);
5714 if (!format
|| !*format
) {
5716 format
= xstrdup("%s");
5718 get_commit_format(format
, &revs
);
5720 pp
.fmt
= revs
.commit_format
;
5721 pp
.output_encoding
= get_log_output_encoding();
5723 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1) {
5724 ret
= error(_("make_script: unhandled options"));
5728 if (prepare_revision_walk(&revs
) < 0) {
5729 ret
= error(_("make_script: error preparing revisions"));
5733 if (rebase_merges
) {
5734 ret
= make_script_with_merges(&pp
, &revs
, out
, flags
);
5738 while ((commit
= get_revision(&revs
))) {
5739 int is_empty
= is_original_commit_empty(commit
);
5741 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5742 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5743 warning(_("skipped previously applied commit %s"),
5744 short_commit_name(commit
));
5748 if (is_empty
&& !keep_empty
)
5750 strbuf_addf(out
, "%s %s ", insn
,
5751 oid_to_hex(&commit
->object
.oid
));
5752 pretty_print_commit(&pp
, commit
, out
);
5754 strbuf_addf(out
, " %c empty", comment_line_char
);
5755 strbuf_addch(out
, '\n');
5758 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5759 _("use --reapply-cherry-picks to include skipped commits"));
5761 release_revisions(&revs
);
5766 * Add commands after pick and (series of) squash/fixup commands
5769 static void todo_list_add_exec_commands(struct todo_list
*todo_list
,
5770 struct string_list
*commands
)
5772 struct strbuf
*buf
= &todo_list
->buf
;
5773 size_t base_offset
= buf
->len
;
5774 int i
, insert
, nr
= 0, alloc
= 0;
5775 struct todo_item
*items
= NULL
, *base_items
= NULL
;
5777 CALLOC_ARRAY(base_items
, commands
->nr
);
5778 for (i
= 0; i
< commands
->nr
; i
++) {
5779 size_t command_len
= strlen(commands
->items
[i
].string
);
5781 strbuf_addstr(buf
, commands
->items
[i
].string
);
5782 strbuf_addch(buf
, '\n');
5784 base_items
[i
].command
= TODO_EXEC
;
5785 base_items
[i
].offset_in_buf
= base_offset
;
5786 base_items
[i
].arg_offset
= base_offset
;
5787 base_items
[i
].arg_len
= command_len
;
5789 base_offset
+= command_len
+ 1;
5793 * Insert <commands> after every pick. Here, fixup/squash chains
5794 * are considered part of the pick, so we insert the commands *after*
5795 * those chains if there are any.
5797 * As we insert the exec commands immediately after rearranging
5798 * any fixups and before the user edits the list, a fixup chain
5799 * can never contain comments (any comments are empty picks that
5800 * have been commented out because the user did not specify
5801 * --keep-empty). So, it is safe to insert an exec command
5802 * without looking at the command following a comment.
5805 for (i
= 0; i
< todo_list
->nr
; i
++) {
5806 enum todo_command command
= todo_list
->items
[i
].command
;
5807 if (insert
&& !is_fixup(command
)) {
5808 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5809 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5815 ALLOC_GROW(items
, nr
+ 1, alloc
);
5816 items
[nr
++] = todo_list
->items
[i
];
5818 if (command
== TODO_PICK
|| command
== TODO_MERGE
)
5822 /* insert or append final <commands> */
5824 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5825 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5830 FREE_AND_NULL(todo_list
->items
);
5831 todo_list
->items
= items
;
5833 todo_list
->alloc
= alloc
;
5836 static void todo_list_to_strbuf(struct repository
*r
, struct todo_list
*todo_list
,
5837 struct strbuf
*buf
, int num
, unsigned flags
)
5839 struct todo_item
*item
;
5840 int i
, max
= todo_list
->nr
;
5842 if (num
> 0 && num
< max
)
5845 for (item
= todo_list
->items
, i
= 0; i
< max
; i
++, item
++) {
5848 /* if the item is not a command write it and continue */
5849 if (item
->command
>= TODO_COMMENT
) {
5850 strbuf_addf(buf
, "%.*s\n", item
->arg_len
,
5851 todo_item_get_arg(todo_list
, item
));
5855 /* add command to the buffer */
5856 cmd
= command_to_char(item
->command
);
5857 if ((flags
& TODO_LIST_ABBREVIATE_CMDS
) && cmd
)
5858 strbuf_addch(buf
, cmd
);
5860 strbuf_addstr(buf
, command_to_string(item
->command
));
5864 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
5865 short_commit_name(item
->commit
) :
5866 oid_to_hex(&item
->commit
->object
.oid
);
5868 if (item
->command
== TODO_FIXUP
) {
5869 if (item
->flags
& TODO_EDIT_FIXUP_MSG
)
5870 strbuf_addstr(buf
, " -c");
5871 else if (item
->flags
& TODO_REPLACE_FIXUP_MSG
) {
5872 strbuf_addstr(buf
, " -C");
5876 if (item
->command
== TODO_MERGE
) {
5877 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
5878 strbuf_addstr(buf
, " -c");
5880 strbuf_addstr(buf
, " -C");
5883 strbuf_addf(buf
, " %s", oid
);
5886 /* add all the rest */
5888 strbuf_addch(buf
, '\n');
5890 strbuf_addf(buf
, " %.*s\n", item
->arg_len
,
5891 todo_item_get_arg(todo_list
, item
));
5895 int todo_list_write_to_file(struct repository
*r
, struct todo_list
*todo_list
,
5896 const char *file
, const char *shortrevisions
,
5897 const char *shortonto
, int num
, unsigned flags
)
5900 struct strbuf buf
= STRBUF_INIT
;
5902 todo_list_to_strbuf(r
, todo_list
, &buf
, num
, flags
);
5903 if (flags
& TODO_LIST_APPEND_TODO_HELP
)
5904 append_todo_help(count_commands(todo_list
),
5905 shortrevisions
, shortonto
, &buf
);
5907 res
= write_message(buf
.buf
, buf
.len
, file
, 0);
5908 strbuf_release(&buf
);
5913 /* skip picking commits whose parents are unchanged */
5914 static int skip_unnecessary_picks(struct repository
*r
,
5915 struct todo_list
*todo_list
,
5916 struct object_id
*base_oid
)
5918 struct object_id
*parent_oid
;
5921 for (i
= 0; i
< todo_list
->nr
; i
++) {
5922 struct todo_item
*item
= todo_list
->items
+ i
;
5924 if (item
->command
>= TODO_NOOP
)
5926 if (item
->command
!= TODO_PICK
)
5928 if (repo_parse_commit(r
, item
->commit
)) {
5929 return error(_("could not parse commit '%s'"),
5930 oid_to_hex(&item
->commit
->object
.oid
));
5932 if (!item
->commit
->parents
)
5933 break; /* root commit */
5934 if (item
->commit
->parents
->next
)
5935 break; /* merge commit */
5936 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
5937 if (!oideq(parent_oid
, base_oid
))
5939 oidcpy(base_oid
, &item
->commit
->object
.oid
);
5942 const char *done_path
= rebase_path_done();
5944 if (todo_list_write_to_file(r
, todo_list
, done_path
, NULL
, NULL
, i
, 0)) {
5945 error_errno(_("could not write to '%s'"), done_path
);
5949 MOVE_ARRAY(todo_list
->items
, todo_list
->items
+ i
, todo_list
->nr
- i
);
5951 todo_list
->current
= 0;
5952 todo_list
->done_nr
+= i
;
5954 if (is_fixup(peek_command(todo_list
, 0)))
5955 record_in_rewritten(base_oid
, peek_command(todo_list
, 0));
5961 struct todo_add_branch_context
{
5962 struct todo_item
*items
;
5966 struct commit
*commit
;
5967 struct string_list refs_to_oids
;
5970 static int add_decorations_to_list(const struct commit
*commit
,
5971 struct todo_add_branch_context
*ctx
)
5973 const struct name_decoration
*decoration
= get_name_decoration(&commit
->object
);
5974 const char *head_ref
= resolve_ref_unsafe("HEAD",
5975 RESOLVE_REF_READING
,
5979 while (decoration
) {
5980 struct todo_item
*item
;
5982 size_t base_offset
= ctx
->buf
->len
;
5985 * If the branch is the current HEAD, then it will be
5986 * updated by the default rebase behavior.
5988 if (head_ref
&& !strcmp(head_ref
, decoration
->name
)) {
5989 decoration
= decoration
->next
;
5993 ALLOC_GROW(ctx
->items
,
5996 item
= &ctx
->items
[ctx
->items_nr
];
5997 memset(item
, 0, sizeof(*item
));
5999 /* If the branch is checked out, then leave a comment instead. */
6000 if ((path
= branch_checked_out(decoration
->name
))) {
6001 item
->command
= TODO_COMMENT
;
6002 strbuf_addf(ctx
->buf
, "# Ref %s checked out at '%s'\n",
6003 decoration
->name
, path
);
6005 struct string_list_item
*sti
;
6006 item
->command
= TODO_UPDATE_REF
;
6007 strbuf_addf(ctx
->buf
, "%s\n", decoration
->name
);
6009 sti
= string_list_insert(&ctx
->refs_to_oids
,
6011 sti
->util
= init_update_ref_record(decoration
->name
);
6014 item
->offset_in_buf
= base_offset
;
6015 item
->arg_offset
= base_offset
;
6016 item
->arg_len
= ctx
->buf
->len
- base_offset
;
6019 decoration
= decoration
->next
;
6026 * For each 'pick' command, find out if the commit has a decoration in
6027 * refs/heads/. If so, then add a 'label for-update-refs/' command.
6029 static int todo_list_add_update_ref_commands(struct todo_list
*todo_list
)
6032 static struct string_list decorate_refs_exclude
= STRING_LIST_INIT_NODUP
;
6033 static struct string_list decorate_refs_exclude_config
= STRING_LIST_INIT_NODUP
;
6034 static struct string_list decorate_refs_include
= STRING_LIST_INIT_NODUP
;
6035 struct decoration_filter decoration_filter
= {
6036 .include_ref_pattern
= &decorate_refs_include
,
6037 .exclude_ref_pattern
= &decorate_refs_exclude
,
6038 .exclude_ref_config_pattern
= &decorate_refs_exclude_config
,
6040 struct todo_add_branch_context ctx
= {
6041 .buf
= &todo_list
->buf
,
6042 .refs_to_oids
= STRING_LIST_INIT_DUP
,
6045 ctx
.items_alloc
= 2 * todo_list
->nr
+ 1;
6046 ALLOC_ARRAY(ctx
.items
, ctx
.items_alloc
);
6048 string_list_append(&decorate_refs_include
, "refs/heads/");
6049 load_ref_decorations(&decoration_filter
, 0);
6051 for (i
= 0; i
< todo_list
->nr
; ) {
6052 struct todo_item
*item
= &todo_list
->items
[i
];
6054 /* insert ith item into new list */
6055 ALLOC_GROW(ctx
.items
,
6059 ctx
.items
[ctx
.items_nr
++] = todo_list
->items
[i
++];
6062 ctx
.commit
= item
->commit
;
6063 add_decorations_to_list(item
->commit
, &ctx
);
6067 res
= write_update_refs_state(&ctx
.refs_to_oids
);
6069 string_list_clear(&ctx
.refs_to_oids
, 1);
6072 /* we failed, so clean up the new list. */
6077 free(todo_list
->items
);
6078 todo_list
->items
= ctx
.items
;
6079 todo_list
->nr
= ctx
.items_nr
;
6080 todo_list
->alloc
= ctx
.items_alloc
;
6085 int complete_action(struct repository
*r
, struct replay_opts
*opts
, unsigned flags
,
6086 const char *shortrevisions
, const char *onto_name
,
6087 struct commit
*onto
, const struct object_id
*orig_head
,
6088 struct string_list
*commands
, unsigned autosquash
,
6089 unsigned update_refs
,
6090 struct todo_list
*todo_list
)
6092 char shortonto
[GIT_MAX_HEXSZ
+ 1];
6093 const char *todo_file
= rebase_path_todo();
6094 struct todo_list new_todo
= TODO_LIST_INIT
;
6095 struct strbuf
*buf
= &todo_list
->buf
, buf2
= STRBUF_INIT
;
6096 struct object_id oid
= onto
->object
.oid
;
6099 repo_find_unique_abbrev_r(r
, shortonto
, &oid
,
6102 if (buf
->len
== 0) {
6103 struct todo_item
*item
= append_new_todo(todo_list
);
6104 item
->command
= TODO_NOOP
;
6105 item
->commit
= NULL
;
6106 item
->arg_len
= item
->arg_offset
= item
->flags
= item
->offset_in_buf
= 0;
6109 if (update_refs
&& todo_list_add_update_ref_commands(todo_list
))
6112 if (autosquash
&& todo_list_rearrange_squash(todo_list
))
6116 todo_list_add_exec_commands(todo_list
, commands
);
6118 if (count_commands(todo_list
) == 0) {
6119 apply_autostash(rebase_path_autostash());
6120 sequencer_remove_state(opts
);
6122 return error(_("nothing to do"));
6125 res
= edit_todo_list(r
, todo_list
, &new_todo
, shortrevisions
,
6129 else if (res
== -2) {
6130 apply_autostash(rebase_path_autostash());
6131 sequencer_remove_state(opts
);
6134 } else if (res
== -3) {
6135 apply_autostash(rebase_path_autostash());
6136 sequencer_remove_state(opts
);
6137 todo_list_release(&new_todo
);
6139 return error(_("nothing to do"));
6140 } else if (res
== -4) {
6141 checkout_onto(r
, opts
, onto_name
, &onto
->object
.oid
, orig_head
);
6142 todo_list_release(&new_todo
);
6147 /* Expand the commit IDs */
6148 todo_list_to_strbuf(r
, &new_todo
, &buf2
, -1, 0);
6149 strbuf_swap(&new_todo
.buf
, &buf2
);
6150 strbuf_release(&buf2
);
6151 new_todo
.total_nr
-= new_todo
.nr
;
6152 if (todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
) < 0)
6153 BUG("invalid todo list after expanding IDs:\n%s",
6156 if (opts
->allow_ff
&& skip_unnecessary_picks(r
, &new_todo
, &oid
)) {
6157 todo_list_release(&new_todo
);
6158 return error(_("could not skip unnecessary pick commands"));
6161 if (todo_list_write_to_file(r
, &new_todo
, todo_file
, NULL
, NULL
, -1,
6162 flags
& ~(TODO_LIST_SHORTEN_IDS
))) {
6163 todo_list_release(&new_todo
);
6164 return error_errno(_("could not write '%s'"), todo_file
);
6169 if (checkout_onto(r
, opts
, onto_name
, &oid
, orig_head
))
6172 if (require_clean_work_tree(r
, "rebase", "", 1, 1))
6175 todo_list_write_total_nr(&new_todo
);
6176 res
= pick_commits(r
, &new_todo
, opts
);
6179 todo_list_release(&new_todo
);
6184 struct subject2item_entry
{
6185 struct hashmap_entry entry
;
6187 char subject
[FLEX_ARRAY
];
6190 static int subject2item_cmp(const void *fndata UNUSED
,
6191 const struct hashmap_entry
*eptr
,
6192 const struct hashmap_entry
*entry_or_key
,
6195 const struct subject2item_entry
*a
, *b
;
6197 a
= container_of(eptr
, const struct subject2item_entry
, entry
);
6198 b
= container_of(entry_or_key
, const struct subject2item_entry
, entry
);
6200 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
6203 define_commit_slab(commit_todo_item
, struct todo_item
*);
6205 static int skip_fixupish(const char *subject
, const char **p
) {
6206 return skip_prefix(subject
, "fixup! ", p
) ||
6207 skip_prefix(subject
, "amend! ", p
) ||
6208 skip_prefix(subject
, "squash! ", p
);
6212 * Rearrange the todo list that has both "pick commit-id msg" and "pick
6213 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
6214 * after the former, and change "pick" to "fixup"/"squash".
6216 * Note that if the config has specified a custom instruction format, each log
6217 * message will have to be retrieved from the commit (as the oneline in the
6218 * script cannot be trusted) in order to normalize the autosquash arrangement.
6220 int todo_list_rearrange_squash(struct todo_list
*todo_list
)
6222 struct hashmap subject2item
;
6223 int rearranged
= 0, *next
, *tail
, i
, nr
= 0, alloc
= 0;
6225 struct commit_todo_item commit_todo
;
6226 struct todo_item
*items
= NULL
;
6228 init_commit_todo_item(&commit_todo
);
6230 * The hashmap maps onelines to the respective todo list index.
6232 * If any items need to be rearranged, the next[i] value will indicate
6233 * which item was moved directly after the i'th.
6235 * In that case, last[i] will indicate the index of the latest item to
6236 * be moved to appear after the i'th.
6238 hashmap_init(&subject2item
, subject2item_cmp
, NULL
, todo_list
->nr
);
6239 ALLOC_ARRAY(next
, todo_list
->nr
);
6240 ALLOC_ARRAY(tail
, todo_list
->nr
);
6241 ALLOC_ARRAY(subjects
, todo_list
->nr
);
6242 for (i
= 0; i
< todo_list
->nr
; i
++) {
6243 struct strbuf buf
= STRBUF_INIT
;
6244 struct todo_item
*item
= todo_list
->items
+ i
;
6245 const char *commit_buffer
, *subject
, *p
;
6248 struct subject2item_entry
*entry
;
6250 next
[i
] = tail
[i
] = -1;
6251 if (!item
->commit
|| item
->command
== TODO_DROP
) {
6256 if (is_fixup(item
->command
)) {
6257 clear_commit_todo_item(&commit_todo
);
6258 return error(_("the script was already rearranged."));
6261 repo_parse_commit(the_repository
, item
->commit
);
6262 commit_buffer
= repo_logmsg_reencode(the_repository
,
6265 find_commit_subject(commit_buffer
, &subject
);
6266 format_subject(&buf
, subject
, " ");
6267 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
6268 repo_unuse_commit_buffer(the_repository
, item
->commit
,
6270 if (skip_fixupish(subject
, &p
)) {
6271 struct commit
*commit2
;
6276 if (!skip_fixupish(p
, &p
))
6280 entry
= hashmap_get_entry_from_hash(&subject2item
,
6282 struct subject2item_entry
,
6285 /* found by title */
6287 else if (!strchr(p
, ' ') &&
6289 lookup_commit_reference_by_name(p
)) &&
6290 *commit_todo_item_at(&commit_todo
, commit2
))
6291 /* found by commit name */
6292 i2
= *commit_todo_item_at(&commit_todo
, commit2
)
6295 /* copy can be a prefix of the commit subject */
6296 for (i2
= 0; i2
< i
; i2
++)
6298 starts_with(subjects
[i2
], p
))
6306 if (starts_with(subject
, "fixup!")) {
6307 todo_list
->items
[i
].command
= TODO_FIXUP
;
6308 } else if (starts_with(subject
, "amend!")) {
6309 todo_list
->items
[i
].command
= TODO_FIXUP
;
6310 todo_list
->items
[i
].flags
= TODO_REPLACE_FIXUP_MSG
;
6312 todo_list
->items
[i
].command
= TODO_SQUASH
;
6318 next
[i
] = next
[tail
[i2
]];
6322 } else if (!hashmap_get_from_hash(&subject2item
,
6323 strhash(subject
), subject
)) {
6324 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
6326 hashmap_entry_init(&entry
->entry
,
6327 strhash(entry
->subject
));
6328 hashmap_put(&subject2item
, &entry
->entry
);
6331 *commit_todo_item_at(&commit_todo
, item
->commit
) = item
;
6335 for (i
= 0; i
< todo_list
->nr
; i
++) {
6336 enum todo_command command
= todo_list
->items
[i
].command
;
6340 * Initially, all commands are 'pick's. If it is a
6341 * fixup or a squash now, we have rearranged it.
6343 if (is_fixup(command
))
6347 ALLOC_GROW(items
, nr
+ 1, alloc
);
6348 items
[nr
++] = todo_list
->items
[cur
];
6353 FREE_AND_NULL(todo_list
->items
);
6354 todo_list
->items
= items
;
6356 todo_list
->alloc
= alloc
;
6361 for (i
= 0; i
< todo_list
->nr
; i
++)
6364 hashmap_clear_and_free(&subject2item
, struct subject2item_entry
, entry
);
6366 clear_commit_todo_item(&commit_todo
);
6371 int sequencer_determine_whence(struct repository
*r
, enum commit_whence
*whence
)
6373 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
6374 struct object_id cherry_pick_head
, rebase_head
;
6376 if (file_exists(git_path_seq_dir()))
6377 *whence
= FROM_CHERRY_PICK_MULTI
;
6378 if (file_exists(rebase_path()) &&
6379 !repo_get_oid(r
, "REBASE_HEAD", &rebase_head
) &&
6380 !repo_get_oid(r
, "CHERRY_PICK_HEAD", &cherry_pick_head
) &&
6381 oideq(&rebase_head
, &cherry_pick_head
))
6382 *whence
= FROM_REBASE_PICK
;
6384 *whence
= FROM_CHERRY_PICK_SINGLE
;
6392 int sequencer_get_update_refs_state(const char *wt_dir
,
6393 struct string_list
*refs
)
6397 struct strbuf ref
= STRBUF_INIT
;
6398 struct strbuf hash
= STRBUF_INIT
;
6399 struct update_ref_record
*rec
= NULL
;
6401 char *path
= rebase_path_update_refs(wt_dir
);
6403 fp
= fopen(path
, "r");
6407 while (strbuf_getline(&ref
, fp
) != EOF
) {
6408 struct string_list_item
*item
;
6410 CALLOC_ARRAY(rec
, 1);
6412 if (strbuf_getline(&hash
, fp
) == EOF
||
6413 get_oid_hex(hash
.buf
, &rec
->before
)) {
6414 warning(_("update-refs file at '%s' is invalid"),
6420 if (strbuf_getline(&hash
, fp
) == EOF
||
6421 get_oid_hex(hash
.buf
, &rec
->after
)) {
6422 warning(_("update-refs file at '%s' is invalid"),
6428 item
= string_list_insert(refs
, ref
.buf
);
6438 strbuf_release(&ref
);
6439 strbuf_release(&hash
);