6 #include "environment.h"
11 #include "object-name.h"
12 #include "object-store.h"
15 #include "sequencer.h"
17 #include "run-command.h"
21 #include "cache-tree.h"
25 #include "merge-ort.h"
26 #include "merge-ort-wrappers.h"
32 #include "wt-status.h"
34 #include "notes-utils.h"
36 #include "unpack-trees.h"
40 #include "commit-slab.h"
42 #include "commit-reach.h"
43 #include "rebase-interactive.h"
48 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
50 static const char sign_off_header
[] = "Signed-off-by: ";
51 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
53 GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
55 static GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
57 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
58 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
59 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
60 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
62 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
64 * The file containing rebase commands, comments, and empty lines.
65 * This file is created by "git rebase -i" then edited by the user. As
66 * the lines are processed, they are removed from the front of this
67 * file and written to the tail of 'done'.
69 GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
70 GIT_PATH_FUNC(rebase_path_todo_backup
, "rebase-merge/git-rebase-todo.backup")
72 GIT_PATH_FUNC(rebase_path_dropped
, "rebase-merge/dropped")
75 * The rebase command lines that have already been processed. A line
76 * is moved here when it is first handled, before any associated user
79 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
81 * The file to keep track of how many commands were already processed (e.g.
84 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum")
86 * The file to keep track of how many commands are to be processed in total
87 * (e.g. for the prompt).
89 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end")
91 * The commit message that is planned to be used for any changes that
92 * need to be committed following a user interaction.
94 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
96 * The file into which is accumulated the suggested commit message for
97 * squash/fixup commands. When the first of a series of squash/fixups
98 * is seen, the file is created and the commit message from the
99 * previous commit and from the first squash/fixup commit are written
100 * to it. The commit message for each subsequent squash/fixup commit
101 * is appended to the file as it is processed.
103 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
105 * If the current series of squash/fixups has not yet included a squash
106 * command, then this file exists and holds the commit message of the
107 * original "pick" commit. (If the series ends without a "squash"
108 * command, then this can be used as the commit message of the combined
109 * commit without opening the editor.)
111 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
113 * This file contains the list fixup/squash commands that have been
114 * accumulated into message-fixup or message-squash so far.
116 static GIT_PATH_FUNC(rebase_path_current_fixups
, "rebase-merge/current-fixups")
118 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
119 * GIT_AUTHOR_DATE that will be used for the commit that is currently
122 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
124 * When an "edit" rebase command is being processed, the SHA1 of the
125 * commit to be edited is recorded in this file. When "git rebase
126 * --continue" is executed, if there are any staged changes then they
127 * will be amended to the HEAD commit, but only provided the HEAD
128 * commit is still the commit to be edited. When any other rebase
129 * command is processed, this file is deleted.
131 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
133 * When we stop at a given patch via the "edit" command, this file contains
134 * the commit object name of the corresponding patch.
136 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
138 * For the post-rewrite hook, we make a list of rewritten commits and
139 * their new sha1s. The rewritten-pending list keeps the sha1s of
140 * commits that have been processed, but not committed yet,
141 * e.g. because they are waiting for a 'squash' command.
143 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
144 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
145 "rebase-merge/rewritten-pending")
148 * The path of the file containing the OID of the "squash onto" commit, i.e.
149 * the dummy commit used for `reset [new root]`.
151 static GIT_PATH_FUNC(rebase_path_squash_onto
, "rebase-merge/squash-onto")
154 * The path of the file listing refs that need to be deleted after the rebase
155 * finishes. This is used by the `label` command to record the need for cleanup.
157 static GIT_PATH_FUNC(rebase_path_refs_to_delete
, "rebase-merge/refs-to-delete")
160 * The update-refs file stores a list of refs that will be updated at the end
161 * of the rebase sequence. The 'update-ref <ref>' commands in the todo file
162 * update the OIDs for the refs in this file, but the refs are not updated
163 * until the end of the rebase sequence.
165 * rebase_path_update_refs() returns the path to this file for a given
166 * worktree directory. For the current worktree, pass the_repository->gitdir.
168 static char *rebase_path_update_refs(const char *wt_git_dir
)
170 return xstrfmt("%s/rebase-merge/update-refs", wt_git_dir
);
174 * The following files are written by git-rebase just after parsing the
177 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
178 static GIT_PATH_FUNC(rebase_path_cdate_is_adate
, "rebase-merge/cdate_is_adate")
179 static GIT_PATH_FUNC(rebase_path_ignore_date
, "rebase-merge/ignore_date")
180 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
181 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
182 static GIT_PATH_FUNC(rebase_path_quiet
, "rebase-merge/quiet")
183 static GIT_PATH_FUNC(rebase_path_signoff
, "rebase-merge/signoff")
184 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
185 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
186 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
187 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
188 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
189 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
190 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec
, "rebase-merge/reschedule-failed-exec")
191 static GIT_PATH_FUNC(rebase_path_no_reschedule_failed_exec
, "rebase-merge/no-reschedule-failed-exec")
192 static GIT_PATH_FUNC(rebase_path_drop_redundant_commits
, "rebase-merge/drop_redundant_commits")
193 static GIT_PATH_FUNC(rebase_path_keep_redundant_commits
, "rebase-merge/keep_redundant_commits")
196 * A 'struct update_refs_record' represents a value in the update-refs
197 * list. We use a string_list to map refs to these (before, after) pairs.
199 struct update_ref_record
{
200 struct object_id before
;
201 struct object_id after
;
204 static struct update_ref_record
*init_update_ref_record(const char *ref
)
206 struct update_ref_record
*rec
;
208 CALLOC_ARRAY(rec
, 1);
210 oidcpy(&rec
->before
, null_oid());
211 oidcpy(&rec
->after
, null_oid());
213 /* This may fail, but that's fine, we will keep the null OID. */
214 read_ref(ref
, &rec
->before
);
219 static int git_sequencer_config(const char *k
, const char *v
, void *cb
)
221 struct replay_opts
*opts
= cb
;
224 if (!strcmp(k
, "commit.cleanup")) {
227 status
= git_config_string(&s
, k
, v
);
231 if (!strcmp(s
, "verbatim")) {
232 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
233 opts
->explicit_cleanup
= 1;
234 } else if (!strcmp(s
, "whitespace")) {
235 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
236 opts
->explicit_cleanup
= 1;
237 } else if (!strcmp(s
, "strip")) {
238 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_ALL
;
239 opts
->explicit_cleanup
= 1;
240 } else if (!strcmp(s
, "scissors")) {
241 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SCISSORS
;
242 opts
->explicit_cleanup
= 1;
244 warning(_("invalid commit message cleanup mode '%s'"),
252 if (!strcmp(k
, "commit.gpgsign")) {
253 opts
->gpg_sign
= git_config_bool(k
, v
) ? xstrdup("") : NULL
;
257 if (!opts
->default_strategy
&& !strcmp(k
, "pull.twohead")) {
258 int ret
= git_config_string((const char**)&opts
->default_strategy
, k
, v
);
261 * pull.twohead is allowed to be multi-valued; we only
262 * care about the first value.
264 char *tmp
= strchr(opts
->default_strategy
, ' ');
271 if (opts
->action
== REPLAY_REVERT
&& !strcmp(k
, "revert.reference"))
272 opts
->commit_use_reference
= git_config_bool(k
, v
);
274 return git_diff_basic_config(k
, v
, NULL
);
277 void sequencer_init_config(struct replay_opts
*opts
)
279 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
280 git_config(git_sequencer_config
, opts
);
283 static inline int is_rebase_i(const struct replay_opts
*opts
)
285 return opts
->action
== REPLAY_INTERACTIVE_REBASE
;
288 static const char *get_dir(const struct replay_opts
*opts
)
290 if (is_rebase_i(opts
))
291 return rebase_path();
292 return git_path_seq_dir();
295 static const char *get_todo_path(const struct replay_opts
*opts
)
297 if (is_rebase_i(opts
))
298 return rebase_path_todo();
299 return git_path_todo_file();
303 * Returns 0 for non-conforming footer
304 * Returns 1 for conforming footer
305 * Returns 2 when sob exists within conforming footer
306 * Returns 3 when sob exists within conforming footer as last entry
308 static int has_conforming_footer(struct strbuf
*sb
, struct strbuf
*sob
,
309 size_t ignore_footer
)
311 struct process_trailer_options opts
= PROCESS_TRAILER_OPTIONS_INIT
;
312 struct trailer_info info
;
314 int found_sob
= 0, found_sob_last
= 0;
320 saved_char
= sb
->buf
[sb
->len
- ignore_footer
];
321 sb
->buf
[sb
->len
- ignore_footer
] = '\0';
324 trailer_info_get(&info
, sb
->buf
, &opts
);
327 sb
->buf
[sb
->len
- ignore_footer
] = saved_char
;
329 if (info
.trailer_start
== info
.trailer_end
)
332 for (i
= 0; i
< info
.trailer_nr
; i
++)
333 if (sob
&& !strncmp(info
.trailers
[i
], sob
->buf
, sob
->len
)) {
335 if (i
== info
.trailer_nr
- 1)
339 trailer_info_release(&info
);
348 static const char *gpg_sign_opt_quoted(struct replay_opts
*opts
)
350 static struct strbuf buf
= STRBUF_INIT
;
354 sq_quotef(&buf
, "-S%s", opts
->gpg_sign
);
358 void replay_opts_release(struct replay_opts
*opts
)
360 free(opts
->gpg_sign
);
361 free(opts
->reflog_action
);
362 free(opts
->default_strategy
);
363 free(opts
->strategy
);
364 for (size_t i
= 0; i
< opts
->xopts_nr
; i
++)
365 free(opts
->xopts
[i
]);
367 strbuf_release(&opts
->current_fixups
);
369 release_revisions(opts
->revs
);
373 int sequencer_remove_state(struct replay_opts
*opts
)
375 struct strbuf buf
= STRBUF_INIT
;
378 if (is_rebase_i(opts
) &&
379 strbuf_read_file(&buf
, rebase_path_refs_to_delete(), 0) > 0) {
382 char *eol
= strchr(p
, '\n');
385 if (delete_ref("(rebase) cleanup", p
, NULL
, 0) < 0) {
386 warning(_("could not delete '%s'"), p
);
396 strbuf_addstr(&buf
, get_dir(opts
));
397 if (remove_dir_recursively(&buf
, 0))
398 ret
= error(_("could not remove '%s'"), buf
.buf
);
399 strbuf_release(&buf
);
404 static const char *action_name(const struct replay_opts
*opts
)
406 switch (opts
->action
) {
410 return N_("cherry-pick");
411 case REPLAY_INTERACTIVE_REBASE
:
414 die(_("unknown action: %d"), opts
->action
);
417 struct commit_message
{
424 static const char *short_commit_name(struct commit
*commit
)
426 return repo_find_unique_abbrev(the_repository
, &commit
->object
.oid
,
430 static int get_message(struct commit
*commit
, struct commit_message
*out
)
432 const char *abbrev
, *subject
;
435 out
->message
= repo_logmsg_reencode(the_repository
, commit
, NULL
,
436 get_commit_output_encoding());
437 abbrev
= short_commit_name(commit
);
439 subject_len
= find_commit_subject(out
->message
, &subject
);
441 out
->subject
= xmemdupz(subject
, subject_len
);
442 out
->label
= xstrfmt("%s (%s)", abbrev
, out
->subject
);
443 out
->parent_label
= xstrfmt("parent of %s", out
->label
);
448 static void free_message(struct commit
*commit
, struct commit_message
*msg
)
450 free(msg
->parent_label
);
453 repo_unuse_commit_buffer(the_repository
, commit
, msg
->message
);
456 static void print_advice(struct repository
*r
, int show_hint
,
457 struct replay_opts
*opts
)
459 char *msg
= getenv("GIT_CHERRY_PICK_HELP");
464 * A conflict has occurred but the porcelain
465 * (typically rebase --interactive) wants to take care
466 * of the commit itself so remove CHERRY_PICK_HEAD
468 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
475 advise(_("after resolving the conflicts, mark the corrected paths\n"
476 "with 'git add <paths>' or 'git rm <paths>'"));
477 else if (opts
->action
== REPLAY_PICK
)
478 advise(_("After resolving the conflicts, mark them with\n"
479 "\"git add/rm <pathspec>\", then run\n"
480 "\"git cherry-pick --continue\".\n"
481 "You can instead skip this commit with \"git cherry-pick --skip\".\n"
482 "To abort and get back to the state before \"git cherry-pick\",\n"
483 "run \"git cherry-pick --abort\"."));
484 else if (opts
->action
== REPLAY_REVERT
)
485 advise(_("After resolving the conflicts, mark them with\n"
486 "\"git add/rm <pathspec>\", then run\n"
487 "\"git revert --continue\".\n"
488 "You can instead skip this commit with \"git revert --skip\".\n"
489 "To abort and get back to the state before \"git revert\",\n"
490 "run \"git revert --abort\"."));
492 BUG("unexpected pick action in print_advice()");
496 static int write_message(const void *buf
, size_t len
, const char *filename
,
499 struct lock_file msg_file
= LOCK_INIT
;
501 int msg_fd
= hold_lock_file_for_update(&msg_file
, filename
, 0);
503 return error_errno(_("could not lock '%s'"), filename
);
504 if (write_in_full(msg_fd
, buf
, len
) < 0) {
505 error_errno(_("could not write to '%s'"), filename
);
506 rollback_lock_file(&msg_file
);
509 if (append_eol
&& write(msg_fd
, "\n", 1) < 0) {
510 error_errno(_("could not write eol to '%s'"), filename
);
511 rollback_lock_file(&msg_file
);
514 if (commit_lock_file(&msg_file
) < 0)
515 return error(_("failed to finalize '%s'"), filename
);
520 int read_oneliner(struct strbuf
*buf
,
521 const char *path
, unsigned flags
)
523 int orig_len
= buf
->len
;
525 if (strbuf_read_file(buf
, path
, 0) < 0) {
526 if ((flags
& READ_ONELINER_WARN_MISSING
) ||
527 (errno
!= ENOENT
&& errno
!= ENOTDIR
))
528 warning_errno(_("could not read '%s'"), path
);
532 if (buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\n') {
533 if (--buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\r')
535 buf
->buf
[buf
->len
] = '\0';
538 if ((flags
& READ_ONELINER_SKIP_IF_EMPTY
) && buf
->len
== orig_len
)
544 static struct tree
*empty_tree(struct repository
*r
)
546 return lookup_tree(r
, the_hash_algo
->empty_tree
);
549 static int error_dirty_index(struct repository
*repo
, struct replay_opts
*opts
)
551 if (repo_read_index_unmerged(repo
))
552 return error_resolve_conflict(action_name(opts
));
554 error(_("your local changes would be overwritten by %s."),
555 _(action_name(opts
)));
557 if (advice_enabled(ADVICE_COMMIT_BEFORE_MERGE
))
558 advise(_("commit your changes or stash them to proceed."));
562 static void update_abort_safety_file(void)
564 struct object_id head
;
566 /* Do nothing on a single-pick */
567 if (!file_exists(git_path_seq_dir()))
570 if (!repo_get_oid(the_repository
, "HEAD", &head
))
571 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head
));
573 write_file(git_path_abort_safety_file(), "%s", "");
576 static int fast_forward_to(struct repository
*r
,
577 const struct object_id
*to
,
578 const struct object_id
*from
,
580 struct replay_opts
*opts
)
582 struct ref_transaction
*transaction
;
583 struct strbuf sb
= STRBUF_INIT
;
584 struct strbuf err
= STRBUF_INIT
;
587 if (checkout_fast_forward(r
, from
, to
, 1))
588 return -1; /* the callee should have complained already */
590 strbuf_addf(&sb
, "%s: fast-forward", action_name(opts
));
592 transaction
= ref_transaction_begin(&err
);
594 ref_transaction_update(transaction
, "HEAD",
595 to
, unborn
&& !is_rebase_i(opts
) ?
598 ref_transaction_commit(transaction
, &err
)) {
599 ref_transaction_free(transaction
);
600 error("%s", err
.buf
);
602 strbuf_release(&err
);
607 strbuf_release(&err
);
608 ref_transaction_free(transaction
);
609 update_abort_safety_file();
613 enum commit_msg_cleanup_mode
get_cleanup_mode(const char *cleanup_arg
,
616 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
617 return use_editor
? COMMIT_MSG_CLEANUP_ALL
:
618 COMMIT_MSG_CLEANUP_SPACE
;
619 else if (!strcmp(cleanup_arg
, "verbatim"))
620 return COMMIT_MSG_CLEANUP_NONE
;
621 else if (!strcmp(cleanup_arg
, "whitespace"))
622 return COMMIT_MSG_CLEANUP_SPACE
;
623 else if (!strcmp(cleanup_arg
, "strip"))
624 return COMMIT_MSG_CLEANUP_ALL
;
625 else if (!strcmp(cleanup_arg
, "scissors"))
626 return use_editor
? COMMIT_MSG_CLEANUP_SCISSORS
:
627 COMMIT_MSG_CLEANUP_SPACE
;
629 die(_("Invalid cleanup mode %s"), cleanup_arg
);
633 * NB using int rather than enum cleanup_mode to stop clang's
634 * -Wtautological-constant-out-of-range-compare complaining that the comparison
637 static const char *describe_cleanup_mode(int cleanup_mode
)
639 static const char *modes
[] = { "whitespace",
644 if (cleanup_mode
< ARRAY_SIZE(modes
))
645 return modes
[cleanup_mode
];
647 BUG("invalid cleanup_mode provided (%d)", cleanup_mode
);
650 void append_conflicts_hint(struct index_state
*istate
,
651 struct strbuf
*msgbuf
, enum commit_msg_cleanup_mode cleanup_mode
)
655 if (cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
) {
656 strbuf_addch(msgbuf
, '\n');
657 wt_status_append_cut_line(msgbuf
);
658 strbuf_addch(msgbuf
, comment_line_char
);
661 strbuf_addch(msgbuf
, '\n');
662 strbuf_commented_addf(msgbuf
, "Conflicts:\n");
663 for (i
= 0; i
< istate
->cache_nr
;) {
664 const struct cache_entry
*ce
= istate
->cache
[i
++];
666 strbuf_commented_addf(msgbuf
, "\t%s\n", ce
->name
);
667 while (i
< istate
->cache_nr
&&
668 !strcmp(ce
->name
, istate
->cache
[i
]->name
))
674 static int do_recursive_merge(struct repository
*r
,
675 struct commit
*base
, struct commit
*next
,
676 const char *base_label
, const char *next_label
,
677 struct object_id
*head
, struct strbuf
*msgbuf
,
678 struct replay_opts
*opts
)
680 struct merge_options o
;
681 struct merge_result result
;
682 struct tree
*next_tree
, *base_tree
, *head_tree
;
683 int clean
, show_output
;
685 struct lock_file index_lock
= LOCK_INIT
;
687 if (repo_hold_locked_index(r
, &index_lock
, LOCK_REPORT_ON_ERROR
) < 0)
692 init_merge_options(&o
, r
);
693 o
.ancestor
= base
? base_label
: "(empty tree)";
695 o
.branch2
= next
? next_label
: "(empty tree)";
696 if (is_rebase_i(opts
))
698 o
.show_rename_progress
= 1;
700 head_tree
= parse_tree_indirect(head
);
701 next_tree
= next
? repo_get_commit_tree(r
, next
) : empty_tree(r
);
702 base_tree
= base
? repo_get_commit_tree(r
, base
) : empty_tree(r
);
704 for (i
= 0; i
< opts
->xopts_nr
; i
++)
705 parse_merge_opt(&o
, opts
->xopts
[i
]);
707 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
708 memset(&result
, 0, sizeof(result
));
709 merge_incore_nonrecursive(&o
, base_tree
, head_tree
, next_tree
,
711 show_output
= !is_rebase_i(opts
) || !result
.clean
;
713 * TODO: merge_switch_to_result will update index/working tree;
714 * we only really want to do that if !result.clean || this is
715 * the final patch to be picked. But determining this is the
716 * final patch would take some work, and "head_tree" would need
717 * to be replace with the tree the index matched before we
718 * started doing any picks.
720 merge_switch_to_result(&o
, head_tree
, &result
, 1, show_output
);
721 clean
= result
.clean
;
723 ensure_full_index(r
->index
);
724 clean
= merge_trees(&o
, head_tree
, next_tree
, base_tree
);
725 if (is_rebase_i(opts
) && clean
<= 0)
726 fputs(o
.obuf
.buf
, stdout
);
727 strbuf_release(&o
.obuf
);
730 rollback_lock_file(&index_lock
);
734 if (write_locked_index(r
->index
, &index_lock
,
735 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
737 * TRANSLATORS: %s will be "revert", "cherry-pick" or
740 return error(_("%s: Unable to write new index file"),
741 _(action_name(opts
)));
744 append_conflicts_hint(r
->index
, msgbuf
,
745 opts
->default_msg_cleanup
);
750 static struct object_id
*get_cache_tree_oid(struct index_state
*istate
)
752 if (!cache_tree_fully_valid(istate
->cache_tree
))
753 if (cache_tree_update(istate
, 0)) {
754 error(_("unable to update cache tree"));
758 return &istate
->cache_tree
->oid
;
761 static int is_index_unchanged(struct repository
*r
)
763 struct object_id head_oid
, *cache_tree_oid
;
764 struct commit
*head_commit
;
765 struct index_state
*istate
= r
->index
;
767 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
768 return error(_("could not resolve HEAD commit"));
770 head_commit
= lookup_commit(r
, &head_oid
);
773 * If head_commit is NULL, check_commit, called from
774 * lookup_commit, would have indicated that head_commit is not
775 * a commit object already. repo_parse_commit() will return failure
776 * without further complaints in such a case. Otherwise, if
777 * the commit is invalid, repo_parse_commit() will complain. So
778 * there is nothing for us to say here. Just return failure.
780 if (repo_parse_commit(r
, head_commit
))
783 if (!(cache_tree_oid
= get_cache_tree_oid(istate
)))
786 return oideq(cache_tree_oid
, get_commit_tree_oid(head_commit
));
789 static int write_author_script(const char *message
)
791 struct strbuf buf
= STRBUF_INIT
;
796 if (!*message
|| starts_with(message
, "\n")) {
798 /* Missing 'author' line? */
799 unlink(rebase_path_author_script());
801 } else if (skip_prefix(message
, "author ", &message
))
803 else if ((eol
= strchr(message
, '\n')))
808 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
809 while (*message
&& *message
!= '\n' && *message
!= '\r')
810 if (skip_prefix(message
, " <", &message
))
812 else if (*message
!= '\'')
813 strbuf_addch(&buf
, *(message
++));
815 strbuf_addf(&buf
, "'\\%c'", *(message
++));
816 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
817 while (*message
&& *message
!= '\n' && *message
!= '\r')
818 if (skip_prefix(message
, "> ", &message
))
820 else if (*message
!= '\'')
821 strbuf_addch(&buf
, *(message
++));
823 strbuf_addf(&buf
, "'\\%c'", *(message
++));
824 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
825 while (*message
&& *message
!= '\n' && *message
!= '\r')
826 if (*message
!= '\'')
827 strbuf_addch(&buf
, *(message
++));
829 strbuf_addf(&buf
, "'\\%c'", *(message
++));
830 strbuf_addch(&buf
, '\'');
831 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
832 strbuf_release(&buf
);
837 * Take a series of KEY='VALUE' lines where VALUE part is
838 * sq-quoted, and append <KEY, VALUE> at the end of the string list
840 static int parse_key_value_squoted(char *buf
, struct string_list
*list
)
843 struct string_list_item
*item
;
845 char *cp
= strchr(buf
, '=');
847 np
= strchrnul(buf
, '\n');
848 return error(_("no key present in '%.*s'"),
849 (int) (np
- buf
), buf
);
851 np
= strchrnul(cp
, '\n');
853 item
= string_list_append(list
, buf
);
855 buf
= np
+ (*np
== '\n');
859 return error(_("unable to dequote value of '%s'"),
861 item
->util
= xstrdup(cp
);
867 * Reads and parses the state directory's "author-script" file, and sets name,
868 * email and date accordingly.
869 * Returns 0 on success, -1 if the file could not be parsed.
871 * The author script is of the format:
873 * GIT_AUTHOR_NAME='$author_name'
874 * GIT_AUTHOR_EMAIL='$author_email'
875 * GIT_AUTHOR_DATE='$author_date'
877 * where $author_name, $author_email and $author_date are quoted. We are strict
878 * with our parsing, as the file was meant to be eval'd in the now-removed
879 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
880 * from what this function expects, it is better to bail out than to do
881 * something that the user does not expect.
883 int read_author_script(const char *path
, char **name
, char **email
, char **date
,
886 struct strbuf buf
= STRBUF_INIT
;
887 struct string_list kv
= STRING_LIST_INIT_DUP
;
888 int retval
= -1; /* assume failure */
889 int i
, name_i
= -2, email_i
= -2, date_i
= -2, err
= 0;
891 if (strbuf_read_file(&buf
, path
, 256) <= 0) {
892 strbuf_release(&buf
);
893 if (errno
== ENOENT
&& allow_missing
)
896 return error_errno(_("could not open '%s' for reading"),
900 if (parse_key_value_squoted(buf
.buf
, &kv
))
903 for (i
= 0; i
< kv
.nr
; i
++) {
904 if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_NAME")) {
906 name_i
= error(_("'GIT_AUTHOR_NAME' already given"));
909 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_EMAIL")) {
911 email_i
= error(_("'GIT_AUTHOR_EMAIL' already given"));
914 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_DATE")) {
916 date_i
= error(_("'GIT_AUTHOR_DATE' already given"));
920 err
= error(_("unknown variable '%s'"),
925 error(_("missing 'GIT_AUTHOR_NAME'"));
927 error(_("missing 'GIT_AUTHOR_EMAIL'"));
929 error(_("missing 'GIT_AUTHOR_DATE'"));
930 if (name_i
< 0 || email_i
< 0 || date_i
< 0 || err
)
932 *name
= kv
.items
[name_i
].util
;
933 *email
= kv
.items
[email_i
].util
;
934 *date
= kv
.items
[date_i
].util
;
937 string_list_clear(&kv
, !!retval
);
938 strbuf_release(&buf
);
943 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
944 * file with shell quoting into struct strvec. Returns -1 on
945 * error, 0 otherwise.
947 static int read_env_script(struct strvec
*env
)
949 char *name
, *email
, *date
;
951 if (read_author_script(rebase_path_author_script(),
952 &name
, &email
, &date
, 0))
955 strvec_pushf(env
, "GIT_AUTHOR_NAME=%s", name
);
956 strvec_pushf(env
, "GIT_AUTHOR_EMAIL=%s", email
);
957 strvec_pushf(env
, "GIT_AUTHOR_DATE=%s", date
);
965 static char *get_author(const char *message
)
970 a
= find_commit_header(message
, "author", &len
);
972 return xmemdupz(a
, len
);
977 static const char *author_date_from_env(const struct strvec
*env
)
982 for (i
= 0; i
< env
->nr
; i
++)
983 if (skip_prefix(env
->v
[i
],
984 "GIT_AUTHOR_DATE=", &date
))
987 * If GIT_AUTHOR_DATE is missing we should have already errored out when
990 BUG("GIT_AUTHOR_DATE missing from author script");
993 static const char staged_changes_advice
[] =
994 N_("you have staged changes in your working tree\n"
995 "If these changes are meant to be squashed into the previous commit, run:\n"
997 " git commit --amend %s\n"
999 "If they are meant to go into a new commit, run:\n"
1003 "In both cases, once you're done, continue with:\n"
1005 " git rebase --continue\n");
1007 #define ALLOW_EMPTY (1<<0)
1008 #define EDIT_MSG (1<<1)
1009 #define AMEND_MSG (1<<2)
1010 #define CLEANUP_MSG (1<<3)
1011 #define VERIFY_MSG (1<<4)
1012 #define CREATE_ROOT_COMMIT (1<<5)
1013 #define VERBATIM_MSG (1<<6)
1015 static int run_command_silent_on_success(struct child_process
*cmd
)
1017 struct strbuf buf
= STRBUF_INIT
;
1020 cmd
->stdout_to_stderr
= 1;
1021 rc
= pipe_command(cmd
,
1027 fputs(buf
.buf
, stderr
);
1028 strbuf_release(&buf
);
1033 * If we are cherry-pick, and if the merge did not result in
1034 * hand-editing, we will hit this commit and inherit the original
1035 * author date and name.
1037 * If we are revert, or if our cherry-pick results in a hand merge,
1038 * we had better say that the current user is responsible for that.
1040 * An exception is when run_git_commit() is called during an
1041 * interactive rebase: in that case, we will want to retain the
1044 static int run_git_commit(const char *defmsg
,
1045 struct replay_opts
*opts
,
1048 struct child_process cmd
= CHILD_PROCESS_INIT
;
1050 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1051 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1055 if (is_rebase_i(opts
) &&
1056 ((opts
->committer_date_is_author_date
&& !opts
->ignore_date
) ||
1057 !(!defmsg
&& (flags
& AMEND_MSG
))) &&
1058 read_env_script(&cmd
.env
)) {
1059 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
1061 return error(_(staged_changes_advice
),
1065 strvec_pushf(&cmd
.env
, GIT_REFLOG_ACTION
"=%s", opts
->reflog_message
);
1067 if (opts
->committer_date_is_author_date
)
1068 strvec_pushf(&cmd
.env
, "GIT_COMMITTER_DATE=%s",
1071 author_date_from_env(&cmd
.env
));
1072 if (opts
->ignore_date
)
1073 strvec_push(&cmd
.env
, "GIT_AUTHOR_DATE=");
1075 strvec_push(&cmd
.args
, "commit");
1077 if (!(flags
& VERIFY_MSG
))
1078 strvec_push(&cmd
.args
, "-n");
1079 if ((flags
& AMEND_MSG
))
1080 strvec_push(&cmd
.args
, "--amend");
1082 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
1084 strvec_push(&cmd
.args
, "--no-gpg-sign");
1086 strvec_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
1087 else if (!(flags
& EDIT_MSG
))
1088 strvec_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
1089 if ((flags
& CLEANUP_MSG
))
1090 strvec_push(&cmd
.args
, "--cleanup=strip");
1091 if ((flags
& VERBATIM_MSG
))
1092 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1093 if ((flags
& EDIT_MSG
))
1094 strvec_push(&cmd
.args
, "-e");
1095 else if (!(flags
& CLEANUP_MSG
) &&
1096 !opts
->signoff
&& !opts
->record_origin
&&
1097 !opts
->explicit_cleanup
)
1098 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1100 if ((flags
& ALLOW_EMPTY
))
1101 strvec_push(&cmd
.args
, "--allow-empty");
1103 if (!(flags
& EDIT_MSG
))
1104 strvec_push(&cmd
.args
, "--allow-empty-message");
1106 if (is_rebase_i(opts
) && !(flags
& EDIT_MSG
))
1107 return run_command_silent_on_success(&cmd
);
1109 return run_command(&cmd
);
1112 static int rest_is_empty(const struct strbuf
*sb
, int start
)
1117 /* Check if the rest is just whitespace and Signed-off-by's. */
1118 for (i
= start
; i
< sb
->len
; i
++) {
1119 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1125 if (strlen(sign_off_header
) <= eol
- i
&&
1126 starts_with(sb
->buf
+ i
, sign_off_header
)) {
1131 if (!isspace(sb
->buf
[i
++]))
1138 void cleanup_message(struct strbuf
*msgbuf
,
1139 enum commit_msg_cleanup_mode cleanup_mode
, int verbose
)
1141 if (verbose
|| /* Truncate the message just before the diff, if any. */
1142 cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
1143 strbuf_setlen(msgbuf
, wt_status_locate_end(msgbuf
->buf
, msgbuf
->len
));
1144 if (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
)
1145 strbuf_stripspace(msgbuf
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1149 * Find out if the message in the strbuf contains only whitespace and
1150 * Signed-off-by lines.
1152 int message_is_empty(const struct strbuf
*sb
,
1153 enum commit_msg_cleanup_mode cleanup_mode
)
1155 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1157 return rest_is_empty(sb
, 0);
1161 * See if the user edited the message in the editor or left what
1162 * was in the template intact
1164 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
1165 enum commit_msg_cleanup_mode cleanup_mode
)
1167 struct strbuf tmpl
= STRBUF_INIT
;
1170 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1173 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
1176 strbuf_stripspace(&tmpl
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1177 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
1179 strbuf_release(&tmpl
);
1180 return rest_is_empty(sb
, start
- sb
->buf
);
1183 int update_head_with_reflog(const struct commit
*old_head
,
1184 const struct object_id
*new_head
,
1185 const char *action
, const struct strbuf
*msg
,
1188 struct ref_transaction
*transaction
;
1189 struct strbuf sb
= STRBUF_INIT
;
1194 strbuf_addstr(&sb
, action
);
1195 strbuf_addstr(&sb
, ": ");
1198 nl
= strchr(msg
->buf
, '\n');
1200 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
1202 strbuf_addbuf(&sb
, msg
);
1203 strbuf_addch(&sb
, '\n');
1206 transaction
= ref_transaction_begin(err
);
1208 ref_transaction_update(transaction
, "HEAD", new_head
,
1209 old_head
? &old_head
->object
.oid
: null_oid(),
1211 ref_transaction_commit(transaction
, err
)) {
1214 ref_transaction_free(transaction
);
1215 strbuf_release(&sb
);
1220 static int run_rewrite_hook(const struct object_id
*oldoid
,
1221 const struct object_id
*newoid
)
1223 struct child_process proc
= CHILD_PROCESS_INIT
;
1225 struct strbuf sb
= STRBUF_INIT
;
1226 const char *hook_path
= find_hook("post-rewrite");
1231 strvec_pushl(&proc
.args
, hook_path
, "amend", NULL
);
1233 proc
.stdout_to_stderr
= 1;
1234 proc
.trace2_hook_name
= "post-rewrite";
1236 code
= start_command(&proc
);
1239 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
1240 sigchain_push(SIGPIPE
, SIG_IGN
);
1241 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
1243 strbuf_release(&sb
);
1244 sigchain_pop(SIGPIPE
);
1245 return finish_command(&proc
);
1248 void commit_post_rewrite(struct repository
*r
,
1249 const struct commit
*old_head
,
1250 const struct object_id
*new_head
)
1252 struct notes_rewrite_cfg
*cfg
;
1254 cfg
= init_copy_notes_for_rewrite("amend");
1256 /* we are amending, so old_head is not NULL */
1257 copy_note_for_rewrite(cfg
, &old_head
->object
.oid
, new_head
);
1258 finish_copy_notes_for_rewrite(r
, cfg
, "Notes added by 'git commit --amend'");
1260 run_rewrite_hook(&old_head
->object
.oid
, new_head
);
1263 static int run_prepare_commit_msg_hook(struct repository
*r
,
1268 const char *name
, *arg1
= NULL
, *arg2
= NULL
;
1270 name
= git_path_commit_editmsg();
1271 if (write_message(msg
->buf
, msg
->len
, name
, 0))
1280 if (run_commit_hook(0, r
->index_file
, NULL
, "prepare-commit-msg", name
,
1282 ret
= error(_("'prepare-commit-msg' hook failed"));
1287 static const char implicit_ident_advice_noconfig
[] =
1288 N_("Your name and email address were configured automatically based\n"
1289 "on your username and hostname. Please check that they are accurate.\n"
1290 "You can suppress this message by setting them explicitly. Run the\n"
1291 "following command and follow the instructions in your editor to edit\n"
1292 "your configuration file:\n"
1294 " git config --global --edit\n"
1296 "After doing this, you may fix the identity used for this commit with:\n"
1298 " git commit --amend --reset-author\n");
1300 static const char implicit_ident_advice_config
[] =
1301 N_("Your name and email address were configured automatically based\n"
1302 "on your username and hostname. Please check that they are accurate.\n"
1303 "You can suppress this message by setting them explicitly:\n"
1305 " git config --global user.name \"Your Name\"\n"
1306 " git config --global user.email you@example.com\n"
1308 "After doing this, you may fix the identity used for this commit with:\n"
1310 " git commit --amend --reset-author\n");
1312 static const char *implicit_ident_advice(void)
1314 char *user_config
= interpolate_path("~/.gitconfig", 0);
1315 char *xdg_config
= xdg_config_home("config");
1316 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1322 return _(implicit_ident_advice_config
);
1324 return _(implicit_ident_advice_noconfig
);
1328 void print_commit_summary(struct repository
*r
,
1330 const struct object_id
*oid
,
1333 struct rev_info rev
;
1334 struct commit
*commit
;
1335 struct strbuf format
= STRBUF_INIT
;
1337 struct pretty_print_context pctx
= {0};
1338 struct strbuf author_ident
= STRBUF_INIT
;
1339 struct strbuf committer_ident
= STRBUF_INIT
;
1340 struct ref_store
*refs
;
1342 commit
= lookup_commit(r
, oid
);
1344 die(_("couldn't look up newly created commit"));
1345 if (repo_parse_commit(r
, commit
))
1346 die(_("could not parse newly created commit"));
1348 strbuf_addstr(&format
, "format:%h] %s");
1350 repo_format_commit_message(r
, commit
, "%an <%ae>", &author_ident
,
1352 repo_format_commit_message(r
, commit
, "%cn <%ce>", &committer_ident
,
1354 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1355 strbuf_addstr(&format
, "\n Author: ");
1356 strbuf_addbuf_percentquote(&format
, &author_ident
);
1358 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
1359 struct strbuf date
= STRBUF_INIT
;
1361 repo_format_commit_message(r
, commit
, "%ad", &date
, &pctx
);
1362 strbuf_addstr(&format
, "\n Date: ");
1363 strbuf_addbuf_percentquote(&format
, &date
);
1364 strbuf_release(&date
);
1366 if (!committer_ident_sufficiently_given()) {
1367 strbuf_addstr(&format
, "\n Committer: ");
1368 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1369 if (advice_enabled(ADVICE_IMPLICIT_IDENTITY
)) {
1370 strbuf_addch(&format
, '\n');
1371 strbuf_addstr(&format
, implicit_ident_advice());
1374 strbuf_release(&author_ident
);
1375 strbuf_release(&committer_ident
);
1377 repo_init_revisions(r
, &rev
, prefix
);
1378 setup_revisions(0, NULL
, &rev
, NULL
);
1381 rev
.diffopt
.output_format
=
1382 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1384 rev
.verbose_header
= 1;
1385 rev
.show_root_diff
= 1;
1386 get_commit_format(format
.buf
, &rev
);
1387 rev
.always_show_header
= 0;
1388 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1389 diff_setup_done(&rev
.diffopt
);
1391 refs
= get_main_ref_store(r
);
1392 head
= refs_resolve_ref_unsafe(refs
, "HEAD", 0, NULL
, NULL
);
1394 die(_("unable to resolve HEAD after creating commit"));
1395 if (!strcmp(head
, "HEAD"))
1396 head
= _("detached HEAD");
1398 skip_prefix(head
, "refs/heads/", &head
);
1399 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1400 _(" (root-commit)") : "");
1402 if (!log_tree_commit(&rev
, commit
)) {
1403 rev
.always_show_header
= 1;
1404 rev
.use_terminator
= 1;
1405 log_tree_commit(&rev
, commit
);
1408 release_revisions(&rev
);
1409 strbuf_release(&format
);
1412 static int parse_head(struct repository
*r
, struct commit
**head
)
1414 struct commit
*current_head
;
1415 struct object_id oid
;
1417 if (repo_get_oid(r
, "HEAD", &oid
)) {
1418 current_head
= NULL
;
1420 current_head
= lookup_commit_reference(r
, &oid
);
1422 return error(_("could not parse HEAD"));
1423 if (!oideq(&oid
, ¤t_head
->object
.oid
)) {
1424 warning(_("HEAD %s is not a commit!"),
1427 if (repo_parse_commit(r
, current_head
))
1428 return error(_("could not parse HEAD commit"));
1430 *head
= current_head
;
1436 * Try to commit without forking 'git commit'. In some cases we need
1437 * to run 'git commit' to display an error message
1440 * -1 - error unable to commit
1442 * 1 - run 'git commit'
1444 static int try_to_commit(struct repository
*r
,
1445 struct strbuf
*msg
, const char *author
,
1446 struct replay_opts
*opts
, unsigned int flags
,
1447 struct object_id
*oid
)
1449 struct object_id tree
;
1450 struct commit
*current_head
= NULL
;
1451 struct commit_list
*parents
= NULL
;
1452 struct commit_extra_header
*extra
= NULL
;
1453 struct strbuf err
= STRBUF_INIT
;
1454 struct strbuf commit_msg
= STRBUF_INIT
;
1455 char *amend_author
= NULL
;
1456 const char *committer
= NULL
;
1457 const char *hook_commit
= NULL
;
1458 enum commit_msg_cleanup_mode cleanup
;
1461 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1462 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1464 if (parse_head(r
, ¤t_head
))
1467 if (flags
& AMEND_MSG
) {
1468 const char *exclude_gpgsig
[] = { "gpgsig", "gpgsig-sha256", NULL
};
1469 const char *out_enc
= get_commit_output_encoding();
1470 const char *message
= repo_logmsg_reencode(r
, current_head
,
1474 const char *orig_message
= NULL
;
1476 find_commit_subject(message
, &orig_message
);
1478 strbuf_addstr(msg
, orig_message
);
1479 hook_commit
= "HEAD";
1481 author
= amend_author
= get_author(message
);
1482 repo_unuse_commit_buffer(r
, current_head
,
1485 res
= error(_("unable to parse commit author"));
1488 parents
= copy_commit_list(current_head
->parents
);
1489 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1490 } else if (current_head
&&
1491 (!(flags
& CREATE_ROOT_COMMIT
) || (flags
& AMEND_MSG
))) {
1492 commit_list_insert(current_head
, &parents
);
1495 if (write_index_as_tree(&tree
, r
->index
, r
->index_file
, 0, NULL
)) {
1496 res
= error(_("git write-tree failed to write a tree"));
1500 if (!(flags
& ALLOW_EMPTY
)) {
1501 struct commit
*first_parent
= current_head
;
1503 if (flags
& AMEND_MSG
) {
1504 if (current_head
->parents
) {
1505 first_parent
= current_head
->parents
->item
;
1506 if (repo_parse_commit(r
, first_parent
)) {
1507 res
= error(_("could not parse HEAD commit"));
1511 first_parent
= NULL
;
1514 if (oideq(first_parent
1515 ? get_commit_tree_oid(first_parent
)
1516 : the_hash_algo
->empty_tree
,
1518 res
= 1; /* run 'git commit' to display error message */
1523 if (hook_exists("prepare-commit-msg")) {
1524 res
= run_prepare_commit_msg_hook(r
, msg
, hook_commit
);
1527 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1529 res
= error_errno(_("unable to read commit message "
1531 git_path_commit_editmsg());
1537 if (flags
& CLEANUP_MSG
)
1538 cleanup
= COMMIT_MSG_CLEANUP_ALL
;
1539 else if (flags
& VERBATIM_MSG
)
1540 cleanup
= COMMIT_MSG_CLEANUP_NONE
;
1541 else if ((opts
->signoff
|| opts
->record_origin
) &&
1542 !opts
->explicit_cleanup
)
1543 cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
1545 cleanup
= opts
->default_msg_cleanup
;
1547 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1548 strbuf_stripspace(msg
, cleanup
== COMMIT_MSG_CLEANUP_ALL
);
1549 if ((flags
& EDIT_MSG
) && message_is_empty(msg
, cleanup
)) {
1550 res
= 1; /* run 'git commit' to display error message */
1554 if (opts
->committer_date_is_author_date
) {
1555 struct ident_split id
;
1556 struct strbuf date
= STRBUF_INIT
;
1558 if (!opts
->ignore_date
) {
1559 if (split_ident_line(&id
, author
, (int)strlen(author
)) < 0) {
1560 res
= error(_("invalid author identity '%s'"),
1564 if (!id
.date_begin
) {
1566 "corrupt author: missing date information"));
1569 strbuf_addf(&date
, "@%.*s %.*s",
1570 (int)(id
.date_end
- id
.date_begin
),
1572 (int)(id
.tz_end
- id
.tz_begin
),
1577 committer
= fmt_ident(getenv("GIT_COMMITTER_NAME"),
1578 getenv("GIT_COMMITTER_EMAIL"),
1579 WANT_COMMITTER_IDENT
,
1580 opts
->ignore_date
? NULL
: date
.buf
,
1582 strbuf_release(&date
);
1587 if (opts
->ignore_date
) {
1588 struct ident_split id
;
1591 if (split_ident_line(&id
, author
, strlen(author
)) < 0) {
1592 error(_("invalid author identity '%s'"), author
);
1595 name
= xmemdupz(id
.name_begin
, id
.name_end
- id
.name_begin
);
1596 email
= xmemdupz(id
.mail_begin
, id
.mail_end
- id
.mail_begin
);
1597 author
= fmt_ident(name
, email
, WANT_AUTHOR_IDENT
, NULL
,
1603 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
, oid
,
1604 author
, committer
, opts
->gpg_sign
, extra
)) {
1605 res
= error(_("failed to write commit object"));
1609 if (update_head_with_reflog(current_head
, oid
, opts
->reflog_message
,
1611 res
= error("%s", err
.buf
);
1615 run_commit_hook(0, r
->index_file
, NULL
, "post-commit", NULL
);
1616 if (flags
& AMEND_MSG
)
1617 commit_post_rewrite(r
, current_head
, oid
);
1620 free_commit_extra_headers(extra
);
1621 strbuf_release(&err
);
1622 strbuf_release(&commit_msg
);
1628 static int write_rebase_head(struct object_id
*oid
)
1630 if (update_ref("rebase", "REBASE_HEAD", oid
,
1631 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1632 return error(_("could not update %s"), "REBASE_HEAD");
1637 static int do_commit(struct repository
*r
,
1638 const char *msg_file
, const char *author
,
1639 struct replay_opts
*opts
, unsigned int flags
,
1640 struct object_id
*oid
)
1644 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
)) {
1645 struct object_id oid
;
1646 struct strbuf sb
= STRBUF_INIT
;
1648 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1649 return error_errno(_("unable to read commit message "
1653 res
= try_to_commit(r
, msg_file
? &sb
: NULL
,
1654 author
, opts
, flags
, &oid
);
1655 strbuf_release(&sb
);
1657 refs_delete_ref(get_main_ref_store(r
), "",
1658 "CHERRY_PICK_HEAD", NULL
, 0);
1659 unlink(git_path_merge_msg(r
));
1660 if (!is_rebase_i(opts
))
1661 print_commit_summary(r
, NULL
, &oid
,
1662 SUMMARY_SHOW_AUTHOR_DATE
);
1667 if (is_rebase_i(opts
) && oid
)
1668 if (write_rebase_head(oid
))
1670 return run_git_commit(msg_file
, opts
, flags
);
1676 static int is_original_commit_empty(struct commit
*commit
)
1678 const struct object_id
*ptree_oid
;
1680 if (repo_parse_commit(the_repository
, commit
))
1681 return error(_("could not parse commit %s"),
1682 oid_to_hex(&commit
->object
.oid
));
1683 if (commit
->parents
) {
1684 struct commit
*parent
= commit
->parents
->item
;
1685 if (repo_parse_commit(the_repository
, parent
))
1686 return error(_("could not parse parent commit %s"),
1687 oid_to_hex(&parent
->object
.oid
));
1688 ptree_oid
= get_commit_tree_oid(parent
);
1690 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1693 return oideq(ptree_oid
, get_commit_tree_oid(commit
));
1697 * Should empty commits be allowed? Return status:
1698 * <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1699 * 0: Halt on empty commit
1700 * 1: Allow empty commit
1701 * 2: Drop empty commit
1703 static int allow_empty(struct repository
*r
,
1704 struct replay_opts
*opts
,
1705 struct commit
*commit
)
1707 int index_unchanged
, originally_empty
;
1712 * (1) we do not allow empty at all and error out.
1714 * (2) we allow ones that were initially empty, and
1715 * just drop the ones that become empty
1717 * (3) we allow ones that were initially empty, but
1718 * halt for the ones that become empty;
1720 * (4) we allow both.
1722 if (!opts
->allow_empty
)
1723 return 0; /* let "git commit" barf as necessary */
1725 index_unchanged
= is_index_unchanged(r
);
1726 if (index_unchanged
< 0)
1727 return index_unchanged
;
1728 if (!index_unchanged
)
1729 return 0; /* we do not have to say --allow-empty */
1731 if (opts
->keep_redundant_commits
)
1734 originally_empty
= is_original_commit_empty(commit
);
1735 if (originally_empty
< 0)
1736 return originally_empty
;
1737 if (originally_empty
)
1739 else if (opts
->drop_redundant_commits
)
1748 } todo_command_info
[] = {
1749 [TODO_PICK
] = { 'p', "pick" },
1750 [TODO_REVERT
] = { 0, "revert" },
1751 [TODO_EDIT
] = { 'e', "edit" },
1752 [TODO_REWORD
] = { 'r', "reword" },
1753 [TODO_FIXUP
] = { 'f', "fixup" },
1754 [TODO_SQUASH
] = { 's', "squash" },
1755 [TODO_EXEC
] = { 'x', "exec" },
1756 [TODO_BREAK
] = { 'b', "break" },
1757 [TODO_LABEL
] = { 'l', "label" },
1758 [TODO_RESET
] = { 't', "reset" },
1759 [TODO_MERGE
] = { 'm', "merge" },
1760 [TODO_UPDATE_REF
] = { 'u', "update-ref" },
1761 [TODO_NOOP
] = { 0, "noop" },
1762 [TODO_DROP
] = { 'd', "drop" },
1763 [TODO_COMMENT
] = { 0, NULL
},
1766 static const char *command_to_string(const enum todo_command command
)
1768 if (command
< TODO_COMMENT
)
1769 return todo_command_info
[command
].str
;
1770 die(_("unknown command: %d"), command
);
1773 static char command_to_char(const enum todo_command command
)
1775 if (command
< TODO_COMMENT
)
1776 return todo_command_info
[command
].c
;
1777 return comment_line_char
;
1780 static int is_noop(const enum todo_command command
)
1782 return TODO_NOOP
<= command
;
1785 static int is_fixup(enum todo_command command
)
1787 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1790 /* Does this command create a (non-merge) commit? */
1791 static int is_pick_or_similar(enum todo_command command
)
1806 enum todo_item_flags
{
1807 TODO_EDIT_MERGE_MSG
= (1 << 0),
1808 TODO_REPLACE_FIXUP_MSG
= (1 << 1),
1809 TODO_EDIT_FIXUP_MSG
= (1 << 2),
1812 static const char first_commit_msg_str
[] = N_("This is the 1st commit message:");
1813 static const char nth_commit_msg_fmt
[] = N_("This is the commit message #%d:");
1814 static const char skip_first_commit_msg_str
[] = N_("The 1st commit message will be skipped:");
1815 static const char skip_nth_commit_msg_fmt
[] = N_("The commit message #%d will be skipped:");
1816 static const char combined_commit_msg_fmt
[] = N_("This is a combination of %d commits.");
1818 static int is_fixup_flag(enum todo_command command
, unsigned flag
)
1820 return command
== TODO_FIXUP
&& ((flag
& TODO_REPLACE_FIXUP_MSG
) ||
1821 (flag
& TODO_EDIT_FIXUP_MSG
));
1825 * Wrapper around strbuf_add_commented_lines() which avoids double
1826 * commenting commit subjects.
1828 static void add_commented_lines(struct strbuf
*buf
, const void *str
, size_t len
)
1830 const char *s
= str
;
1831 while (len
> 0 && s
[0] == comment_line_char
) {
1833 const char *n
= memchr(s
, '\n', len
);
1838 strbuf_add(buf
, s
, count
);
1842 strbuf_add_commented_lines(buf
, s
, len
);
1845 /* Does the current fixup chain contain a squash command? */
1846 static int seen_squash(struct replay_opts
*opts
)
1848 return starts_with(opts
->current_fixups
.buf
, "squash") ||
1849 strstr(opts
->current_fixups
.buf
, "\nsquash");
1852 static void update_comment_bufs(struct strbuf
*buf1
, struct strbuf
*buf2
, int n
)
1854 strbuf_setlen(buf1
, 2);
1855 strbuf_addf(buf1
, _(nth_commit_msg_fmt
), n
);
1856 strbuf_addch(buf1
, '\n');
1857 strbuf_setlen(buf2
, 2);
1858 strbuf_addf(buf2
, _(skip_nth_commit_msg_fmt
), n
);
1859 strbuf_addch(buf2
, '\n');
1863 * Comment out any un-commented commit messages, updating the message comments
1864 * to say they will be skipped but do not comment out the empty lines that
1865 * surround commit messages and their comments.
1867 static void update_squash_message_for_fixup(struct strbuf
*msg
)
1869 void (*copy_lines
)(struct strbuf
*, const void *, size_t) = strbuf_add
;
1870 struct strbuf buf1
= STRBUF_INIT
, buf2
= STRBUF_INIT
;
1871 const char *s
, *start
;
1873 size_t orig_msg_len
;
1876 strbuf_addf(&buf1
, "# %s\n", _(first_commit_msg_str
));
1877 strbuf_addf(&buf2
, "# %s\n", _(skip_first_commit_msg_str
));
1878 s
= start
= orig_msg
= strbuf_detach(msg
, &orig_msg_len
);
1882 if (skip_prefix(s
, buf1
.buf
, &next
)) {
1884 * Copy the last message, preserving the blank line
1885 * preceding the current line
1887 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1888 copy_lines(msg
, start
, s
- start
- off
);
1890 strbuf_addch(msg
, '\n');
1892 * The next message needs to be commented out but the
1893 * message header is already commented out so just copy
1894 * it and the blank line that follows it.
1896 strbuf_addbuf(msg
, &buf2
);
1898 strbuf_addch(msg
, *next
++);
1900 copy_lines
= add_commented_lines
;
1901 update_comment_bufs(&buf1
, &buf2
, ++i
);
1902 } else if (skip_prefix(s
, buf2
.buf
, &next
)) {
1903 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1904 copy_lines(msg
, start
, s
- start
- off
);
1907 copy_lines
= strbuf_add
;
1908 update_comment_bufs(&buf1
, &buf2
, ++i
);
1910 s
= strchr(s
, '\n');
1915 copy_lines(msg
, start
, orig_msg_len
- (start
- orig_msg
));
1917 strbuf_release(&buf1
);
1918 strbuf_release(&buf2
);
1921 static int append_squash_message(struct strbuf
*buf
, const char *body
,
1922 enum todo_command command
, struct replay_opts
*opts
,
1925 const char *fixup_msg
;
1926 size_t commented_len
= 0, fixup_off
;
1928 * amend is non-interactive and not normally used with fixup!
1929 * or squash! commits, so only comment out those subjects when
1930 * squashing commit messages.
1932 if (starts_with(body
, "amend!") ||
1933 ((command
== TODO_SQUASH
|| seen_squash(opts
)) &&
1934 (starts_with(body
, "squash!") || starts_with(body
, "fixup!"))))
1935 commented_len
= commit_subject_length(body
);
1937 strbuf_addf(buf
, "\n%c ", comment_line_char
);
1938 strbuf_addf(buf
, _(nth_commit_msg_fmt
),
1939 ++opts
->current_fixup_count
+ 1);
1940 strbuf_addstr(buf
, "\n\n");
1941 strbuf_add_commented_lines(buf
, body
, commented_len
);
1942 /* buf->buf may be reallocated so store an offset into the buffer */
1943 fixup_off
= buf
->len
;
1944 strbuf_addstr(buf
, body
+ commented_len
);
1946 /* fixup -C after squash behaves like squash */
1947 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
)) {
1949 * We're replacing the commit message so we need to
1950 * append the Signed-off-by: trailer if the user
1951 * requested '--signoff'.
1954 append_signoff(buf
, 0, 0);
1956 if ((command
== TODO_FIXUP
) &&
1957 (flag
& TODO_REPLACE_FIXUP_MSG
) &&
1958 (file_exists(rebase_path_fixup_msg()) ||
1959 !file_exists(rebase_path_squash_msg()))) {
1960 fixup_msg
= skip_blank_lines(buf
->buf
+ fixup_off
);
1961 if (write_message(fixup_msg
, strlen(fixup_msg
),
1962 rebase_path_fixup_msg(), 0) < 0)
1963 return error(_("cannot write '%s'"),
1964 rebase_path_fixup_msg());
1966 unlink(rebase_path_fixup_msg());
1969 unlink(rebase_path_fixup_msg());
1975 static int update_squash_messages(struct repository
*r
,
1976 enum todo_command command
,
1977 struct commit
*commit
,
1978 struct replay_opts
*opts
,
1981 struct strbuf buf
= STRBUF_INIT
;
1983 const char *message
, *body
;
1984 const char *encoding
= get_commit_output_encoding();
1986 if (opts
->current_fixup_count
> 0) {
1987 struct strbuf header
= STRBUF_INIT
;
1990 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
1991 return error(_("could not read '%s'"),
1992 rebase_path_squash_msg());
1994 eol
= buf
.buf
[0] != comment_line_char
?
1995 buf
.buf
: strchrnul(buf
.buf
, '\n');
1997 strbuf_addf(&header
, "%c ", comment_line_char
);
1998 strbuf_addf(&header
, _(combined_commit_msg_fmt
),
1999 opts
->current_fixup_count
+ 2);
2000 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
2001 strbuf_release(&header
);
2002 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
))
2003 update_squash_message_for_fixup(&buf
);
2005 struct object_id head
;
2006 struct commit
*head_commit
;
2007 const char *head_message
, *body
;
2009 if (repo_get_oid(r
, "HEAD", &head
))
2010 return error(_("need a HEAD to fixup"));
2011 if (!(head_commit
= lookup_commit_reference(r
, &head
)))
2012 return error(_("could not read HEAD"));
2013 if (!(head_message
= repo_logmsg_reencode(r
, head_commit
, NULL
,
2015 return error(_("could not read HEAD's commit message"));
2017 find_commit_subject(head_message
, &body
);
2018 if (command
== TODO_FIXUP
&& !flag
&& write_message(body
, strlen(body
),
2019 rebase_path_fixup_msg(), 0) < 0) {
2020 repo_unuse_commit_buffer(r
, head_commit
, head_message
);
2021 return error(_("cannot write '%s'"), rebase_path_fixup_msg());
2023 strbuf_addf(&buf
, "%c ", comment_line_char
);
2024 strbuf_addf(&buf
, _(combined_commit_msg_fmt
), 2);
2025 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
2026 strbuf_addstr(&buf
, is_fixup_flag(command
, flag
) ?
2027 _(skip_first_commit_msg_str
) :
2028 _(first_commit_msg_str
));
2029 strbuf_addstr(&buf
, "\n\n");
2030 if (is_fixup_flag(command
, flag
))
2031 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
2033 strbuf_addstr(&buf
, body
);
2035 repo_unuse_commit_buffer(r
, head_commit
, head_message
);
2038 if (!(message
= repo_logmsg_reencode(r
, commit
, NULL
, encoding
)))
2039 return error(_("could not read commit message of %s"),
2040 oid_to_hex(&commit
->object
.oid
));
2041 find_commit_subject(message
, &body
);
2043 if (command
== TODO_SQUASH
|| is_fixup_flag(command
, flag
)) {
2044 res
= append_squash_message(&buf
, body
, command
, opts
, flag
);
2045 } else if (command
== TODO_FIXUP
) {
2046 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
2047 strbuf_addf(&buf
, _(skip_nth_commit_msg_fmt
),
2048 ++opts
->current_fixup_count
+ 1);
2049 strbuf_addstr(&buf
, "\n\n");
2050 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
2052 return error(_("unknown command: %d"), command
);
2053 repo_unuse_commit_buffer(r
, commit
, message
);
2056 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(),
2058 strbuf_release(&buf
);
2061 strbuf_addf(&opts
->current_fixups
, "%s%s %s",
2062 opts
->current_fixups
.len
? "\n" : "",
2063 command_to_string(command
),
2064 oid_to_hex(&commit
->object
.oid
));
2065 res
= write_message(opts
->current_fixups
.buf
,
2066 opts
->current_fixups
.len
,
2067 rebase_path_current_fixups(), 0);
2073 static void flush_rewritten_pending(void)
2075 struct strbuf buf
= STRBUF_INIT
;
2076 struct object_id newoid
;
2079 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
2080 !repo_get_oid(the_repository
, "HEAD", &newoid
) &&
2081 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
2082 char *bol
= buf
.buf
, *eol
;
2085 eol
= strchrnul(bol
, '\n');
2086 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
2087 bol
, oid_to_hex(&newoid
));
2093 unlink(rebase_path_rewritten_pending());
2095 strbuf_release(&buf
);
2098 static void record_in_rewritten(struct object_id
*oid
,
2099 enum todo_command next_command
)
2101 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
2106 fprintf(out
, "%s\n", oid_to_hex(oid
));
2109 if (!is_fixup(next_command
))
2110 flush_rewritten_pending();
2113 static int should_edit(struct replay_opts
*opts
) {
2116 * Note that we only handle the case of non-conflicted
2117 * commits; continue_single_pick() handles the conflicted
2118 * commits itself instead of calling this function.
2120 return (opts
->action
== REPLAY_REVERT
&& isatty(0)) ? 1 : 0;
2124 static void refer_to_commit(struct replay_opts
*opts
,
2125 struct strbuf
*msgbuf
, struct commit
*commit
)
2127 if (opts
->commit_use_reference
) {
2128 struct pretty_print_context ctx
= {
2129 .abbrev
= DEFAULT_ABBREV
,
2130 .date_mode
.type
= DATE_SHORT
,
2132 repo_format_commit_message(the_repository
, commit
,
2133 "%h (%s, %ad)", msgbuf
, &ctx
);
2135 strbuf_addstr(msgbuf
, oid_to_hex(&commit
->object
.oid
));
2139 static int do_pick_commit(struct repository
*r
,
2140 struct todo_item
*item
,
2141 struct replay_opts
*opts
,
2142 int final_fixup
, int *check_todo
)
2144 unsigned int flags
= should_edit(opts
) ? EDIT_MSG
: 0;
2145 const char *msg_file
= should_edit(opts
) ? NULL
: git_path_merge_msg(r
);
2146 struct object_id head
;
2147 struct commit
*base
, *next
, *parent
;
2148 const char *base_label
, *next_label
;
2149 char *author
= NULL
;
2150 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
2151 struct strbuf msgbuf
= STRBUF_INIT
;
2152 int res
, unborn
= 0, reword
= 0, allow
, drop_commit
;
2153 enum todo_command command
= item
->command
;
2154 struct commit
*commit
= item
->commit
;
2156 if (opts
->no_commit
) {
2158 * We do not intend to commit immediately. We just want to
2159 * merge the differences in, so let's compute the tree
2160 * that represents the "current" state for the merge machinery
2163 if (write_index_as_tree(&head
, r
->index
, r
->index_file
, 0, NULL
))
2164 return error(_("your index file is unmerged."));
2166 unborn
= repo_get_oid(r
, "HEAD", &head
);
2167 /* Do we want to generate a root commit? */
2168 if (is_pick_or_similar(command
) && opts
->have_squash_onto
&&
2169 oideq(&head
, &opts
->squash_onto
)) {
2170 if (is_fixup(command
))
2171 return error(_("cannot fixup root commit"));
2172 flags
|= CREATE_ROOT_COMMIT
;
2175 oidcpy(&head
, the_hash_algo
->empty_tree
);
2176 if (index_differs_from(r
, unborn
? empty_tree_oid_hex() : "HEAD",
2178 return error_dirty_index(r
, opts
);
2180 discard_index(r
->index
);
2182 if (!commit
->parents
)
2184 else if (commit
->parents
->next
) {
2185 /* Reverting or cherry-picking a merge commit */
2187 struct commit_list
*p
;
2189 if (!opts
->mainline
)
2190 return error(_("commit %s is a merge but no -m option was given."),
2191 oid_to_hex(&commit
->object
.oid
));
2193 for (cnt
= 1, p
= commit
->parents
;
2194 cnt
!= opts
->mainline
&& p
;
2197 if (cnt
!= opts
->mainline
|| !p
)
2198 return error(_("commit %s does not have parent %d"),
2199 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2201 } else if (1 < opts
->mainline
)
2203 * Non-first parent explicitly specified as mainline for
2206 return error(_("commit %s does not have parent %d"),
2207 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2209 parent
= commit
->parents
->item
;
2211 if (get_message(commit
, &msg
) != 0)
2212 return error(_("cannot get commit message for %s"),
2213 oid_to_hex(&commit
->object
.oid
));
2215 if (opts
->allow_ff
&& !is_fixup(command
) &&
2216 ((parent
&& oideq(&parent
->object
.oid
, &head
)) ||
2217 (!parent
&& unborn
))) {
2218 if (is_rebase_i(opts
))
2219 write_author_script(msg
.message
);
2220 res
= fast_forward_to(r
, &commit
->object
.oid
, &head
, unborn
,
2222 if (res
|| command
!= TODO_REWORD
)
2226 goto fast_forward_edit
;
2228 if (parent
&& repo_parse_commit(r
, parent
) < 0)
2229 /* TRANSLATORS: The first %s will be a "todo" command like
2230 "revert" or "pick", the second %s a SHA1. */
2231 return error(_("%s: cannot parse parent commit %s"),
2232 command_to_string(command
),
2233 oid_to_hex(&parent
->object
.oid
));
2236 * "commit" is an existing commit. We would want to apply
2237 * the difference it introduces since its first parent "prev"
2238 * on top of the current HEAD if we are cherry-pick. Or the
2239 * reverse of it if we are revert.
2242 if (command
== TODO_REVERT
) {
2244 base_label
= msg
.label
;
2246 next_label
= msg
.parent_label
;
2247 if (opts
->commit_use_reference
) {
2248 strbuf_addstr(&msgbuf
,
2249 "# *** SAY WHY WE ARE REVERTING ON THE TITLE LINE ***");
2251 strbuf_addstr(&msgbuf
, "Revert \"");
2252 strbuf_addstr(&msgbuf
, msg
.subject
);
2253 strbuf_addstr(&msgbuf
, "\"");
2255 strbuf_addstr(&msgbuf
, "\n\nThis reverts commit ");
2256 refer_to_commit(opts
, &msgbuf
, commit
);
2258 if (commit
->parents
&& commit
->parents
->next
) {
2259 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
2260 refer_to_commit(opts
, &msgbuf
, parent
);
2262 strbuf_addstr(&msgbuf
, ".\n");
2267 base_label
= msg
.parent_label
;
2269 next_label
= msg
.label
;
2271 /* Append the commit log message to msgbuf. */
2272 if (find_commit_subject(msg
.message
, &p
))
2273 strbuf_addstr(&msgbuf
, p
);
2275 if (opts
->record_origin
) {
2276 strbuf_complete_line(&msgbuf
);
2277 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
2278 strbuf_addch(&msgbuf
, '\n');
2279 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
2280 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
2281 strbuf_addstr(&msgbuf
, ")\n");
2283 if (!is_fixup(command
))
2284 author
= get_author(msg
.message
);
2287 if (command
== TODO_REWORD
)
2289 else if (is_fixup(command
)) {
2290 if (update_squash_messages(r
, command
, commit
,
2291 opts
, item
->flags
)) {
2297 msg_file
= rebase_path_squash_msg();
2298 else if (file_exists(rebase_path_fixup_msg())) {
2299 flags
|= VERBATIM_MSG
;
2300 msg_file
= rebase_path_fixup_msg();
2302 const char *dest
= git_path_squash_msg(r
);
2304 if (copy_file(dest
, rebase_path_squash_msg(), 0666)) {
2305 res
= error(_("could not rename '%s' to '%s'"),
2306 rebase_path_squash_msg(), dest
);
2309 unlink(git_path_merge_msg(r
));
2315 if (opts
->signoff
&& !is_fixup(command
))
2316 append_signoff(&msgbuf
, 0, 0);
2318 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
2320 else if (!opts
->strategy
||
2321 !strcmp(opts
->strategy
, "recursive") ||
2322 !strcmp(opts
->strategy
, "ort") ||
2323 command
== TODO_REVERT
) {
2324 res
= do_recursive_merge(r
, base
, next
, base_label
, next_label
,
2325 &head
, &msgbuf
, opts
);
2329 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
2330 git_path_merge_msg(r
), 0);
2332 struct commit_list
*common
= NULL
;
2333 struct commit_list
*remotes
= NULL
;
2335 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
2336 git_path_merge_msg(r
), 0);
2338 commit_list_insert(base
, &common
);
2339 commit_list_insert(next
, &remotes
);
2340 res
|= try_merge_command(r
, opts
->strategy
,
2341 opts
->xopts_nr
, (const char **)opts
->xopts
,
2342 common
, oid_to_hex(&head
), remotes
);
2343 free_commit_list(common
);
2344 free_commit_list(remotes
);
2348 * If the merge was clean or if it failed due to conflict, we write
2349 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
2350 * However, if the merge did not even start, then we don't want to
2353 if ((command
== TODO_PICK
|| command
== TODO_REWORD
||
2354 command
== TODO_EDIT
) && !opts
->no_commit
&&
2355 (res
== 0 || res
== 1) &&
2356 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
2357 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2359 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
2360 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
2361 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2365 error(command
== TODO_REVERT
2366 ? _("could not revert %s... %s")
2367 : _("could not apply %s... %s"),
2368 short_commit_name(commit
), msg
.subject
);
2369 print_advice(r
, res
== 1, opts
);
2370 repo_rerere(r
, opts
->allow_rerere_auto
);
2375 allow
= allow_empty(r
, opts
, commit
);
2379 } else if (allow
== 1) {
2380 flags
|= ALLOW_EMPTY
;
2381 } else if (allow
== 2) {
2383 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
2385 unlink(git_path_merge_msg(r
));
2386 unlink(git_path_auto_merge(r
));
2388 _("dropping %s %s -- patch contents already upstream\n"),
2389 oid_to_hex(&commit
->object
.oid
), msg
.subject
);
2390 } /* else allow == 0 and there's nothing special to do */
2391 if (!opts
->no_commit
&& !drop_commit
) {
2392 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
2393 res
= do_commit(r
, msg_file
, author
, opts
, flags
,
2394 commit
? &commit
->object
.oid
: NULL
);
2396 res
= error(_("unable to parse commit author"));
2397 *check_todo
= !!(flags
& EDIT_MSG
);
2398 if (!res
&& reword
) {
2400 res
= run_git_commit(NULL
, opts
, EDIT_MSG
|
2401 VERIFY_MSG
| AMEND_MSG
|
2402 (flags
& ALLOW_EMPTY
));
2408 if (!res
&& final_fixup
) {
2409 unlink(rebase_path_fixup_msg());
2410 unlink(rebase_path_squash_msg());
2411 unlink(rebase_path_current_fixups());
2412 strbuf_reset(&opts
->current_fixups
);
2413 opts
->current_fixup_count
= 0;
2417 free_message(commit
, &msg
);
2419 strbuf_release(&msgbuf
);
2420 update_abort_safety_file();
2425 static int prepare_revs(struct replay_opts
*opts
)
2428 * picking (but not reverting) ranges (but not individual revisions)
2429 * should be done in reverse
2431 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
2432 opts
->revs
->reverse
^= 1;
2434 if (prepare_revision_walk(opts
->revs
))
2435 return error(_("revision walk setup failed"));
2440 static int read_and_refresh_cache(struct repository
*r
,
2441 struct replay_opts
*opts
)
2443 struct lock_file index_lock
= LOCK_INIT
;
2444 int index_fd
= repo_hold_locked_index(r
, &index_lock
, 0);
2445 if (repo_read_index(r
) < 0) {
2446 rollback_lock_file(&index_lock
);
2447 return error(_("git %s: failed to read the index"),
2450 refresh_index(r
->index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
2452 if (index_fd
>= 0) {
2453 if (write_locked_index(r
->index
, &index_lock
,
2454 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
2455 return error(_("git %s: failed to refresh the index"),
2461 * If we are resolving merges in any way other than "ort", then
2462 * expand the sparse index.
2464 if (opts
->strategy
&& strcmp(opts
->strategy
, "ort"))
2465 ensure_full_index(r
->index
);
2469 void todo_list_release(struct todo_list
*todo_list
)
2471 strbuf_release(&todo_list
->buf
);
2472 FREE_AND_NULL(todo_list
->items
);
2473 todo_list
->nr
= todo_list
->alloc
= 0;
2476 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
2478 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
2479 todo_list
->total_nr
++;
2480 return todo_list
->items
+ todo_list
->nr
++;
2483 const char *todo_item_get_arg(struct todo_list
*todo_list
,
2484 struct todo_item
*item
)
2486 return todo_list
->buf
.buf
+ item
->arg_offset
;
2489 static int is_command(enum todo_command command
, const char **bol
)
2491 const char *str
= todo_command_info
[command
].str
;
2492 const char nick
= todo_command_info
[command
].c
;
2493 const char *p
= *bol
;
2495 return (skip_prefix(p
, str
, &p
) || (nick
&& *p
++ == nick
)) &&
2496 (*p
== ' ' || *p
== '\t' || *p
== '\n' || *p
== '\r' || !*p
) &&
2500 static int check_label_or_ref_arg(enum todo_command command
, const char *arg
)
2505 * '#' is not a valid label as the merge command uses it to
2506 * separate merge parents from the commit subject.
2508 if (!strcmp(arg
, "#") ||
2509 check_refname_format(arg
, REFNAME_ALLOW_ONELEVEL
))
2510 return error(_("'%s' is not a valid label"), arg
);
2513 case TODO_UPDATE_REF
:
2514 if (check_refname_format(arg
, REFNAME_ALLOW_ONELEVEL
))
2515 return error(_("'%s' is not a valid refname"), arg
);
2516 if (check_refname_format(arg
, 0))
2517 return error(_("update-ref requires a fully qualified "
2518 "refname e.g. refs/heads/%s"), arg
);
2522 BUG("unexpected todo_command");
2528 static int parse_insn_line(struct repository
*r
, struct todo_item
*item
,
2529 const char *buf
, const char *bol
, char *eol
)
2531 struct object_id commit_oid
;
2532 char *end_of_object_name
;
2533 int i
, saved
, status
, padding
;
2538 bol
+= strspn(bol
, " \t");
2540 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
2541 item
->command
= TODO_COMMENT
;
2542 item
->commit
= NULL
;
2543 item
->arg_offset
= bol
- buf
;
2544 item
->arg_len
= eol
- bol
;
2548 for (i
= 0; i
< TODO_COMMENT
; i
++)
2549 if (is_command(i
, &bol
)) {
2553 if (i
>= TODO_COMMENT
)
2554 return error(_("invalid command '%.*s'"),
2555 (int)strcspn(bol
, " \t\r\n"), bol
);
2557 /* Eat up extra spaces/ tabs before object name */
2558 padding
= strspn(bol
, " \t");
2561 if (item
->command
== TODO_NOOP
|| item
->command
== TODO_BREAK
) {
2563 return error(_("%s does not accept arguments: '%s'"),
2564 command_to_string(item
->command
), bol
);
2565 item
->commit
= NULL
;
2566 item
->arg_offset
= bol
- buf
;
2567 item
->arg_len
= eol
- bol
;
2572 return error(_("missing arguments for %s"),
2573 command_to_string(item
->command
));
2575 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
2576 item
->command
== TODO_RESET
|| item
->command
== TODO_UPDATE_REF
) {
2579 item
->commit
= NULL
;
2580 item
->arg_offset
= bol
- buf
;
2581 item
->arg_len
= (int)(eol
- bol
);
2582 if (item
->command
== TODO_LABEL
||
2583 item
->command
== TODO_UPDATE_REF
) {
2586 ret
= check_label_or_ref_arg(item
->command
, bol
);
2592 if (item
->command
== TODO_FIXUP
) {
2593 if (skip_prefix(bol
, "-C", &bol
)) {
2594 bol
+= strspn(bol
, " \t");
2595 item
->flags
|= TODO_REPLACE_FIXUP_MSG
;
2596 } else if (skip_prefix(bol
, "-c", &bol
)) {
2597 bol
+= strspn(bol
, " \t");
2598 item
->flags
|= TODO_EDIT_FIXUP_MSG
;
2602 if (item
->command
== TODO_MERGE
) {
2603 if (skip_prefix(bol
, "-C", &bol
))
2604 bol
+= strspn(bol
, " \t");
2605 else if (skip_prefix(bol
, "-c", &bol
)) {
2606 bol
+= strspn(bol
, " \t");
2607 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2609 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2610 item
->commit
= NULL
;
2611 item
->arg_offset
= bol
- buf
;
2612 item
->arg_len
= (int)(eol
- bol
);
2617 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
2618 saved
= *end_of_object_name
;
2619 *end_of_object_name
= '\0';
2620 status
= repo_get_oid(r
, bol
, &commit_oid
);
2622 error(_("could not parse '%s'"), bol
); /* return later */
2623 *end_of_object_name
= saved
;
2625 bol
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2626 item
->arg_offset
= bol
- buf
;
2627 item
->arg_len
= (int)(eol
- bol
);
2632 item
->commit
= lookup_commit_reference(r
, &commit_oid
);
2633 return item
->commit
? 0 : -1;
2636 int sequencer_get_last_command(struct repository
*r
, enum replay_action
*action
)
2638 const char *todo_file
, *bol
;
2639 struct strbuf buf
= STRBUF_INIT
;
2642 todo_file
= git_path_todo_file();
2643 if (strbuf_read_file(&buf
, todo_file
, 0) < 0) {
2644 if (errno
== ENOENT
|| errno
== ENOTDIR
)
2647 return error_errno("unable to open '%s'", todo_file
);
2649 bol
= buf
.buf
+ strspn(buf
.buf
, " \t\r\n");
2650 if (is_command(TODO_PICK
, &bol
) && (*bol
== ' ' || *bol
== '\t'))
2651 *action
= REPLAY_PICK
;
2652 else if (is_command(TODO_REVERT
, &bol
) &&
2653 (*bol
== ' ' || *bol
== '\t'))
2654 *action
= REPLAY_REVERT
;
2658 strbuf_release(&buf
);
2663 int todo_list_parse_insn_buffer(struct repository
*r
, char *buf
,
2664 struct todo_list
*todo_list
)
2666 struct todo_item
*item
;
2667 char *p
= buf
, *next_p
;
2668 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2670 todo_list
->current
= todo_list
->nr
= 0;
2672 for (i
= 1; *p
; i
++, p
= next_p
) {
2673 char *eol
= strchrnul(p
, '\n');
2675 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2677 if (p
!= eol
&& eol
[-1] == '\r')
2678 eol
--; /* strip Carriage Return */
2680 item
= append_new_todo(todo_list
);
2681 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2682 if (parse_insn_line(r
, item
, buf
, p
, eol
)) {
2683 res
= error(_("invalid line %d: %.*s"),
2684 i
, (int)(eol
- p
), p
);
2685 item
->command
= TODO_COMMENT
+ 1;
2686 item
->arg_offset
= p
- buf
;
2687 item
->arg_len
= (int)(eol
- p
);
2688 item
->commit
= NULL
;
2693 else if (is_fixup(item
->command
))
2694 return error(_("cannot '%s' without a previous commit"),
2695 command_to_string(item
->command
));
2696 else if (!is_noop(item
->command
))
2703 static int count_commands(struct todo_list
*todo_list
)
2707 for (i
= 0; i
< todo_list
->nr
; i
++)
2708 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2714 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2716 return index
< todo_list
->nr
?
2717 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2720 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2722 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2725 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2727 return get_item_line_offset(todo_list
, index
+ 1)
2728 - get_item_line_offset(todo_list
, index
);
2731 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2736 fd
= open(path
, O_RDONLY
);
2738 return error_errno(_("could not open '%s'"), path
);
2739 len
= strbuf_read(sb
, fd
, 0);
2742 return error(_("could not read '%s'."), path
);
2746 static int have_finished_the_last_pick(void)
2748 struct strbuf buf
= STRBUF_INIT
;
2750 const char *todo_path
= git_path_todo_file();
2753 if (strbuf_read_file(&buf
, todo_path
, 0) < 0) {
2754 if (errno
== ENOENT
) {
2757 error_errno("unable to open '%s'", todo_path
);
2761 /* If there is only one line then we are done */
2762 eol
= strchr(buf
.buf
, '\n');
2763 if (!eol
|| !eol
[1])
2766 strbuf_release(&buf
);
2771 void sequencer_post_commit_cleanup(struct repository
*r
, int verbose
)
2773 struct replay_opts opts
= REPLAY_OPTS_INIT
;
2774 int need_cleanup
= 0;
2776 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
2777 if (!refs_delete_ref(get_main_ref_store(r
), "",
2778 "CHERRY_PICK_HEAD", NULL
, 0) &&
2780 warning(_("cancelling a cherry picking in progress"));
2781 opts
.action
= REPLAY_PICK
;
2785 if (refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
2786 if (!refs_delete_ref(get_main_ref_store(r
), "", "REVERT_HEAD",
2789 warning(_("cancelling a revert in progress"));
2790 opts
.action
= REPLAY_REVERT
;
2794 unlink(git_path_auto_merge(r
));
2799 if (!have_finished_the_last_pick())
2802 sequencer_remove_state(&opts
);
2805 static void todo_list_write_total_nr(struct todo_list
*todo_list
)
2807 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2810 fprintf(f
, "%d\n", todo_list
->total_nr
);
2815 static int read_populate_todo(struct repository
*r
,
2816 struct todo_list
*todo_list
,
2817 struct replay_opts
*opts
)
2819 const char *todo_file
= get_todo_path(opts
);
2822 strbuf_reset(&todo_list
->buf
);
2823 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2826 res
= todo_list_parse_insn_buffer(r
, todo_list
->buf
.buf
, todo_list
);
2828 if (is_rebase_i(opts
))
2829 return error(_("please fix this using "
2830 "'git rebase --edit-todo'."));
2831 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2834 if (!todo_list
->nr
&&
2835 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2836 return error(_("no commits parsed."));
2838 if (!is_rebase_i(opts
)) {
2839 enum todo_command valid
=
2840 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2843 for (i
= 0; i
< todo_list
->nr
; i
++)
2844 if (valid
== todo_list
->items
[i
].command
)
2846 else if (valid
== TODO_PICK
)
2847 return error(_("cannot cherry-pick during a revert."));
2849 return error(_("cannot revert during a cherry-pick."));
2852 if (is_rebase_i(opts
)) {
2853 struct todo_list done
= TODO_LIST_INIT
;
2855 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2856 !todo_list_parse_insn_buffer(r
, done
.buf
.buf
, &done
))
2857 todo_list
->done_nr
= count_commands(&done
);
2859 todo_list
->done_nr
= 0;
2861 todo_list
->total_nr
= todo_list
->done_nr
2862 + count_commands(todo_list
);
2863 todo_list_release(&done
);
2865 todo_list_write_total_nr(todo_list
);
2871 static int git_config_string_dup(char **dest
,
2872 const char *var
, const char *value
)
2875 return config_error_nonbool(var
);
2877 *dest
= xstrdup(value
);
2881 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
2883 struct replay_opts
*opts
= data
;
2888 else if (!strcmp(key
, "options.no-commit"))
2889 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
2890 else if (!strcmp(key
, "options.edit"))
2891 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
2892 else if (!strcmp(key
, "options.allow-empty"))
2894 git_config_bool_or_int(key
, value
, &error_flag
);
2895 else if (!strcmp(key
, "options.allow-empty-message"))
2896 opts
->allow_empty_message
=
2897 git_config_bool_or_int(key
, value
, &error_flag
);
2898 else if (!strcmp(key
, "options.keep-redundant-commits"))
2899 opts
->keep_redundant_commits
=
2900 git_config_bool_or_int(key
, value
, &error_flag
);
2901 else if (!strcmp(key
, "options.signoff"))
2902 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
2903 else if (!strcmp(key
, "options.record-origin"))
2904 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
2905 else if (!strcmp(key
, "options.allow-ff"))
2906 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
2907 else if (!strcmp(key
, "options.mainline"))
2908 opts
->mainline
= git_config_int(key
, value
);
2909 else if (!strcmp(key
, "options.strategy"))
2910 git_config_string_dup(&opts
->strategy
, key
, value
);
2911 else if (!strcmp(key
, "options.gpg-sign"))
2912 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
2913 else if (!strcmp(key
, "options.strategy-option")) {
2914 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
2915 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(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 void parse_strategy_opts(struct replay_opts
*opts
, char *raw_opts
)
2936 char *strategy_opts_string
= raw_opts
;
2938 if (*strategy_opts_string
== ' ')
2939 strategy_opts_string
++;
2941 count
= split_cmdline(strategy_opts_string
,
2942 (const char ***)&opts
->xopts
);
2944 die(_("could not split '%s': %s"), strategy_opts_string
,
2945 split_cmdline_strerror(count
));
2946 opts
->xopts_nr
= count
;
2947 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
2948 const char *arg
= opts
->xopts
[i
];
2950 skip_prefix(arg
, "--", &arg
);
2951 opts
->xopts
[i
] = xstrdup(arg
);
2955 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2958 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2960 free(opts
->strategy
);
2961 opts
->strategy
= strbuf_detach(buf
, NULL
);
2962 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2965 parse_strategy_opts(opts
, buf
->buf
);
2968 static int read_populate_opts(struct replay_opts
*opts
)
2970 if (is_rebase_i(opts
)) {
2971 struct strbuf buf
= STRBUF_INIT
;
2974 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(),
2975 READ_ONELINER_SKIP_IF_EMPTY
)) {
2976 if (!starts_with(buf
.buf
, "-S"))
2979 free(opts
->gpg_sign
);
2980 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2985 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(),
2986 READ_ONELINER_SKIP_IF_EMPTY
)) {
2987 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2988 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2989 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2990 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2994 if (file_exists(rebase_path_verbose()))
2997 if (file_exists(rebase_path_quiet()))
3000 if (file_exists(rebase_path_signoff())) {
3005 if (file_exists(rebase_path_cdate_is_adate())) {
3007 opts
->committer_date_is_author_date
= 1;
3010 if (file_exists(rebase_path_ignore_date())) {
3012 opts
->ignore_date
= 1;
3015 if (file_exists(rebase_path_reschedule_failed_exec()))
3016 opts
->reschedule_failed_exec
= 1;
3017 else if (file_exists(rebase_path_no_reschedule_failed_exec()))
3018 opts
->reschedule_failed_exec
= 0;
3020 if (file_exists(rebase_path_drop_redundant_commits()))
3021 opts
->drop_redundant_commits
= 1;
3023 if (file_exists(rebase_path_keep_redundant_commits()))
3024 opts
->keep_redundant_commits
= 1;
3026 read_strategy_opts(opts
, &buf
);
3029 if (read_oneliner(&opts
->current_fixups
,
3030 rebase_path_current_fixups(),
3031 READ_ONELINER_SKIP_IF_EMPTY
)) {
3032 const char *p
= opts
->current_fixups
.buf
;
3033 opts
->current_fixup_count
= 1;
3034 while ((p
= strchr(p
, '\n'))) {
3035 opts
->current_fixup_count
++;
3040 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
3041 if (repo_get_oid_committish(the_repository
, buf
.buf
, &opts
->squash_onto
) < 0) {
3042 ret
= error(_("unusable squash-onto"));
3045 opts
->have_squash_onto
= 1;
3049 strbuf_release(&buf
);
3053 if (!file_exists(git_path_opts_file()))
3056 * The function git_parse_source(), called from git_config_from_file(),
3057 * may die() in case of a syntactically incorrect file. We do not care
3058 * about this case, though, because we wrote that file ourselves, so we
3059 * are pretty certain that it is syntactically correct.
3061 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
3062 return error(_("malformed options sheet: '%s'"),
3063 git_path_opts_file());
3067 static void write_strategy_opts(struct replay_opts
*opts
)
3070 struct strbuf buf
= STRBUF_INIT
;
3072 for (i
= 0; i
< opts
->xopts_nr
; ++i
)
3073 strbuf_addf(&buf
, " --%s", opts
->xopts
[i
]);
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 struct lock_file head_lock
= LOCK_INIT
;
3207 struct strbuf buf
= STRBUF_INIT
;
3211 fd
= hold_lock_file_for_update(&head_lock
, git_path_head_file(), 0);
3213 return error_errno(_("could not lock HEAD"));
3214 strbuf_addf(&buf
, "%s\n", head
);
3215 written
= write_in_full(fd
, buf
.buf
, buf
.len
);
3216 strbuf_release(&buf
);
3218 error_errno(_("could not write to '%s'"), git_path_head_file());
3219 rollback_lock_file(&head_lock
);
3222 if (commit_lock_file(&head_lock
) < 0)
3223 return error(_("failed to finalize '%s'"), git_path_head_file());
3227 static int rollback_is_safe(void)
3229 struct strbuf sb
= STRBUF_INIT
;
3230 struct object_id expected_head
, actual_head
;
3232 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
3234 if (get_oid_hex(sb
.buf
, &expected_head
)) {
3235 strbuf_release(&sb
);
3236 die(_("could not parse %s"), git_path_abort_safety_file());
3238 strbuf_release(&sb
);
3240 else if (errno
== ENOENT
)
3241 oidclr(&expected_head
);
3243 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
3245 if (repo_get_oid(the_repository
, "HEAD", &actual_head
))
3246 oidclr(&actual_head
);
3248 return oideq(&actual_head
, &expected_head
);
3251 static int reset_merge(const struct object_id
*oid
)
3253 struct child_process cmd
= CHILD_PROCESS_INIT
;
3256 strvec_pushl(&cmd
.args
, "reset", "--merge", NULL
);
3258 if (!is_null_oid(oid
))
3259 strvec_push(&cmd
.args
, oid_to_hex(oid
));
3261 return run_command(&cmd
);
3264 static int rollback_single_pick(struct repository
*r
)
3266 struct object_id head_oid
;
3268 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
3269 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
3270 return error(_("no cherry-pick or revert in progress"));
3271 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
3272 return error(_("cannot resolve HEAD"));
3273 if (is_null_oid(&head_oid
))
3274 return error(_("cannot abort from a branch yet to be born"));
3275 return reset_merge(&head_oid
);
3278 static int skip_single_pick(void)
3280 struct object_id head
;
3282 if (read_ref_full("HEAD", 0, &head
, NULL
))
3283 return error(_("cannot resolve HEAD"));
3284 return reset_merge(&head
);
3287 int sequencer_rollback(struct repository
*r
, struct replay_opts
*opts
)
3290 struct object_id oid
;
3291 struct strbuf buf
= STRBUF_INIT
;
3294 f
= fopen(git_path_head_file(), "r");
3295 if (!f
&& errno
== ENOENT
) {
3297 * There is no multiple-cherry-pick in progress.
3298 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
3299 * a single-cherry-pick in progress, abort that.
3301 return rollback_single_pick(r
);
3304 return error_errno(_("cannot open '%s'"), git_path_head_file());
3305 if (strbuf_getline_lf(&buf
, f
)) {
3306 error(_("cannot read '%s': %s"), git_path_head_file(),
3307 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
3312 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
3313 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
3314 git_path_head_file());
3317 if (is_null_oid(&oid
)) {
3318 error(_("cannot abort from a branch yet to be born"));
3322 if (!rollback_is_safe()) {
3323 /* Do not error, just do not rollback */
3324 warning(_("You seem to have moved HEAD. "
3325 "Not rewinding, check your HEAD!"));
3327 if (reset_merge(&oid
))
3329 strbuf_release(&buf
);
3330 return sequencer_remove_state(opts
);
3332 strbuf_release(&buf
);
3336 int sequencer_skip(struct repository
*r
, struct replay_opts
*opts
)
3338 enum replay_action action
= -1;
3339 sequencer_get_last_command(r
, &action
);
3342 * Check whether the subcommand requested to skip the commit is actually
3343 * in progress and that it's safe to skip the commit.
3345 * opts->action tells us which subcommand requested to skip the commit.
3346 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
3347 * action is in progress and we can skip the commit.
3349 * Otherwise we check that the last instruction was related to the
3350 * particular subcommand we're trying to execute and barf if that's not
3353 * Finally we check that the rollback is "safe", i.e., has the HEAD
3354 * moved? In this case, it doesn't make sense to "reset the merge" and
3355 * "skip the commit" as the user already handled this by committing. But
3356 * we'd not want to barf here, instead give advice on how to proceed. We
3357 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
3358 * it gets removed when the user commits, so if it still exists we're
3359 * sure the user can't have committed before.
3361 switch (opts
->action
) {
3363 if (!refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
3364 if (action
!= REPLAY_REVERT
)
3365 return error(_("no revert in progress"));
3366 if (!rollback_is_safe())
3371 if (!refs_ref_exists(get_main_ref_store(r
),
3372 "CHERRY_PICK_HEAD")) {
3373 if (action
!= REPLAY_PICK
)
3374 return error(_("no cherry-pick in progress"));
3375 if (!rollback_is_safe())
3380 BUG("unexpected action in sequencer_skip");
3383 if (skip_single_pick())
3384 return error(_("failed to skip the commit"));
3385 if (!is_directory(git_path_seq_dir()))
3388 return sequencer_continue(r
, opts
);
3391 error(_("there is nothing to skip"));
3393 if (advice_enabled(ADVICE_RESOLVE_CONFLICT
)) {
3394 advise(_("have you committed already?\n"
3395 "try \"git %s --continue\""),
3396 action
== REPLAY_REVERT
? "revert" : "cherry-pick");
3401 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
3403 struct lock_file todo_lock
= LOCK_INIT
;
3404 const char *todo_path
= get_todo_path(opts
);
3405 int next
= todo_list
->current
, offset
, fd
;
3408 * rebase -i writes "git-rebase-todo" without the currently executing
3409 * command, appending it to "done" instead.
3411 if (is_rebase_i(opts
))
3414 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
3416 return error_errno(_("could not lock '%s'"), todo_path
);
3417 offset
= get_item_line_offset(todo_list
, next
);
3418 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
3419 todo_list
->buf
.len
- offset
) < 0)
3420 return error_errno(_("could not write to '%s'"), todo_path
);
3421 if (commit_lock_file(&todo_lock
) < 0)
3422 return error(_("failed to finalize '%s'"), todo_path
);
3424 if (is_rebase_i(opts
) && next
> 0) {
3425 const char *done
= rebase_path_done();
3426 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
3431 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
3432 get_item_line_length(todo_list
, next
- 1))
3434 ret
= error_errno(_("could not write to '%s'"), done
);
3436 ret
= error_errno(_("failed to finalize '%s'"), done
);
3442 static int save_opts(struct replay_opts
*opts
)
3444 const char *opts_file
= git_path_opts_file();
3447 if (opts
->no_commit
)
3448 res
|= git_config_set_in_file_gently(opts_file
,
3449 "options.no-commit", "true");
3450 if (opts
->edit
>= 0)
3451 res
|= git_config_set_in_file_gently(opts_file
, "options.edit",
3452 opts
->edit
? "true" : "false");
3453 if (opts
->allow_empty
)
3454 res
|= git_config_set_in_file_gently(opts_file
,
3455 "options.allow-empty", "true");
3456 if (opts
->allow_empty_message
)
3457 res
|= git_config_set_in_file_gently(opts_file
,
3458 "options.allow-empty-message", "true");
3459 if (opts
->keep_redundant_commits
)
3460 res
|= git_config_set_in_file_gently(opts_file
,
3461 "options.keep-redundant-commits", "true");
3463 res
|= git_config_set_in_file_gently(opts_file
,
3464 "options.signoff", "true");
3465 if (opts
->record_origin
)
3466 res
|= git_config_set_in_file_gently(opts_file
,
3467 "options.record-origin", "true");
3469 res
|= git_config_set_in_file_gently(opts_file
,
3470 "options.allow-ff", "true");
3471 if (opts
->mainline
) {
3472 struct strbuf buf
= STRBUF_INIT
;
3473 strbuf_addf(&buf
, "%d", opts
->mainline
);
3474 res
|= git_config_set_in_file_gently(opts_file
,
3475 "options.mainline", buf
.buf
);
3476 strbuf_release(&buf
);
3479 res
|= git_config_set_in_file_gently(opts_file
,
3480 "options.strategy", opts
->strategy
);
3482 res
|= git_config_set_in_file_gently(opts_file
,
3483 "options.gpg-sign", opts
->gpg_sign
);
3486 for (i
= 0; i
< opts
->xopts_nr
; i
++)
3487 res
|= git_config_set_multivar_in_file_gently(opts_file
,
3488 "options.strategy-option",
3489 opts
->xopts
[i
], "^$", 0);
3491 if (opts
->allow_rerere_auto
)
3492 res
|= git_config_set_in_file_gently(opts_file
,
3493 "options.allow-rerere-auto",
3494 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
3497 if (opts
->explicit_cleanup
)
3498 res
|= git_config_set_in_file_gently(opts_file
,
3499 "options.default-msg-cleanup",
3500 describe_cleanup_mode(opts
->default_msg_cleanup
));
3504 static int make_patch(struct repository
*r
,
3505 struct commit
*commit
,
3506 struct replay_opts
*opts
)
3508 struct strbuf buf
= STRBUF_INIT
;
3509 struct rev_info log_tree_opt
;
3510 const char *subject
;
3511 char hex
[GIT_MAX_HEXSZ
+ 1];
3514 oid_to_hex_r(hex
, &commit
->object
.oid
);
3515 if (write_message(hex
, strlen(hex
), rebase_path_stopped_sha(), 1) < 0)
3517 res
|= write_rebase_head(&commit
->object
.oid
);
3519 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
3520 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3521 repo_init_revisions(r
, &log_tree_opt
, NULL
);
3522 log_tree_opt
.abbrev
= 0;
3523 log_tree_opt
.diff
= 1;
3524 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
3525 log_tree_opt
.disable_stdin
= 1;
3526 log_tree_opt
.no_commit_id
= 1;
3527 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
3528 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
3529 if (!log_tree_opt
.diffopt
.file
)
3530 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
3532 res
|= log_tree_commit(&log_tree_opt
, commit
);
3533 fclose(log_tree_opt
.diffopt
.file
);
3537 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
3538 if (!file_exists(buf
.buf
)) {
3539 const char *encoding
= get_commit_output_encoding();
3540 const char *commit_buffer
= repo_logmsg_reencode(r
,
3543 find_commit_subject(commit_buffer
, &subject
);
3544 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
3545 repo_unuse_commit_buffer(r
, commit
,
3548 strbuf_release(&buf
);
3549 release_revisions(&log_tree_opt
);
3554 static int intend_to_amend(void)
3556 struct object_id head
;
3559 if (repo_get_oid(the_repository
, "HEAD", &head
))
3560 return error(_("cannot read HEAD"));
3562 p
= oid_to_hex(&head
);
3563 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
3566 static int error_with_patch(struct repository
*r
,
3567 struct commit
*commit
,
3568 const char *subject
, int subject_len
,
3569 struct replay_opts
*opts
,
3570 int exit_code
, int to_amend
)
3573 if (make_patch(r
, commit
, opts
))
3575 } else if (copy_file(rebase_path_message(),
3576 git_path_merge_msg(r
), 0666))
3577 return error(_("unable to copy '%s' to '%s'"),
3578 git_path_merge_msg(r
), rebase_path_message());
3581 if (intend_to_amend())
3585 _("You can amend the commit now, with\n"
3587 " git commit --amend %s\n"
3589 "Once you are satisfied with your changes, run\n"
3591 " git rebase --continue\n"),
3592 gpg_sign_opt_quoted(opts
));
3593 } else if (exit_code
) {
3595 fprintf_ln(stderr
, _("Could not apply %s... %.*s"),
3596 short_commit_name(commit
), subject_len
, subject
);
3599 * We don't have the hash of the parent so
3600 * just print the line from the todo file.
3602 fprintf_ln(stderr
, _("Could not merge %.*s"),
3603 subject_len
, subject
);
3609 static int error_failed_squash(struct repository
*r
,
3610 struct commit
*commit
,
3611 struct replay_opts
*opts
,
3613 const char *subject
)
3615 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3616 return error(_("could not copy '%s' to '%s'"),
3617 rebase_path_squash_msg(), rebase_path_message());
3618 unlink(git_path_merge_msg(r
));
3619 if (copy_file(git_path_merge_msg(r
), rebase_path_message(), 0666))
3620 return error(_("could not copy '%s' to '%s'"),
3621 rebase_path_message(),
3622 git_path_merge_msg(r
));
3623 return error_with_patch(r
, commit
, subject
, subject_len
, opts
, 1, 0);
3626 static int do_exec(struct repository
*r
, const char *command_line
)
3628 struct child_process cmd
= CHILD_PROCESS_INIT
;
3631 fprintf(stderr
, _("Executing: %s\n"), command_line
);
3633 strvec_push(&cmd
.args
, command_line
);
3634 status
= run_command(&cmd
);
3636 /* force re-reading of the cache */
3637 discard_index(r
->index
);
3638 if (repo_read_index(r
) < 0)
3639 return error(_("could not read index"));
3641 dirty
= require_clean_work_tree(r
, "rebase", NULL
, 1, 1);
3644 warning(_("execution failed: %s\n%s"
3645 "You can fix the problem, and then run\n"
3647 " git rebase --continue\n"
3650 dirty
? N_("and made changes to the index and/or the "
3651 "working tree\n") : "");
3653 /* command not found */
3656 warning(_("execution succeeded: %s\nbut "
3657 "left changes to the index and/or the working tree\n"
3658 "Commit or stash your changes, and then run\n"
3660 " git rebase --continue\n"
3661 "\n"), command_line
);
3668 __attribute__((format (printf
, 2, 3)))
3669 static int safe_append(const char *filename
, const char *fmt
, ...)
3672 struct lock_file lock
= LOCK_INIT
;
3673 int fd
= hold_lock_file_for_update(&lock
, filename
,
3674 LOCK_REPORT_ON_ERROR
);
3675 struct strbuf buf
= STRBUF_INIT
;
3680 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
3681 error_errno(_("could not read '%s'"), filename
);
3682 rollback_lock_file(&lock
);
3685 strbuf_complete(&buf
, '\n');
3687 strbuf_vaddf(&buf
, fmt
, ap
);
3690 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
3691 error_errno(_("could not write to '%s'"), filename
);
3692 strbuf_release(&buf
);
3693 rollback_lock_file(&lock
);
3696 if (commit_lock_file(&lock
) < 0) {
3697 strbuf_release(&buf
);
3698 rollback_lock_file(&lock
);
3699 return error(_("failed to finalize '%s'"), filename
);
3702 strbuf_release(&buf
);
3706 static int do_label(struct repository
*r
, const char *name
, int len
)
3708 struct ref_store
*refs
= get_main_ref_store(r
);
3709 struct ref_transaction
*transaction
;
3710 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
3711 struct strbuf msg
= STRBUF_INIT
;
3713 struct object_id head_oid
;
3715 if (len
== 1 && *name
== '#')
3716 return error(_("illegal label name: '%.*s'"), len
, name
);
3718 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3719 strbuf_addf(&msg
, "rebase (label) '%.*s'", len
, name
);
3721 transaction
= ref_store_transaction_begin(refs
, &err
);
3723 error("%s", err
.buf
);
3725 } else if (repo_get_oid(r
, "HEAD", &head_oid
)) {
3726 error(_("could not read HEAD"));
3728 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
3729 NULL
, 0, msg
.buf
, &err
) < 0 ||
3730 ref_transaction_commit(transaction
, &err
)) {
3731 error("%s", err
.buf
);
3734 ref_transaction_free(transaction
);
3735 strbuf_release(&err
);
3736 strbuf_release(&msg
);
3739 ret
= safe_append(rebase_path_refs_to_delete(),
3740 "%s\n", ref_name
.buf
);
3741 strbuf_release(&ref_name
);
3746 static const char *sequencer_reflog_action(struct replay_opts
*opts
)
3748 if (!opts
->reflog_action
) {
3749 opts
->reflog_action
= getenv(GIT_REFLOG_ACTION
);
3750 opts
->reflog_action
=
3751 xstrdup(opts
->reflog_action
? opts
->reflog_action
3752 : action_name(opts
));
3755 return opts
->reflog_action
;
3758 __attribute__((format (printf
, 3, 4)))
3759 static const char *reflog_message(struct replay_opts
*opts
,
3760 const char *sub_action
, const char *fmt
, ...)
3763 static struct strbuf buf
= STRBUF_INIT
;
3767 strbuf_addstr(&buf
, sequencer_reflog_action(opts
));
3769 strbuf_addf(&buf
, " (%s)", sub_action
);
3771 strbuf_addstr(&buf
, ": ");
3772 strbuf_vaddf(&buf
, fmt
, ap
);
3779 static struct commit
*lookup_label(struct repository
*r
, const char *label
,
3780 int len
, struct strbuf
*buf
)
3782 struct commit
*commit
;
3783 struct object_id oid
;
3786 strbuf_addf(buf
, "refs/rewritten/%.*s", len
, label
);
3787 if (!read_ref(buf
->buf
, &oid
)) {
3788 commit
= lookup_commit_object(r
, &oid
);
3790 /* fall back to non-rewritten ref or commit */
3791 strbuf_splice(buf
, 0, strlen("refs/rewritten/"), "", 0);
3792 commit
= lookup_commit_reference_by_name(buf
->buf
);
3796 error(_("could not resolve '%s'"), buf
->buf
);
3801 static int do_reset(struct repository
*r
,
3802 const char *name
, int len
,
3803 struct replay_opts
*opts
)
3805 struct strbuf ref_name
= STRBUF_INIT
;
3806 struct object_id oid
;
3807 struct lock_file lock
= LOCK_INIT
;
3808 struct tree_desc desc
= { 0 };
3810 struct unpack_trees_options unpack_tree_opts
= { 0 };
3813 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0)
3816 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
3817 if (!opts
->have_squash_onto
) {
3819 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
3820 NULL
, &opts
->squash_onto
,
3822 return error(_("writing fake root commit"));
3823 opts
->have_squash_onto
= 1;
3824 hex
= oid_to_hex(&opts
->squash_onto
);
3825 if (write_message(hex
, strlen(hex
),
3826 rebase_path_squash_onto(), 0))
3827 return error(_("writing squash-onto"));
3829 oidcpy(&oid
, &opts
->squash_onto
);
3832 struct commit
*commit
;
3834 /* Determine the length of the label */
3835 for (i
= 0; i
< len
; i
++)
3836 if (isspace(name
[i
]))
3840 commit
= lookup_label(r
, name
, len
, &ref_name
);
3845 oid
= commit
->object
.oid
;
3848 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
3849 unpack_tree_opts
.head_idx
= 1;
3850 unpack_tree_opts
.src_index
= r
->index
;
3851 unpack_tree_opts
.dst_index
= r
->index
;
3852 unpack_tree_opts
.fn
= oneway_merge
;
3853 unpack_tree_opts
.merge
= 1;
3854 unpack_tree_opts
.update
= 1;
3855 unpack_tree_opts
.preserve_ignored
= 0; /* FIXME: !overwrite_ignore */
3856 unpack_tree_opts
.skip_cache_tree_update
= 1;
3857 init_checkout_metadata(&unpack_tree_opts
.meta
, name
, &oid
, NULL
);
3859 if (repo_read_index_unmerged(r
)) {
3860 ret
= error_resolve_conflict(action_name(opts
));
3864 if (!fill_tree_descriptor(r
, &desc
, &oid
)) {
3865 ret
= error(_("failed to find tree of %s"), oid_to_hex(&oid
));
3869 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
3874 tree
= parse_tree_indirect(&oid
);
3875 prime_cache_tree(r
, r
->index
, tree
);
3877 if (write_locked_index(r
->index
, &lock
, COMMIT_LOCK
) < 0)
3878 ret
= error(_("could not write index"));
3881 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
3882 len
, name
), "HEAD", &oid
,
3883 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3885 free((void *)desc
.buffer
);
3887 rollback_lock_file(&lock
);
3888 strbuf_release(&ref_name
);
3889 clear_unpack_trees_porcelain(&unpack_tree_opts
);
3893 static int do_merge(struct repository
*r
,
3894 struct commit
*commit
,
3895 const char *arg
, int arg_len
,
3896 int flags
, int *check_todo
, struct replay_opts
*opts
)
3898 int run_commit_flags
= 0;
3899 struct strbuf ref_name
= STRBUF_INIT
;
3900 struct commit
*head_commit
, *merge_commit
, *i
;
3901 struct commit_list
*bases
, *j
;
3902 struct commit_list
*to_merge
= NULL
, **tail
= &to_merge
;
3903 const char *strategy
= !opts
->xopts_nr
&&
3905 !strcmp(opts
->strategy
, "recursive") ||
3906 !strcmp(opts
->strategy
, "ort")) ?
3907 NULL
: opts
->strategy
;
3908 struct merge_options o
;
3909 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
, k
;
3910 static struct lock_file lock
;
3913 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0) {
3918 head_commit
= lookup_commit_reference_by_name("HEAD");
3920 ret
= error(_("cannot merge without a current revision"));
3925 * For octopus merges, the arg starts with the list of revisions to be
3926 * merged. The list is optionally followed by '#' and the oneline.
3928 merge_arg_len
= oneline_offset
= arg_len
;
3929 for (p
= arg
; p
- arg
< arg_len
; p
+= strspn(p
, " \t\n")) {
3932 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
3933 p
+= 1 + strspn(p
+ 1, " \t\n");
3934 oneline_offset
= p
- arg
;
3937 k
= strcspn(p
, " \t\n");
3940 merge_commit
= lookup_label(r
, p
, k
, &ref_name
);
3941 if (!merge_commit
) {
3942 ret
= error(_("unable to parse '%.*s'"), k
, p
);
3945 tail
= &commit_list_insert(merge_commit
, tail
)->next
;
3947 merge_arg_len
= p
- arg
;
3951 ret
= error(_("nothing to merge: '%.*s'"), arg_len
, arg
);
3955 if (opts
->have_squash_onto
&&
3956 oideq(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
3958 * When the user tells us to "merge" something into a
3959 * "[new root]", let's simply fast-forward to the merge head.
3961 rollback_lock_file(&lock
);
3963 ret
= error(_("octopus merge cannot be executed on "
3964 "top of a [new root]"));
3966 ret
= fast_forward_to(r
, &to_merge
->item
->object
.oid
,
3967 &head_commit
->object
.oid
, 0,
3973 * If HEAD is not identical to the first parent of the original merge
3974 * commit, we cannot fast-forward.
3976 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
3977 oideq(&commit
->parents
->item
->object
.oid
,
3978 &head_commit
->object
.oid
);
3981 * If any merge head is different from the original one, we cannot
3984 if (can_fast_forward
) {
3985 struct commit_list
*p
= commit
->parents
->next
;
3987 for (j
= to_merge
; j
&& p
; j
= j
->next
, p
= p
->next
)
3988 if (!oideq(&j
->item
->object
.oid
,
3989 &p
->item
->object
.oid
)) {
3990 can_fast_forward
= 0;
3994 * If the number of merge heads differs from the original merge
3995 * commit, we cannot fast-forward.
3998 can_fast_forward
= 0;
4001 if (can_fast_forward
) {
4002 rollback_lock_file(&lock
);
4003 ret
= fast_forward_to(r
, &commit
->object
.oid
,
4004 &head_commit
->object
.oid
, 0, opts
);
4005 if (flags
& TODO_EDIT_MERGE_MSG
)
4006 goto fast_forward_edit
;
4012 const char *encoding
= get_commit_output_encoding();
4013 const char *message
= repo_logmsg_reencode(r
, commit
, NULL
,
4019 ret
= error(_("could not get commit message of '%s'"),
4020 oid_to_hex(&commit
->object
.oid
));
4023 write_author_script(message
);
4024 find_commit_subject(message
, &body
);
4026 ret
= write_message(body
, len
, git_path_merge_msg(r
), 0);
4027 repo_unuse_commit_buffer(r
, commit
, message
);
4029 error_errno(_("could not write '%s'"),
4030 git_path_merge_msg(r
));
4034 struct strbuf buf
= STRBUF_INIT
;
4037 strbuf_addf(&buf
, "author %s", git_author_info(0));
4038 write_author_script(buf
.buf
);
4041 if (oneline_offset
< arg_len
) {
4042 p
= arg
+ oneline_offset
;
4043 len
= arg_len
- oneline_offset
;
4045 strbuf_addf(&buf
, "Merge %s '%.*s'",
4046 to_merge
->next
? "branches" : "branch",
4047 merge_arg_len
, arg
);
4052 ret
= write_message(p
, len
, git_path_merge_msg(r
), 0);
4053 strbuf_release(&buf
);
4055 error_errno(_("could not write '%s'"),
4056 git_path_merge_msg(r
));
4061 if (strategy
|| to_merge
->next
) {
4063 struct child_process cmd
= CHILD_PROCESS_INIT
;
4065 if (read_env_script(&cmd
.env
)) {
4066 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
4068 ret
= error(_(staged_changes_advice
), gpg_opt
, gpg_opt
);
4072 if (opts
->committer_date_is_author_date
)
4073 strvec_pushf(&cmd
.env
, "GIT_COMMITTER_DATE=%s",
4076 author_date_from_env(&cmd
.env
));
4077 if (opts
->ignore_date
)
4078 strvec_push(&cmd
.env
, "GIT_AUTHOR_DATE=");
4081 strvec_push(&cmd
.args
, "merge");
4082 strvec_push(&cmd
.args
, "-s");
4084 strvec_push(&cmd
.args
, "octopus");
4086 strvec_push(&cmd
.args
, strategy
);
4087 for (k
= 0; k
< opts
->xopts_nr
; k
++)
4088 strvec_pushf(&cmd
.args
,
4089 "-X%s", opts
->xopts
[k
]);
4091 if (!(flags
& TODO_EDIT_MERGE_MSG
))
4092 strvec_push(&cmd
.args
, "--no-edit");
4094 strvec_push(&cmd
.args
, "--edit");
4095 strvec_push(&cmd
.args
, "--no-ff");
4096 strvec_push(&cmd
.args
, "--no-log");
4097 strvec_push(&cmd
.args
, "--no-stat");
4098 strvec_push(&cmd
.args
, "-F");
4099 strvec_push(&cmd
.args
, git_path_merge_msg(r
));
4101 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
4103 strvec_push(&cmd
.args
, "--no-gpg-sign");
4105 /* Add the tips to be merged */
4106 for (j
= to_merge
; j
; j
= j
->next
)
4107 strvec_push(&cmd
.args
,
4108 oid_to_hex(&j
->item
->object
.oid
));
4110 strbuf_release(&ref_name
);
4111 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
4113 rollback_lock_file(&lock
);
4115 ret
= run_command(&cmd
);
4117 /* force re-reading of the cache */
4119 discard_index(r
->index
);
4120 if (repo_read_index(r
) < 0)
4121 ret
= error(_("could not read index"));
4126 merge_commit
= to_merge
->item
;
4127 bases
= repo_get_merge_bases(r
, head_commit
, merge_commit
);
4128 if (bases
&& oideq(&merge_commit
->object
.oid
,
4129 &bases
->item
->object
.oid
)) {
4131 /* skip merging an ancestor of HEAD */
4135 write_message(oid_to_hex(&merge_commit
->object
.oid
), the_hash_algo
->hexsz
,
4136 git_path_merge_head(r
), 0);
4137 write_message("no-ff", 5, git_path_merge_mode(r
), 0);
4139 bases
= reverse_commit_list(bases
);
4142 init_merge_options(&o
, r
);
4144 o
.branch2
= ref_name
.buf
;
4145 o
.buffer_output
= 2;
4147 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
4149 * TODO: Should use merge_incore_recursive() and
4150 * merge_switch_to_result(), skipping the call to
4151 * merge_switch_to_result() when we don't actually need to
4152 * update the index and working copy immediately.
4154 ret
= merge_ort_recursive(&o
,
4155 head_commit
, merge_commit
, bases
,
4158 ret
= merge_recursive(&o
, head_commit
, merge_commit
, bases
,
4162 fputs(o
.obuf
.buf
, stdout
);
4163 strbuf_release(&o
.obuf
);
4165 error(_("could not even attempt to merge '%.*s'"),
4166 merge_arg_len
, arg
);
4170 * The return value of merge_recursive() is 1 on clean, and 0 on
4173 * Let's reverse that, so that do_merge() returns 0 upon success and
4174 * 1 upon failed merge (keeping the return value -1 for the cases where
4175 * we will want to reschedule the `merge` command).
4179 if (r
->index
->cache_changed
&&
4180 write_locked_index(r
->index
, &lock
, COMMIT_LOCK
)) {
4181 ret
= error(_("merge: Unable to write new index file"));
4185 rollback_lock_file(&lock
);
4187 repo_rerere(r
, opts
->allow_rerere_auto
);
4190 * In case of problems, we now want to return a positive
4191 * value (a negative one would indicate that the `merge`
4192 * command needs to be rescheduled).
4194 ret
= !!run_git_commit(git_path_merge_msg(r
), opts
,
4197 if (!ret
&& flags
& TODO_EDIT_MERGE_MSG
) {
4200 run_commit_flags
|= AMEND_MSG
| EDIT_MSG
| VERIFY_MSG
;
4201 ret
= !!run_git_commit(NULL
, opts
, run_commit_flags
);
4206 strbuf_release(&ref_name
);
4207 rollback_lock_file(&lock
);
4208 free_commit_list(to_merge
);
4212 static int write_update_refs_state(struct string_list
*refs_to_oids
)
4215 struct lock_file lock
= LOCK_INIT
;
4217 struct string_list_item
*item
;
4220 path
= rebase_path_update_refs(the_repository
->gitdir
);
4222 if (!refs_to_oids
->nr
) {
4223 if (unlink(path
) && errno
!= ENOENT
)
4224 result
= error_errno(_("could not unlink: %s"), path
);
4228 if (safe_create_leading_directories(path
)) {
4229 result
= error(_("unable to create leading directories of %s"),
4234 if (hold_lock_file_for_update(&lock
, path
, 0) < 0) {
4235 result
= error(_("another 'rebase' process appears to be running; "
4236 "'%s.lock' already exists"),
4241 fp
= fdopen_lock_file(&lock
, "w");
4243 result
= error_errno(_("could not open '%s' for writing"), path
);
4244 rollback_lock_file(&lock
);
4248 for_each_string_list_item(item
, refs_to_oids
) {
4249 struct update_ref_record
*rec
= item
->util
;
4250 fprintf(fp
, "%s\n%s\n%s\n", item
->string
,
4251 oid_to_hex(&rec
->before
), oid_to_hex(&rec
->after
));
4254 result
= commit_lock_file(&lock
);
4262 * Parse the update-refs file for the current rebase, then remove the
4263 * refs that do not appear in the todo_list (and have not had updated
4264 * values stored) and add refs that are in the todo_list but not
4265 * represented in the update-refs file.
4267 * If there are changes to the update-refs list, then write the new state
4270 void todo_list_filter_update_refs(struct repository
*r
,
4271 struct todo_list
*todo_list
)
4275 struct string_list update_refs
= STRING_LIST_INIT_DUP
;
4277 sequencer_get_update_refs_state(r
->gitdir
, &update_refs
);
4280 * For each item in the update_refs list, if it has no updated
4281 * value and does not appear in the todo_list, then remove it
4282 * from the update_refs list.
4284 for (i
= 0; i
< update_refs
.nr
; i
++) {
4287 const char *ref
= update_refs
.items
[i
].string
;
4288 size_t reflen
= strlen(ref
);
4289 struct update_ref_record
*rec
= update_refs
.items
[i
].util
;
4291 /* OID already stored as updated. */
4292 if (!is_null_oid(&rec
->after
))
4295 for (j
= 0; !found
&& j
< todo_list
->total_nr
; j
++) {
4296 struct todo_item
*item
= &todo_list
->items
[j
];
4297 const char *arg
= todo_list
->buf
.buf
+ item
->arg_offset
;
4299 if (item
->command
!= TODO_UPDATE_REF
)
4302 if (item
->arg_len
!= reflen
||
4303 strncmp(arg
, ref
, reflen
))
4310 free(update_refs
.items
[i
].string
);
4311 free(update_refs
.items
[i
].util
);
4314 MOVE_ARRAY(update_refs
.items
+ i
, update_refs
.items
+ i
+ 1, update_refs
.nr
- i
);
4322 * For each todo_item, check if its ref is in the update_refs list.
4323 * If not, then add it as an un-updated ref.
4325 for (i
= 0; i
< todo_list
->total_nr
; i
++) {
4326 struct todo_item
*item
= &todo_list
->items
[i
];
4327 const char *arg
= todo_list
->buf
.buf
+ item
->arg_offset
;
4330 if (item
->command
!= TODO_UPDATE_REF
)
4333 for (j
= 0; !found
&& j
< update_refs
.nr
; j
++) {
4334 const char *ref
= update_refs
.items
[j
].string
;
4336 found
= strlen(ref
) == item
->arg_len
&&
4337 !strncmp(ref
, arg
, item
->arg_len
);
4341 struct string_list_item
*inserted
;
4342 struct strbuf argref
= STRBUF_INIT
;
4344 strbuf_add(&argref
, arg
, item
->arg_len
);
4345 inserted
= string_list_insert(&update_refs
, argref
.buf
);
4346 inserted
->util
= init_update_ref_record(argref
.buf
);
4347 strbuf_release(&argref
);
4353 write_update_refs_state(&update_refs
);
4354 string_list_clear(&update_refs
, 1);
4357 static int do_update_ref(struct repository
*r
, const char *refname
)
4359 struct string_list_item
*item
;
4360 struct string_list list
= STRING_LIST_INIT_DUP
;
4362 if (sequencer_get_update_refs_state(r
->gitdir
, &list
))
4365 for_each_string_list_item(item
, &list
) {
4366 if (!strcmp(item
->string
, refname
)) {
4367 struct update_ref_record
*rec
= item
->util
;
4368 if (read_ref("HEAD", &rec
->after
))
4374 write_update_refs_state(&list
);
4375 string_list_clear(&list
, 1);
4379 static int do_update_refs(struct repository
*r
, int quiet
)
4382 struct string_list_item
*item
;
4383 struct string_list refs_to_oids
= STRING_LIST_INIT_DUP
;
4384 struct ref_store
*refs
= get_main_ref_store(r
);
4385 struct strbuf update_msg
= STRBUF_INIT
;
4386 struct strbuf error_msg
= STRBUF_INIT
;
4388 if ((res
= sequencer_get_update_refs_state(r
->gitdir
, &refs_to_oids
)))
4391 for_each_string_list_item(item
, &refs_to_oids
) {
4392 struct update_ref_record
*rec
= item
->util
;
4395 loop_res
= refs_update_ref(refs
, "rewritten during rebase",
4397 &rec
->after
, &rec
->before
,
4398 0, UPDATE_REFS_MSG_ON_ERR
);
4405 strbuf_addf(&error_msg
, "\t%s\n", item
->string
);
4407 strbuf_addf(&update_msg
, "\t%s\n", item
->string
);
4411 (update_msg
.len
|| error_msg
.len
)) {
4413 _("Updated the following refs with %s:\n%s"),
4419 _("Failed to update the following refs with %s:\n%s"),
4424 string_list_clear(&refs_to_oids
, 1);
4425 strbuf_release(&update_msg
);
4426 strbuf_release(&error_msg
);
4430 static int is_final_fixup(struct todo_list
*todo_list
)
4432 int i
= todo_list
->current
;
4434 if (!is_fixup(todo_list
->items
[i
].command
))
4437 while (++i
< todo_list
->nr
)
4438 if (is_fixup(todo_list
->items
[i
].command
))
4440 else if (!is_noop(todo_list
->items
[i
].command
))
4445 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
4449 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
4450 if (!is_noop(todo_list
->items
[i
].command
))
4451 return todo_list
->items
[i
].command
;
4456 void create_autostash(struct repository
*r
, const char *path
)
4458 struct strbuf buf
= STRBUF_INIT
;
4459 struct lock_file lock_file
= LOCK_INIT
;
4462 fd
= repo_hold_locked_index(r
, &lock_file
, 0);
4463 refresh_index(r
->index
, REFRESH_QUIET
, NULL
, NULL
, NULL
);
4465 repo_update_index_if_able(r
, &lock_file
);
4466 rollback_lock_file(&lock_file
);
4468 if (has_unstaged_changes(r
, 1) ||
4469 has_uncommitted_changes(r
, 1)) {
4470 struct child_process stash
= CHILD_PROCESS_INIT
;
4471 struct reset_head_opts ropts
= { .flags
= RESET_HEAD_HARD
};
4472 struct object_id oid
;
4474 strvec_pushl(&stash
.args
,
4475 "stash", "create", "autostash", NULL
);
4479 if (capture_command(&stash
, &buf
, GIT_MAX_HEXSZ
))
4480 die(_("Cannot autostash"));
4481 strbuf_trim_trailing_newline(&buf
);
4482 if (repo_get_oid(r
, buf
.buf
, &oid
))
4483 die(_("Unexpected stash response: '%s'"),
4486 strbuf_add_unique_abbrev(&buf
, &oid
, DEFAULT_ABBREV
);
4488 if (safe_create_leading_directories_const(path
))
4489 die(_("Could not create directory for '%s'"),
4491 write_file(path
, "%s", oid_to_hex(&oid
));
4492 printf(_("Created autostash: %s\n"), buf
.buf
);
4493 if (reset_head(r
, &ropts
) < 0)
4494 die(_("could not reset --hard"));
4495 discard_index(r
->index
);
4496 if (repo_read_index(r
) < 0)
4497 die(_("could not read index"));
4499 strbuf_release(&buf
);
4502 static int apply_save_autostash_oid(const char *stash_oid
, int attempt_apply
)
4504 struct child_process child
= CHILD_PROCESS_INIT
;
4507 if (attempt_apply
) {
4509 child
.no_stdout
= 1;
4510 child
.no_stderr
= 1;
4511 strvec_push(&child
.args
, "stash");
4512 strvec_push(&child
.args
, "apply");
4513 strvec_push(&child
.args
, stash_oid
);
4514 ret
= run_command(&child
);
4517 if (attempt_apply
&& !ret
)
4518 fprintf(stderr
, _("Applied autostash.\n"));
4520 struct child_process store
= CHILD_PROCESS_INIT
;
4523 strvec_push(&store
.args
, "stash");
4524 strvec_push(&store
.args
, "store");
4525 strvec_push(&store
.args
, "-m");
4526 strvec_push(&store
.args
, "autostash");
4527 strvec_push(&store
.args
, "-q");
4528 strvec_push(&store
.args
, stash_oid
);
4529 if (run_command(&store
))
4530 ret
= error(_("cannot store %s"), stash_oid
);
4534 "Your changes are safe in the stash.\n"
4535 "You can run \"git stash pop\" or"
4536 " \"git stash drop\" at any time.\n"),
4538 _("Applying autostash resulted in conflicts.") :
4539 _("Autostash exists; creating a new stash entry."));
4545 static int apply_save_autostash(const char *path
, int attempt_apply
)
4547 struct strbuf stash_oid
= STRBUF_INIT
;
4550 if (!read_oneliner(&stash_oid
, path
,
4551 READ_ONELINER_SKIP_IF_EMPTY
)) {
4552 strbuf_release(&stash_oid
);
4555 strbuf_trim(&stash_oid
);
4557 ret
= apply_save_autostash_oid(stash_oid
.buf
, attempt_apply
);
4560 strbuf_release(&stash_oid
);
4564 int save_autostash(const char *path
)
4566 return apply_save_autostash(path
, 0);
4569 int apply_autostash(const char *path
)
4571 return apply_save_autostash(path
, 1);
4574 int apply_autostash_oid(const char *stash_oid
)
4576 return apply_save_autostash_oid(stash_oid
, 1);
4579 static int checkout_onto(struct repository
*r
, struct replay_opts
*opts
,
4580 const char *onto_name
, const struct object_id
*onto
,
4581 const struct object_id
*orig_head
)
4583 struct reset_head_opts ropts
= {
4585 .orig_head
= orig_head
,
4586 .flags
= RESET_HEAD_DETACH
| RESET_ORIG_HEAD
|
4587 RESET_HEAD_RUN_POST_CHECKOUT_HOOK
,
4588 .head_msg
= reflog_message(opts
, "start", "checkout %s",
4590 .default_reflog_action
= sequencer_reflog_action(opts
)
4592 if (reset_head(r
, &ropts
)) {
4593 apply_autostash(rebase_path_autostash());
4594 sequencer_remove_state(opts
);
4595 return error(_("could not detach HEAD"));
4601 static int stopped_at_head(struct repository
*r
)
4603 struct object_id head
;
4604 struct commit
*commit
;
4605 struct commit_message message
;
4607 if (repo_get_oid(r
, "HEAD", &head
) ||
4608 !(commit
= lookup_commit(r
, &head
)) ||
4609 repo_parse_commit(r
, commit
) || get_message(commit
, &message
))
4610 fprintf(stderr
, _("Stopped at HEAD\n"));
4612 fprintf(stderr
, _("Stopped at %s\n"), message
.label
);
4613 free_message(commit
, &message
);
4619 static int reread_todo_if_changed(struct repository
*r
,
4620 struct todo_list
*todo_list
,
4621 struct replay_opts
*opts
)
4624 struct strbuf buf
= STRBUF_INIT
;
4626 if (strbuf_read_file_or_whine(&buf
, get_todo_path(opts
)) < 0)
4628 offset
= get_item_line_offset(todo_list
, todo_list
->current
+ 1);
4629 if (buf
.len
!= todo_list
->buf
.len
- offset
||
4630 memcmp(buf
.buf
, todo_list
->buf
.buf
+ offset
, buf
.len
)) {
4631 /* Reread the todo file if it has changed. */
4632 todo_list_release(todo_list
);
4633 if (read_populate_todo(r
, todo_list
, opts
))
4634 return -1; /* message was printed */
4635 /* `current` will be incremented on return */
4636 todo_list
->current
= -1;
4638 strbuf_release(&buf
);
4643 static const char rescheduled_advice
[] =
4644 N_("Could not execute the todo command\n"
4648 "It has been rescheduled; To edit the command before continuing, please\n"
4649 "edit the todo list first:\n"
4651 " git rebase --edit-todo\n"
4652 " git rebase --continue\n");
4654 static int pick_commits(struct repository
*r
,
4655 struct todo_list
*todo_list
,
4656 struct replay_opts
*opts
)
4658 int res
= 0, reschedule
= 0;
4660 opts
->reflog_message
= sequencer_reflog_action(opts
);
4662 assert(!(opts
->signoff
|| opts
->no_commit
||
4663 opts
->record_origin
|| should_edit(opts
) ||
4664 opts
->committer_date_is_author_date
||
4665 opts
->ignore_date
));
4666 if (read_and_refresh_cache(r
, opts
))
4669 while (todo_list
->current
< todo_list
->nr
) {
4670 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
4671 const char *arg
= todo_item_get_arg(todo_list
, item
);
4674 if (save_todo(todo_list
, opts
))
4676 if (is_rebase_i(opts
)) {
4677 if (item
->command
!= TODO_COMMENT
) {
4678 FILE *f
= fopen(rebase_path_msgnum(), "w");
4680 todo_list
->done_nr
++;
4683 fprintf(f
, "%d\n", todo_list
->done_nr
);
4687 fprintf(stderr
, _("Rebasing (%d/%d)%s"),
4689 todo_list
->total_nr
,
4690 opts
->verbose
? "\n" : "\r");
4692 unlink(rebase_path_message());
4693 unlink(rebase_path_author_script());
4694 unlink(rebase_path_stopped_sha());
4695 unlink(rebase_path_amend());
4696 unlink(git_path_merge_head(r
));
4697 unlink(git_path_auto_merge(r
));
4698 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
4700 if (item
->command
== TODO_BREAK
) {
4703 return stopped_at_head(r
);
4706 if (item
->command
<= TODO_SQUASH
) {
4707 if (is_rebase_i(opts
))
4708 opts
->reflog_message
= reflog_message(opts
,
4709 command_to_string(item
->command
), NULL
);
4711 res
= do_pick_commit(r
, item
, opts
,
4712 is_final_fixup(todo_list
),
4714 if (is_rebase_i(opts
) && res
< 0) {
4716 advise(_(rescheduled_advice
),
4717 get_item_line_length(todo_list
,
4718 todo_list
->current
),
4719 get_item_line(todo_list
,
4720 todo_list
->current
));
4721 todo_list
->current
--;
4722 if (save_todo(todo_list
, opts
))
4725 if (item
->command
== TODO_EDIT
) {
4726 struct commit
*commit
= item
->commit
;
4731 _("Stopped at %s... %.*s\n"),
4732 short_commit_name(commit
),
4733 item
->arg_len
, arg
);
4735 return error_with_patch(r
, commit
,
4736 arg
, item
->arg_len
, opts
, res
, !res
);
4738 if (is_rebase_i(opts
) && !res
)
4739 record_in_rewritten(&item
->commit
->object
.oid
,
4740 peek_command(todo_list
, 1));
4741 if (res
&& is_fixup(item
->command
)) {
4744 return error_failed_squash(r
, item
->commit
, opts
,
4745 item
->arg_len
, arg
);
4746 } else if (res
&& is_rebase_i(opts
) && item
->commit
) {
4748 struct object_id oid
;
4751 * If we are rewording and have either
4752 * fast-forwarded already, or are about to
4753 * create a new root commit, we want to amend,
4754 * otherwise we do not.
4756 if (item
->command
== TODO_REWORD
&&
4757 !repo_get_oid(r
, "HEAD", &oid
) &&
4758 (oideq(&item
->commit
->object
.oid
, &oid
) ||
4759 (opts
->have_squash_onto
&&
4760 oideq(&opts
->squash_onto
, &oid
))))
4763 return res
| error_with_patch(r
, item
->commit
,
4764 arg
, item
->arg_len
, opts
,
4767 } else if (item
->command
== TODO_EXEC
) {
4768 char *end_of_arg
= (char *)(arg
+ item
->arg_len
);
4769 int saved
= *end_of_arg
;
4774 res
= do_exec(r
, arg
);
4775 *end_of_arg
= saved
;
4778 if (opts
->reschedule_failed_exec
)
4782 } else if (item
->command
== TODO_LABEL
) {
4783 if ((res
= do_label(r
, arg
, item
->arg_len
)))
4785 } else if (item
->command
== TODO_RESET
) {
4786 if ((res
= do_reset(r
, arg
, item
->arg_len
, opts
)))
4788 } else if (item
->command
== TODO_MERGE
) {
4789 if ((res
= do_merge(r
, item
->commit
, arg
, item
->arg_len
,
4790 item
->flags
, &check_todo
, opts
)) < 0)
4792 else if (item
->commit
)
4793 record_in_rewritten(&item
->commit
->object
.oid
,
4794 peek_command(todo_list
, 1));
4796 /* failed with merge conflicts */
4797 return error_with_patch(r
, item
->commit
,
4800 } else if (item
->command
== TODO_UPDATE_REF
) {
4801 struct strbuf ref
= STRBUF_INIT
;
4802 strbuf_add(&ref
, arg
, item
->arg_len
);
4803 if ((res
= do_update_ref(r
, ref
.buf
)))
4805 strbuf_release(&ref
);
4806 } else if (!is_noop(item
->command
))
4807 return error(_("unknown command %d"), item
->command
);
4810 advise(_(rescheduled_advice
),
4811 get_item_line_length(todo_list
,
4812 todo_list
->current
),
4813 get_item_line(todo_list
, todo_list
->current
));
4814 todo_list
->current
--;
4815 if (save_todo(todo_list
, opts
))
4818 return error_with_patch(r
,
4822 } else if (is_rebase_i(opts
) && check_todo
&& !res
&&
4823 reread_todo_if_changed(r
, todo_list
, opts
)) {
4827 todo_list
->current
++;
4832 if (is_rebase_i(opts
)) {
4833 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
4836 /* Stopped in the middle, as planned? */
4837 if (todo_list
->current
< todo_list
->nr
)
4840 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
4841 starts_with(head_ref
.buf
, "refs/")) {
4843 struct object_id head
, orig
;
4846 if (repo_get_oid(r
, "HEAD", &head
)) {
4847 res
= error(_("cannot read HEAD"));
4849 strbuf_release(&head_ref
);
4850 strbuf_release(&buf
);
4853 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
4854 get_oid_hex(buf
.buf
, &orig
)) {
4855 res
= error(_("could not read orig-head"));
4856 goto cleanup_head_ref
;
4859 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
4860 res
= error(_("could not read 'onto'"));
4861 goto cleanup_head_ref
;
4863 msg
= reflog_message(opts
, "finish", "%s onto %s",
4864 head_ref
.buf
, buf
.buf
);
4865 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
4866 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
4867 res
= error(_("could not update %s"),
4869 goto cleanup_head_ref
;
4871 msg
= reflog_message(opts
, "finish", "returning to %s",
4873 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
4874 res
= error(_("could not update HEAD to %s"),
4876 goto cleanup_head_ref
;
4881 if (opts
->verbose
) {
4882 struct rev_info log_tree_opt
;
4883 struct object_id orig
, head
;
4885 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
4886 repo_init_revisions(r
, &log_tree_opt
, NULL
);
4887 log_tree_opt
.diff
= 1;
4888 log_tree_opt
.diffopt
.output_format
=
4889 DIFF_FORMAT_DIFFSTAT
;
4890 log_tree_opt
.disable_stdin
= 1;
4892 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
4893 !repo_get_oid(r
, buf
.buf
, &orig
) &&
4894 !repo_get_oid(r
, "HEAD", &head
)) {
4895 diff_tree_oid(&orig
, &head
, "",
4896 &log_tree_opt
.diffopt
);
4897 log_tree_diff_flush(&log_tree_opt
);
4899 release_revisions(&log_tree_opt
);
4901 flush_rewritten_pending();
4902 if (!stat(rebase_path_rewritten_list(), &st
) &&
4904 struct child_process child
= CHILD_PROCESS_INIT
;
4905 struct run_hooks_opt hook_opt
= RUN_HOOKS_OPT_INIT
;
4907 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
4909 strvec_push(&child
.args
, "notes");
4910 strvec_push(&child
.args
, "copy");
4911 strvec_push(&child
.args
, "--for-rewrite=rebase");
4912 /* we don't care if this copying failed */
4913 run_command(&child
);
4915 hook_opt
.path_to_stdin
= rebase_path_rewritten_list();
4916 strvec_push(&hook_opt
.args
, "rebase");
4917 run_hooks_opt("post-rewrite", &hook_opt
);
4919 apply_autostash(rebase_path_autostash());
4925 _("Successfully rebased and updated %s.\n"),
4929 strbuf_release(&buf
);
4930 strbuf_release(&head_ref
);
4932 if (do_update_refs(r
, opts
->quiet
))
4937 * Sequence of picks finished successfully; cleanup by
4938 * removing the .git/sequencer directory
4940 return sequencer_remove_state(opts
);
4943 static int continue_single_pick(struct repository
*r
, struct replay_opts
*opts
)
4945 struct child_process cmd
= CHILD_PROCESS_INIT
;
4947 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
4948 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
4949 return error(_("no cherry-pick or revert in progress"));
4952 strvec_push(&cmd
.args
, "commit");
4955 * continue_single_pick() handles the case of recovering from a
4956 * conflict. should_edit() doesn't handle that case; for a conflict,
4957 * we want to edit if the user asked for it, or if they didn't specify
4958 * and stdin is a tty.
4960 if (!opts
->edit
|| (opts
->edit
< 0 && !isatty(0)))
4962 * Include --cleanup=strip as well because we don't want the
4963 * "# Conflicts:" messages.
4965 strvec_pushl(&cmd
.args
, "--no-edit", "--cleanup=strip", NULL
);
4967 return run_command(&cmd
);
4970 static int commit_staged_changes(struct repository
*r
,
4971 struct replay_opts
*opts
,
4972 struct todo_list
*todo_list
)
4974 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
4975 unsigned int final_fixup
= 0, is_clean
;
4977 if (has_unstaged_changes(r
, 1))
4978 return error(_("cannot rebase: You have unstaged changes."));
4980 is_clean
= !has_uncommitted_changes(r
, 0);
4982 if (file_exists(rebase_path_amend())) {
4983 struct strbuf rev
= STRBUF_INIT
;
4984 struct object_id head
, to_amend
;
4986 if (repo_get_oid(r
, "HEAD", &head
))
4987 return error(_("cannot amend non-existing commit"));
4988 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
4989 return error(_("invalid file: '%s'"), rebase_path_amend());
4990 if (get_oid_hex(rev
.buf
, &to_amend
))
4991 return error(_("invalid contents: '%s'"),
4992 rebase_path_amend());
4993 if (!is_clean
&& !oideq(&head
, &to_amend
))
4994 return error(_("\nYou have uncommitted changes in your "
4995 "working tree. Please, commit them\n"
4996 "first and then run 'git rebase "
4997 "--continue' again."));
4999 * When skipping a failed fixup/squash, we need to edit the
5000 * commit message, the current fixup list and count, and if it
5001 * was the last fixup/squash in the chain, we need to clean up
5002 * the commit message and if there was a squash, let the user
5005 if (!is_clean
|| !opts
->current_fixup_count
)
5006 ; /* this is not the final fixup */
5007 else if (!oideq(&head
, &to_amend
) ||
5008 !file_exists(rebase_path_stopped_sha())) {
5009 /* was a final fixup or squash done manually? */
5010 if (!is_fixup(peek_command(todo_list
, 0))) {
5011 unlink(rebase_path_fixup_msg());
5012 unlink(rebase_path_squash_msg());
5013 unlink(rebase_path_current_fixups());
5014 strbuf_reset(&opts
->current_fixups
);
5015 opts
->current_fixup_count
= 0;
5018 /* we are in a fixup/squash chain */
5019 const char *p
= opts
->current_fixups
.buf
;
5020 int len
= opts
->current_fixups
.len
;
5022 opts
->current_fixup_count
--;
5024 BUG("Incorrect current_fixups:\n%s", p
);
5025 while (len
&& p
[len
- 1] != '\n')
5027 strbuf_setlen(&opts
->current_fixups
, len
);
5028 if (write_message(p
, len
, rebase_path_current_fixups(),
5030 return error(_("could not write file: '%s'"),
5031 rebase_path_current_fixups());
5034 * If a fixup/squash in a fixup/squash chain failed, the
5035 * commit message is already correct, no need to commit
5038 * Only if it is the final command in the fixup/squash
5039 * chain, and only if the chain is longer than a single
5040 * fixup/squash command (which was just skipped), do we
5041 * actually need to re-commit with a cleaned up commit
5044 if (opts
->current_fixup_count
> 0 &&
5045 !is_fixup(peek_command(todo_list
, 0))) {
5048 * If there was not a single "squash" in the
5049 * chain, we only need to clean up the commit
5050 * message, no need to bother the user with
5051 * opening the commit message in the editor.
5053 if (!starts_with(p
, "squash ") &&
5054 !strstr(p
, "\nsquash "))
5055 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
5056 } else if (is_fixup(peek_command(todo_list
, 0))) {
5058 * We need to update the squash message to skip
5059 * the latest commit message.
5061 struct commit
*commit
;
5062 const char *path
= rebase_path_squash_msg();
5063 const char *encoding
= get_commit_output_encoding();
5065 if (parse_head(r
, &commit
) ||
5066 !(p
= repo_logmsg_reencode(r
, commit
, NULL
, encoding
)) ||
5067 write_message(p
, strlen(p
), path
, 0)) {
5068 repo_unuse_commit_buffer(r
, commit
, p
);
5069 return error(_("could not write file: "
5072 repo_unuse_commit_buffer(r
,
5077 strbuf_release(&rev
);
5082 if (refs_ref_exists(get_main_ref_store(r
),
5083 "CHERRY_PICK_HEAD") &&
5084 refs_delete_ref(get_main_ref_store(r
), "",
5085 "CHERRY_PICK_HEAD", NULL
, 0))
5086 return error(_("could not remove CHERRY_PICK_HEAD"));
5087 if (unlink(git_path_merge_msg(r
)) && errno
!= ENOENT
)
5088 return error_errno(_("could not remove '%s'"),
5089 git_path_merge_msg(r
));
5094 if (run_git_commit(final_fixup
? NULL
: rebase_path_message(),
5096 return error(_("could not commit staged changes."));
5097 unlink(rebase_path_amend());
5098 unlink(git_path_merge_head(r
));
5099 unlink(git_path_auto_merge(r
));
5101 unlink(rebase_path_fixup_msg());
5102 unlink(rebase_path_squash_msg());
5104 if (opts
->current_fixup_count
> 0) {
5106 * Whether final fixup or not, we just cleaned up the commit
5109 unlink(rebase_path_current_fixups());
5110 strbuf_reset(&opts
->current_fixups
);
5111 opts
->current_fixup_count
= 0;
5116 int sequencer_continue(struct repository
*r
, struct replay_opts
*opts
)
5118 struct todo_list todo_list
= TODO_LIST_INIT
;
5121 if (read_and_refresh_cache(r
, opts
))
5124 if (read_populate_opts(opts
))
5126 if (is_rebase_i(opts
)) {
5127 if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
5128 goto release_todo_list
;
5130 if (file_exists(rebase_path_dropped())) {
5131 if ((res
= todo_list_check_against_backup(r
, &todo_list
)))
5132 goto release_todo_list
;
5134 unlink(rebase_path_dropped());
5137 opts
->reflog_message
= reflog_message(opts
, "continue", NULL
);
5138 if (commit_staged_changes(r
, opts
, &todo_list
)) {
5140 goto release_todo_list
;
5142 } else if (!file_exists(get_todo_path(opts
)))
5143 return continue_single_pick(r
, opts
);
5144 else if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
5145 goto release_todo_list
;
5147 if (!is_rebase_i(opts
)) {
5148 /* Verify that the conflict has been resolved */
5149 if (refs_ref_exists(get_main_ref_store(r
),
5150 "CHERRY_PICK_HEAD") ||
5151 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
5152 res
= continue_single_pick(r
, opts
);
5154 goto release_todo_list
;
5156 if (index_differs_from(r
, "HEAD", NULL
, 0)) {
5157 res
= error_dirty_index(r
, opts
);
5158 goto release_todo_list
;
5160 todo_list
.current
++;
5161 } else if (file_exists(rebase_path_stopped_sha())) {
5162 struct strbuf buf
= STRBUF_INIT
;
5163 struct object_id oid
;
5165 if (read_oneliner(&buf
, rebase_path_stopped_sha(),
5166 READ_ONELINER_SKIP_IF_EMPTY
) &&
5167 !get_oid_hex(buf
.buf
, &oid
))
5168 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
5169 strbuf_release(&buf
);
5172 res
= pick_commits(r
, &todo_list
, opts
);
5174 todo_list_release(&todo_list
);
5178 static int single_pick(struct repository
*r
,
5179 struct commit
*cmit
,
5180 struct replay_opts
*opts
)
5183 struct todo_item item
;
5185 item
.command
= opts
->action
== REPLAY_PICK
?
5186 TODO_PICK
: TODO_REVERT
;
5189 opts
->reflog_message
= sequencer_reflog_action(opts
);
5190 return do_pick_commit(r
, &item
, opts
, 0, &check_todo
);
5193 int sequencer_pick_revisions(struct repository
*r
,
5194 struct replay_opts
*opts
)
5196 struct todo_list todo_list
= TODO_LIST_INIT
;
5197 struct object_id oid
;
5201 if (read_and_refresh_cache(r
, opts
))
5204 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
5205 struct object_id oid
;
5206 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
5208 /* This happens when using --stdin. */
5212 if (!repo_get_oid(r
, name
, &oid
)) {
5213 if (!lookup_commit_reference_gently(r
, &oid
, 1)) {
5214 enum object_type type
= oid_object_info(r
,
5217 return error(_("%s: can't cherry-pick a %s"),
5218 name
, type_name(type
));
5221 return error(_("%s: bad revision"), name
);
5225 * If we were called as "git cherry-pick <commit>", just
5226 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
5227 * REVERT_HEAD, and don't touch the sequencer state.
5228 * This means it is possible to cherry-pick in the middle
5229 * of a cherry-pick sequence.
5231 if (opts
->revs
->cmdline
.nr
== 1 &&
5232 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
5233 opts
->revs
->no_walk
&&
5234 !opts
->revs
->cmdline
.rev
->flags
) {
5235 struct commit
*cmit
;
5236 if (prepare_revision_walk(opts
->revs
))
5237 return error(_("revision walk setup failed"));
5238 cmit
= get_revision(opts
->revs
);
5240 return error(_("empty commit set passed"));
5241 if (get_revision(opts
->revs
))
5242 BUG("unexpected extra commit from walk");
5243 return single_pick(r
, cmit
, opts
);
5247 * Start a new cherry-pick/ revert sequence; but
5248 * first, make sure that an existing one isn't in
5252 if (walk_revs_populate_todo(&todo_list
, opts
) ||
5253 create_seq_dir(r
) < 0)
5255 if (repo_get_oid(r
, "HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
5256 return error(_("can't revert as initial commit"));
5257 if (save_head(oid_to_hex(&oid
)))
5259 if (save_opts(opts
))
5261 update_abort_safety_file();
5262 res
= pick_commits(r
, &todo_list
, opts
);
5263 todo_list_release(&todo_list
);
5267 void append_signoff(struct strbuf
*msgbuf
, size_t ignore_footer
, unsigned flag
)
5269 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
5270 struct strbuf sob
= STRBUF_INIT
;
5273 strbuf_addstr(&sob
, sign_off_header
);
5274 strbuf_addstr(&sob
, fmt_name(WANT_COMMITTER_IDENT
));
5275 strbuf_addch(&sob
, '\n');
5278 strbuf_complete_line(msgbuf
);
5281 * If the whole message buffer is equal to the sob, pretend that we
5282 * found a conforming footer with a matching sob
5284 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
5285 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
5288 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
5291 const char *append_newlines
= NULL
;
5292 size_t len
= msgbuf
->len
- ignore_footer
;
5296 * The buffer is completely empty. Leave foom for
5297 * the title and body to be filled in by the user.
5299 append_newlines
= "\n\n";
5300 } else if (len
== 1) {
5302 * Buffer contains a single newline. Add another
5303 * so that we leave room for the title and body.
5305 append_newlines
= "\n";
5306 } else if (msgbuf
->buf
[len
- 2] != '\n') {
5308 * Buffer ends with a single newline. Add another
5309 * so that there is an empty line between the message
5312 append_newlines
= "\n";
5313 } /* else, the buffer already ends with two newlines. */
5315 if (append_newlines
)
5316 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
5317 append_newlines
, strlen(append_newlines
));
5320 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
5321 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
5324 strbuf_release(&sob
);
5327 struct labels_entry
{
5328 struct hashmap_entry entry
;
5329 char label
[FLEX_ARRAY
];
5332 static int labels_cmp(const void *fndata UNUSED
,
5333 const struct hashmap_entry
*eptr
,
5334 const struct hashmap_entry
*entry_or_key
, const void *key
)
5336 const struct labels_entry
*a
, *b
;
5338 a
= container_of(eptr
, const struct labels_entry
, entry
);
5339 b
= container_of(entry_or_key
, const struct labels_entry
, entry
);
5341 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
5344 struct string_entry
{
5345 struct oidmap_entry entry
;
5346 char string
[FLEX_ARRAY
];
5349 struct label_state
{
5350 struct oidmap commit2label
;
5351 struct hashmap labels
;
5355 static const char *label_oid(struct object_id
*oid
, const char *label
,
5356 struct label_state
*state
)
5358 struct labels_entry
*labels_entry
;
5359 struct string_entry
*string_entry
;
5360 struct object_id dummy
;
5363 string_entry
= oidmap_get(&state
->commit2label
, oid
);
5365 return string_entry
->string
;
5368 * For "uninteresting" commits, i.e. commits that are not to be
5369 * rebased, and which can therefore not be labeled, we use a unique
5370 * abbreviation of the commit name. This is slightly more complicated
5371 * than calling repo_find_unique_abbrev() because we also need to make
5372 * sure that the abbreviation does not conflict with any other
5375 * We disallow "interesting" commits to be labeled by a string that
5376 * is a valid full-length hash, to ensure that we always can find an
5377 * abbreviation for any uninteresting commit's names that does not
5378 * clash with any other label.
5380 strbuf_reset(&state
->buf
);
5384 strbuf_grow(&state
->buf
, GIT_MAX_HEXSZ
);
5385 label
= p
= state
->buf
.buf
;
5387 repo_find_unique_abbrev_r(the_repository
, p
, oid
,
5391 * We may need to extend the abbreviated hash so that there is
5392 * no conflicting label.
5394 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
5395 size_t i
= strlen(p
) + 1;
5397 oid_to_hex_r(p
, oid
);
5398 for (; i
< the_hash_algo
->hexsz
; i
++) {
5401 if (!hashmap_get_from_hash(&state
->labels
,
5408 struct strbuf
*buf
= &state
->buf
;
5411 * Sanitize labels by replacing non-alpha-numeric characters
5412 * (including white-space ones) by dashes, as they might be
5413 * illegal in file names (and hence in ref names).
5415 * Note that we retain non-ASCII UTF-8 characters (identified
5416 * via the most significant bit). They should be all acceptable
5417 * in file names. We do not validate the UTF-8 here, that's not
5418 * the job of this function.
5420 for (; *label
; label
++)
5421 if ((*label
& 0x80) || isalnum(*label
))
5422 strbuf_addch(buf
, *label
);
5423 /* avoid leading dash and double-dashes */
5424 else if (buf
->len
&& buf
->buf
[buf
->len
- 1] != '-')
5425 strbuf_addch(buf
, '-');
5427 strbuf_addstr(buf
, "rev-");
5428 strbuf_add_unique_abbrev(buf
, oid
, default_abbrev
);
5432 if ((buf
->len
== the_hash_algo
->hexsz
&&
5433 !get_oid_hex(label
, &dummy
)) ||
5434 (buf
->len
== 1 && *label
== '#') ||
5435 hashmap_get_from_hash(&state
->labels
,
5436 strihash(label
), label
)) {
5438 * If the label already exists, or if the label is a
5439 * valid full OID, or the label is a '#' (which we use
5440 * as a separator between merge heads and oneline), we
5441 * append a dash and a number to make it unique.
5443 size_t len
= buf
->len
;
5445 for (i
= 2; ; i
++) {
5446 strbuf_setlen(buf
, len
);
5447 strbuf_addf(buf
, "-%d", i
);
5448 if (!hashmap_get_from_hash(&state
->labels
,
5458 FLEX_ALLOC_STR(labels_entry
, label
, label
);
5459 hashmap_entry_init(&labels_entry
->entry
, strihash(label
));
5460 hashmap_add(&state
->labels
, &labels_entry
->entry
);
5462 FLEX_ALLOC_STR(string_entry
, string
, label
);
5463 oidcpy(&string_entry
->entry
.oid
, oid
);
5464 oidmap_put(&state
->commit2label
, string_entry
);
5466 return string_entry
->string
;
5469 static int make_script_with_merges(struct pretty_print_context
*pp
,
5470 struct rev_info
*revs
, struct strbuf
*out
,
5473 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5474 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
5475 int root_with_onto
= flags
& TODO_LIST_ROOT_WITH_ONTO
;
5476 int skipped_commit
= 0;
5477 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
5478 struct strbuf label
= STRBUF_INIT
;
5479 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
5480 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
5481 struct commit
*commit
;
5482 struct oidmap commit2todo
= OIDMAP_INIT
;
5483 struct string_entry
*entry
;
5484 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
5485 shown
= OIDSET_INIT
;
5486 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
5488 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
5489 const char *cmd_pick
= abbr
? "p" : "pick",
5490 *cmd_label
= abbr
? "l" : "label",
5491 *cmd_reset
= abbr
? "t" : "reset",
5492 *cmd_merge
= abbr
? "m" : "merge";
5494 oidmap_init(&commit2todo
, 0);
5495 oidmap_init(&state
.commit2label
, 0);
5496 hashmap_init(&state
.labels
, labels_cmp
, NULL
, 0);
5497 strbuf_init(&state
.buf
, 32);
5499 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
5500 struct labels_entry
*onto_label_entry
;
5501 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
5502 FLEX_ALLOC_STR(entry
, string
, "onto");
5503 oidcpy(&entry
->entry
.oid
, oid
);
5504 oidmap_put(&state
.commit2label
, entry
);
5506 FLEX_ALLOC_STR(onto_label_entry
, label
, "onto");
5507 hashmap_entry_init(&onto_label_entry
->entry
, strihash("onto"));
5508 hashmap_add(&state
.labels
, &onto_label_entry
->entry
);
5513 * - get onelines for all commits
5514 * - gather all branch tips (i.e. 2nd or later parents of merges)
5515 * - label all branch tips
5517 while ((commit
= get_revision(revs
))) {
5518 struct commit_list
*to_merge
;
5519 const char *p1
, *p2
;
5520 struct object_id
*oid
;
5523 tail
= &commit_list_insert(commit
, tail
)->next
;
5524 oidset_insert(&interesting
, &commit
->object
.oid
);
5526 is_empty
= is_original_commit_empty(commit
);
5527 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5528 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5529 warning(_("skipped previously applied commit %s"),
5530 short_commit_name(commit
));
5534 if (is_empty
&& !keep_empty
)
5537 strbuf_reset(&oneline
);
5538 pretty_print_commit(pp
, commit
, &oneline
);
5540 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
5542 /* non-merge commit: easy case */
5544 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
5545 oid_to_hex(&commit
->object
.oid
),
5548 strbuf_addf(&buf
, " %c empty",
5551 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5552 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5553 oidmap_put(&commit2todo
, entry
);
5558 /* Create a label */
5559 strbuf_reset(&label
);
5560 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
5561 (p1
= strchr(p1
, '\'')) &&
5562 (p2
= strchr(++p1
, '\'')))
5563 strbuf_add(&label
, p1
, p2
- p1
);
5564 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
5566 (p1
= strstr(p1
, " from ")))
5567 strbuf_addstr(&label
, p1
+ strlen(" from "));
5569 strbuf_addbuf(&label
, &oneline
);
5572 strbuf_addf(&buf
, "%s -C %s",
5573 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
5575 /* label the tips of merged branches */
5576 for (; to_merge
; to_merge
= to_merge
->next
) {
5577 oid
= &to_merge
->item
->object
.oid
;
5578 strbuf_addch(&buf
, ' ');
5580 if (!oidset_contains(&interesting
, oid
)) {
5581 strbuf_addstr(&buf
, label_oid(oid
, NULL
,
5586 tips_tail
= &commit_list_insert(to_merge
->item
,
5589 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
5591 strbuf_addf(&buf
, " # %s", oneline
.buf
);
5593 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5594 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5595 oidmap_put(&commit2todo
, entry
);
5598 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5599 _("use --reapply-cherry-picks to include skipped commits"));
5603 * - label branch points
5604 * - add HEAD to the branch tips
5606 for (iter
= commits
; iter
; iter
= iter
->next
) {
5607 struct commit_list
*parent
= iter
->item
->parents
;
5608 for (; parent
; parent
= parent
->next
) {
5609 struct object_id
*oid
= &parent
->item
->object
.oid
;
5610 if (!oidset_contains(&interesting
, oid
))
5612 if (oidset_insert(&child_seen
, oid
))
5613 label_oid(oid
, "branch-point", &state
);
5616 /* Add HEAD as implicit "tip of branch" */
5618 tips_tail
= &commit_list_insert(iter
->item
,
5623 * Third phase: output the todo list. This is a bit tricky, as we
5624 * want to avoid jumping back and forth between revisions. To
5625 * accomplish that goal, we walk backwards from the branch tips,
5626 * gathering commits not yet shown, reversing the list on the fly,
5627 * then outputting that list (labeling revisions as needed).
5629 strbuf_addf(out
, "%s onto\n", cmd_label
);
5630 for (iter
= tips
; iter
; iter
= iter
->next
) {
5631 struct commit_list
*list
= NULL
, *iter2
;
5633 commit
= iter
->item
;
5634 if (oidset_contains(&shown
, &commit
->object
.oid
))
5636 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
5639 strbuf_addf(out
, "\n%c Branch %s\n", comment_line_char
, entry
->string
);
5641 strbuf_addch(out
, '\n');
5643 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
5644 !oidset_contains(&shown
, &commit
->object
.oid
)) {
5645 commit_list_insert(commit
, &list
);
5646 if (!commit
->parents
) {
5650 commit
= commit
->parents
->item
;
5654 strbuf_addf(out
, "%s %s\n", cmd_reset
,
5655 rebase_cousins
|| root_with_onto
?
5656 "onto" : "[new root]");
5658 const char *to
= NULL
;
5660 entry
= oidmap_get(&state
.commit2label
,
5661 &commit
->object
.oid
);
5664 else if (!rebase_cousins
)
5665 to
= label_oid(&commit
->object
.oid
, NULL
,
5668 if (!to
|| !strcmp(to
, "onto"))
5669 strbuf_addf(out
, "%s onto\n", cmd_reset
);
5671 strbuf_reset(&oneline
);
5672 pretty_print_commit(pp
, commit
, &oneline
);
5673 strbuf_addf(out
, "%s %s # %s\n",
5674 cmd_reset
, to
, oneline
.buf
);
5678 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
5679 struct object_id
*oid
= &iter2
->item
->object
.oid
;
5680 entry
= oidmap_get(&commit2todo
, oid
);
5681 /* only show if not already upstream */
5683 strbuf_addf(out
, "%s\n", entry
->string
);
5684 entry
= oidmap_get(&state
.commit2label
, oid
);
5686 strbuf_addf(out
, "%s %s\n",
5687 cmd_label
, entry
->string
);
5688 oidset_insert(&shown
, oid
);
5691 free_commit_list(list
);
5694 free_commit_list(commits
);
5695 free_commit_list(tips
);
5697 strbuf_release(&label
);
5698 strbuf_release(&oneline
);
5699 strbuf_release(&buf
);
5701 oidmap_free(&commit2todo
, 1);
5702 oidmap_free(&state
.commit2label
, 1);
5703 hashmap_clear_and_free(&state
.labels
, struct labels_entry
, entry
);
5704 strbuf_release(&state
.buf
);
5709 int sequencer_make_script(struct repository
*r
, struct strbuf
*out
, int argc
,
5710 const char **argv
, unsigned flags
)
5712 char *format
= NULL
;
5713 struct pretty_print_context pp
= {0};
5714 struct rev_info revs
;
5715 struct commit
*commit
;
5716 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5717 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
5718 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
5719 int reapply_cherry_picks
= flags
& TODO_LIST_REAPPLY_CHERRY_PICKS
;
5720 int skipped_commit
= 0;
5723 repo_init_revisions(r
, &revs
, NULL
);
5724 revs
.verbose_header
= 1;
5726 revs
.max_parents
= 1;
5727 revs
.cherry_mark
= !reapply_cherry_picks
;
5730 revs
.right_only
= 1;
5731 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
5732 revs
.topo_order
= 1;
5734 revs
.pretty_given
= 1;
5735 git_config_get_string("rebase.instructionFormat", &format
);
5736 if (!format
|| !*format
) {
5738 format
= xstrdup("%s");
5740 get_commit_format(format
, &revs
);
5742 pp
.fmt
= revs
.commit_format
;
5743 pp
.output_encoding
= get_log_output_encoding();
5745 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1) {
5746 ret
= error(_("make_script: unhandled options"));
5750 if (prepare_revision_walk(&revs
) < 0) {
5751 ret
= error(_("make_script: error preparing revisions"));
5755 if (rebase_merges
) {
5756 ret
= make_script_with_merges(&pp
, &revs
, out
, flags
);
5760 while ((commit
= get_revision(&revs
))) {
5761 int is_empty
= is_original_commit_empty(commit
);
5763 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5764 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5765 warning(_("skipped previously applied commit %s"),
5766 short_commit_name(commit
));
5770 if (is_empty
&& !keep_empty
)
5772 strbuf_addf(out
, "%s %s ", insn
,
5773 oid_to_hex(&commit
->object
.oid
));
5774 pretty_print_commit(&pp
, commit
, out
);
5776 strbuf_addf(out
, " %c empty", comment_line_char
);
5777 strbuf_addch(out
, '\n');
5780 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5781 _("use --reapply-cherry-picks to include skipped commits"));
5783 release_revisions(&revs
);
5788 * Add commands after pick and (series of) squash/fixup commands
5791 static void todo_list_add_exec_commands(struct todo_list
*todo_list
,
5792 struct string_list
*commands
)
5794 struct strbuf
*buf
= &todo_list
->buf
;
5795 size_t base_offset
= buf
->len
;
5796 int i
, insert
, nr
= 0, alloc
= 0;
5797 struct todo_item
*items
= NULL
, *base_items
= NULL
;
5799 CALLOC_ARRAY(base_items
, commands
->nr
);
5800 for (i
= 0; i
< commands
->nr
; i
++) {
5801 size_t command_len
= strlen(commands
->items
[i
].string
);
5803 strbuf_addstr(buf
, commands
->items
[i
].string
);
5804 strbuf_addch(buf
, '\n');
5806 base_items
[i
].command
= TODO_EXEC
;
5807 base_items
[i
].offset_in_buf
= base_offset
;
5808 base_items
[i
].arg_offset
= base_offset
;
5809 base_items
[i
].arg_len
= command_len
;
5811 base_offset
+= command_len
+ 1;
5815 * Insert <commands> after every pick. Here, fixup/squash chains
5816 * are considered part of the pick, so we insert the commands *after*
5817 * those chains if there are any.
5819 * As we insert the exec commands immediately after rearranging
5820 * any fixups and before the user edits the list, a fixup chain
5821 * can never contain comments (any comments are empty picks that
5822 * have been commented out because the user did not specify
5823 * --keep-empty). So, it is safe to insert an exec command
5824 * without looking at the command following a comment.
5827 for (i
= 0; i
< todo_list
->nr
; i
++) {
5828 enum todo_command command
= todo_list
->items
[i
].command
;
5829 if (insert
&& !is_fixup(command
)) {
5830 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5831 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5837 ALLOC_GROW(items
, nr
+ 1, alloc
);
5838 items
[nr
++] = todo_list
->items
[i
];
5840 if (command
== TODO_PICK
|| command
== TODO_MERGE
)
5844 /* insert or append final <commands> */
5846 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5847 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5852 FREE_AND_NULL(todo_list
->items
);
5853 todo_list
->items
= items
;
5855 todo_list
->alloc
= alloc
;
5858 static void todo_list_to_strbuf(struct repository
*r
, struct todo_list
*todo_list
,
5859 struct strbuf
*buf
, int num
, unsigned flags
)
5861 struct todo_item
*item
;
5862 int i
, max
= todo_list
->nr
;
5864 if (num
> 0 && num
< max
)
5867 for (item
= todo_list
->items
, i
= 0; i
< max
; i
++, item
++) {
5870 /* if the item is not a command write it and continue */
5871 if (item
->command
>= TODO_COMMENT
) {
5872 strbuf_addf(buf
, "%.*s\n", item
->arg_len
,
5873 todo_item_get_arg(todo_list
, item
));
5877 /* add command to the buffer */
5878 cmd
= command_to_char(item
->command
);
5879 if ((flags
& TODO_LIST_ABBREVIATE_CMDS
) && cmd
)
5880 strbuf_addch(buf
, cmd
);
5882 strbuf_addstr(buf
, command_to_string(item
->command
));
5886 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
5887 short_commit_name(item
->commit
) :
5888 oid_to_hex(&item
->commit
->object
.oid
);
5890 if (item
->command
== TODO_FIXUP
) {
5891 if (item
->flags
& TODO_EDIT_FIXUP_MSG
)
5892 strbuf_addstr(buf
, " -c");
5893 else if (item
->flags
& TODO_REPLACE_FIXUP_MSG
) {
5894 strbuf_addstr(buf
, " -C");
5898 if (item
->command
== TODO_MERGE
) {
5899 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
5900 strbuf_addstr(buf
, " -c");
5902 strbuf_addstr(buf
, " -C");
5905 strbuf_addf(buf
, " %s", oid
);
5908 /* add all the rest */
5910 strbuf_addch(buf
, '\n');
5912 strbuf_addf(buf
, " %.*s\n", item
->arg_len
,
5913 todo_item_get_arg(todo_list
, item
));
5917 int todo_list_write_to_file(struct repository
*r
, struct todo_list
*todo_list
,
5918 const char *file
, const char *shortrevisions
,
5919 const char *shortonto
, int num
, unsigned flags
)
5922 struct strbuf buf
= STRBUF_INIT
;
5924 todo_list_to_strbuf(r
, todo_list
, &buf
, num
, flags
);
5925 if (flags
& TODO_LIST_APPEND_TODO_HELP
)
5926 append_todo_help(count_commands(todo_list
),
5927 shortrevisions
, shortonto
, &buf
);
5929 res
= write_message(buf
.buf
, buf
.len
, file
, 0);
5930 strbuf_release(&buf
);
5935 /* skip picking commits whose parents are unchanged */
5936 static int skip_unnecessary_picks(struct repository
*r
,
5937 struct todo_list
*todo_list
,
5938 struct object_id
*base_oid
)
5940 struct object_id
*parent_oid
;
5943 for (i
= 0; i
< todo_list
->nr
; i
++) {
5944 struct todo_item
*item
= todo_list
->items
+ i
;
5946 if (item
->command
>= TODO_NOOP
)
5948 if (item
->command
!= TODO_PICK
)
5950 if (repo_parse_commit(r
, item
->commit
)) {
5951 return error(_("could not parse commit '%s'"),
5952 oid_to_hex(&item
->commit
->object
.oid
));
5954 if (!item
->commit
->parents
)
5955 break; /* root commit */
5956 if (item
->commit
->parents
->next
)
5957 break; /* merge commit */
5958 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
5959 if (!oideq(parent_oid
, base_oid
))
5961 oidcpy(base_oid
, &item
->commit
->object
.oid
);
5964 const char *done_path
= rebase_path_done();
5966 if (todo_list_write_to_file(r
, todo_list
, done_path
, NULL
, NULL
, i
, 0)) {
5967 error_errno(_("could not write to '%s'"), done_path
);
5971 MOVE_ARRAY(todo_list
->items
, todo_list
->items
+ i
, todo_list
->nr
- i
);
5973 todo_list
->current
= 0;
5974 todo_list
->done_nr
+= i
;
5976 if (is_fixup(peek_command(todo_list
, 0)))
5977 record_in_rewritten(base_oid
, peek_command(todo_list
, 0));
5983 struct todo_add_branch_context
{
5984 struct todo_item
*items
;
5988 struct commit
*commit
;
5989 struct string_list refs_to_oids
;
5992 static int add_decorations_to_list(const struct commit
*commit
,
5993 struct todo_add_branch_context
*ctx
)
5995 const struct name_decoration
*decoration
= get_name_decoration(&commit
->object
);
5996 const char *head_ref
= resolve_ref_unsafe("HEAD",
5997 RESOLVE_REF_READING
,
6001 while (decoration
) {
6002 struct todo_item
*item
;
6004 size_t base_offset
= ctx
->buf
->len
;
6007 * If the branch is the current HEAD, then it will be
6008 * updated by the default rebase behavior.
6010 if (head_ref
&& !strcmp(head_ref
, decoration
->name
)) {
6011 decoration
= decoration
->next
;
6015 ALLOC_GROW(ctx
->items
,
6018 item
= &ctx
->items
[ctx
->items_nr
];
6019 memset(item
, 0, sizeof(*item
));
6021 /* If the branch is checked out, then leave a comment instead. */
6022 if ((path
= branch_checked_out(decoration
->name
))) {
6023 item
->command
= TODO_COMMENT
;
6024 strbuf_addf(ctx
->buf
, "# Ref %s checked out at '%s'\n",
6025 decoration
->name
, path
);
6027 struct string_list_item
*sti
;
6028 item
->command
= TODO_UPDATE_REF
;
6029 strbuf_addf(ctx
->buf
, "%s\n", decoration
->name
);
6031 sti
= string_list_insert(&ctx
->refs_to_oids
,
6033 sti
->util
= init_update_ref_record(decoration
->name
);
6036 item
->offset_in_buf
= base_offset
;
6037 item
->arg_offset
= base_offset
;
6038 item
->arg_len
= ctx
->buf
->len
- base_offset
;
6041 decoration
= decoration
->next
;
6048 * For each 'pick' command, find out if the commit has a decoration in
6049 * refs/heads/. If so, then add a 'label for-update-refs/' command.
6051 static int todo_list_add_update_ref_commands(struct todo_list
*todo_list
)
6054 static struct string_list decorate_refs_exclude
= STRING_LIST_INIT_NODUP
;
6055 static struct string_list decorate_refs_exclude_config
= STRING_LIST_INIT_NODUP
;
6056 static struct string_list decorate_refs_include
= STRING_LIST_INIT_NODUP
;
6057 struct decoration_filter decoration_filter
= {
6058 .include_ref_pattern
= &decorate_refs_include
,
6059 .exclude_ref_pattern
= &decorate_refs_exclude
,
6060 .exclude_ref_config_pattern
= &decorate_refs_exclude_config
,
6062 struct todo_add_branch_context ctx
= {
6063 .buf
= &todo_list
->buf
,
6064 .refs_to_oids
= STRING_LIST_INIT_DUP
,
6067 ctx
.items_alloc
= 2 * todo_list
->nr
+ 1;
6068 ALLOC_ARRAY(ctx
.items
, ctx
.items_alloc
);
6070 string_list_append(&decorate_refs_include
, "refs/heads/");
6071 load_ref_decorations(&decoration_filter
, 0);
6073 for (i
= 0; i
< todo_list
->nr
; ) {
6074 struct todo_item
*item
= &todo_list
->items
[i
];
6076 /* insert ith item into new list */
6077 ALLOC_GROW(ctx
.items
,
6081 ctx
.items
[ctx
.items_nr
++] = todo_list
->items
[i
++];
6084 ctx
.commit
= item
->commit
;
6085 add_decorations_to_list(item
->commit
, &ctx
);
6089 res
= write_update_refs_state(&ctx
.refs_to_oids
);
6091 string_list_clear(&ctx
.refs_to_oids
, 1);
6094 /* we failed, so clean up the new list. */
6099 free(todo_list
->items
);
6100 todo_list
->items
= ctx
.items
;
6101 todo_list
->nr
= ctx
.items_nr
;
6102 todo_list
->alloc
= ctx
.items_alloc
;
6107 int complete_action(struct repository
*r
, struct replay_opts
*opts
, unsigned flags
,
6108 const char *shortrevisions
, const char *onto_name
,
6109 struct commit
*onto
, const struct object_id
*orig_head
,
6110 struct string_list
*commands
, unsigned autosquash
,
6111 unsigned update_refs
,
6112 struct todo_list
*todo_list
)
6114 char shortonto
[GIT_MAX_HEXSZ
+ 1];
6115 const char *todo_file
= rebase_path_todo();
6116 struct todo_list new_todo
= TODO_LIST_INIT
;
6117 struct strbuf
*buf
= &todo_list
->buf
, buf2
= STRBUF_INIT
;
6118 struct object_id oid
= onto
->object
.oid
;
6121 repo_find_unique_abbrev_r(r
, shortonto
, &oid
,
6124 if (buf
->len
== 0) {
6125 struct todo_item
*item
= append_new_todo(todo_list
);
6126 item
->command
= TODO_NOOP
;
6127 item
->commit
= NULL
;
6128 item
->arg_len
= item
->arg_offset
= item
->flags
= item
->offset_in_buf
= 0;
6131 if (update_refs
&& todo_list_add_update_ref_commands(todo_list
))
6134 if (autosquash
&& todo_list_rearrange_squash(todo_list
))
6138 todo_list_add_exec_commands(todo_list
, commands
);
6140 if (count_commands(todo_list
) == 0) {
6141 apply_autostash(rebase_path_autostash());
6142 sequencer_remove_state(opts
);
6144 return error(_("nothing to do"));
6147 res
= edit_todo_list(r
, todo_list
, &new_todo
, shortrevisions
,
6151 else if (res
== -2) {
6152 apply_autostash(rebase_path_autostash());
6153 sequencer_remove_state(opts
);
6156 } else if (res
== -3) {
6157 apply_autostash(rebase_path_autostash());
6158 sequencer_remove_state(opts
);
6159 todo_list_release(&new_todo
);
6161 return error(_("nothing to do"));
6162 } else if (res
== -4) {
6163 checkout_onto(r
, opts
, onto_name
, &onto
->object
.oid
, orig_head
);
6164 todo_list_release(&new_todo
);
6169 /* Expand the commit IDs */
6170 todo_list_to_strbuf(r
, &new_todo
, &buf2
, -1, 0);
6171 strbuf_swap(&new_todo
.buf
, &buf2
);
6172 strbuf_release(&buf2
);
6173 new_todo
.total_nr
-= new_todo
.nr
;
6174 if (todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
) < 0)
6175 BUG("invalid todo list after expanding IDs:\n%s",
6178 if (opts
->allow_ff
&& skip_unnecessary_picks(r
, &new_todo
, &oid
)) {
6179 todo_list_release(&new_todo
);
6180 return error(_("could not skip unnecessary pick commands"));
6183 if (todo_list_write_to_file(r
, &new_todo
, todo_file
, NULL
, NULL
, -1,
6184 flags
& ~(TODO_LIST_SHORTEN_IDS
))) {
6185 todo_list_release(&new_todo
);
6186 return error_errno(_("could not write '%s'"), todo_file
);
6191 if (checkout_onto(r
, opts
, onto_name
, &oid
, orig_head
))
6194 if (require_clean_work_tree(r
, "rebase", "", 1, 1))
6197 todo_list_write_total_nr(&new_todo
);
6198 res
= pick_commits(r
, &new_todo
, opts
);
6201 todo_list_release(&new_todo
);
6206 struct subject2item_entry
{
6207 struct hashmap_entry entry
;
6209 char subject
[FLEX_ARRAY
];
6212 static int subject2item_cmp(const void *fndata UNUSED
,
6213 const struct hashmap_entry
*eptr
,
6214 const struct hashmap_entry
*entry_or_key
,
6217 const struct subject2item_entry
*a
, *b
;
6219 a
= container_of(eptr
, const struct subject2item_entry
, entry
);
6220 b
= container_of(entry_or_key
, const struct subject2item_entry
, entry
);
6222 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
6225 define_commit_slab(commit_todo_item
, struct todo_item
*);
6227 static int skip_fixupish(const char *subject
, const char **p
) {
6228 return skip_prefix(subject
, "fixup! ", p
) ||
6229 skip_prefix(subject
, "amend! ", p
) ||
6230 skip_prefix(subject
, "squash! ", p
);
6234 * Rearrange the todo list that has both "pick commit-id msg" and "pick
6235 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
6236 * after the former, and change "pick" to "fixup"/"squash".
6238 * Note that if the config has specified a custom instruction format, each log
6239 * message will have to be retrieved from the commit (as the oneline in the
6240 * script cannot be trusted) in order to normalize the autosquash arrangement.
6242 int todo_list_rearrange_squash(struct todo_list
*todo_list
)
6244 struct hashmap subject2item
;
6245 int rearranged
= 0, *next
, *tail
, i
, nr
= 0, alloc
= 0;
6247 struct commit_todo_item commit_todo
;
6248 struct todo_item
*items
= NULL
;
6250 init_commit_todo_item(&commit_todo
);
6252 * The hashmap maps onelines to the respective todo list index.
6254 * If any items need to be rearranged, the next[i] value will indicate
6255 * which item was moved directly after the i'th.
6257 * In that case, last[i] will indicate the index of the latest item to
6258 * be moved to appear after the i'th.
6260 hashmap_init(&subject2item
, subject2item_cmp
, NULL
, todo_list
->nr
);
6261 ALLOC_ARRAY(next
, todo_list
->nr
);
6262 ALLOC_ARRAY(tail
, todo_list
->nr
);
6263 ALLOC_ARRAY(subjects
, todo_list
->nr
);
6264 for (i
= 0; i
< todo_list
->nr
; i
++) {
6265 struct strbuf buf
= STRBUF_INIT
;
6266 struct todo_item
*item
= todo_list
->items
+ i
;
6267 const char *commit_buffer
, *subject
, *p
;
6270 struct subject2item_entry
*entry
;
6272 next
[i
] = tail
[i
] = -1;
6273 if (!item
->commit
|| item
->command
== TODO_DROP
) {
6278 if (is_fixup(item
->command
)) {
6279 clear_commit_todo_item(&commit_todo
);
6280 return error(_("the script was already rearranged."));
6283 repo_parse_commit(the_repository
, item
->commit
);
6284 commit_buffer
= repo_logmsg_reencode(the_repository
,
6287 find_commit_subject(commit_buffer
, &subject
);
6288 format_subject(&buf
, subject
, " ");
6289 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
6290 repo_unuse_commit_buffer(the_repository
, item
->commit
,
6292 if (skip_fixupish(subject
, &p
)) {
6293 struct commit
*commit2
;
6298 if (!skip_fixupish(p
, &p
))
6302 entry
= hashmap_get_entry_from_hash(&subject2item
,
6304 struct subject2item_entry
,
6307 /* found by title */
6309 else if (!strchr(p
, ' ') &&
6311 lookup_commit_reference_by_name(p
)) &&
6312 *commit_todo_item_at(&commit_todo
, commit2
))
6313 /* found by commit name */
6314 i2
= *commit_todo_item_at(&commit_todo
, commit2
)
6317 /* copy can be a prefix of the commit subject */
6318 for (i2
= 0; i2
< i
; i2
++)
6320 starts_with(subjects
[i2
], p
))
6328 if (starts_with(subject
, "fixup!")) {
6329 todo_list
->items
[i
].command
= TODO_FIXUP
;
6330 } else if (starts_with(subject
, "amend!")) {
6331 todo_list
->items
[i
].command
= TODO_FIXUP
;
6332 todo_list
->items
[i
].flags
= TODO_REPLACE_FIXUP_MSG
;
6334 todo_list
->items
[i
].command
= TODO_SQUASH
;
6340 next
[i
] = next
[tail
[i2
]];
6344 } else if (!hashmap_get_from_hash(&subject2item
,
6345 strhash(subject
), subject
)) {
6346 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
6348 hashmap_entry_init(&entry
->entry
,
6349 strhash(entry
->subject
));
6350 hashmap_put(&subject2item
, &entry
->entry
);
6353 *commit_todo_item_at(&commit_todo
, item
->commit
) = item
;
6357 for (i
= 0; i
< todo_list
->nr
; i
++) {
6358 enum todo_command command
= todo_list
->items
[i
].command
;
6362 * Initially, all commands are 'pick's. If it is a
6363 * fixup or a squash now, we have rearranged it.
6365 if (is_fixup(command
))
6369 ALLOC_GROW(items
, nr
+ 1, alloc
);
6370 items
[nr
++] = todo_list
->items
[cur
];
6375 FREE_AND_NULL(todo_list
->items
);
6376 todo_list
->items
= items
;
6378 todo_list
->alloc
= alloc
;
6383 for (i
= 0; i
< todo_list
->nr
; i
++)
6386 hashmap_clear_and_free(&subject2item
, struct subject2item_entry
, entry
);
6388 clear_commit_todo_item(&commit_todo
);
6393 int sequencer_determine_whence(struct repository
*r
, enum commit_whence
*whence
)
6395 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
6396 struct object_id cherry_pick_head
, rebase_head
;
6398 if (file_exists(git_path_seq_dir()))
6399 *whence
= FROM_CHERRY_PICK_MULTI
;
6400 if (file_exists(rebase_path()) &&
6401 !repo_get_oid(r
, "REBASE_HEAD", &rebase_head
) &&
6402 !repo_get_oid(r
, "CHERRY_PICK_HEAD", &cherry_pick_head
) &&
6403 oideq(&rebase_head
, &cherry_pick_head
))
6404 *whence
= FROM_REBASE_PICK
;
6406 *whence
= FROM_CHERRY_PICK_SINGLE
;
6414 int sequencer_get_update_refs_state(const char *wt_dir
,
6415 struct string_list
*refs
)
6419 struct strbuf ref
= STRBUF_INIT
;
6420 struct strbuf hash
= STRBUF_INIT
;
6421 struct update_ref_record
*rec
= NULL
;
6423 char *path
= rebase_path_update_refs(wt_dir
);
6425 fp
= fopen(path
, "r");
6429 while (strbuf_getline(&ref
, fp
) != EOF
) {
6430 struct string_list_item
*item
;
6432 CALLOC_ARRAY(rec
, 1);
6434 if (strbuf_getline(&hash
, fp
) == EOF
||
6435 get_oid_hex(hash
.buf
, &rec
->before
)) {
6436 warning(_("update-refs file at '%s' is invalid"),
6442 if (strbuf_getline(&hash
, fp
) == EOF
||
6443 get_oid_hex(hash
.buf
, &rec
->after
)) {
6444 warning(_("update-refs file at '%s' is invalid"),
6450 item
= string_list_insert(refs
, ref
.buf
);
6460 strbuf_release(&ref
);
6461 strbuf_release(&hash
);