5 #include "environment.h"
10 #include "object-store.h"
13 #include "sequencer.h"
15 #include "run-command.h"
19 #include "cache-tree.h"
23 #include "merge-ort.h"
24 #include "merge-ort-wrappers.h"
30 #include "wt-status.h"
32 #include "notes-utils.h"
34 #include "unpack-trees.h"
38 #include "commit-slab.h"
40 #include "commit-reach.h"
41 #include "rebase-interactive.h"
46 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
48 static const char sign_off_header
[] = "Signed-off-by: ";
49 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
51 GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
53 static GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
55 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
56 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
57 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
58 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
60 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
62 * The file containing rebase commands, comments, and empty lines.
63 * This file is created by "git rebase -i" then edited by the user. As
64 * the lines are processed, they are removed from the front of this
65 * file and written to the tail of 'done'.
67 GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
68 GIT_PATH_FUNC(rebase_path_todo_backup
, "rebase-merge/git-rebase-todo.backup")
70 GIT_PATH_FUNC(rebase_path_dropped
, "rebase-merge/dropped")
73 * The rebase command lines that have already been processed. A line
74 * is moved here when it is first handled, before any associated user
77 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
79 * The file to keep track of how many commands were already processed (e.g.
82 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum")
84 * The file to keep track of how many commands are to be processed in total
85 * (e.g. for the prompt).
87 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end")
89 * The commit message that is planned to be used for any changes that
90 * need to be committed following a user interaction.
92 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
94 * The file into which is accumulated the suggested commit message for
95 * squash/fixup commands. When the first of a series of squash/fixups
96 * is seen, the file is created and the commit message from the
97 * previous commit and from the first squash/fixup commit are written
98 * to it. The commit message for each subsequent squash/fixup commit
99 * is appended to the file as it is processed.
101 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
103 * If the current series of squash/fixups has not yet included a squash
104 * command, then this file exists and holds the commit message of the
105 * original "pick" commit. (If the series ends without a "squash"
106 * command, then this can be used as the commit message of the combined
107 * commit without opening the editor.)
109 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
111 * This file contains the list fixup/squash commands that have been
112 * accumulated into message-fixup or message-squash so far.
114 static GIT_PATH_FUNC(rebase_path_current_fixups
, "rebase-merge/current-fixups")
116 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
117 * GIT_AUTHOR_DATE that will be used for the commit that is currently
120 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
122 * When an "edit" rebase command is being processed, the SHA1 of the
123 * commit to be edited is recorded in this file. When "git rebase
124 * --continue" is executed, if there are any staged changes then they
125 * will be amended to the HEAD commit, but only provided the HEAD
126 * commit is still the commit to be edited. When any other rebase
127 * command is processed, this file is deleted.
129 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
131 * When we stop at a given patch via the "edit" command, this file contains
132 * the commit object name of the corresponding patch.
134 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
136 * For the post-rewrite hook, we make a list of rewritten commits and
137 * their new sha1s. The rewritten-pending list keeps the sha1s of
138 * commits that have been processed, but not committed yet,
139 * e.g. because they are waiting for a 'squash' command.
141 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
142 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
143 "rebase-merge/rewritten-pending")
146 * The path of the file containing the OID of the "squash onto" commit, i.e.
147 * the dummy commit used for `reset [new root]`.
149 static GIT_PATH_FUNC(rebase_path_squash_onto
, "rebase-merge/squash-onto")
152 * The path of the file listing refs that need to be deleted after the rebase
153 * finishes. This is used by the `label` command to record the need for cleanup.
155 static GIT_PATH_FUNC(rebase_path_refs_to_delete
, "rebase-merge/refs-to-delete")
158 * The update-refs file stores a list of refs that will be updated at the end
159 * of the rebase sequence. The 'update-ref <ref>' commands in the todo file
160 * update the OIDs for the refs in this file, but the refs are not updated
161 * until the end of the rebase sequence.
163 * rebase_path_update_refs() returns the path to this file for a given
164 * worktree directory. For the current worktree, pass the_repository->gitdir.
166 static char *rebase_path_update_refs(const char *wt_git_dir
)
168 return xstrfmt("%s/rebase-merge/update-refs", wt_git_dir
);
172 * The following files are written by git-rebase just after parsing the
175 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
176 static GIT_PATH_FUNC(rebase_path_cdate_is_adate
, "rebase-merge/cdate_is_adate")
177 static GIT_PATH_FUNC(rebase_path_ignore_date
, "rebase-merge/ignore_date")
178 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
179 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
180 static GIT_PATH_FUNC(rebase_path_quiet
, "rebase-merge/quiet")
181 static GIT_PATH_FUNC(rebase_path_signoff
, "rebase-merge/signoff")
182 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
183 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
184 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
185 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
186 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
187 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
188 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec
, "rebase-merge/reschedule-failed-exec")
189 static GIT_PATH_FUNC(rebase_path_no_reschedule_failed_exec
, "rebase-merge/no-reschedule-failed-exec")
190 static GIT_PATH_FUNC(rebase_path_drop_redundant_commits
, "rebase-merge/drop_redundant_commits")
191 static GIT_PATH_FUNC(rebase_path_keep_redundant_commits
, "rebase-merge/keep_redundant_commits")
194 * A 'struct update_refs_record' represents a value in the update-refs
195 * list. We use a string_list to map refs to these (before, after) pairs.
197 struct update_ref_record
{
198 struct object_id before
;
199 struct object_id after
;
202 static struct update_ref_record
*init_update_ref_record(const char *ref
)
204 struct update_ref_record
*rec
;
206 CALLOC_ARRAY(rec
, 1);
208 oidcpy(&rec
->before
, null_oid());
209 oidcpy(&rec
->after
, null_oid());
211 /* This may fail, but that's fine, we will keep the null OID. */
212 read_ref(ref
, &rec
->before
);
217 static int git_sequencer_config(const char *k
, const char *v
, void *cb
)
219 struct replay_opts
*opts
= cb
;
222 if (!strcmp(k
, "commit.cleanup")) {
225 status
= git_config_string(&s
, k
, v
);
229 if (!strcmp(s
, "verbatim")) {
230 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
231 opts
->explicit_cleanup
= 1;
232 } else if (!strcmp(s
, "whitespace")) {
233 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
234 opts
->explicit_cleanup
= 1;
235 } else if (!strcmp(s
, "strip")) {
236 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_ALL
;
237 opts
->explicit_cleanup
= 1;
238 } else if (!strcmp(s
, "scissors")) {
239 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SCISSORS
;
240 opts
->explicit_cleanup
= 1;
242 warning(_("invalid commit message cleanup mode '%s'"),
250 if (!strcmp(k
, "commit.gpgsign")) {
251 opts
->gpg_sign
= git_config_bool(k
, v
) ? xstrdup("") : NULL
;
255 if (!opts
->default_strategy
&& !strcmp(k
, "pull.twohead")) {
256 int ret
= git_config_string((const char**)&opts
->default_strategy
, k
, v
);
259 * pull.twohead is allowed to be multi-valued; we only
260 * care about the first value.
262 char *tmp
= strchr(opts
->default_strategy
, ' ');
269 if (opts
->action
== REPLAY_REVERT
&& !strcmp(k
, "revert.reference"))
270 opts
->commit_use_reference
= git_config_bool(k
, v
);
272 return git_diff_basic_config(k
, v
, NULL
);
275 void sequencer_init_config(struct replay_opts
*opts
)
277 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
278 git_config(git_sequencer_config
, opts
);
281 static inline int is_rebase_i(const struct replay_opts
*opts
)
283 return opts
->action
== REPLAY_INTERACTIVE_REBASE
;
286 static const char *get_dir(const struct replay_opts
*opts
)
288 if (is_rebase_i(opts
))
289 return rebase_path();
290 return git_path_seq_dir();
293 static const char *get_todo_path(const struct replay_opts
*opts
)
295 if (is_rebase_i(opts
))
296 return rebase_path_todo();
297 return git_path_todo_file();
301 * Returns 0 for non-conforming footer
302 * Returns 1 for conforming footer
303 * Returns 2 when sob exists within conforming footer
304 * Returns 3 when sob exists within conforming footer as last entry
306 static int has_conforming_footer(struct strbuf
*sb
, struct strbuf
*sob
,
307 size_t ignore_footer
)
309 struct process_trailer_options opts
= PROCESS_TRAILER_OPTIONS_INIT
;
310 struct trailer_info info
;
312 int found_sob
= 0, found_sob_last
= 0;
318 saved_char
= sb
->buf
[sb
->len
- ignore_footer
];
319 sb
->buf
[sb
->len
- ignore_footer
] = '\0';
322 trailer_info_get(&info
, sb
->buf
, &opts
);
325 sb
->buf
[sb
->len
- ignore_footer
] = saved_char
;
327 if (info
.trailer_start
== info
.trailer_end
)
330 for (i
= 0; i
< info
.trailer_nr
; i
++)
331 if (sob
&& !strncmp(info
.trailers
[i
], sob
->buf
, sob
->len
)) {
333 if (i
== info
.trailer_nr
- 1)
337 trailer_info_release(&info
);
346 static const char *gpg_sign_opt_quoted(struct replay_opts
*opts
)
348 static struct strbuf buf
= STRBUF_INIT
;
352 sq_quotef(&buf
, "-S%s", opts
->gpg_sign
);
356 void replay_opts_release(struct replay_opts
*opts
)
358 free(opts
->gpg_sign
);
359 free(opts
->reflog_action
);
360 free(opts
->default_strategy
);
361 free(opts
->strategy
);
362 for (size_t i
= 0; i
< opts
->xopts_nr
; i
++)
363 free(opts
->xopts
[i
]);
365 strbuf_release(&opts
->current_fixups
);
367 release_revisions(opts
->revs
);
371 int sequencer_remove_state(struct replay_opts
*opts
)
373 struct strbuf buf
= STRBUF_INIT
;
376 if (is_rebase_i(opts
) &&
377 strbuf_read_file(&buf
, rebase_path_refs_to_delete(), 0) > 0) {
380 char *eol
= strchr(p
, '\n');
383 if (delete_ref("(rebase) cleanup", p
, NULL
, 0) < 0) {
384 warning(_("could not delete '%s'"), p
);
394 strbuf_addstr(&buf
, get_dir(opts
));
395 if (remove_dir_recursively(&buf
, 0))
396 ret
= error(_("could not remove '%s'"), buf
.buf
);
397 strbuf_release(&buf
);
402 static const char *action_name(const struct replay_opts
*opts
)
404 switch (opts
->action
) {
408 return N_("cherry-pick");
409 case REPLAY_INTERACTIVE_REBASE
:
412 die(_("unknown action: %d"), opts
->action
);
415 struct commit_message
{
422 static const char *short_commit_name(struct commit
*commit
)
424 return repo_find_unique_abbrev(the_repository
, &commit
->object
.oid
,
428 static int get_message(struct commit
*commit
, struct commit_message
*out
)
430 const char *abbrev
, *subject
;
433 out
->message
= repo_logmsg_reencode(the_repository
, commit
, NULL
,
434 get_commit_output_encoding());
435 abbrev
= short_commit_name(commit
);
437 subject_len
= find_commit_subject(out
->message
, &subject
);
439 out
->subject
= xmemdupz(subject
, subject_len
);
440 out
->label
= xstrfmt("%s (%s)", abbrev
, out
->subject
);
441 out
->parent_label
= xstrfmt("parent of %s", out
->label
);
446 static void free_message(struct commit
*commit
, struct commit_message
*msg
)
448 free(msg
->parent_label
);
451 repo_unuse_commit_buffer(the_repository
, commit
, msg
->message
);
454 static void print_advice(struct repository
*r
, int show_hint
,
455 struct replay_opts
*opts
)
457 char *msg
= getenv("GIT_CHERRY_PICK_HELP");
462 * A conflict has occurred but the porcelain
463 * (typically rebase --interactive) wants to take care
464 * of the commit itself so remove CHERRY_PICK_HEAD
466 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
473 advise(_("after resolving the conflicts, mark the corrected paths\n"
474 "with 'git add <paths>' or 'git rm <paths>'"));
475 else if (opts
->action
== REPLAY_PICK
)
476 advise(_("After resolving the conflicts, mark them with\n"
477 "\"git add/rm <pathspec>\", then run\n"
478 "\"git cherry-pick --continue\".\n"
479 "You can instead skip this commit with \"git cherry-pick --skip\".\n"
480 "To abort and get back to the state before \"git cherry-pick\",\n"
481 "run \"git cherry-pick --abort\"."));
482 else if (opts
->action
== REPLAY_REVERT
)
483 advise(_("After resolving the conflicts, mark them with\n"
484 "\"git add/rm <pathspec>\", then run\n"
485 "\"git revert --continue\".\n"
486 "You can instead skip this commit with \"git revert --skip\".\n"
487 "To abort and get back to the state before \"git revert\",\n"
488 "run \"git revert --abort\"."));
490 BUG("unexpected pick action in print_advice()");
494 static int write_message(const void *buf
, size_t len
, const char *filename
,
497 struct lock_file msg_file
= LOCK_INIT
;
499 int msg_fd
= hold_lock_file_for_update(&msg_file
, filename
, 0);
501 return error_errno(_("could not lock '%s'"), filename
);
502 if (write_in_full(msg_fd
, buf
, len
) < 0) {
503 error_errno(_("could not write to '%s'"), filename
);
504 rollback_lock_file(&msg_file
);
507 if (append_eol
&& write(msg_fd
, "\n", 1) < 0) {
508 error_errno(_("could not write eol to '%s'"), filename
);
509 rollback_lock_file(&msg_file
);
512 if (commit_lock_file(&msg_file
) < 0)
513 return error(_("failed to finalize '%s'"), filename
);
518 int read_oneliner(struct strbuf
*buf
,
519 const char *path
, unsigned flags
)
521 int orig_len
= buf
->len
;
523 if (strbuf_read_file(buf
, path
, 0) < 0) {
524 if ((flags
& READ_ONELINER_WARN_MISSING
) ||
525 (errno
!= ENOENT
&& errno
!= ENOTDIR
))
526 warning_errno(_("could not read '%s'"), path
);
530 if (buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\n') {
531 if (--buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\r')
533 buf
->buf
[buf
->len
] = '\0';
536 if ((flags
& READ_ONELINER_SKIP_IF_EMPTY
) && buf
->len
== orig_len
)
542 static struct tree
*empty_tree(struct repository
*r
)
544 return lookup_tree(r
, the_hash_algo
->empty_tree
);
547 static int error_dirty_index(struct repository
*repo
, struct replay_opts
*opts
)
549 if (repo_read_index_unmerged(repo
))
550 return error_resolve_conflict(action_name(opts
));
552 error(_("your local changes would be overwritten by %s."),
553 _(action_name(opts
)));
555 if (advice_enabled(ADVICE_COMMIT_BEFORE_MERGE
))
556 advise(_("commit your changes or stash them to proceed."));
560 static void update_abort_safety_file(void)
562 struct object_id head
;
564 /* Do nothing on a single-pick */
565 if (!file_exists(git_path_seq_dir()))
568 if (!repo_get_oid(the_repository
, "HEAD", &head
))
569 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head
));
571 write_file(git_path_abort_safety_file(), "%s", "");
574 static int fast_forward_to(struct repository
*r
,
575 const struct object_id
*to
,
576 const struct object_id
*from
,
578 struct replay_opts
*opts
)
580 struct ref_transaction
*transaction
;
581 struct strbuf sb
= STRBUF_INIT
;
582 struct strbuf err
= STRBUF_INIT
;
585 if (checkout_fast_forward(r
, from
, to
, 1))
586 return -1; /* the callee should have complained already */
588 strbuf_addf(&sb
, "%s: fast-forward", action_name(opts
));
590 transaction
= ref_transaction_begin(&err
);
592 ref_transaction_update(transaction
, "HEAD",
593 to
, unborn
&& !is_rebase_i(opts
) ?
596 ref_transaction_commit(transaction
, &err
)) {
597 ref_transaction_free(transaction
);
598 error("%s", err
.buf
);
600 strbuf_release(&err
);
605 strbuf_release(&err
);
606 ref_transaction_free(transaction
);
607 update_abort_safety_file();
611 enum commit_msg_cleanup_mode
get_cleanup_mode(const char *cleanup_arg
,
614 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
615 return use_editor
? COMMIT_MSG_CLEANUP_ALL
:
616 COMMIT_MSG_CLEANUP_SPACE
;
617 else if (!strcmp(cleanup_arg
, "verbatim"))
618 return COMMIT_MSG_CLEANUP_NONE
;
619 else if (!strcmp(cleanup_arg
, "whitespace"))
620 return COMMIT_MSG_CLEANUP_SPACE
;
621 else if (!strcmp(cleanup_arg
, "strip"))
622 return COMMIT_MSG_CLEANUP_ALL
;
623 else if (!strcmp(cleanup_arg
, "scissors"))
624 return use_editor
? COMMIT_MSG_CLEANUP_SCISSORS
:
625 COMMIT_MSG_CLEANUP_SPACE
;
627 die(_("Invalid cleanup mode %s"), cleanup_arg
);
631 * NB using int rather than enum cleanup_mode to stop clang's
632 * -Wtautological-constant-out-of-range-compare complaining that the comparison
635 static const char *describe_cleanup_mode(int cleanup_mode
)
637 static const char *modes
[] = { "whitespace",
642 if (cleanup_mode
< ARRAY_SIZE(modes
))
643 return modes
[cleanup_mode
];
645 BUG("invalid cleanup_mode provided (%d)", cleanup_mode
);
648 void append_conflicts_hint(struct index_state
*istate
,
649 struct strbuf
*msgbuf
, enum commit_msg_cleanup_mode cleanup_mode
)
653 if (cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
) {
654 strbuf_addch(msgbuf
, '\n');
655 wt_status_append_cut_line(msgbuf
);
656 strbuf_addch(msgbuf
, comment_line_char
);
659 strbuf_addch(msgbuf
, '\n');
660 strbuf_commented_addf(msgbuf
, "Conflicts:\n");
661 for (i
= 0; i
< istate
->cache_nr
;) {
662 const struct cache_entry
*ce
= istate
->cache
[i
++];
664 strbuf_commented_addf(msgbuf
, "\t%s\n", ce
->name
);
665 while (i
< istate
->cache_nr
&&
666 !strcmp(ce
->name
, istate
->cache
[i
]->name
))
672 static int do_recursive_merge(struct repository
*r
,
673 struct commit
*base
, struct commit
*next
,
674 const char *base_label
, const char *next_label
,
675 struct object_id
*head
, struct strbuf
*msgbuf
,
676 struct replay_opts
*opts
)
678 struct merge_options o
;
679 struct merge_result result
;
680 struct tree
*next_tree
, *base_tree
, *head_tree
;
681 int clean
, show_output
;
683 struct lock_file index_lock
= LOCK_INIT
;
685 if (repo_hold_locked_index(r
, &index_lock
, LOCK_REPORT_ON_ERROR
) < 0)
690 init_merge_options(&o
, r
);
691 o
.ancestor
= base
? base_label
: "(empty tree)";
693 o
.branch2
= next
? next_label
: "(empty tree)";
694 if (is_rebase_i(opts
))
696 o
.show_rename_progress
= 1;
698 head_tree
= parse_tree_indirect(head
);
699 next_tree
= next
? repo_get_commit_tree(r
, next
) : empty_tree(r
);
700 base_tree
= base
? repo_get_commit_tree(r
, base
) : empty_tree(r
);
702 for (i
= 0; i
< opts
->xopts_nr
; i
++)
703 parse_merge_opt(&o
, opts
->xopts
[i
]);
705 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
706 memset(&result
, 0, sizeof(result
));
707 merge_incore_nonrecursive(&o
, base_tree
, head_tree
, next_tree
,
709 show_output
= !is_rebase_i(opts
) || !result
.clean
;
711 * TODO: merge_switch_to_result will update index/working tree;
712 * we only really want to do that if !result.clean || this is
713 * the final patch to be picked. But determining this is the
714 * final patch would take some work, and "head_tree" would need
715 * to be replace with the tree the index matched before we
716 * started doing any picks.
718 merge_switch_to_result(&o
, head_tree
, &result
, 1, show_output
);
719 clean
= result
.clean
;
721 ensure_full_index(r
->index
);
722 clean
= merge_trees(&o
, head_tree
, next_tree
, base_tree
);
723 if (is_rebase_i(opts
) && clean
<= 0)
724 fputs(o
.obuf
.buf
, stdout
);
725 strbuf_release(&o
.obuf
);
728 rollback_lock_file(&index_lock
);
732 if (write_locked_index(r
->index
, &index_lock
,
733 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
735 * TRANSLATORS: %s will be "revert", "cherry-pick" or
738 return error(_("%s: Unable to write new index file"),
739 _(action_name(opts
)));
742 append_conflicts_hint(r
->index
, msgbuf
,
743 opts
->default_msg_cleanup
);
748 static struct object_id
*get_cache_tree_oid(struct index_state
*istate
)
750 if (!cache_tree_fully_valid(istate
->cache_tree
))
751 if (cache_tree_update(istate
, 0)) {
752 error(_("unable to update cache tree"));
756 return &istate
->cache_tree
->oid
;
759 static int is_index_unchanged(struct repository
*r
)
761 struct object_id head_oid
, *cache_tree_oid
;
762 struct commit
*head_commit
;
763 struct index_state
*istate
= r
->index
;
765 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
766 return error(_("could not resolve HEAD commit"));
768 head_commit
= lookup_commit(r
, &head_oid
);
771 * If head_commit is NULL, check_commit, called from
772 * lookup_commit, would have indicated that head_commit is not
773 * a commit object already. repo_parse_commit() will return failure
774 * without further complaints in such a case. Otherwise, if
775 * the commit is invalid, repo_parse_commit() will complain. So
776 * there is nothing for us to say here. Just return failure.
778 if (repo_parse_commit(r
, head_commit
))
781 if (!(cache_tree_oid
= get_cache_tree_oid(istate
)))
784 return oideq(cache_tree_oid
, get_commit_tree_oid(head_commit
));
787 static int write_author_script(const char *message
)
789 struct strbuf buf
= STRBUF_INIT
;
794 if (!*message
|| starts_with(message
, "\n")) {
796 /* Missing 'author' line? */
797 unlink(rebase_path_author_script());
799 } else if (skip_prefix(message
, "author ", &message
))
801 else if ((eol
= strchr(message
, '\n')))
806 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
807 while (*message
&& *message
!= '\n' && *message
!= '\r')
808 if (skip_prefix(message
, " <", &message
))
810 else if (*message
!= '\'')
811 strbuf_addch(&buf
, *(message
++));
813 strbuf_addf(&buf
, "'\\%c'", *(message
++));
814 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
815 while (*message
&& *message
!= '\n' && *message
!= '\r')
816 if (skip_prefix(message
, "> ", &message
))
818 else if (*message
!= '\'')
819 strbuf_addch(&buf
, *(message
++));
821 strbuf_addf(&buf
, "'\\%c'", *(message
++));
822 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
823 while (*message
&& *message
!= '\n' && *message
!= '\r')
824 if (*message
!= '\'')
825 strbuf_addch(&buf
, *(message
++));
827 strbuf_addf(&buf
, "'\\%c'", *(message
++));
828 strbuf_addch(&buf
, '\'');
829 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
830 strbuf_release(&buf
);
835 * Take a series of KEY='VALUE' lines where VALUE part is
836 * sq-quoted, and append <KEY, VALUE> at the end of the string list
838 static int parse_key_value_squoted(char *buf
, struct string_list
*list
)
841 struct string_list_item
*item
;
843 char *cp
= strchr(buf
, '=');
845 np
= strchrnul(buf
, '\n');
846 return error(_("no key present in '%.*s'"),
847 (int) (np
- buf
), buf
);
849 np
= strchrnul(cp
, '\n');
851 item
= string_list_append(list
, buf
);
853 buf
= np
+ (*np
== '\n');
857 return error(_("unable to dequote value of '%s'"),
859 item
->util
= xstrdup(cp
);
865 * Reads and parses the state directory's "author-script" file, and sets name,
866 * email and date accordingly.
867 * Returns 0 on success, -1 if the file could not be parsed.
869 * The author script is of the format:
871 * GIT_AUTHOR_NAME='$author_name'
872 * GIT_AUTHOR_EMAIL='$author_email'
873 * GIT_AUTHOR_DATE='$author_date'
875 * where $author_name, $author_email and $author_date are quoted. We are strict
876 * with our parsing, as the file was meant to be eval'd in the now-removed
877 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
878 * from what this function expects, it is better to bail out than to do
879 * something that the user does not expect.
881 int read_author_script(const char *path
, char **name
, char **email
, char **date
,
884 struct strbuf buf
= STRBUF_INIT
;
885 struct string_list kv
= STRING_LIST_INIT_DUP
;
886 int retval
= -1; /* assume failure */
887 int i
, name_i
= -2, email_i
= -2, date_i
= -2, err
= 0;
889 if (strbuf_read_file(&buf
, path
, 256) <= 0) {
890 strbuf_release(&buf
);
891 if (errno
== ENOENT
&& allow_missing
)
894 return error_errno(_("could not open '%s' for reading"),
898 if (parse_key_value_squoted(buf
.buf
, &kv
))
901 for (i
= 0; i
< kv
.nr
; i
++) {
902 if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_NAME")) {
904 name_i
= error(_("'GIT_AUTHOR_NAME' already given"));
907 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_EMAIL")) {
909 email_i
= error(_("'GIT_AUTHOR_EMAIL' already given"));
912 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_DATE")) {
914 date_i
= error(_("'GIT_AUTHOR_DATE' already given"));
918 err
= error(_("unknown variable '%s'"),
923 error(_("missing 'GIT_AUTHOR_NAME'"));
925 error(_("missing 'GIT_AUTHOR_EMAIL'"));
927 error(_("missing 'GIT_AUTHOR_DATE'"));
928 if (name_i
< 0 || email_i
< 0 || date_i
< 0 || err
)
930 *name
= kv
.items
[name_i
].util
;
931 *email
= kv
.items
[email_i
].util
;
932 *date
= kv
.items
[date_i
].util
;
935 string_list_clear(&kv
, !!retval
);
936 strbuf_release(&buf
);
941 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
942 * file with shell quoting into struct strvec. Returns -1 on
943 * error, 0 otherwise.
945 static int read_env_script(struct strvec
*env
)
947 char *name
, *email
, *date
;
949 if (read_author_script(rebase_path_author_script(),
950 &name
, &email
, &date
, 0))
953 strvec_pushf(env
, "GIT_AUTHOR_NAME=%s", name
);
954 strvec_pushf(env
, "GIT_AUTHOR_EMAIL=%s", email
);
955 strvec_pushf(env
, "GIT_AUTHOR_DATE=%s", date
);
963 static char *get_author(const char *message
)
968 a
= find_commit_header(message
, "author", &len
);
970 return xmemdupz(a
, len
);
975 static const char *author_date_from_env(const struct strvec
*env
)
980 for (i
= 0; i
< env
->nr
; i
++)
981 if (skip_prefix(env
->v
[i
],
982 "GIT_AUTHOR_DATE=", &date
))
985 * If GIT_AUTHOR_DATE is missing we should have already errored out when
988 BUG("GIT_AUTHOR_DATE missing from author script");
991 static const char staged_changes_advice
[] =
992 N_("you have staged changes in your working tree\n"
993 "If these changes are meant to be squashed into the previous commit, run:\n"
995 " git commit --amend %s\n"
997 "If they are meant to go into a new commit, run:\n"
1001 "In both cases, once you're done, continue with:\n"
1003 " git rebase --continue\n");
1005 #define ALLOW_EMPTY (1<<0)
1006 #define EDIT_MSG (1<<1)
1007 #define AMEND_MSG (1<<2)
1008 #define CLEANUP_MSG (1<<3)
1009 #define VERIFY_MSG (1<<4)
1010 #define CREATE_ROOT_COMMIT (1<<5)
1011 #define VERBATIM_MSG (1<<6)
1013 static int run_command_silent_on_success(struct child_process
*cmd
)
1015 struct strbuf buf
= STRBUF_INIT
;
1018 cmd
->stdout_to_stderr
= 1;
1019 rc
= pipe_command(cmd
,
1025 fputs(buf
.buf
, stderr
);
1026 strbuf_release(&buf
);
1031 * If we are cherry-pick, and if the merge did not result in
1032 * hand-editing, we will hit this commit and inherit the original
1033 * author date and name.
1035 * If we are revert, or if our cherry-pick results in a hand merge,
1036 * we had better say that the current user is responsible for that.
1038 * An exception is when run_git_commit() is called during an
1039 * interactive rebase: in that case, we will want to retain the
1042 static int run_git_commit(const char *defmsg
,
1043 struct replay_opts
*opts
,
1046 struct child_process cmd
= CHILD_PROCESS_INIT
;
1048 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1049 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1053 if (is_rebase_i(opts
) &&
1054 ((opts
->committer_date_is_author_date
&& !opts
->ignore_date
) ||
1055 !(!defmsg
&& (flags
& AMEND_MSG
))) &&
1056 read_env_script(&cmd
.env
)) {
1057 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
1059 return error(_(staged_changes_advice
),
1063 strvec_pushf(&cmd
.env
, GIT_REFLOG_ACTION
"=%s", opts
->reflog_message
);
1065 if (opts
->committer_date_is_author_date
)
1066 strvec_pushf(&cmd
.env
, "GIT_COMMITTER_DATE=%s",
1069 author_date_from_env(&cmd
.env
));
1070 if (opts
->ignore_date
)
1071 strvec_push(&cmd
.env
, "GIT_AUTHOR_DATE=");
1073 strvec_push(&cmd
.args
, "commit");
1075 if (!(flags
& VERIFY_MSG
))
1076 strvec_push(&cmd
.args
, "-n");
1077 if ((flags
& AMEND_MSG
))
1078 strvec_push(&cmd
.args
, "--amend");
1080 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
1082 strvec_push(&cmd
.args
, "--no-gpg-sign");
1084 strvec_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
1085 else if (!(flags
& EDIT_MSG
))
1086 strvec_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
1087 if ((flags
& CLEANUP_MSG
))
1088 strvec_push(&cmd
.args
, "--cleanup=strip");
1089 if ((flags
& VERBATIM_MSG
))
1090 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1091 if ((flags
& EDIT_MSG
))
1092 strvec_push(&cmd
.args
, "-e");
1093 else if (!(flags
& CLEANUP_MSG
) &&
1094 !opts
->signoff
&& !opts
->record_origin
&&
1095 !opts
->explicit_cleanup
)
1096 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1098 if ((flags
& ALLOW_EMPTY
))
1099 strvec_push(&cmd
.args
, "--allow-empty");
1101 if (!(flags
& EDIT_MSG
))
1102 strvec_push(&cmd
.args
, "--allow-empty-message");
1104 if (is_rebase_i(opts
) && !(flags
& EDIT_MSG
))
1105 return run_command_silent_on_success(&cmd
);
1107 return run_command(&cmd
);
1110 static int rest_is_empty(const struct strbuf
*sb
, int start
)
1115 /* Check if the rest is just whitespace and Signed-off-by's. */
1116 for (i
= start
; i
< sb
->len
; i
++) {
1117 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1123 if (strlen(sign_off_header
) <= eol
- i
&&
1124 starts_with(sb
->buf
+ i
, sign_off_header
)) {
1129 if (!isspace(sb
->buf
[i
++]))
1136 void cleanup_message(struct strbuf
*msgbuf
,
1137 enum commit_msg_cleanup_mode cleanup_mode
, int verbose
)
1139 if (verbose
|| /* Truncate the message just before the diff, if any. */
1140 cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
1141 strbuf_setlen(msgbuf
, wt_status_locate_end(msgbuf
->buf
, msgbuf
->len
));
1142 if (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
)
1143 strbuf_stripspace(msgbuf
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1147 * Find out if the message in the strbuf contains only whitespace and
1148 * Signed-off-by lines.
1150 int message_is_empty(const struct strbuf
*sb
,
1151 enum commit_msg_cleanup_mode cleanup_mode
)
1153 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1155 return rest_is_empty(sb
, 0);
1159 * See if the user edited the message in the editor or left what
1160 * was in the template intact
1162 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
1163 enum commit_msg_cleanup_mode cleanup_mode
)
1165 struct strbuf tmpl
= STRBUF_INIT
;
1168 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1171 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
1174 strbuf_stripspace(&tmpl
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1175 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
1177 strbuf_release(&tmpl
);
1178 return rest_is_empty(sb
, start
- sb
->buf
);
1181 int update_head_with_reflog(const struct commit
*old_head
,
1182 const struct object_id
*new_head
,
1183 const char *action
, const struct strbuf
*msg
,
1186 struct ref_transaction
*transaction
;
1187 struct strbuf sb
= STRBUF_INIT
;
1192 strbuf_addstr(&sb
, action
);
1193 strbuf_addstr(&sb
, ": ");
1196 nl
= strchr(msg
->buf
, '\n');
1198 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
1200 strbuf_addbuf(&sb
, msg
);
1201 strbuf_addch(&sb
, '\n');
1204 transaction
= ref_transaction_begin(err
);
1206 ref_transaction_update(transaction
, "HEAD", new_head
,
1207 old_head
? &old_head
->object
.oid
: null_oid(),
1209 ref_transaction_commit(transaction
, err
)) {
1212 ref_transaction_free(transaction
);
1213 strbuf_release(&sb
);
1218 static int run_rewrite_hook(const struct object_id
*oldoid
,
1219 const struct object_id
*newoid
)
1221 struct child_process proc
= CHILD_PROCESS_INIT
;
1223 struct strbuf sb
= STRBUF_INIT
;
1224 const char *hook_path
= find_hook("post-rewrite");
1229 strvec_pushl(&proc
.args
, hook_path
, "amend", NULL
);
1231 proc
.stdout_to_stderr
= 1;
1232 proc
.trace2_hook_name
= "post-rewrite";
1234 code
= start_command(&proc
);
1237 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
1238 sigchain_push(SIGPIPE
, SIG_IGN
);
1239 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
1241 strbuf_release(&sb
);
1242 sigchain_pop(SIGPIPE
);
1243 return finish_command(&proc
);
1246 void commit_post_rewrite(struct repository
*r
,
1247 const struct commit
*old_head
,
1248 const struct object_id
*new_head
)
1250 struct notes_rewrite_cfg
*cfg
;
1252 cfg
= init_copy_notes_for_rewrite("amend");
1254 /* we are amending, so old_head is not NULL */
1255 copy_note_for_rewrite(cfg
, &old_head
->object
.oid
, new_head
);
1256 finish_copy_notes_for_rewrite(r
, cfg
, "Notes added by 'git commit --amend'");
1258 run_rewrite_hook(&old_head
->object
.oid
, new_head
);
1261 static int run_prepare_commit_msg_hook(struct repository
*r
,
1266 const char *name
, *arg1
= NULL
, *arg2
= NULL
;
1268 name
= git_path_commit_editmsg();
1269 if (write_message(msg
->buf
, msg
->len
, name
, 0))
1278 if (run_commit_hook(0, r
->index_file
, NULL
, "prepare-commit-msg", name
,
1280 ret
= error(_("'prepare-commit-msg' hook failed"));
1285 static const char implicit_ident_advice_noconfig
[] =
1286 N_("Your name and email address were configured automatically based\n"
1287 "on your username and hostname. Please check that they are accurate.\n"
1288 "You can suppress this message by setting them explicitly. Run the\n"
1289 "following command and follow the instructions in your editor to edit\n"
1290 "your configuration file:\n"
1292 " git config --global --edit\n"
1294 "After doing this, you may fix the identity used for this commit with:\n"
1296 " git commit --amend --reset-author\n");
1298 static const char implicit_ident_advice_config
[] =
1299 N_("Your name and email address were configured automatically based\n"
1300 "on your username and hostname. Please check that they are accurate.\n"
1301 "You can suppress this message by setting them explicitly:\n"
1303 " git config --global user.name \"Your Name\"\n"
1304 " git config --global user.email you@example.com\n"
1306 "After doing this, you may fix the identity used for this commit with:\n"
1308 " git commit --amend --reset-author\n");
1310 static const char *implicit_ident_advice(void)
1312 char *user_config
= interpolate_path("~/.gitconfig", 0);
1313 char *xdg_config
= xdg_config_home("config");
1314 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1320 return _(implicit_ident_advice_config
);
1322 return _(implicit_ident_advice_noconfig
);
1326 void print_commit_summary(struct repository
*r
,
1328 const struct object_id
*oid
,
1331 struct rev_info rev
;
1332 struct commit
*commit
;
1333 struct strbuf format
= STRBUF_INIT
;
1335 struct pretty_print_context pctx
= {0};
1336 struct strbuf author_ident
= STRBUF_INIT
;
1337 struct strbuf committer_ident
= STRBUF_INIT
;
1338 struct ref_store
*refs
;
1340 commit
= lookup_commit(r
, oid
);
1342 die(_("couldn't look up newly created commit"));
1343 if (repo_parse_commit(r
, commit
))
1344 die(_("could not parse newly created commit"));
1346 strbuf_addstr(&format
, "format:%h] %s");
1348 repo_format_commit_message(r
, commit
, "%an <%ae>", &author_ident
,
1350 repo_format_commit_message(r
, commit
, "%cn <%ce>", &committer_ident
,
1352 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1353 strbuf_addstr(&format
, "\n Author: ");
1354 strbuf_addbuf_percentquote(&format
, &author_ident
);
1356 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
1357 struct strbuf date
= STRBUF_INIT
;
1359 repo_format_commit_message(r
, commit
, "%ad", &date
, &pctx
);
1360 strbuf_addstr(&format
, "\n Date: ");
1361 strbuf_addbuf_percentquote(&format
, &date
);
1362 strbuf_release(&date
);
1364 if (!committer_ident_sufficiently_given()) {
1365 strbuf_addstr(&format
, "\n Committer: ");
1366 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1367 if (advice_enabled(ADVICE_IMPLICIT_IDENTITY
)) {
1368 strbuf_addch(&format
, '\n');
1369 strbuf_addstr(&format
, implicit_ident_advice());
1372 strbuf_release(&author_ident
);
1373 strbuf_release(&committer_ident
);
1375 repo_init_revisions(r
, &rev
, prefix
);
1376 setup_revisions(0, NULL
, &rev
, NULL
);
1379 rev
.diffopt
.output_format
=
1380 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1382 rev
.verbose_header
= 1;
1383 rev
.show_root_diff
= 1;
1384 get_commit_format(format
.buf
, &rev
);
1385 rev
.always_show_header
= 0;
1386 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1387 diff_setup_done(&rev
.diffopt
);
1389 refs
= get_main_ref_store(r
);
1390 head
= refs_resolve_ref_unsafe(refs
, "HEAD", 0, NULL
, NULL
);
1392 die(_("unable to resolve HEAD after creating commit"));
1393 if (!strcmp(head
, "HEAD"))
1394 head
= _("detached HEAD");
1396 skip_prefix(head
, "refs/heads/", &head
);
1397 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1398 _(" (root-commit)") : "");
1400 if (!log_tree_commit(&rev
, commit
)) {
1401 rev
.always_show_header
= 1;
1402 rev
.use_terminator
= 1;
1403 log_tree_commit(&rev
, commit
);
1406 release_revisions(&rev
);
1407 strbuf_release(&format
);
1410 static int parse_head(struct repository
*r
, struct commit
**head
)
1412 struct commit
*current_head
;
1413 struct object_id oid
;
1415 if (repo_get_oid(r
, "HEAD", &oid
)) {
1416 current_head
= NULL
;
1418 current_head
= lookup_commit_reference(r
, &oid
);
1420 return error(_("could not parse HEAD"));
1421 if (!oideq(&oid
, ¤t_head
->object
.oid
)) {
1422 warning(_("HEAD %s is not a commit!"),
1425 if (repo_parse_commit(r
, current_head
))
1426 return error(_("could not parse HEAD commit"));
1428 *head
= current_head
;
1434 * Try to commit without forking 'git commit'. In some cases we need
1435 * to run 'git commit' to display an error message
1438 * -1 - error unable to commit
1440 * 1 - run 'git commit'
1442 static int try_to_commit(struct repository
*r
,
1443 struct strbuf
*msg
, const char *author
,
1444 struct replay_opts
*opts
, unsigned int flags
,
1445 struct object_id
*oid
)
1447 struct object_id tree
;
1448 struct commit
*current_head
= NULL
;
1449 struct commit_list
*parents
= NULL
;
1450 struct commit_extra_header
*extra
= NULL
;
1451 struct strbuf err
= STRBUF_INIT
;
1452 struct strbuf commit_msg
= STRBUF_INIT
;
1453 char *amend_author
= NULL
;
1454 const char *committer
= NULL
;
1455 const char *hook_commit
= NULL
;
1456 enum commit_msg_cleanup_mode cleanup
;
1459 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1460 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1462 if (parse_head(r
, ¤t_head
))
1465 if (flags
& AMEND_MSG
) {
1466 const char *exclude_gpgsig
[] = { "gpgsig", "gpgsig-sha256", NULL
};
1467 const char *out_enc
= get_commit_output_encoding();
1468 const char *message
= repo_logmsg_reencode(r
, current_head
,
1472 const char *orig_message
= NULL
;
1474 find_commit_subject(message
, &orig_message
);
1476 strbuf_addstr(msg
, orig_message
);
1477 hook_commit
= "HEAD";
1479 author
= amend_author
= get_author(message
);
1480 repo_unuse_commit_buffer(r
, current_head
,
1483 res
= error(_("unable to parse commit author"));
1486 parents
= copy_commit_list(current_head
->parents
);
1487 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1488 } else if (current_head
&&
1489 (!(flags
& CREATE_ROOT_COMMIT
) || (flags
& AMEND_MSG
))) {
1490 commit_list_insert(current_head
, &parents
);
1493 if (write_index_as_tree(&tree
, r
->index
, r
->index_file
, 0, NULL
)) {
1494 res
= error(_("git write-tree failed to write a tree"));
1498 if (!(flags
& ALLOW_EMPTY
)) {
1499 struct commit
*first_parent
= current_head
;
1501 if (flags
& AMEND_MSG
) {
1502 if (current_head
->parents
) {
1503 first_parent
= current_head
->parents
->item
;
1504 if (repo_parse_commit(r
, first_parent
)) {
1505 res
= error(_("could not parse HEAD commit"));
1509 first_parent
= NULL
;
1512 if (oideq(first_parent
1513 ? get_commit_tree_oid(first_parent
)
1514 : the_hash_algo
->empty_tree
,
1516 res
= 1; /* run 'git commit' to display error message */
1521 if (hook_exists("prepare-commit-msg")) {
1522 res
= run_prepare_commit_msg_hook(r
, msg
, hook_commit
);
1525 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1527 res
= error_errno(_("unable to read commit message "
1529 git_path_commit_editmsg());
1535 if (flags
& CLEANUP_MSG
)
1536 cleanup
= COMMIT_MSG_CLEANUP_ALL
;
1537 else if (flags
& VERBATIM_MSG
)
1538 cleanup
= COMMIT_MSG_CLEANUP_NONE
;
1539 else if ((opts
->signoff
|| opts
->record_origin
) &&
1540 !opts
->explicit_cleanup
)
1541 cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
1543 cleanup
= opts
->default_msg_cleanup
;
1545 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1546 strbuf_stripspace(msg
, cleanup
== COMMIT_MSG_CLEANUP_ALL
);
1547 if ((flags
& EDIT_MSG
) && message_is_empty(msg
, cleanup
)) {
1548 res
= 1; /* run 'git commit' to display error message */
1552 if (opts
->committer_date_is_author_date
) {
1553 struct ident_split id
;
1554 struct strbuf date
= STRBUF_INIT
;
1556 if (!opts
->ignore_date
) {
1557 if (split_ident_line(&id
, author
, (int)strlen(author
)) < 0) {
1558 res
= error(_("invalid author identity '%s'"),
1562 if (!id
.date_begin
) {
1564 "corrupt author: missing date information"));
1567 strbuf_addf(&date
, "@%.*s %.*s",
1568 (int)(id
.date_end
- id
.date_begin
),
1570 (int)(id
.tz_end
- id
.tz_begin
),
1575 committer
= fmt_ident(getenv("GIT_COMMITTER_NAME"),
1576 getenv("GIT_COMMITTER_EMAIL"),
1577 WANT_COMMITTER_IDENT
,
1578 opts
->ignore_date
? NULL
: date
.buf
,
1580 strbuf_release(&date
);
1585 if (opts
->ignore_date
) {
1586 struct ident_split id
;
1589 if (split_ident_line(&id
, author
, strlen(author
)) < 0) {
1590 error(_("invalid author identity '%s'"), author
);
1593 name
= xmemdupz(id
.name_begin
, id
.name_end
- id
.name_begin
);
1594 email
= xmemdupz(id
.mail_begin
, id
.mail_end
- id
.mail_begin
);
1595 author
= fmt_ident(name
, email
, WANT_AUTHOR_IDENT
, NULL
,
1601 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
, oid
,
1602 author
, committer
, opts
->gpg_sign
, extra
)) {
1603 res
= error(_("failed to write commit object"));
1607 if (update_head_with_reflog(current_head
, oid
, opts
->reflog_message
,
1609 res
= error("%s", err
.buf
);
1613 run_commit_hook(0, r
->index_file
, NULL
, "post-commit", NULL
);
1614 if (flags
& AMEND_MSG
)
1615 commit_post_rewrite(r
, current_head
, oid
);
1618 free_commit_extra_headers(extra
);
1619 strbuf_release(&err
);
1620 strbuf_release(&commit_msg
);
1626 static int write_rebase_head(struct object_id
*oid
)
1628 if (update_ref("rebase", "REBASE_HEAD", oid
,
1629 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1630 return error(_("could not update %s"), "REBASE_HEAD");
1635 static int do_commit(struct repository
*r
,
1636 const char *msg_file
, const char *author
,
1637 struct replay_opts
*opts
, unsigned int flags
,
1638 struct object_id
*oid
)
1642 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
)) {
1643 struct object_id oid
;
1644 struct strbuf sb
= STRBUF_INIT
;
1646 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1647 return error_errno(_("unable to read commit message "
1651 res
= try_to_commit(r
, msg_file
? &sb
: NULL
,
1652 author
, opts
, flags
, &oid
);
1653 strbuf_release(&sb
);
1655 refs_delete_ref(get_main_ref_store(r
), "",
1656 "CHERRY_PICK_HEAD", NULL
, 0);
1657 unlink(git_path_merge_msg(r
));
1658 if (!is_rebase_i(opts
))
1659 print_commit_summary(r
, NULL
, &oid
,
1660 SUMMARY_SHOW_AUTHOR_DATE
);
1665 if (is_rebase_i(opts
) && oid
)
1666 if (write_rebase_head(oid
))
1668 return run_git_commit(msg_file
, opts
, flags
);
1674 static int is_original_commit_empty(struct commit
*commit
)
1676 const struct object_id
*ptree_oid
;
1678 if (repo_parse_commit(the_repository
, commit
))
1679 return error(_("could not parse commit %s"),
1680 oid_to_hex(&commit
->object
.oid
));
1681 if (commit
->parents
) {
1682 struct commit
*parent
= commit
->parents
->item
;
1683 if (repo_parse_commit(the_repository
, parent
))
1684 return error(_("could not parse parent commit %s"),
1685 oid_to_hex(&parent
->object
.oid
));
1686 ptree_oid
= get_commit_tree_oid(parent
);
1688 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1691 return oideq(ptree_oid
, get_commit_tree_oid(commit
));
1695 * Should empty commits be allowed? Return status:
1696 * <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1697 * 0: Halt on empty commit
1698 * 1: Allow empty commit
1699 * 2: Drop empty commit
1701 static int allow_empty(struct repository
*r
,
1702 struct replay_opts
*opts
,
1703 struct commit
*commit
)
1705 int index_unchanged
, originally_empty
;
1710 * (1) we do not allow empty at all and error out.
1712 * (2) we allow ones that were initially empty, and
1713 * just drop the ones that become empty
1715 * (3) we allow ones that were initially empty, but
1716 * halt for the ones that become empty;
1718 * (4) we allow both.
1720 if (!opts
->allow_empty
)
1721 return 0; /* let "git commit" barf as necessary */
1723 index_unchanged
= is_index_unchanged(r
);
1724 if (index_unchanged
< 0)
1725 return index_unchanged
;
1726 if (!index_unchanged
)
1727 return 0; /* we do not have to say --allow-empty */
1729 if (opts
->keep_redundant_commits
)
1732 originally_empty
= is_original_commit_empty(commit
);
1733 if (originally_empty
< 0)
1734 return originally_empty
;
1735 if (originally_empty
)
1737 else if (opts
->drop_redundant_commits
)
1746 } todo_command_info
[] = {
1747 [TODO_PICK
] = { 'p', "pick" },
1748 [TODO_REVERT
] = { 0, "revert" },
1749 [TODO_EDIT
] = { 'e', "edit" },
1750 [TODO_REWORD
] = { 'r', "reword" },
1751 [TODO_FIXUP
] = { 'f', "fixup" },
1752 [TODO_SQUASH
] = { 's', "squash" },
1753 [TODO_EXEC
] = { 'x', "exec" },
1754 [TODO_BREAK
] = { 'b', "break" },
1755 [TODO_LABEL
] = { 'l', "label" },
1756 [TODO_RESET
] = { 't', "reset" },
1757 [TODO_MERGE
] = { 'm', "merge" },
1758 [TODO_UPDATE_REF
] = { 'u', "update-ref" },
1759 [TODO_NOOP
] = { 0, "noop" },
1760 [TODO_DROP
] = { 'd', "drop" },
1761 [TODO_COMMENT
] = { 0, NULL
},
1764 static const char *command_to_string(const enum todo_command command
)
1766 if (command
< TODO_COMMENT
)
1767 return todo_command_info
[command
].str
;
1768 die(_("unknown command: %d"), command
);
1771 static char command_to_char(const enum todo_command command
)
1773 if (command
< TODO_COMMENT
)
1774 return todo_command_info
[command
].c
;
1775 return comment_line_char
;
1778 static int is_noop(const enum todo_command command
)
1780 return TODO_NOOP
<= command
;
1783 static int is_fixup(enum todo_command command
)
1785 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1788 /* Does this command create a (non-merge) commit? */
1789 static int is_pick_or_similar(enum todo_command command
)
1804 enum todo_item_flags
{
1805 TODO_EDIT_MERGE_MSG
= (1 << 0),
1806 TODO_REPLACE_FIXUP_MSG
= (1 << 1),
1807 TODO_EDIT_FIXUP_MSG
= (1 << 2),
1810 static const char first_commit_msg_str
[] = N_("This is the 1st commit message:");
1811 static const char nth_commit_msg_fmt
[] = N_("This is the commit message #%d:");
1812 static const char skip_first_commit_msg_str
[] = N_("The 1st commit message will be skipped:");
1813 static const char skip_nth_commit_msg_fmt
[] = N_("The commit message #%d will be skipped:");
1814 static const char combined_commit_msg_fmt
[] = N_("This is a combination of %d commits.");
1816 static int is_fixup_flag(enum todo_command command
, unsigned flag
)
1818 return command
== TODO_FIXUP
&& ((flag
& TODO_REPLACE_FIXUP_MSG
) ||
1819 (flag
& TODO_EDIT_FIXUP_MSG
));
1823 * Wrapper around strbuf_add_commented_lines() which avoids double
1824 * commenting commit subjects.
1826 static void add_commented_lines(struct strbuf
*buf
, const void *str
, size_t len
)
1828 const char *s
= str
;
1829 while (len
> 0 && s
[0] == comment_line_char
) {
1831 const char *n
= memchr(s
, '\n', len
);
1836 strbuf_add(buf
, s
, count
);
1840 strbuf_add_commented_lines(buf
, s
, len
);
1843 /* Does the current fixup chain contain a squash command? */
1844 static int seen_squash(struct replay_opts
*opts
)
1846 return starts_with(opts
->current_fixups
.buf
, "squash") ||
1847 strstr(opts
->current_fixups
.buf
, "\nsquash");
1850 static void update_comment_bufs(struct strbuf
*buf1
, struct strbuf
*buf2
, int n
)
1852 strbuf_setlen(buf1
, 2);
1853 strbuf_addf(buf1
, _(nth_commit_msg_fmt
), n
);
1854 strbuf_addch(buf1
, '\n');
1855 strbuf_setlen(buf2
, 2);
1856 strbuf_addf(buf2
, _(skip_nth_commit_msg_fmt
), n
);
1857 strbuf_addch(buf2
, '\n');
1861 * Comment out any un-commented commit messages, updating the message comments
1862 * to say they will be skipped but do not comment out the empty lines that
1863 * surround commit messages and their comments.
1865 static void update_squash_message_for_fixup(struct strbuf
*msg
)
1867 void (*copy_lines
)(struct strbuf
*, const void *, size_t) = strbuf_add
;
1868 struct strbuf buf1
= STRBUF_INIT
, buf2
= STRBUF_INIT
;
1869 const char *s
, *start
;
1871 size_t orig_msg_len
;
1874 strbuf_addf(&buf1
, "# %s\n", _(first_commit_msg_str
));
1875 strbuf_addf(&buf2
, "# %s\n", _(skip_first_commit_msg_str
));
1876 s
= start
= orig_msg
= strbuf_detach(msg
, &orig_msg_len
);
1880 if (skip_prefix(s
, buf1
.buf
, &next
)) {
1882 * Copy the last message, preserving the blank line
1883 * preceding the current line
1885 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1886 copy_lines(msg
, start
, s
- start
- off
);
1888 strbuf_addch(msg
, '\n');
1890 * The next message needs to be commented out but the
1891 * message header is already commented out so just copy
1892 * it and the blank line that follows it.
1894 strbuf_addbuf(msg
, &buf2
);
1896 strbuf_addch(msg
, *next
++);
1898 copy_lines
= add_commented_lines
;
1899 update_comment_bufs(&buf1
, &buf2
, ++i
);
1900 } else if (skip_prefix(s
, buf2
.buf
, &next
)) {
1901 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1902 copy_lines(msg
, start
, s
- start
- off
);
1905 copy_lines
= strbuf_add
;
1906 update_comment_bufs(&buf1
, &buf2
, ++i
);
1908 s
= strchr(s
, '\n');
1913 copy_lines(msg
, start
, orig_msg_len
- (start
- orig_msg
));
1915 strbuf_release(&buf1
);
1916 strbuf_release(&buf2
);
1919 static int append_squash_message(struct strbuf
*buf
, const char *body
,
1920 enum todo_command command
, struct replay_opts
*opts
,
1923 const char *fixup_msg
;
1924 size_t commented_len
= 0, fixup_off
;
1926 * amend is non-interactive and not normally used with fixup!
1927 * or squash! commits, so only comment out those subjects when
1928 * squashing commit messages.
1930 if (starts_with(body
, "amend!") ||
1931 ((command
== TODO_SQUASH
|| seen_squash(opts
)) &&
1932 (starts_with(body
, "squash!") || starts_with(body
, "fixup!"))))
1933 commented_len
= commit_subject_length(body
);
1935 strbuf_addf(buf
, "\n%c ", comment_line_char
);
1936 strbuf_addf(buf
, _(nth_commit_msg_fmt
),
1937 ++opts
->current_fixup_count
+ 1);
1938 strbuf_addstr(buf
, "\n\n");
1939 strbuf_add_commented_lines(buf
, body
, commented_len
);
1940 /* buf->buf may be reallocated so store an offset into the buffer */
1941 fixup_off
= buf
->len
;
1942 strbuf_addstr(buf
, body
+ commented_len
);
1944 /* fixup -C after squash behaves like squash */
1945 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
)) {
1947 * We're replacing the commit message so we need to
1948 * append the Signed-off-by: trailer if the user
1949 * requested '--signoff'.
1952 append_signoff(buf
, 0, 0);
1954 if ((command
== TODO_FIXUP
) &&
1955 (flag
& TODO_REPLACE_FIXUP_MSG
) &&
1956 (file_exists(rebase_path_fixup_msg()) ||
1957 !file_exists(rebase_path_squash_msg()))) {
1958 fixup_msg
= skip_blank_lines(buf
->buf
+ fixup_off
);
1959 if (write_message(fixup_msg
, strlen(fixup_msg
),
1960 rebase_path_fixup_msg(), 0) < 0)
1961 return error(_("cannot write '%s'"),
1962 rebase_path_fixup_msg());
1964 unlink(rebase_path_fixup_msg());
1967 unlink(rebase_path_fixup_msg());
1973 static int update_squash_messages(struct repository
*r
,
1974 enum todo_command command
,
1975 struct commit
*commit
,
1976 struct replay_opts
*opts
,
1979 struct strbuf buf
= STRBUF_INIT
;
1981 const char *message
, *body
;
1982 const char *encoding
= get_commit_output_encoding();
1984 if (opts
->current_fixup_count
> 0) {
1985 struct strbuf header
= STRBUF_INIT
;
1988 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
1989 return error(_("could not read '%s'"),
1990 rebase_path_squash_msg());
1992 eol
= buf
.buf
[0] != comment_line_char
?
1993 buf
.buf
: strchrnul(buf
.buf
, '\n');
1995 strbuf_addf(&header
, "%c ", comment_line_char
);
1996 strbuf_addf(&header
, _(combined_commit_msg_fmt
),
1997 opts
->current_fixup_count
+ 2);
1998 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
1999 strbuf_release(&header
);
2000 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
))
2001 update_squash_message_for_fixup(&buf
);
2003 struct object_id head
;
2004 struct commit
*head_commit
;
2005 const char *head_message
, *body
;
2007 if (repo_get_oid(r
, "HEAD", &head
))
2008 return error(_("need a HEAD to fixup"));
2009 if (!(head_commit
= lookup_commit_reference(r
, &head
)))
2010 return error(_("could not read HEAD"));
2011 if (!(head_message
= repo_logmsg_reencode(r
, head_commit
, NULL
,
2013 return error(_("could not read HEAD's commit message"));
2015 find_commit_subject(head_message
, &body
);
2016 if (command
== TODO_FIXUP
&& !flag
&& write_message(body
, strlen(body
),
2017 rebase_path_fixup_msg(), 0) < 0) {
2018 repo_unuse_commit_buffer(r
, head_commit
, head_message
);
2019 return error(_("cannot write '%s'"), rebase_path_fixup_msg());
2021 strbuf_addf(&buf
, "%c ", comment_line_char
);
2022 strbuf_addf(&buf
, _(combined_commit_msg_fmt
), 2);
2023 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
2024 strbuf_addstr(&buf
, is_fixup_flag(command
, flag
) ?
2025 _(skip_first_commit_msg_str
) :
2026 _(first_commit_msg_str
));
2027 strbuf_addstr(&buf
, "\n\n");
2028 if (is_fixup_flag(command
, flag
))
2029 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
2031 strbuf_addstr(&buf
, body
);
2033 repo_unuse_commit_buffer(r
, head_commit
, head_message
);
2036 if (!(message
= repo_logmsg_reencode(r
, commit
, NULL
, encoding
)))
2037 return error(_("could not read commit message of %s"),
2038 oid_to_hex(&commit
->object
.oid
));
2039 find_commit_subject(message
, &body
);
2041 if (command
== TODO_SQUASH
|| is_fixup_flag(command
, flag
)) {
2042 res
= append_squash_message(&buf
, body
, command
, opts
, flag
);
2043 } else if (command
== TODO_FIXUP
) {
2044 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
2045 strbuf_addf(&buf
, _(skip_nth_commit_msg_fmt
),
2046 ++opts
->current_fixup_count
+ 1);
2047 strbuf_addstr(&buf
, "\n\n");
2048 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
2050 return error(_("unknown command: %d"), command
);
2051 repo_unuse_commit_buffer(r
, commit
, message
);
2054 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(),
2056 strbuf_release(&buf
);
2059 strbuf_addf(&opts
->current_fixups
, "%s%s %s",
2060 opts
->current_fixups
.len
? "\n" : "",
2061 command_to_string(command
),
2062 oid_to_hex(&commit
->object
.oid
));
2063 res
= write_message(opts
->current_fixups
.buf
,
2064 opts
->current_fixups
.len
,
2065 rebase_path_current_fixups(), 0);
2071 static void flush_rewritten_pending(void)
2073 struct strbuf buf
= STRBUF_INIT
;
2074 struct object_id newoid
;
2077 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
2078 !repo_get_oid(the_repository
, "HEAD", &newoid
) &&
2079 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
2080 char *bol
= buf
.buf
, *eol
;
2083 eol
= strchrnul(bol
, '\n');
2084 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
2085 bol
, oid_to_hex(&newoid
));
2091 unlink(rebase_path_rewritten_pending());
2093 strbuf_release(&buf
);
2096 static void record_in_rewritten(struct object_id
*oid
,
2097 enum todo_command next_command
)
2099 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
2104 fprintf(out
, "%s\n", oid_to_hex(oid
));
2107 if (!is_fixup(next_command
))
2108 flush_rewritten_pending();
2111 static int should_edit(struct replay_opts
*opts
) {
2114 * Note that we only handle the case of non-conflicted
2115 * commits; continue_single_pick() handles the conflicted
2116 * commits itself instead of calling this function.
2118 return (opts
->action
== REPLAY_REVERT
&& isatty(0)) ? 1 : 0;
2122 static void refer_to_commit(struct replay_opts
*opts
,
2123 struct strbuf
*msgbuf
, struct commit
*commit
)
2125 if (opts
->commit_use_reference
) {
2126 struct pretty_print_context ctx
= {
2127 .abbrev
= DEFAULT_ABBREV
,
2128 .date_mode
.type
= DATE_SHORT
,
2130 repo_format_commit_message(the_repository
, commit
,
2131 "%h (%s, %ad)", msgbuf
, &ctx
);
2133 strbuf_addstr(msgbuf
, oid_to_hex(&commit
->object
.oid
));
2137 static int do_pick_commit(struct repository
*r
,
2138 struct todo_item
*item
,
2139 struct replay_opts
*opts
,
2140 int final_fixup
, int *check_todo
)
2142 unsigned int flags
= should_edit(opts
) ? EDIT_MSG
: 0;
2143 const char *msg_file
= should_edit(opts
) ? NULL
: git_path_merge_msg(r
);
2144 struct object_id head
;
2145 struct commit
*base
, *next
, *parent
;
2146 const char *base_label
, *next_label
;
2147 char *author
= NULL
;
2148 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
2149 struct strbuf msgbuf
= STRBUF_INIT
;
2150 int res
, unborn
= 0, reword
= 0, allow
, drop_commit
;
2151 enum todo_command command
= item
->command
;
2152 struct commit
*commit
= item
->commit
;
2154 if (opts
->no_commit
) {
2156 * We do not intend to commit immediately. We just want to
2157 * merge the differences in, so let's compute the tree
2158 * that represents the "current" state for the merge machinery
2161 if (write_index_as_tree(&head
, r
->index
, r
->index_file
, 0, NULL
))
2162 return error(_("your index file is unmerged."));
2164 unborn
= repo_get_oid(r
, "HEAD", &head
);
2165 /* Do we want to generate a root commit? */
2166 if (is_pick_or_similar(command
) && opts
->have_squash_onto
&&
2167 oideq(&head
, &opts
->squash_onto
)) {
2168 if (is_fixup(command
))
2169 return error(_("cannot fixup root commit"));
2170 flags
|= CREATE_ROOT_COMMIT
;
2173 oidcpy(&head
, the_hash_algo
->empty_tree
);
2174 if (index_differs_from(r
, unborn
? empty_tree_oid_hex() : "HEAD",
2176 return error_dirty_index(r
, opts
);
2178 discard_index(r
->index
);
2180 if (!commit
->parents
)
2182 else if (commit
->parents
->next
) {
2183 /* Reverting or cherry-picking a merge commit */
2185 struct commit_list
*p
;
2187 if (!opts
->mainline
)
2188 return error(_("commit %s is a merge but no -m option was given."),
2189 oid_to_hex(&commit
->object
.oid
));
2191 for (cnt
= 1, p
= commit
->parents
;
2192 cnt
!= opts
->mainline
&& p
;
2195 if (cnt
!= opts
->mainline
|| !p
)
2196 return error(_("commit %s does not have parent %d"),
2197 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2199 } else if (1 < opts
->mainline
)
2201 * Non-first parent explicitly specified as mainline for
2204 return error(_("commit %s does not have parent %d"),
2205 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2207 parent
= commit
->parents
->item
;
2209 if (get_message(commit
, &msg
) != 0)
2210 return error(_("cannot get commit message for %s"),
2211 oid_to_hex(&commit
->object
.oid
));
2213 if (opts
->allow_ff
&& !is_fixup(command
) &&
2214 ((parent
&& oideq(&parent
->object
.oid
, &head
)) ||
2215 (!parent
&& unborn
))) {
2216 if (is_rebase_i(opts
))
2217 write_author_script(msg
.message
);
2218 res
= fast_forward_to(r
, &commit
->object
.oid
, &head
, unborn
,
2220 if (res
|| command
!= TODO_REWORD
)
2224 goto fast_forward_edit
;
2226 if (parent
&& repo_parse_commit(r
, parent
) < 0)
2227 /* TRANSLATORS: The first %s will be a "todo" command like
2228 "revert" or "pick", the second %s a SHA1. */
2229 return error(_("%s: cannot parse parent commit %s"),
2230 command_to_string(command
),
2231 oid_to_hex(&parent
->object
.oid
));
2234 * "commit" is an existing commit. We would want to apply
2235 * the difference it introduces since its first parent "prev"
2236 * on top of the current HEAD if we are cherry-pick. Or the
2237 * reverse of it if we are revert.
2240 if (command
== TODO_REVERT
) {
2242 base_label
= msg
.label
;
2244 next_label
= msg
.parent_label
;
2245 if (opts
->commit_use_reference
) {
2246 strbuf_addstr(&msgbuf
,
2247 "# *** SAY WHY WE ARE REVERTING ON THE TITLE LINE ***");
2249 strbuf_addstr(&msgbuf
, "Revert \"");
2250 strbuf_addstr(&msgbuf
, msg
.subject
);
2251 strbuf_addstr(&msgbuf
, "\"");
2253 strbuf_addstr(&msgbuf
, "\n\nThis reverts commit ");
2254 refer_to_commit(opts
, &msgbuf
, commit
);
2256 if (commit
->parents
&& commit
->parents
->next
) {
2257 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
2258 refer_to_commit(opts
, &msgbuf
, parent
);
2260 strbuf_addstr(&msgbuf
, ".\n");
2265 base_label
= msg
.parent_label
;
2267 next_label
= msg
.label
;
2269 /* Append the commit log message to msgbuf. */
2270 if (find_commit_subject(msg
.message
, &p
))
2271 strbuf_addstr(&msgbuf
, p
);
2273 if (opts
->record_origin
) {
2274 strbuf_complete_line(&msgbuf
);
2275 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
2276 strbuf_addch(&msgbuf
, '\n');
2277 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
2278 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
2279 strbuf_addstr(&msgbuf
, ")\n");
2281 if (!is_fixup(command
))
2282 author
= get_author(msg
.message
);
2285 if (command
== TODO_REWORD
)
2287 else if (is_fixup(command
)) {
2288 if (update_squash_messages(r
, command
, commit
,
2289 opts
, item
->flags
)) {
2295 msg_file
= rebase_path_squash_msg();
2296 else if (file_exists(rebase_path_fixup_msg())) {
2297 flags
|= VERBATIM_MSG
;
2298 msg_file
= rebase_path_fixup_msg();
2300 const char *dest
= git_path_squash_msg(r
);
2302 if (copy_file(dest
, rebase_path_squash_msg(), 0666)) {
2303 res
= error(_("could not rename '%s' to '%s'"),
2304 rebase_path_squash_msg(), dest
);
2307 unlink(git_path_merge_msg(r
));
2313 if (opts
->signoff
&& !is_fixup(command
))
2314 append_signoff(&msgbuf
, 0, 0);
2316 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
2318 else if (!opts
->strategy
||
2319 !strcmp(opts
->strategy
, "recursive") ||
2320 !strcmp(opts
->strategy
, "ort") ||
2321 command
== TODO_REVERT
) {
2322 res
= do_recursive_merge(r
, base
, next
, base_label
, next_label
,
2323 &head
, &msgbuf
, opts
);
2327 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
2328 git_path_merge_msg(r
), 0);
2330 struct commit_list
*common
= NULL
;
2331 struct commit_list
*remotes
= NULL
;
2333 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
2334 git_path_merge_msg(r
), 0);
2336 commit_list_insert(base
, &common
);
2337 commit_list_insert(next
, &remotes
);
2338 res
|= try_merge_command(r
, opts
->strategy
,
2339 opts
->xopts_nr
, (const char **)opts
->xopts
,
2340 common
, oid_to_hex(&head
), remotes
);
2341 free_commit_list(common
);
2342 free_commit_list(remotes
);
2346 * If the merge was clean or if it failed due to conflict, we write
2347 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
2348 * However, if the merge did not even start, then we don't want to
2351 if ((command
== TODO_PICK
|| command
== TODO_REWORD
||
2352 command
== TODO_EDIT
) && !opts
->no_commit
&&
2353 (res
== 0 || res
== 1) &&
2354 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
2355 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2357 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
2358 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
2359 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2363 error(command
== TODO_REVERT
2364 ? _("could not revert %s... %s")
2365 : _("could not apply %s... %s"),
2366 short_commit_name(commit
), msg
.subject
);
2367 print_advice(r
, res
== 1, opts
);
2368 repo_rerere(r
, opts
->allow_rerere_auto
);
2373 allow
= allow_empty(r
, opts
, commit
);
2377 } else if (allow
== 1) {
2378 flags
|= ALLOW_EMPTY
;
2379 } else if (allow
== 2) {
2381 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
2383 unlink(git_path_merge_msg(r
));
2384 unlink(git_path_auto_merge(r
));
2386 _("dropping %s %s -- patch contents already upstream\n"),
2387 oid_to_hex(&commit
->object
.oid
), msg
.subject
);
2388 } /* else allow == 0 and there's nothing special to do */
2389 if (!opts
->no_commit
&& !drop_commit
) {
2390 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
2391 res
= do_commit(r
, msg_file
, author
, opts
, flags
,
2392 commit
? &commit
->object
.oid
: NULL
);
2394 res
= error(_("unable to parse commit author"));
2395 *check_todo
= !!(flags
& EDIT_MSG
);
2396 if (!res
&& reword
) {
2398 res
= run_git_commit(NULL
, opts
, EDIT_MSG
|
2399 VERIFY_MSG
| AMEND_MSG
|
2400 (flags
& ALLOW_EMPTY
));
2406 if (!res
&& final_fixup
) {
2407 unlink(rebase_path_fixup_msg());
2408 unlink(rebase_path_squash_msg());
2409 unlink(rebase_path_current_fixups());
2410 strbuf_reset(&opts
->current_fixups
);
2411 opts
->current_fixup_count
= 0;
2415 free_message(commit
, &msg
);
2417 strbuf_release(&msgbuf
);
2418 update_abort_safety_file();
2423 static int prepare_revs(struct replay_opts
*opts
)
2426 * picking (but not reverting) ranges (but not individual revisions)
2427 * should be done in reverse
2429 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
2430 opts
->revs
->reverse
^= 1;
2432 if (prepare_revision_walk(opts
->revs
))
2433 return error(_("revision walk setup failed"));
2438 static int read_and_refresh_cache(struct repository
*r
,
2439 struct replay_opts
*opts
)
2441 struct lock_file index_lock
= LOCK_INIT
;
2442 int index_fd
= repo_hold_locked_index(r
, &index_lock
, 0);
2443 if (repo_read_index(r
) < 0) {
2444 rollback_lock_file(&index_lock
);
2445 return error(_("git %s: failed to read the index"),
2448 refresh_index(r
->index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
2450 if (index_fd
>= 0) {
2451 if (write_locked_index(r
->index
, &index_lock
,
2452 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
2453 return error(_("git %s: failed to refresh the index"),
2459 * If we are resolving merges in any way other than "ort", then
2460 * expand the sparse index.
2462 if (opts
->strategy
&& strcmp(opts
->strategy
, "ort"))
2463 ensure_full_index(r
->index
);
2467 void todo_list_release(struct todo_list
*todo_list
)
2469 strbuf_release(&todo_list
->buf
);
2470 FREE_AND_NULL(todo_list
->items
);
2471 todo_list
->nr
= todo_list
->alloc
= 0;
2474 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
2476 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
2477 todo_list
->total_nr
++;
2478 return todo_list
->items
+ todo_list
->nr
++;
2481 const char *todo_item_get_arg(struct todo_list
*todo_list
,
2482 struct todo_item
*item
)
2484 return todo_list
->buf
.buf
+ item
->arg_offset
;
2487 static int is_command(enum todo_command command
, const char **bol
)
2489 const char *str
= todo_command_info
[command
].str
;
2490 const char nick
= todo_command_info
[command
].c
;
2491 const char *p
= *bol
;
2493 return (skip_prefix(p
, str
, &p
) || (nick
&& *p
++ == nick
)) &&
2494 (*p
== ' ' || *p
== '\t' || *p
== '\n' || *p
== '\r' || !*p
) &&
2498 static int check_label_or_ref_arg(enum todo_command command
, const char *arg
)
2503 * '#' is not a valid label as the merge command uses it to
2504 * separate merge parents from the commit subject.
2506 if (!strcmp(arg
, "#") ||
2507 check_refname_format(arg
, REFNAME_ALLOW_ONELEVEL
))
2508 return error(_("'%s' is not a valid label"), arg
);
2511 case TODO_UPDATE_REF
:
2512 if (check_refname_format(arg
, REFNAME_ALLOW_ONELEVEL
))
2513 return error(_("'%s' is not a valid refname"), arg
);
2514 if (check_refname_format(arg
, 0))
2515 return error(_("update-ref requires a fully qualified "
2516 "refname e.g. refs/heads/%s"), arg
);
2520 BUG("unexpected todo_command");
2526 static int parse_insn_line(struct repository
*r
, struct todo_item
*item
,
2527 const char *buf
, const char *bol
, char *eol
)
2529 struct object_id commit_oid
;
2530 char *end_of_object_name
;
2531 int i
, saved
, status
, padding
;
2536 bol
+= strspn(bol
, " \t");
2538 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
2539 item
->command
= TODO_COMMENT
;
2540 item
->commit
= NULL
;
2541 item
->arg_offset
= bol
- buf
;
2542 item
->arg_len
= eol
- bol
;
2546 for (i
= 0; i
< TODO_COMMENT
; i
++)
2547 if (is_command(i
, &bol
)) {
2551 if (i
>= TODO_COMMENT
)
2552 return error(_("invalid command '%.*s'"),
2553 (int)strcspn(bol
, " \t\r\n"), bol
);
2555 /* Eat up extra spaces/ tabs before object name */
2556 padding
= strspn(bol
, " \t");
2559 if (item
->command
== TODO_NOOP
|| item
->command
== TODO_BREAK
) {
2561 return error(_("%s does not accept arguments: '%s'"),
2562 command_to_string(item
->command
), bol
);
2563 item
->commit
= NULL
;
2564 item
->arg_offset
= bol
- buf
;
2565 item
->arg_len
= eol
- bol
;
2570 return error(_("missing arguments for %s"),
2571 command_to_string(item
->command
));
2573 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
2574 item
->command
== TODO_RESET
|| item
->command
== TODO_UPDATE_REF
) {
2577 item
->commit
= NULL
;
2578 item
->arg_offset
= bol
- buf
;
2579 item
->arg_len
= (int)(eol
- bol
);
2580 if (item
->command
== TODO_LABEL
||
2581 item
->command
== TODO_UPDATE_REF
) {
2584 ret
= check_label_or_ref_arg(item
->command
, bol
);
2590 if (item
->command
== TODO_FIXUP
) {
2591 if (skip_prefix(bol
, "-C", &bol
)) {
2592 bol
+= strspn(bol
, " \t");
2593 item
->flags
|= TODO_REPLACE_FIXUP_MSG
;
2594 } else if (skip_prefix(bol
, "-c", &bol
)) {
2595 bol
+= strspn(bol
, " \t");
2596 item
->flags
|= TODO_EDIT_FIXUP_MSG
;
2600 if (item
->command
== TODO_MERGE
) {
2601 if (skip_prefix(bol
, "-C", &bol
))
2602 bol
+= strspn(bol
, " \t");
2603 else if (skip_prefix(bol
, "-c", &bol
)) {
2604 bol
+= strspn(bol
, " \t");
2605 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2607 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2608 item
->commit
= NULL
;
2609 item
->arg_offset
= bol
- buf
;
2610 item
->arg_len
= (int)(eol
- bol
);
2615 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
2616 saved
= *end_of_object_name
;
2617 *end_of_object_name
= '\0';
2618 status
= repo_get_oid(r
, bol
, &commit_oid
);
2620 error(_("could not parse '%s'"), bol
); /* return later */
2621 *end_of_object_name
= saved
;
2623 bol
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2624 item
->arg_offset
= bol
- buf
;
2625 item
->arg_len
= (int)(eol
- bol
);
2630 item
->commit
= lookup_commit_reference(r
, &commit_oid
);
2631 return item
->commit
? 0 : -1;
2634 int sequencer_get_last_command(struct repository
*r
, enum replay_action
*action
)
2636 const char *todo_file
, *bol
;
2637 struct strbuf buf
= STRBUF_INIT
;
2640 todo_file
= git_path_todo_file();
2641 if (strbuf_read_file(&buf
, todo_file
, 0) < 0) {
2642 if (errno
== ENOENT
|| errno
== ENOTDIR
)
2645 return error_errno("unable to open '%s'", todo_file
);
2647 bol
= buf
.buf
+ strspn(buf
.buf
, " \t\r\n");
2648 if (is_command(TODO_PICK
, &bol
) && (*bol
== ' ' || *bol
== '\t'))
2649 *action
= REPLAY_PICK
;
2650 else if (is_command(TODO_REVERT
, &bol
) &&
2651 (*bol
== ' ' || *bol
== '\t'))
2652 *action
= REPLAY_REVERT
;
2656 strbuf_release(&buf
);
2661 int todo_list_parse_insn_buffer(struct repository
*r
, char *buf
,
2662 struct todo_list
*todo_list
)
2664 struct todo_item
*item
;
2665 char *p
= buf
, *next_p
;
2666 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2668 todo_list
->current
= todo_list
->nr
= 0;
2670 for (i
= 1; *p
; i
++, p
= next_p
) {
2671 char *eol
= strchrnul(p
, '\n');
2673 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2675 if (p
!= eol
&& eol
[-1] == '\r')
2676 eol
--; /* strip Carriage Return */
2678 item
= append_new_todo(todo_list
);
2679 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2680 if (parse_insn_line(r
, item
, buf
, p
, eol
)) {
2681 res
= error(_("invalid line %d: %.*s"),
2682 i
, (int)(eol
- p
), p
);
2683 item
->command
= TODO_COMMENT
+ 1;
2684 item
->arg_offset
= p
- buf
;
2685 item
->arg_len
= (int)(eol
- p
);
2686 item
->commit
= NULL
;
2691 else if (is_fixup(item
->command
))
2692 return error(_("cannot '%s' without a previous commit"),
2693 command_to_string(item
->command
));
2694 else if (!is_noop(item
->command
))
2701 static int count_commands(struct todo_list
*todo_list
)
2705 for (i
= 0; i
< todo_list
->nr
; i
++)
2706 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2712 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2714 return index
< todo_list
->nr
?
2715 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2718 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2720 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2723 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2725 return get_item_line_offset(todo_list
, index
+ 1)
2726 - get_item_line_offset(todo_list
, index
);
2729 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2734 fd
= open(path
, O_RDONLY
);
2736 return error_errno(_("could not open '%s'"), path
);
2737 len
= strbuf_read(sb
, fd
, 0);
2740 return error(_("could not read '%s'."), path
);
2744 static int have_finished_the_last_pick(void)
2746 struct strbuf buf
= STRBUF_INIT
;
2748 const char *todo_path
= git_path_todo_file();
2751 if (strbuf_read_file(&buf
, todo_path
, 0) < 0) {
2752 if (errno
== ENOENT
) {
2755 error_errno("unable to open '%s'", todo_path
);
2759 /* If there is only one line then we are done */
2760 eol
= strchr(buf
.buf
, '\n');
2761 if (!eol
|| !eol
[1])
2764 strbuf_release(&buf
);
2769 void sequencer_post_commit_cleanup(struct repository
*r
, int verbose
)
2771 struct replay_opts opts
= REPLAY_OPTS_INIT
;
2772 int need_cleanup
= 0;
2774 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
2775 if (!refs_delete_ref(get_main_ref_store(r
), "",
2776 "CHERRY_PICK_HEAD", NULL
, 0) &&
2778 warning(_("cancelling a cherry picking in progress"));
2779 opts
.action
= REPLAY_PICK
;
2783 if (refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
2784 if (!refs_delete_ref(get_main_ref_store(r
), "", "REVERT_HEAD",
2787 warning(_("cancelling a revert in progress"));
2788 opts
.action
= REPLAY_REVERT
;
2792 unlink(git_path_auto_merge(r
));
2797 if (!have_finished_the_last_pick())
2800 sequencer_remove_state(&opts
);
2803 static void todo_list_write_total_nr(struct todo_list
*todo_list
)
2805 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2808 fprintf(f
, "%d\n", todo_list
->total_nr
);
2813 static int read_populate_todo(struct repository
*r
,
2814 struct todo_list
*todo_list
,
2815 struct replay_opts
*opts
)
2817 const char *todo_file
= get_todo_path(opts
);
2820 strbuf_reset(&todo_list
->buf
);
2821 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2824 res
= todo_list_parse_insn_buffer(r
, todo_list
->buf
.buf
, todo_list
);
2826 if (is_rebase_i(opts
))
2827 return error(_("please fix this using "
2828 "'git rebase --edit-todo'."));
2829 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2832 if (!todo_list
->nr
&&
2833 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2834 return error(_("no commits parsed."));
2836 if (!is_rebase_i(opts
)) {
2837 enum todo_command valid
=
2838 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2841 for (i
= 0; i
< todo_list
->nr
; i
++)
2842 if (valid
== todo_list
->items
[i
].command
)
2844 else if (valid
== TODO_PICK
)
2845 return error(_("cannot cherry-pick during a revert."));
2847 return error(_("cannot revert during a cherry-pick."));
2850 if (is_rebase_i(opts
)) {
2851 struct todo_list done
= TODO_LIST_INIT
;
2853 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2854 !todo_list_parse_insn_buffer(r
, done
.buf
.buf
, &done
))
2855 todo_list
->done_nr
= count_commands(&done
);
2857 todo_list
->done_nr
= 0;
2859 todo_list
->total_nr
= todo_list
->done_nr
2860 + count_commands(todo_list
);
2861 todo_list_release(&done
);
2863 todo_list_write_total_nr(todo_list
);
2869 static int git_config_string_dup(char **dest
,
2870 const char *var
, const char *value
)
2873 return config_error_nonbool(var
);
2875 *dest
= xstrdup(value
);
2879 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
2881 struct replay_opts
*opts
= data
;
2886 else if (!strcmp(key
, "options.no-commit"))
2887 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
2888 else if (!strcmp(key
, "options.edit"))
2889 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
2890 else if (!strcmp(key
, "options.allow-empty"))
2892 git_config_bool_or_int(key
, value
, &error_flag
);
2893 else if (!strcmp(key
, "options.allow-empty-message"))
2894 opts
->allow_empty_message
=
2895 git_config_bool_or_int(key
, value
, &error_flag
);
2896 else if (!strcmp(key
, "options.keep-redundant-commits"))
2897 opts
->keep_redundant_commits
=
2898 git_config_bool_or_int(key
, value
, &error_flag
);
2899 else if (!strcmp(key
, "options.signoff"))
2900 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
2901 else if (!strcmp(key
, "options.record-origin"))
2902 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
2903 else if (!strcmp(key
, "options.allow-ff"))
2904 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
2905 else if (!strcmp(key
, "options.mainline"))
2906 opts
->mainline
= git_config_int(key
, value
);
2907 else if (!strcmp(key
, "options.strategy"))
2908 git_config_string_dup(&opts
->strategy
, key
, value
);
2909 else if (!strcmp(key
, "options.gpg-sign"))
2910 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
2911 else if (!strcmp(key
, "options.strategy-option")) {
2912 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
2913 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(value
);
2914 } else if (!strcmp(key
, "options.allow-rerere-auto"))
2915 opts
->allow_rerere_auto
=
2916 git_config_bool_or_int(key
, value
, &error_flag
) ?
2917 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
2918 else if (!strcmp(key
, "options.default-msg-cleanup")) {
2919 opts
->explicit_cleanup
= 1;
2920 opts
->default_msg_cleanup
= get_cleanup_mode(value
, 1);
2922 return error(_("invalid key: %s"), key
);
2925 return error(_("invalid value for '%s': '%s'"), key
, value
);
2930 void parse_strategy_opts(struct replay_opts
*opts
, char *raw_opts
)
2934 char *strategy_opts_string
= raw_opts
;
2936 if (*strategy_opts_string
== ' ')
2937 strategy_opts_string
++;
2939 count
= split_cmdline(strategy_opts_string
,
2940 (const char ***)&opts
->xopts
);
2942 die(_("could not split '%s': %s"), strategy_opts_string
,
2943 split_cmdline_strerror(count
));
2944 opts
->xopts_nr
= count
;
2945 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
2946 const char *arg
= opts
->xopts
[i
];
2948 skip_prefix(arg
, "--", &arg
);
2949 opts
->xopts
[i
] = xstrdup(arg
);
2953 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2956 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2958 free(opts
->strategy
);
2959 opts
->strategy
= strbuf_detach(buf
, NULL
);
2960 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2963 parse_strategy_opts(opts
, buf
->buf
);
2966 static int read_populate_opts(struct replay_opts
*opts
)
2968 if (is_rebase_i(opts
)) {
2969 struct strbuf buf
= STRBUF_INIT
;
2972 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(),
2973 READ_ONELINER_SKIP_IF_EMPTY
)) {
2974 if (!starts_with(buf
.buf
, "-S"))
2977 free(opts
->gpg_sign
);
2978 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2983 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(),
2984 READ_ONELINER_SKIP_IF_EMPTY
)) {
2985 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2986 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2987 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2988 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2992 if (file_exists(rebase_path_verbose()))
2995 if (file_exists(rebase_path_quiet()))
2998 if (file_exists(rebase_path_signoff())) {
3003 if (file_exists(rebase_path_cdate_is_adate())) {
3005 opts
->committer_date_is_author_date
= 1;
3008 if (file_exists(rebase_path_ignore_date())) {
3010 opts
->ignore_date
= 1;
3013 if (file_exists(rebase_path_reschedule_failed_exec()))
3014 opts
->reschedule_failed_exec
= 1;
3015 else if (file_exists(rebase_path_no_reschedule_failed_exec()))
3016 opts
->reschedule_failed_exec
= 0;
3018 if (file_exists(rebase_path_drop_redundant_commits()))
3019 opts
->drop_redundant_commits
= 1;
3021 if (file_exists(rebase_path_keep_redundant_commits()))
3022 opts
->keep_redundant_commits
= 1;
3024 read_strategy_opts(opts
, &buf
);
3027 if (read_oneliner(&opts
->current_fixups
,
3028 rebase_path_current_fixups(),
3029 READ_ONELINER_SKIP_IF_EMPTY
)) {
3030 const char *p
= opts
->current_fixups
.buf
;
3031 opts
->current_fixup_count
= 1;
3032 while ((p
= strchr(p
, '\n'))) {
3033 opts
->current_fixup_count
++;
3038 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
3039 if (repo_get_oid_committish(the_repository
, buf
.buf
, &opts
->squash_onto
) < 0) {
3040 ret
= error(_("unusable squash-onto"));
3043 opts
->have_squash_onto
= 1;
3047 strbuf_release(&buf
);
3051 if (!file_exists(git_path_opts_file()))
3054 * The function git_parse_source(), called from git_config_from_file(),
3055 * may die() in case of a syntactically incorrect file. We do not care
3056 * about this case, though, because we wrote that file ourselves, so we
3057 * are pretty certain that it is syntactically correct.
3059 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
3060 return error(_("malformed options sheet: '%s'"),
3061 git_path_opts_file());
3065 static void write_strategy_opts(struct replay_opts
*opts
)
3068 struct strbuf buf
= STRBUF_INIT
;
3070 for (i
= 0; i
< opts
->xopts_nr
; ++i
)
3071 strbuf_addf(&buf
, " --%s", opts
->xopts
[i
]);
3073 write_file(rebase_path_strategy_opts(), "%s\n", buf
.buf
);
3074 strbuf_release(&buf
);
3077 int write_basic_state(struct replay_opts
*opts
, const char *head_name
,
3078 struct commit
*onto
, const struct object_id
*orig_head
)
3081 write_file(rebase_path_head_name(), "%s\n", head_name
);
3083 write_file(rebase_path_onto(), "%s\n",
3084 oid_to_hex(&onto
->object
.oid
));
3086 write_file(rebase_path_orig_head(), "%s\n",
3087 oid_to_hex(orig_head
));
3090 write_file(rebase_path_quiet(), "%s", "");
3092 write_file(rebase_path_verbose(), "%s", "");
3094 write_file(rebase_path_strategy(), "%s\n", opts
->strategy
);
3095 if (opts
->xopts_nr
> 0)
3096 write_strategy_opts(opts
);
3098 if (opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
)
3099 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
3100 else if (opts
->allow_rerere_auto
== RERERE_NOAUTOUPDATE
)
3101 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
3104 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts
->gpg_sign
);
3106 write_file(rebase_path_signoff(), "--signoff\n");
3107 if (opts
->drop_redundant_commits
)
3108 write_file(rebase_path_drop_redundant_commits(), "%s", "");
3109 if (opts
->keep_redundant_commits
)
3110 write_file(rebase_path_keep_redundant_commits(), "%s", "");
3111 if (opts
->committer_date_is_author_date
)
3112 write_file(rebase_path_cdate_is_adate(), "%s", "");
3113 if (opts
->ignore_date
)
3114 write_file(rebase_path_ignore_date(), "%s", "");
3115 if (opts
->reschedule_failed_exec
)
3116 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
3118 write_file(rebase_path_no_reschedule_failed_exec(), "%s", "");
3123 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
3124 struct replay_opts
*opts
)
3126 enum todo_command command
= opts
->action
== REPLAY_PICK
?
3127 TODO_PICK
: TODO_REVERT
;
3128 const char *command_string
= todo_command_info
[command
].str
;
3129 const char *encoding
;
3130 struct commit
*commit
;
3132 if (prepare_revs(opts
))
3135 encoding
= get_log_output_encoding();
3137 while ((commit
= get_revision(opts
->revs
))) {
3138 struct todo_item
*item
= append_new_todo(todo_list
);
3139 const char *commit_buffer
= repo_logmsg_reencode(the_repository
,
3142 const char *subject
;
3145 item
->command
= command
;
3146 item
->commit
= commit
;
3147 item
->arg_offset
= 0;
3149 item
->offset_in_buf
= todo_list
->buf
.len
;
3150 subject_len
= find_commit_subject(commit_buffer
, &subject
);
3151 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
3152 short_commit_name(commit
), subject_len
, subject
);
3153 repo_unuse_commit_buffer(the_repository
, commit
,
3158 return error(_("empty commit set passed"));
3163 static int create_seq_dir(struct repository
*r
)
3165 enum replay_action action
;
3166 const char *in_progress_error
= NULL
;
3167 const char *in_progress_advice
= NULL
;
3168 unsigned int advise_skip
=
3169 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD") ||
3170 refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD");
3172 if (!sequencer_get_last_command(r
, &action
)) {
3175 in_progress_error
= _("revert is already in progress");
3176 in_progress_advice
=
3177 _("try \"git revert (--continue | %s--abort | --quit)\"");
3180 in_progress_error
= _("cherry-pick is already in progress");
3181 in_progress_advice
=
3182 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
3185 BUG("unexpected action in create_seq_dir");
3188 if (in_progress_error
) {
3189 error("%s", in_progress_error
);
3190 if (advice_enabled(ADVICE_SEQUENCER_IN_USE
))
3191 advise(in_progress_advice
,
3192 advise_skip
? "--skip | " : "");
3195 if (mkdir(git_path_seq_dir(), 0777) < 0)
3196 return error_errno(_("could not create sequencer directory '%s'"),
3197 git_path_seq_dir());
3202 static int save_head(const char *head
)
3204 return write_message(head
, strlen(head
), git_path_head_file(), 1);
3207 static int rollback_is_safe(void)
3209 struct strbuf sb
= STRBUF_INIT
;
3210 struct object_id expected_head
, actual_head
;
3212 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
3214 if (get_oid_hex(sb
.buf
, &expected_head
)) {
3215 strbuf_release(&sb
);
3216 die(_("could not parse %s"), git_path_abort_safety_file());
3218 strbuf_release(&sb
);
3220 else if (errno
== ENOENT
)
3221 oidclr(&expected_head
);
3223 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
3225 if (repo_get_oid(the_repository
, "HEAD", &actual_head
))
3226 oidclr(&actual_head
);
3228 return oideq(&actual_head
, &expected_head
);
3231 static int reset_merge(const struct object_id
*oid
)
3233 struct child_process cmd
= CHILD_PROCESS_INIT
;
3236 strvec_pushl(&cmd
.args
, "reset", "--merge", NULL
);
3238 if (!is_null_oid(oid
))
3239 strvec_push(&cmd
.args
, oid_to_hex(oid
));
3241 return run_command(&cmd
);
3244 static int rollback_single_pick(struct repository
*r
)
3246 struct object_id head_oid
;
3248 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
3249 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
3250 return error(_("no cherry-pick or revert in progress"));
3251 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
3252 return error(_("cannot resolve HEAD"));
3253 if (is_null_oid(&head_oid
))
3254 return error(_("cannot abort from a branch yet to be born"));
3255 return reset_merge(&head_oid
);
3258 static int skip_single_pick(void)
3260 struct object_id head
;
3262 if (read_ref_full("HEAD", 0, &head
, NULL
))
3263 return error(_("cannot resolve HEAD"));
3264 return reset_merge(&head
);
3267 int sequencer_rollback(struct repository
*r
, struct replay_opts
*opts
)
3270 struct object_id oid
;
3271 struct strbuf buf
= STRBUF_INIT
;
3274 f
= fopen(git_path_head_file(), "r");
3275 if (!f
&& errno
== ENOENT
) {
3277 * There is no multiple-cherry-pick in progress.
3278 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
3279 * a single-cherry-pick in progress, abort that.
3281 return rollback_single_pick(r
);
3284 return error_errno(_("cannot open '%s'"), git_path_head_file());
3285 if (strbuf_getline_lf(&buf
, f
)) {
3286 error(_("cannot read '%s': %s"), git_path_head_file(),
3287 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
3292 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
3293 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
3294 git_path_head_file());
3297 if (is_null_oid(&oid
)) {
3298 error(_("cannot abort from a branch yet to be born"));
3302 if (!rollback_is_safe()) {
3303 /* Do not error, just do not rollback */
3304 warning(_("You seem to have moved HEAD. "
3305 "Not rewinding, check your HEAD!"));
3307 if (reset_merge(&oid
))
3309 strbuf_release(&buf
);
3310 return sequencer_remove_state(opts
);
3312 strbuf_release(&buf
);
3316 int sequencer_skip(struct repository
*r
, struct replay_opts
*opts
)
3318 enum replay_action action
= -1;
3319 sequencer_get_last_command(r
, &action
);
3322 * Check whether the subcommand requested to skip the commit is actually
3323 * in progress and that it's safe to skip the commit.
3325 * opts->action tells us which subcommand requested to skip the commit.
3326 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
3327 * action is in progress and we can skip the commit.
3329 * Otherwise we check that the last instruction was related to the
3330 * particular subcommand we're trying to execute and barf if that's not
3333 * Finally we check that the rollback is "safe", i.e., has the HEAD
3334 * moved? In this case, it doesn't make sense to "reset the merge" and
3335 * "skip the commit" as the user already handled this by committing. But
3336 * we'd not want to barf here, instead give advice on how to proceed. We
3337 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
3338 * it gets removed when the user commits, so if it still exists we're
3339 * sure the user can't have committed before.
3341 switch (opts
->action
) {
3343 if (!refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
3344 if (action
!= REPLAY_REVERT
)
3345 return error(_("no revert in progress"));
3346 if (!rollback_is_safe())
3351 if (!refs_ref_exists(get_main_ref_store(r
),
3352 "CHERRY_PICK_HEAD")) {
3353 if (action
!= REPLAY_PICK
)
3354 return error(_("no cherry-pick in progress"));
3355 if (!rollback_is_safe())
3360 BUG("unexpected action in sequencer_skip");
3363 if (skip_single_pick())
3364 return error(_("failed to skip the commit"));
3365 if (!is_directory(git_path_seq_dir()))
3368 return sequencer_continue(r
, opts
);
3371 error(_("there is nothing to skip"));
3373 if (advice_enabled(ADVICE_RESOLVE_CONFLICT
)) {
3374 advise(_("have you committed already?\n"
3375 "try \"git %s --continue\""),
3376 action
== REPLAY_REVERT
? "revert" : "cherry-pick");
3381 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
3383 struct lock_file todo_lock
= LOCK_INIT
;
3384 const char *todo_path
= get_todo_path(opts
);
3385 int next
= todo_list
->current
, offset
, fd
;
3388 * rebase -i writes "git-rebase-todo" without the currently executing
3389 * command, appending it to "done" instead.
3391 if (is_rebase_i(opts
))
3394 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
3396 return error_errno(_("could not lock '%s'"), todo_path
);
3397 offset
= get_item_line_offset(todo_list
, next
);
3398 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
3399 todo_list
->buf
.len
- offset
) < 0)
3400 return error_errno(_("could not write to '%s'"), todo_path
);
3401 if (commit_lock_file(&todo_lock
) < 0)
3402 return error(_("failed to finalize '%s'"), todo_path
);
3404 if (is_rebase_i(opts
) && next
> 0) {
3405 const char *done
= rebase_path_done();
3406 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
3411 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
3412 get_item_line_length(todo_list
, next
- 1))
3414 ret
= error_errno(_("could not write to '%s'"), done
);
3416 ret
= error_errno(_("failed to finalize '%s'"), done
);
3422 static int save_opts(struct replay_opts
*opts
)
3424 const char *opts_file
= git_path_opts_file();
3427 if (opts
->no_commit
)
3428 res
|= git_config_set_in_file_gently(opts_file
,
3429 "options.no-commit", "true");
3430 if (opts
->edit
>= 0)
3431 res
|= git_config_set_in_file_gently(opts_file
, "options.edit",
3432 opts
->edit
? "true" : "false");
3433 if (opts
->allow_empty
)
3434 res
|= git_config_set_in_file_gently(opts_file
,
3435 "options.allow-empty", "true");
3436 if (opts
->allow_empty_message
)
3437 res
|= git_config_set_in_file_gently(opts_file
,
3438 "options.allow-empty-message", "true");
3439 if (opts
->keep_redundant_commits
)
3440 res
|= git_config_set_in_file_gently(opts_file
,
3441 "options.keep-redundant-commits", "true");
3443 res
|= git_config_set_in_file_gently(opts_file
,
3444 "options.signoff", "true");
3445 if (opts
->record_origin
)
3446 res
|= git_config_set_in_file_gently(opts_file
,
3447 "options.record-origin", "true");
3449 res
|= git_config_set_in_file_gently(opts_file
,
3450 "options.allow-ff", "true");
3451 if (opts
->mainline
) {
3452 struct strbuf buf
= STRBUF_INIT
;
3453 strbuf_addf(&buf
, "%d", opts
->mainline
);
3454 res
|= git_config_set_in_file_gently(opts_file
,
3455 "options.mainline", buf
.buf
);
3456 strbuf_release(&buf
);
3459 res
|= git_config_set_in_file_gently(opts_file
,
3460 "options.strategy", opts
->strategy
);
3462 res
|= git_config_set_in_file_gently(opts_file
,
3463 "options.gpg-sign", opts
->gpg_sign
);
3466 for (i
= 0; i
< opts
->xopts_nr
; i
++)
3467 res
|= git_config_set_multivar_in_file_gently(opts_file
,
3468 "options.strategy-option",
3469 opts
->xopts
[i
], "^$", 0);
3471 if (opts
->allow_rerere_auto
)
3472 res
|= git_config_set_in_file_gently(opts_file
,
3473 "options.allow-rerere-auto",
3474 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
3477 if (opts
->explicit_cleanup
)
3478 res
|= git_config_set_in_file_gently(opts_file
,
3479 "options.default-msg-cleanup",
3480 describe_cleanup_mode(opts
->default_msg_cleanup
));
3484 static int make_patch(struct repository
*r
,
3485 struct commit
*commit
,
3486 struct replay_opts
*opts
)
3488 struct strbuf buf
= STRBUF_INIT
;
3489 struct rev_info log_tree_opt
;
3490 const char *subject
;
3491 char hex
[GIT_MAX_HEXSZ
+ 1];
3494 oid_to_hex_r(hex
, &commit
->object
.oid
);
3495 if (write_message(hex
, strlen(hex
), rebase_path_stopped_sha(), 1) < 0)
3497 res
|= write_rebase_head(&commit
->object
.oid
);
3499 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
3500 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3501 repo_init_revisions(r
, &log_tree_opt
, NULL
);
3502 log_tree_opt
.abbrev
= 0;
3503 log_tree_opt
.diff
= 1;
3504 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
3505 log_tree_opt
.disable_stdin
= 1;
3506 log_tree_opt
.no_commit_id
= 1;
3507 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
3508 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
3509 if (!log_tree_opt
.diffopt
.file
)
3510 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
3512 res
|= log_tree_commit(&log_tree_opt
, commit
);
3513 fclose(log_tree_opt
.diffopt
.file
);
3517 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
3518 if (!file_exists(buf
.buf
)) {
3519 const char *encoding
= get_commit_output_encoding();
3520 const char *commit_buffer
= repo_logmsg_reencode(r
,
3523 find_commit_subject(commit_buffer
, &subject
);
3524 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
3525 repo_unuse_commit_buffer(r
, commit
,
3528 strbuf_release(&buf
);
3529 release_revisions(&log_tree_opt
);
3534 static int intend_to_amend(void)
3536 struct object_id head
;
3539 if (repo_get_oid(the_repository
, "HEAD", &head
))
3540 return error(_("cannot read HEAD"));
3542 p
= oid_to_hex(&head
);
3543 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
3546 static int error_with_patch(struct repository
*r
,
3547 struct commit
*commit
,
3548 const char *subject
, int subject_len
,
3549 struct replay_opts
*opts
,
3550 int exit_code
, int to_amend
)
3553 if (make_patch(r
, commit
, opts
))
3555 } else if (copy_file(rebase_path_message(),
3556 git_path_merge_msg(r
), 0666))
3557 return error(_("unable to copy '%s' to '%s'"),
3558 git_path_merge_msg(r
), rebase_path_message());
3561 if (intend_to_amend())
3565 _("You can amend the commit now, with\n"
3567 " git commit --amend %s\n"
3569 "Once you are satisfied with your changes, run\n"
3571 " git rebase --continue\n"),
3572 gpg_sign_opt_quoted(opts
));
3573 } else if (exit_code
) {
3575 fprintf_ln(stderr
, _("Could not apply %s... %.*s"),
3576 short_commit_name(commit
), subject_len
, subject
);
3579 * We don't have the hash of the parent so
3580 * just print the line from the todo file.
3582 fprintf_ln(stderr
, _("Could not merge %.*s"),
3583 subject_len
, subject
);
3589 static int error_failed_squash(struct repository
*r
,
3590 struct commit
*commit
,
3591 struct replay_opts
*opts
,
3593 const char *subject
)
3595 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3596 return error(_("could not copy '%s' to '%s'"),
3597 rebase_path_squash_msg(), rebase_path_message());
3598 unlink(git_path_merge_msg(r
));
3599 if (copy_file(git_path_merge_msg(r
), rebase_path_message(), 0666))
3600 return error(_("could not copy '%s' to '%s'"),
3601 rebase_path_message(),
3602 git_path_merge_msg(r
));
3603 return error_with_patch(r
, commit
, subject
, subject_len
, opts
, 1, 0);
3606 static int do_exec(struct repository
*r
, const char *command_line
)
3608 struct child_process cmd
= CHILD_PROCESS_INIT
;
3611 fprintf(stderr
, _("Executing: %s\n"), command_line
);
3613 strvec_push(&cmd
.args
, command_line
);
3614 status
= run_command(&cmd
);
3616 /* force re-reading of the cache */
3617 discard_index(r
->index
);
3618 if (repo_read_index(r
) < 0)
3619 return error(_("could not read index"));
3621 dirty
= require_clean_work_tree(r
, "rebase", NULL
, 1, 1);
3624 warning(_("execution failed: %s\n%s"
3625 "You can fix the problem, and then run\n"
3627 " git rebase --continue\n"
3630 dirty
? N_("and made changes to the index and/or the "
3631 "working tree\n") : "");
3633 /* command not found */
3636 warning(_("execution succeeded: %s\nbut "
3637 "left changes to the index and/or the working tree\n"
3638 "Commit or stash your changes, and then run\n"
3640 " git rebase --continue\n"
3641 "\n"), command_line
);
3648 __attribute__((format (printf
, 2, 3)))
3649 static int safe_append(const char *filename
, const char *fmt
, ...)
3652 struct lock_file lock
= LOCK_INIT
;
3653 int fd
= hold_lock_file_for_update(&lock
, filename
,
3654 LOCK_REPORT_ON_ERROR
);
3655 struct strbuf buf
= STRBUF_INIT
;
3660 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
3661 error_errno(_("could not read '%s'"), filename
);
3662 rollback_lock_file(&lock
);
3665 strbuf_complete(&buf
, '\n');
3667 strbuf_vaddf(&buf
, fmt
, ap
);
3670 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
3671 error_errno(_("could not write to '%s'"), filename
);
3672 strbuf_release(&buf
);
3673 rollback_lock_file(&lock
);
3676 if (commit_lock_file(&lock
) < 0) {
3677 strbuf_release(&buf
);
3678 return error(_("failed to finalize '%s'"), filename
);
3681 strbuf_release(&buf
);
3685 static int do_label(struct repository
*r
, const char *name
, int len
)
3687 struct ref_store
*refs
= get_main_ref_store(r
);
3688 struct ref_transaction
*transaction
;
3689 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
3690 struct strbuf msg
= STRBUF_INIT
;
3692 struct object_id head_oid
;
3694 if (len
== 1 && *name
== '#')
3695 return error(_("illegal label name: '%.*s'"), len
, name
);
3697 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3698 strbuf_addf(&msg
, "rebase (label) '%.*s'", len
, name
);
3700 transaction
= ref_store_transaction_begin(refs
, &err
);
3702 error("%s", err
.buf
);
3704 } else if (repo_get_oid(r
, "HEAD", &head_oid
)) {
3705 error(_("could not read HEAD"));
3707 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
3708 NULL
, 0, msg
.buf
, &err
) < 0 ||
3709 ref_transaction_commit(transaction
, &err
)) {
3710 error("%s", err
.buf
);
3713 ref_transaction_free(transaction
);
3714 strbuf_release(&err
);
3715 strbuf_release(&msg
);
3718 ret
= safe_append(rebase_path_refs_to_delete(),
3719 "%s\n", ref_name
.buf
);
3720 strbuf_release(&ref_name
);
3725 static const char *sequencer_reflog_action(struct replay_opts
*opts
)
3727 if (!opts
->reflog_action
) {
3728 opts
->reflog_action
= getenv(GIT_REFLOG_ACTION
);
3729 opts
->reflog_action
=
3730 xstrdup(opts
->reflog_action
? opts
->reflog_action
3731 : action_name(opts
));
3734 return opts
->reflog_action
;
3737 __attribute__((format (printf
, 3, 4)))
3738 static const char *reflog_message(struct replay_opts
*opts
,
3739 const char *sub_action
, const char *fmt
, ...)
3742 static struct strbuf buf
= STRBUF_INIT
;
3746 strbuf_addstr(&buf
, sequencer_reflog_action(opts
));
3748 strbuf_addf(&buf
, " (%s)", sub_action
);
3750 strbuf_addstr(&buf
, ": ");
3751 strbuf_vaddf(&buf
, fmt
, ap
);
3758 static struct commit
*lookup_label(struct repository
*r
, const char *label
,
3759 int len
, struct strbuf
*buf
)
3761 struct commit
*commit
;
3762 struct object_id oid
;
3765 strbuf_addf(buf
, "refs/rewritten/%.*s", len
, label
);
3766 if (!read_ref(buf
->buf
, &oid
)) {
3767 commit
= lookup_commit_object(r
, &oid
);
3769 /* fall back to non-rewritten ref or commit */
3770 strbuf_splice(buf
, 0, strlen("refs/rewritten/"), "", 0);
3771 commit
= lookup_commit_reference_by_name(buf
->buf
);
3775 error(_("could not resolve '%s'"), buf
->buf
);
3780 static int do_reset(struct repository
*r
,
3781 const char *name
, int len
,
3782 struct replay_opts
*opts
)
3784 struct strbuf ref_name
= STRBUF_INIT
;
3785 struct object_id oid
;
3786 struct lock_file lock
= LOCK_INIT
;
3787 struct tree_desc desc
= { 0 };
3789 struct unpack_trees_options unpack_tree_opts
= { 0 };
3792 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0)
3795 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
3796 if (!opts
->have_squash_onto
) {
3798 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
3799 NULL
, &opts
->squash_onto
,
3801 return error(_("writing fake root commit"));
3802 opts
->have_squash_onto
= 1;
3803 hex
= oid_to_hex(&opts
->squash_onto
);
3804 if (write_message(hex
, strlen(hex
),
3805 rebase_path_squash_onto(), 0))
3806 return error(_("writing squash-onto"));
3808 oidcpy(&oid
, &opts
->squash_onto
);
3811 struct commit
*commit
;
3813 /* Determine the length of the label */
3814 for (i
= 0; i
< len
; i
++)
3815 if (isspace(name
[i
]))
3819 commit
= lookup_label(r
, name
, len
, &ref_name
);
3824 oid
= commit
->object
.oid
;
3827 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
3828 unpack_tree_opts
.head_idx
= 1;
3829 unpack_tree_opts
.src_index
= r
->index
;
3830 unpack_tree_opts
.dst_index
= r
->index
;
3831 unpack_tree_opts
.fn
= oneway_merge
;
3832 unpack_tree_opts
.merge
= 1;
3833 unpack_tree_opts
.update
= 1;
3834 unpack_tree_opts
.preserve_ignored
= 0; /* FIXME: !overwrite_ignore */
3835 unpack_tree_opts
.skip_cache_tree_update
= 1;
3836 init_checkout_metadata(&unpack_tree_opts
.meta
, name
, &oid
, NULL
);
3838 if (repo_read_index_unmerged(r
)) {
3839 ret
= error_resolve_conflict(action_name(opts
));
3843 if (!fill_tree_descriptor(r
, &desc
, &oid
)) {
3844 ret
= error(_("failed to find tree of %s"), oid_to_hex(&oid
));
3848 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
3853 tree
= parse_tree_indirect(&oid
);
3854 prime_cache_tree(r
, r
->index
, tree
);
3856 if (write_locked_index(r
->index
, &lock
, COMMIT_LOCK
) < 0)
3857 ret
= error(_("could not write index"));
3860 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
3861 len
, name
), "HEAD", &oid
,
3862 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3864 free((void *)desc
.buffer
);
3866 rollback_lock_file(&lock
);
3867 strbuf_release(&ref_name
);
3868 clear_unpack_trees_porcelain(&unpack_tree_opts
);
3872 static int do_merge(struct repository
*r
,
3873 struct commit
*commit
,
3874 const char *arg
, int arg_len
,
3875 int flags
, int *check_todo
, struct replay_opts
*opts
)
3877 int run_commit_flags
= 0;
3878 struct strbuf ref_name
= STRBUF_INIT
;
3879 struct commit
*head_commit
, *merge_commit
, *i
;
3880 struct commit_list
*bases
, *j
;
3881 struct commit_list
*to_merge
= NULL
, **tail
= &to_merge
;
3882 const char *strategy
= !opts
->xopts_nr
&&
3884 !strcmp(opts
->strategy
, "recursive") ||
3885 !strcmp(opts
->strategy
, "ort")) ?
3886 NULL
: opts
->strategy
;
3887 struct merge_options o
;
3888 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
, k
;
3889 static struct lock_file lock
;
3892 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0) {
3897 head_commit
= lookup_commit_reference_by_name("HEAD");
3899 ret
= error(_("cannot merge without a current revision"));
3904 * For octopus merges, the arg starts with the list of revisions to be
3905 * merged. The list is optionally followed by '#' and the oneline.
3907 merge_arg_len
= oneline_offset
= arg_len
;
3908 for (p
= arg
; p
- arg
< arg_len
; p
+= strspn(p
, " \t\n")) {
3911 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
3912 p
+= 1 + strspn(p
+ 1, " \t\n");
3913 oneline_offset
= p
- arg
;
3916 k
= strcspn(p
, " \t\n");
3919 merge_commit
= lookup_label(r
, p
, k
, &ref_name
);
3920 if (!merge_commit
) {
3921 ret
= error(_("unable to parse '%.*s'"), k
, p
);
3924 tail
= &commit_list_insert(merge_commit
, tail
)->next
;
3926 merge_arg_len
= p
- arg
;
3930 ret
= error(_("nothing to merge: '%.*s'"), arg_len
, arg
);
3934 if (opts
->have_squash_onto
&&
3935 oideq(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
3937 * When the user tells us to "merge" something into a
3938 * "[new root]", let's simply fast-forward to the merge head.
3940 rollback_lock_file(&lock
);
3942 ret
= error(_("octopus merge cannot be executed on "
3943 "top of a [new root]"));
3945 ret
= fast_forward_to(r
, &to_merge
->item
->object
.oid
,
3946 &head_commit
->object
.oid
, 0,
3952 * If HEAD is not identical to the first parent of the original merge
3953 * commit, we cannot fast-forward.
3955 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
3956 oideq(&commit
->parents
->item
->object
.oid
,
3957 &head_commit
->object
.oid
);
3960 * If any merge head is different from the original one, we cannot
3963 if (can_fast_forward
) {
3964 struct commit_list
*p
= commit
->parents
->next
;
3966 for (j
= to_merge
; j
&& p
; j
= j
->next
, p
= p
->next
)
3967 if (!oideq(&j
->item
->object
.oid
,
3968 &p
->item
->object
.oid
)) {
3969 can_fast_forward
= 0;
3973 * If the number of merge heads differs from the original merge
3974 * commit, we cannot fast-forward.
3977 can_fast_forward
= 0;
3980 if (can_fast_forward
) {
3981 rollback_lock_file(&lock
);
3982 ret
= fast_forward_to(r
, &commit
->object
.oid
,
3983 &head_commit
->object
.oid
, 0, opts
);
3984 if (flags
& TODO_EDIT_MERGE_MSG
)
3985 goto fast_forward_edit
;
3991 const char *encoding
= get_commit_output_encoding();
3992 const char *message
= repo_logmsg_reencode(r
, commit
, NULL
,
3998 ret
= error(_("could not get commit message of '%s'"),
3999 oid_to_hex(&commit
->object
.oid
));
4002 write_author_script(message
);
4003 find_commit_subject(message
, &body
);
4005 ret
= write_message(body
, len
, git_path_merge_msg(r
), 0);
4006 repo_unuse_commit_buffer(r
, commit
, message
);
4008 error_errno(_("could not write '%s'"),
4009 git_path_merge_msg(r
));
4013 struct strbuf buf
= STRBUF_INIT
;
4016 strbuf_addf(&buf
, "author %s", git_author_info(0));
4017 write_author_script(buf
.buf
);
4020 if (oneline_offset
< arg_len
) {
4021 p
= arg
+ oneline_offset
;
4022 len
= arg_len
- oneline_offset
;
4024 strbuf_addf(&buf
, "Merge %s '%.*s'",
4025 to_merge
->next
? "branches" : "branch",
4026 merge_arg_len
, arg
);
4031 ret
= write_message(p
, len
, git_path_merge_msg(r
), 0);
4032 strbuf_release(&buf
);
4034 error_errno(_("could not write '%s'"),
4035 git_path_merge_msg(r
));
4040 if (strategy
|| to_merge
->next
) {
4042 struct child_process cmd
= CHILD_PROCESS_INIT
;
4044 if (read_env_script(&cmd
.env
)) {
4045 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
4047 ret
= error(_(staged_changes_advice
), gpg_opt
, gpg_opt
);
4051 if (opts
->committer_date_is_author_date
)
4052 strvec_pushf(&cmd
.env
, "GIT_COMMITTER_DATE=%s",
4055 author_date_from_env(&cmd
.env
));
4056 if (opts
->ignore_date
)
4057 strvec_push(&cmd
.env
, "GIT_AUTHOR_DATE=");
4060 strvec_push(&cmd
.args
, "merge");
4061 strvec_push(&cmd
.args
, "-s");
4063 strvec_push(&cmd
.args
, "octopus");
4065 strvec_push(&cmd
.args
, strategy
);
4066 for (k
= 0; k
< opts
->xopts_nr
; k
++)
4067 strvec_pushf(&cmd
.args
,
4068 "-X%s", opts
->xopts
[k
]);
4070 if (!(flags
& TODO_EDIT_MERGE_MSG
))
4071 strvec_push(&cmd
.args
, "--no-edit");
4073 strvec_push(&cmd
.args
, "--edit");
4074 strvec_push(&cmd
.args
, "--no-ff");
4075 strvec_push(&cmd
.args
, "--no-log");
4076 strvec_push(&cmd
.args
, "--no-stat");
4077 strvec_push(&cmd
.args
, "-F");
4078 strvec_push(&cmd
.args
, git_path_merge_msg(r
));
4080 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
4082 strvec_push(&cmd
.args
, "--no-gpg-sign");
4084 /* Add the tips to be merged */
4085 for (j
= to_merge
; j
; j
= j
->next
)
4086 strvec_push(&cmd
.args
,
4087 oid_to_hex(&j
->item
->object
.oid
));
4089 strbuf_release(&ref_name
);
4090 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
4092 rollback_lock_file(&lock
);
4094 ret
= run_command(&cmd
);
4096 /* force re-reading of the cache */
4098 discard_index(r
->index
);
4099 if (repo_read_index(r
) < 0)
4100 ret
= error(_("could not read index"));
4105 merge_commit
= to_merge
->item
;
4106 bases
= repo_get_merge_bases(r
, head_commit
, merge_commit
);
4107 if (bases
&& oideq(&merge_commit
->object
.oid
,
4108 &bases
->item
->object
.oid
)) {
4110 /* skip merging an ancestor of HEAD */
4114 write_message(oid_to_hex(&merge_commit
->object
.oid
), the_hash_algo
->hexsz
,
4115 git_path_merge_head(r
), 0);
4116 write_message("no-ff", 5, git_path_merge_mode(r
), 0);
4118 bases
= reverse_commit_list(bases
);
4121 init_merge_options(&o
, r
);
4123 o
.branch2
= ref_name
.buf
;
4124 o
.buffer_output
= 2;
4126 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
4128 * TODO: Should use merge_incore_recursive() and
4129 * merge_switch_to_result(), skipping the call to
4130 * merge_switch_to_result() when we don't actually need to
4131 * update the index and working copy immediately.
4133 ret
= merge_ort_recursive(&o
,
4134 head_commit
, merge_commit
, bases
,
4137 ret
= merge_recursive(&o
, head_commit
, merge_commit
, bases
,
4141 fputs(o
.obuf
.buf
, stdout
);
4142 strbuf_release(&o
.obuf
);
4144 error(_("could not even attempt to merge '%.*s'"),
4145 merge_arg_len
, arg
);
4149 * The return value of merge_recursive() is 1 on clean, and 0 on
4152 * Let's reverse that, so that do_merge() returns 0 upon success and
4153 * 1 upon failed merge (keeping the return value -1 for the cases where
4154 * we will want to reschedule the `merge` command).
4158 if (r
->index
->cache_changed
&&
4159 write_locked_index(r
->index
, &lock
, COMMIT_LOCK
)) {
4160 ret
= error(_("merge: Unable to write new index file"));
4164 rollback_lock_file(&lock
);
4166 repo_rerere(r
, opts
->allow_rerere_auto
);
4169 * In case of problems, we now want to return a positive
4170 * value (a negative one would indicate that the `merge`
4171 * command needs to be rescheduled).
4173 ret
= !!run_git_commit(git_path_merge_msg(r
), opts
,
4176 if (!ret
&& flags
& TODO_EDIT_MERGE_MSG
) {
4179 run_commit_flags
|= AMEND_MSG
| EDIT_MSG
| VERIFY_MSG
;
4180 ret
= !!run_git_commit(NULL
, opts
, run_commit_flags
);
4185 strbuf_release(&ref_name
);
4186 rollback_lock_file(&lock
);
4187 free_commit_list(to_merge
);
4191 static int write_update_refs_state(struct string_list
*refs_to_oids
)
4194 struct lock_file lock
= LOCK_INIT
;
4196 struct string_list_item
*item
;
4199 path
= rebase_path_update_refs(the_repository
->gitdir
);
4201 if (!refs_to_oids
->nr
) {
4202 if (unlink(path
) && errno
!= ENOENT
)
4203 result
= error_errno(_("could not unlink: %s"), path
);
4207 if (safe_create_leading_directories(path
)) {
4208 result
= error(_("unable to create leading directories of %s"),
4213 if (hold_lock_file_for_update(&lock
, path
, 0) < 0) {
4214 result
= error(_("another 'rebase' process appears to be running; "
4215 "'%s.lock' already exists"),
4220 fp
= fdopen_lock_file(&lock
, "w");
4222 result
= error_errno(_("could not open '%s' for writing"), path
);
4223 rollback_lock_file(&lock
);
4227 for_each_string_list_item(item
, refs_to_oids
) {
4228 struct update_ref_record
*rec
= item
->util
;
4229 fprintf(fp
, "%s\n%s\n%s\n", item
->string
,
4230 oid_to_hex(&rec
->before
), oid_to_hex(&rec
->after
));
4233 result
= commit_lock_file(&lock
);
4241 * Parse the update-refs file for the current rebase, then remove the
4242 * refs that do not appear in the todo_list (and have not had updated
4243 * values stored) and add refs that are in the todo_list but not
4244 * represented in the update-refs file.
4246 * If there are changes to the update-refs list, then write the new state
4249 void todo_list_filter_update_refs(struct repository
*r
,
4250 struct todo_list
*todo_list
)
4254 struct string_list update_refs
= STRING_LIST_INIT_DUP
;
4256 sequencer_get_update_refs_state(r
->gitdir
, &update_refs
);
4259 * For each item in the update_refs list, if it has no updated
4260 * value and does not appear in the todo_list, then remove it
4261 * from the update_refs list.
4263 for (i
= 0; i
< update_refs
.nr
; i
++) {
4266 const char *ref
= update_refs
.items
[i
].string
;
4267 size_t reflen
= strlen(ref
);
4268 struct update_ref_record
*rec
= update_refs
.items
[i
].util
;
4270 /* OID already stored as updated. */
4271 if (!is_null_oid(&rec
->after
))
4274 for (j
= 0; !found
&& j
< todo_list
->total_nr
; j
++) {
4275 struct todo_item
*item
= &todo_list
->items
[j
];
4276 const char *arg
= todo_list
->buf
.buf
+ item
->arg_offset
;
4278 if (item
->command
!= TODO_UPDATE_REF
)
4281 if (item
->arg_len
!= reflen
||
4282 strncmp(arg
, ref
, reflen
))
4289 free(update_refs
.items
[i
].string
);
4290 free(update_refs
.items
[i
].util
);
4293 MOVE_ARRAY(update_refs
.items
+ i
, update_refs
.items
+ i
+ 1, update_refs
.nr
- i
);
4301 * For each todo_item, check if its ref is in the update_refs list.
4302 * If not, then add it as an un-updated ref.
4304 for (i
= 0; i
< todo_list
->total_nr
; i
++) {
4305 struct todo_item
*item
= &todo_list
->items
[i
];
4306 const char *arg
= todo_list
->buf
.buf
+ item
->arg_offset
;
4309 if (item
->command
!= TODO_UPDATE_REF
)
4312 for (j
= 0; !found
&& j
< update_refs
.nr
; j
++) {
4313 const char *ref
= update_refs
.items
[j
].string
;
4315 found
= strlen(ref
) == item
->arg_len
&&
4316 !strncmp(ref
, arg
, item
->arg_len
);
4320 struct string_list_item
*inserted
;
4321 struct strbuf argref
= STRBUF_INIT
;
4323 strbuf_add(&argref
, arg
, item
->arg_len
);
4324 inserted
= string_list_insert(&update_refs
, argref
.buf
);
4325 inserted
->util
= init_update_ref_record(argref
.buf
);
4326 strbuf_release(&argref
);
4332 write_update_refs_state(&update_refs
);
4333 string_list_clear(&update_refs
, 1);
4336 static int do_update_ref(struct repository
*r
, const char *refname
)
4338 struct string_list_item
*item
;
4339 struct string_list list
= STRING_LIST_INIT_DUP
;
4341 if (sequencer_get_update_refs_state(r
->gitdir
, &list
))
4344 for_each_string_list_item(item
, &list
) {
4345 if (!strcmp(item
->string
, refname
)) {
4346 struct update_ref_record
*rec
= item
->util
;
4347 if (read_ref("HEAD", &rec
->after
))
4353 write_update_refs_state(&list
);
4354 string_list_clear(&list
, 1);
4358 static int do_update_refs(struct repository
*r
, int quiet
)
4361 struct string_list_item
*item
;
4362 struct string_list refs_to_oids
= STRING_LIST_INIT_DUP
;
4363 struct ref_store
*refs
= get_main_ref_store(r
);
4364 struct strbuf update_msg
= STRBUF_INIT
;
4365 struct strbuf error_msg
= STRBUF_INIT
;
4367 if ((res
= sequencer_get_update_refs_state(r
->gitdir
, &refs_to_oids
)))
4370 for_each_string_list_item(item
, &refs_to_oids
) {
4371 struct update_ref_record
*rec
= item
->util
;
4374 loop_res
= refs_update_ref(refs
, "rewritten during rebase",
4376 &rec
->after
, &rec
->before
,
4377 0, UPDATE_REFS_MSG_ON_ERR
);
4384 strbuf_addf(&error_msg
, "\t%s\n", item
->string
);
4386 strbuf_addf(&update_msg
, "\t%s\n", item
->string
);
4390 (update_msg
.len
|| error_msg
.len
)) {
4392 _("Updated the following refs with %s:\n%s"),
4398 _("Failed to update the following refs with %s:\n%s"),
4403 string_list_clear(&refs_to_oids
, 1);
4404 strbuf_release(&update_msg
);
4405 strbuf_release(&error_msg
);
4409 static int is_final_fixup(struct todo_list
*todo_list
)
4411 int i
= todo_list
->current
;
4413 if (!is_fixup(todo_list
->items
[i
].command
))
4416 while (++i
< todo_list
->nr
)
4417 if (is_fixup(todo_list
->items
[i
].command
))
4419 else if (!is_noop(todo_list
->items
[i
].command
))
4424 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
4428 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
4429 if (!is_noop(todo_list
->items
[i
].command
))
4430 return todo_list
->items
[i
].command
;
4435 void create_autostash(struct repository
*r
, const char *path
)
4437 struct strbuf buf
= STRBUF_INIT
;
4438 struct lock_file lock_file
= LOCK_INIT
;
4441 fd
= repo_hold_locked_index(r
, &lock_file
, 0);
4442 refresh_index(r
->index
, REFRESH_QUIET
, NULL
, NULL
, NULL
);
4444 repo_update_index_if_able(r
, &lock_file
);
4445 rollback_lock_file(&lock_file
);
4447 if (has_unstaged_changes(r
, 1) ||
4448 has_uncommitted_changes(r
, 1)) {
4449 struct child_process stash
= CHILD_PROCESS_INIT
;
4450 struct reset_head_opts ropts
= { .flags
= RESET_HEAD_HARD
};
4451 struct object_id oid
;
4453 strvec_pushl(&stash
.args
,
4454 "stash", "create", "autostash", NULL
);
4458 if (capture_command(&stash
, &buf
, GIT_MAX_HEXSZ
))
4459 die(_("Cannot autostash"));
4460 strbuf_trim_trailing_newline(&buf
);
4461 if (repo_get_oid(r
, buf
.buf
, &oid
))
4462 die(_("Unexpected stash response: '%s'"),
4465 strbuf_add_unique_abbrev(&buf
, &oid
, DEFAULT_ABBREV
);
4467 if (safe_create_leading_directories_const(path
))
4468 die(_("Could not create directory for '%s'"),
4470 write_file(path
, "%s", oid_to_hex(&oid
));
4471 printf(_("Created autostash: %s\n"), buf
.buf
);
4472 if (reset_head(r
, &ropts
) < 0)
4473 die(_("could not reset --hard"));
4474 discard_index(r
->index
);
4475 if (repo_read_index(r
) < 0)
4476 die(_("could not read index"));
4478 strbuf_release(&buf
);
4481 static int apply_save_autostash_oid(const char *stash_oid
, int attempt_apply
)
4483 struct child_process child
= CHILD_PROCESS_INIT
;
4486 if (attempt_apply
) {
4488 child
.no_stdout
= 1;
4489 child
.no_stderr
= 1;
4490 strvec_push(&child
.args
, "stash");
4491 strvec_push(&child
.args
, "apply");
4492 strvec_push(&child
.args
, stash_oid
);
4493 ret
= run_command(&child
);
4496 if (attempt_apply
&& !ret
)
4497 fprintf(stderr
, _("Applied autostash.\n"));
4499 struct child_process store
= CHILD_PROCESS_INIT
;
4502 strvec_push(&store
.args
, "stash");
4503 strvec_push(&store
.args
, "store");
4504 strvec_push(&store
.args
, "-m");
4505 strvec_push(&store
.args
, "autostash");
4506 strvec_push(&store
.args
, "-q");
4507 strvec_push(&store
.args
, stash_oid
);
4508 if (run_command(&store
))
4509 ret
= error(_("cannot store %s"), stash_oid
);
4513 "Your changes are safe in the stash.\n"
4514 "You can run \"git stash pop\" or"
4515 " \"git stash drop\" at any time.\n"),
4517 _("Applying autostash resulted in conflicts.") :
4518 _("Autostash exists; creating a new stash entry."));
4524 static int apply_save_autostash(const char *path
, int attempt_apply
)
4526 struct strbuf stash_oid
= STRBUF_INIT
;
4529 if (!read_oneliner(&stash_oid
, path
,
4530 READ_ONELINER_SKIP_IF_EMPTY
)) {
4531 strbuf_release(&stash_oid
);
4534 strbuf_trim(&stash_oid
);
4536 ret
= apply_save_autostash_oid(stash_oid
.buf
, attempt_apply
);
4539 strbuf_release(&stash_oid
);
4543 int save_autostash(const char *path
)
4545 return apply_save_autostash(path
, 0);
4548 int apply_autostash(const char *path
)
4550 return apply_save_autostash(path
, 1);
4553 int apply_autostash_oid(const char *stash_oid
)
4555 return apply_save_autostash_oid(stash_oid
, 1);
4558 static int checkout_onto(struct repository
*r
, struct replay_opts
*opts
,
4559 const char *onto_name
, const struct object_id
*onto
,
4560 const struct object_id
*orig_head
)
4562 struct reset_head_opts ropts
= {
4564 .orig_head
= orig_head
,
4565 .flags
= RESET_HEAD_DETACH
| RESET_ORIG_HEAD
|
4566 RESET_HEAD_RUN_POST_CHECKOUT_HOOK
,
4567 .head_msg
= reflog_message(opts
, "start", "checkout %s",
4569 .default_reflog_action
= sequencer_reflog_action(opts
)
4571 if (reset_head(r
, &ropts
)) {
4572 apply_autostash(rebase_path_autostash());
4573 sequencer_remove_state(opts
);
4574 return error(_("could not detach HEAD"));
4580 static int stopped_at_head(struct repository
*r
)
4582 struct object_id head
;
4583 struct commit
*commit
;
4584 struct commit_message message
;
4586 if (repo_get_oid(r
, "HEAD", &head
) ||
4587 !(commit
= lookup_commit(r
, &head
)) ||
4588 repo_parse_commit(r
, commit
) || get_message(commit
, &message
))
4589 fprintf(stderr
, _("Stopped at HEAD\n"));
4591 fprintf(stderr
, _("Stopped at %s\n"), message
.label
);
4592 free_message(commit
, &message
);
4598 static int reread_todo_if_changed(struct repository
*r
,
4599 struct todo_list
*todo_list
,
4600 struct replay_opts
*opts
)
4603 struct strbuf buf
= STRBUF_INIT
;
4605 if (strbuf_read_file_or_whine(&buf
, get_todo_path(opts
)) < 0)
4607 offset
= get_item_line_offset(todo_list
, todo_list
->current
+ 1);
4608 if (buf
.len
!= todo_list
->buf
.len
- offset
||
4609 memcmp(buf
.buf
, todo_list
->buf
.buf
+ offset
, buf
.len
)) {
4610 /* Reread the todo file if it has changed. */
4611 todo_list_release(todo_list
);
4612 if (read_populate_todo(r
, todo_list
, opts
))
4613 return -1; /* message was printed */
4614 /* `current` will be incremented on return */
4615 todo_list
->current
= -1;
4617 strbuf_release(&buf
);
4622 static const char rescheduled_advice
[] =
4623 N_("Could not execute the todo command\n"
4627 "It has been rescheduled; To edit the command before continuing, please\n"
4628 "edit the todo list first:\n"
4630 " git rebase --edit-todo\n"
4631 " git rebase --continue\n");
4633 static int pick_commits(struct repository
*r
,
4634 struct todo_list
*todo_list
,
4635 struct replay_opts
*opts
)
4637 int res
= 0, reschedule
= 0;
4639 opts
->reflog_message
= sequencer_reflog_action(opts
);
4641 assert(!(opts
->signoff
|| opts
->no_commit
||
4642 opts
->record_origin
|| should_edit(opts
) ||
4643 opts
->committer_date_is_author_date
||
4644 opts
->ignore_date
));
4645 if (read_and_refresh_cache(r
, opts
))
4648 while (todo_list
->current
< todo_list
->nr
) {
4649 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
4650 const char *arg
= todo_item_get_arg(todo_list
, item
);
4653 if (save_todo(todo_list
, opts
))
4655 if (is_rebase_i(opts
)) {
4656 if (item
->command
!= TODO_COMMENT
) {
4657 FILE *f
= fopen(rebase_path_msgnum(), "w");
4659 todo_list
->done_nr
++;
4662 fprintf(f
, "%d\n", todo_list
->done_nr
);
4666 fprintf(stderr
, _("Rebasing (%d/%d)%s"),
4668 todo_list
->total_nr
,
4669 opts
->verbose
? "\n" : "\r");
4671 unlink(rebase_path_message());
4672 unlink(rebase_path_author_script());
4673 unlink(rebase_path_stopped_sha());
4674 unlink(rebase_path_amend());
4675 unlink(git_path_merge_head(r
));
4676 unlink(git_path_auto_merge(r
));
4677 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
4679 if (item
->command
== TODO_BREAK
) {
4682 return stopped_at_head(r
);
4685 if (item
->command
<= TODO_SQUASH
) {
4686 if (is_rebase_i(opts
))
4687 opts
->reflog_message
= reflog_message(opts
,
4688 command_to_string(item
->command
), NULL
);
4690 res
= do_pick_commit(r
, item
, opts
,
4691 is_final_fixup(todo_list
),
4693 if (is_rebase_i(opts
) && res
< 0) {
4695 advise(_(rescheduled_advice
),
4696 get_item_line_length(todo_list
,
4697 todo_list
->current
),
4698 get_item_line(todo_list
,
4699 todo_list
->current
));
4700 todo_list
->current
--;
4701 if (save_todo(todo_list
, opts
))
4704 if (item
->command
== TODO_EDIT
) {
4705 struct commit
*commit
= item
->commit
;
4710 _("Stopped at %s... %.*s\n"),
4711 short_commit_name(commit
),
4712 item
->arg_len
, arg
);
4714 return error_with_patch(r
, commit
,
4715 arg
, item
->arg_len
, opts
, res
, !res
);
4717 if (is_rebase_i(opts
) && !res
)
4718 record_in_rewritten(&item
->commit
->object
.oid
,
4719 peek_command(todo_list
, 1));
4720 if (res
&& is_fixup(item
->command
)) {
4723 return error_failed_squash(r
, item
->commit
, opts
,
4724 item
->arg_len
, arg
);
4725 } else if (res
&& is_rebase_i(opts
) && item
->commit
) {
4727 struct object_id oid
;
4730 * If we are rewording and have either
4731 * fast-forwarded already, or are about to
4732 * create a new root commit, we want to amend,
4733 * otherwise we do not.
4735 if (item
->command
== TODO_REWORD
&&
4736 !repo_get_oid(r
, "HEAD", &oid
) &&
4737 (oideq(&item
->commit
->object
.oid
, &oid
) ||
4738 (opts
->have_squash_onto
&&
4739 oideq(&opts
->squash_onto
, &oid
))))
4742 return res
| error_with_patch(r
, item
->commit
,
4743 arg
, item
->arg_len
, opts
,
4746 } else if (item
->command
== TODO_EXEC
) {
4747 char *end_of_arg
= (char *)(arg
+ item
->arg_len
);
4748 int saved
= *end_of_arg
;
4753 res
= do_exec(r
, arg
);
4754 *end_of_arg
= saved
;
4757 if (opts
->reschedule_failed_exec
)
4761 } else if (item
->command
== TODO_LABEL
) {
4762 if ((res
= do_label(r
, arg
, item
->arg_len
)))
4764 } else if (item
->command
== TODO_RESET
) {
4765 if ((res
= do_reset(r
, arg
, item
->arg_len
, opts
)))
4767 } else if (item
->command
== TODO_MERGE
) {
4768 if ((res
= do_merge(r
, item
->commit
, arg
, item
->arg_len
,
4769 item
->flags
, &check_todo
, opts
)) < 0)
4771 else if (item
->commit
)
4772 record_in_rewritten(&item
->commit
->object
.oid
,
4773 peek_command(todo_list
, 1));
4775 /* failed with merge conflicts */
4776 return error_with_patch(r
, item
->commit
,
4779 } else if (item
->command
== TODO_UPDATE_REF
) {
4780 struct strbuf ref
= STRBUF_INIT
;
4781 strbuf_add(&ref
, arg
, item
->arg_len
);
4782 if ((res
= do_update_ref(r
, ref
.buf
)))
4784 strbuf_release(&ref
);
4785 } else if (!is_noop(item
->command
))
4786 return error(_("unknown command %d"), item
->command
);
4789 advise(_(rescheduled_advice
),
4790 get_item_line_length(todo_list
,
4791 todo_list
->current
),
4792 get_item_line(todo_list
, todo_list
->current
));
4793 todo_list
->current
--;
4794 if (save_todo(todo_list
, opts
))
4797 return error_with_patch(r
,
4801 } else if (is_rebase_i(opts
) && check_todo
&& !res
&&
4802 reread_todo_if_changed(r
, todo_list
, opts
)) {
4806 todo_list
->current
++;
4811 if (is_rebase_i(opts
)) {
4812 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
4815 /* Stopped in the middle, as planned? */
4816 if (todo_list
->current
< todo_list
->nr
)
4819 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
4820 starts_with(head_ref
.buf
, "refs/")) {
4822 struct object_id head
, orig
;
4825 if (repo_get_oid(r
, "HEAD", &head
)) {
4826 res
= error(_("cannot read HEAD"));
4828 strbuf_release(&head_ref
);
4829 strbuf_release(&buf
);
4832 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
4833 get_oid_hex(buf
.buf
, &orig
)) {
4834 res
= error(_("could not read orig-head"));
4835 goto cleanup_head_ref
;
4838 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
4839 res
= error(_("could not read 'onto'"));
4840 goto cleanup_head_ref
;
4842 msg
= reflog_message(opts
, "finish", "%s onto %s",
4843 head_ref
.buf
, buf
.buf
);
4844 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
4845 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
4846 res
= error(_("could not update %s"),
4848 goto cleanup_head_ref
;
4850 msg
= reflog_message(opts
, "finish", "returning to %s",
4852 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
4853 res
= error(_("could not update HEAD to %s"),
4855 goto cleanup_head_ref
;
4860 if (opts
->verbose
) {
4861 struct rev_info log_tree_opt
;
4862 struct object_id orig
, head
;
4864 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
4865 repo_init_revisions(r
, &log_tree_opt
, NULL
);
4866 log_tree_opt
.diff
= 1;
4867 log_tree_opt
.diffopt
.output_format
=
4868 DIFF_FORMAT_DIFFSTAT
;
4869 log_tree_opt
.disable_stdin
= 1;
4871 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
4872 !repo_get_oid(r
, buf
.buf
, &orig
) &&
4873 !repo_get_oid(r
, "HEAD", &head
)) {
4874 diff_tree_oid(&orig
, &head
, "",
4875 &log_tree_opt
.diffopt
);
4876 log_tree_diff_flush(&log_tree_opt
);
4878 release_revisions(&log_tree_opt
);
4880 flush_rewritten_pending();
4881 if (!stat(rebase_path_rewritten_list(), &st
) &&
4883 struct child_process child
= CHILD_PROCESS_INIT
;
4884 struct run_hooks_opt hook_opt
= RUN_HOOKS_OPT_INIT
;
4886 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
4888 strvec_push(&child
.args
, "notes");
4889 strvec_push(&child
.args
, "copy");
4890 strvec_push(&child
.args
, "--for-rewrite=rebase");
4891 /* we don't care if this copying failed */
4892 run_command(&child
);
4894 hook_opt
.path_to_stdin
= rebase_path_rewritten_list();
4895 strvec_push(&hook_opt
.args
, "rebase");
4896 run_hooks_opt("post-rewrite", &hook_opt
);
4898 apply_autostash(rebase_path_autostash());
4904 _("Successfully rebased and updated %s.\n"),
4908 strbuf_release(&buf
);
4909 strbuf_release(&head_ref
);
4911 if (do_update_refs(r
, opts
->quiet
))
4916 * Sequence of picks finished successfully; cleanup by
4917 * removing the .git/sequencer directory
4919 return sequencer_remove_state(opts
);
4922 static int continue_single_pick(struct repository
*r
, struct replay_opts
*opts
)
4924 struct child_process cmd
= CHILD_PROCESS_INIT
;
4926 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
4927 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
4928 return error(_("no cherry-pick or revert in progress"));
4931 strvec_push(&cmd
.args
, "commit");
4934 * continue_single_pick() handles the case of recovering from a
4935 * conflict. should_edit() doesn't handle that case; for a conflict,
4936 * we want to edit if the user asked for it, or if they didn't specify
4937 * and stdin is a tty.
4939 if (!opts
->edit
|| (opts
->edit
< 0 && !isatty(0)))
4941 * Include --cleanup=strip as well because we don't want the
4942 * "# Conflicts:" messages.
4944 strvec_pushl(&cmd
.args
, "--no-edit", "--cleanup=strip", NULL
);
4946 return run_command(&cmd
);
4949 static int commit_staged_changes(struct repository
*r
,
4950 struct replay_opts
*opts
,
4951 struct todo_list
*todo_list
)
4953 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
4954 unsigned int final_fixup
= 0, is_clean
;
4956 if (has_unstaged_changes(r
, 1))
4957 return error(_("cannot rebase: You have unstaged changes."));
4959 is_clean
= !has_uncommitted_changes(r
, 0);
4961 if (file_exists(rebase_path_amend())) {
4962 struct strbuf rev
= STRBUF_INIT
;
4963 struct object_id head
, to_amend
;
4965 if (repo_get_oid(r
, "HEAD", &head
))
4966 return error(_("cannot amend non-existing commit"));
4967 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
4968 return error(_("invalid file: '%s'"), rebase_path_amend());
4969 if (get_oid_hex(rev
.buf
, &to_amend
))
4970 return error(_("invalid contents: '%s'"),
4971 rebase_path_amend());
4972 if (!is_clean
&& !oideq(&head
, &to_amend
))
4973 return error(_("\nYou have uncommitted changes in your "
4974 "working tree. Please, commit them\n"
4975 "first and then run 'git rebase "
4976 "--continue' again."));
4978 * When skipping a failed fixup/squash, we need to edit the
4979 * commit message, the current fixup list and count, and if it
4980 * was the last fixup/squash in the chain, we need to clean up
4981 * the commit message and if there was a squash, let the user
4984 if (!is_clean
|| !opts
->current_fixup_count
)
4985 ; /* this is not the final fixup */
4986 else if (!oideq(&head
, &to_amend
) ||
4987 !file_exists(rebase_path_stopped_sha())) {
4988 /* was a final fixup or squash done manually? */
4989 if (!is_fixup(peek_command(todo_list
, 0))) {
4990 unlink(rebase_path_fixup_msg());
4991 unlink(rebase_path_squash_msg());
4992 unlink(rebase_path_current_fixups());
4993 strbuf_reset(&opts
->current_fixups
);
4994 opts
->current_fixup_count
= 0;
4997 /* we are in a fixup/squash chain */
4998 const char *p
= opts
->current_fixups
.buf
;
4999 int len
= opts
->current_fixups
.len
;
5001 opts
->current_fixup_count
--;
5003 BUG("Incorrect current_fixups:\n%s", p
);
5004 while (len
&& p
[len
- 1] != '\n')
5006 strbuf_setlen(&opts
->current_fixups
, len
);
5007 if (write_message(p
, len
, rebase_path_current_fixups(),
5009 return error(_("could not write file: '%s'"),
5010 rebase_path_current_fixups());
5013 * If a fixup/squash in a fixup/squash chain failed, the
5014 * commit message is already correct, no need to commit
5017 * Only if it is the final command in the fixup/squash
5018 * chain, and only if the chain is longer than a single
5019 * fixup/squash command (which was just skipped), do we
5020 * actually need to re-commit with a cleaned up commit
5023 if (opts
->current_fixup_count
> 0 &&
5024 !is_fixup(peek_command(todo_list
, 0))) {
5027 * If there was not a single "squash" in the
5028 * chain, we only need to clean up the commit
5029 * message, no need to bother the user with
5030 * opening the commit message in the editor.
5032 if (!starts_with(p
, "squash ") &&
5033 !strstr(p
, "\nsquash "))
5034 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
5035 } else if (is_fixup(peek_command(todo_list
, 0))) {
5037 * We need to update the squash message to skip
5038 * the latest commit message.
5040 struct commit
*commit
;
5041 const char *path
= rebase_path_squash_msg();
5042 const char *encoding
= get_commit_output_encoding();
5044 if (parse_head(r
, &commit
) ||
5045 !(p
= repo_logmsg_reencode(r
, commit
, NULL
, encoding
)) ||
5046 write_message(p
, strlen(p
), path
, 0)) {
5047 repo_unuse_commit_buffer(r
, commit
, p
);
5048 return error(_("could not write file: "
5051 repo_unuse_commit_buffer(r
,
5056 strbuf_release(&rev
);
5061 if (refs_ref_exists(get_main_ref_store(r
),
5062 "CHERRY_PICK_HEAD") &&
5063 refs_delete_ref(get_main_ref_store(r
), "",
5064 "CHERRY_PICK_HEAD", NULL
, 0))
5065 return error(_("could not remove CHERRY_PICK_HEAD"));
5066 if (unlink(git_path_merge_msg(r
)) && errno
!= ENOENT
)
5067 return error_errno(_("could not remove '%s'"),
5068 git_path_merge_msg(r
));
5073 if (run_git_commit(final_fixup
? NULL
: rebase_path_message(),
5075 return error(_("could not commit staged changes."));
5076 unlink(rebase_path_amend());
5077 unlink(git_path_merge_head(r
));
5078 unlink(git_path_auto_merge(r
));
5080 unlink(rebase_path_fixup_msg());
5081 unlink(rebase_path_squash_msg());
5083 if (opts
->current_fixup_count
> 0) {
5085 * Whether final fixup or not, we just cleaned up the commit
5088 unlink(rebase_path_current_fixups());
5089 strbuf_reset(&opts
->current_fixups
);
5090 opts
->current_fixup_count
= 0;
5095 int sequencer_continue(struct repository
*r
, struct replay_opts
*opts
)
5097 struct todo_list todo_list
= TODO_LIST_INIT
;
5100 if (read_and_refresh_cache(r
, opts
))
5103 if (read_populate_opts(opts
))
5105 if (is_rebase_i(opts
)) {
5106 if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
5107 goto release_todo_list
;
5109 if (file_exists(rebase_path_dropped())) {
5110 if ((res
= todo_list_check_against_backup(r
, &todo_list
)))
5111 goto release_todo_list
;
5113 unlink(rebase_path_dropped());
5116 opts
->reflog_message
= reflog_message(opts
, "continue", NULL
);
5117 if (commit_staged_changes(r
, opts
, &todo_list
)) {
5119 goto release_todo_list
;
5121 } else if (!file_exists(get_todo_path(opts
)))
5122 return continue_single_pick(r
, opts
);
5123 else if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
5124 goto release_todo_list
;
5126 if (!is_rebase_i(opts
)) {
5127 /* Verify that the conflict has been resolved */
5128 if (refs_ref_exists(get_main_ref_store(r
),
5129 "CHERRY_PICK_HEAD") ||
5130 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
5131 res
= continue_single_pick(r
, opts
);
5133 goto release_todo_list
;
5135 if (index_differs_from(r
, "HEAD", NULL
, 0)) {
5136 res
= error_dirty_index(r
, opts
);
5137 goto release_todo_list
;
5139 todo_list
.current
++;
5140 } else if (file_exists(rebase_path_stopped_sha())) {
5141 struct strbuf buf
= STRBUF_INIT
;
5142 struct object_id oid
;
5144 if (read_oneliner(&buf
, rebase_path_stopped_sha(),
5145 READ_ONELINER_SKIP_IF_EMPTY
) &&
5146 !get_oid_hex(buf
.buf
, &oid
))
5147 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
5148 strbuf_release(&buf
);
5151 res
= pick_commits(r
, &todo_list
, opts
);
5153 todo_list_release(&todo_list
);
5157 static int single_pick(struct repository
*r
,
5158 struct commit
*cmit
,
5159 struct replay_opts
*opts
)
5162 struct todo_item item
;
5164 item
.command
= opts
->action
== REPLAY_PICK
?
5165 TODO_PICK
: TODO_REVERT
;
5168 opts
->reflog_message
= sequencer_reflog_action(opts
);
5169 return do_pick_commit(r
, &item
, opts
, 0, &check_todo
);
5172 int sequencer_pick_revisions(struct repository
*r
,
5173 struct replay_opts
*opts
)
5175 struct todo_list todo_list
= TODO_LIST_INIT
;
5176 struct object_id oid
;
5180 if (read_and_refresh_cache(r
, opts
))
5183 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
5184 struct object_id oid
;
5185 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
5187 /* This happens when using --stdin. */
5191 if (!repo_get_oid(r
, name
, &oid
)) {
5192 if (!lookup_commit_reference_gently(r
, &oid
, 1)) {
5193 enum object_type type
= oid_object_info(r
,
5196 return error(_("%s: can't cherry-pick a %s"),
5197 name
, type_name(type
));
5200 return error(_("%s: bad revision"), name
);
5204 * If we were called as "git cherry-pick <commit>", just
5205 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
5206 * REVERT_HEAD, and don't touch the sequencer state.
5207 * This means it is possible to cherry-pick in the middle
5208 * of a cherry-pick sequence.
5210 if (opts
->revs
->cmdline
.nr
== 1 &&
5211 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
5212 opts
->revs
->no_walk
&&
5213 !opts
->revs
->cmdline
.rev
->flags
) {
5214 struct commit
*cmit
;
5215 if (prepare_revision_walk(opts
->revs
))
5216 return error(_("revision walk setup failed"));
5217 cmit
= get_revision(opts
->revs
);
5219 return error(_("empty commit set passed"));
5220 if (get_revision(opts
->revs
))
5221 BUG("unexpected extra commit from walk");
5222 return single_pick(r
, cmit
, opts
);
5226 * Start a new cherry-pick/ revert sequence; but
5227 * first, make sure that an existing one isn't in
5231 if (walk_revs_populate_todo(&todo_list
, opts
) ||
5232 create_seq_dir(r
) < 0)
5234 if (repo_get_oid(r
, "HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
5235 return error(_("can't revert as initial commit"));
5236 if (save_head(oid_to_hex(&oid
)))
5238 if (save_opts(opts
))
5240 update_abort_safety_file();
5241 res
= pick_commits(r
, &todo_list
, opts
);
5242 todo_list_release(&todo_list
);
5246 void append_signoff(struct strbuf
*msgbuf
, size_t ignore_footer
, unsigned flag
)
5248 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
5249 struct strbuf sob
= STRBUF_INIT
;
5252 strbuf_addstr(&sob
, sign_off_header
);
5253 strbuf_addstr(&sob
, fmt_name(WANT_COMMITTER_IDENT
));
5254 strbuf_addch(&sob
, '\n');
5257 strbuf_complete_line(msgbuf
);
5260 * If the whole message buffer is equal to the sob, pretend that we
5261 * found a conforming footer with a matching sob
5263 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
5264 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
5267 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
5270 const char *append_newlines
= NULL
;
5271 size_t len
= msgbuf
->len
- ignore_footer
;
5275 * The buffer is completely empty. Leave foom for
5276 * the title and body to be filled in by the user.
5278 append_newlines
= "\n\n";
5279 } else if (len
== 1) {
5281 * Buffer contains a single newline. Add another
5282 * so that we leave room for the title and body.
5284 append_newlines
= "\n";
5285 } else if (msgbuf
->buf
[len
- 2] != '\n') {
5287 * Buffer ends with a single newline. Add another
5288 * so that there is an empty line between the message
5291 append_newlines
= "\n";
5292 } /* else, the buffer already ends with two newlines. */
5294 if (append_newlines
)
5295 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
5296 append_newlines
, strlen(append_newlines
));
5299 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
5300 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
5303 strbuf_release(&sob
);
5306 struct labels_entry
{
5307 struct hashmap_entry entry
;
5308 char label
[FLEX_ARRAY
];
5311 static int labels_cmp(const void *fndata UNUSED
,
5312 const struct hashmap_entry
*eptr
,
5313 const struct hashmap_entry
*entry_or_key
, const void *key
)
5315 const struct labels_entry
*a
, *b
;
5317 a
= container_of(eptr
, const struct labels_entry
, entry
);
5318 b
= container_of(entry_or_key
, const struct labels_entry
, entry
);
5320 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
5323 struct string_entry
{
5324 struct oidmap_entry entry
;
5325 char string
[FLEX_ARRAY
];
5328 struct label_state
{
5329 struct oidmap commit2label
;
5330 struct hashmap labels
;
5334 static const char *label_oid(struct object_id
*oid
, const char *label
,
5335 struct label_state
*state
)
5337 struct labels_entry
*labels_entry
;
5338 struct string_entry
*string_entry
;
5339 struct object_id dummy
;
5342 string_entry
= oidmap_get(&state
->commit2label
, oid
);
5344 return string_entry
->string
;
5347 * For "uninteresting" commits, i.e. commits that are not to be
5348 * rebased, and which can therefore not be labeled, we use a unique
5349 * abbreviation of the commit name. This is slightly more complicated
5350 * than calling repo_find_unique_abbrev() because we also need to make
5351 * sure that the abbreviation does not conflict with any other
5354 * We disallow "interesting" commits to be labeled by a string that
5355 * is a valid full-length hash, to ensure that we always can find an
5356 * abbreviation for any uninteresting commit's names that does not
5357 * clash with any other label.
5359 strbuf_reset(&state
->buf
);
5363 strbuf_grow(&state
->buf
, GIT_MAX_HEXSZ
);
5364 label
= p
= state
->buf
.buf
;
5366 repo_find_unique_abbrev_r(the_repository
, p
, oid
,
5370 * We may need to extend the abbreviated hash so that there is
5371 * no conflicting label.
5373 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
5374 size_t i
= strlen(p
) + 1;
5376 oid_to_hex_r(p
, oid
);
5377 for (; i
< the_hash_algo
->hexsz
; i
++) {
5380 if (!hashmap_get_from_hash(&state
->labels
,
5387 struct strbuf
*buf
= &state
->buf
;
5390 * Sanitize labels by replacing non-alpha-numeric characters
5391 * (including white-space ones) by dashes, as they might be
5392 * illegal in file names (and hence in ref names).
5394 * Note that we retain non-ASCII UTF-8 characters (identified
5395 * via the most significant bit). They should be all acceptable
5396 * in file names. We do not validate the UTF-8 here, that's not
5397 * the job of this function.
5399 for (; *label
; label
++)
5400 if ((*label
& 0x80) || isalnum(*label
))
5401 strbuf_addch(buf
, *label
);
5402 /* avoid leading dash and double-dashes */
5403 else if (buf
->len
&& buf
->buf
[buf
->len
- 1] != '-')
5404 strbuf_addch(buf
, '-');
5406 strbuf_addstr(buf
, "rev-");
5407 strbuf_add_unique_abbrev(buf
, oid
, default_abbrev
);
5411 if ((buf
->len
== the_hash_algo
->hexsz
&&
5412 !get_oid_hex(label
, &dummy
)) ||
5413 (buf
->len
== 1 && *label
== '#') ||
5414 hashmap_get_from_hash(&state
->labels
,
5415 strihash(label
), label
)) {
5417 * If the label already exists, or if the label is a
5418 * valid full OID, or the label is a '#' (which we use
5419 * as a separator between merge heads and oneline), we
5420 * append a dash and a number to make it unique.
5422 size_t len
= buf
->len
;
5424 for (i
= 2; ; i
++) {
5425 strbuf_setlen(buf
, len
);
5426 strbuf_addf(buf
, "-%d", i
);
5427 if (!hashmap_get_from_hash(&state
->labels
,
5437 FLEX_ALLOC_STR(labels_entry
, label
, label
);
5438 hashmap_entry_init(&labels_entry
->entry
, strihash(label
));
5439 hashmap_add(&state
->labels
, &labels_entry
->entry
);
5441 FLEX_ALLOC_STR(string_entry
, string
, label
);
5442 oidcpy(&string_entry
->entry
.oid
, oid
);
5443 oidmap_put(&state
->commit2label
, string_entry
);
5445 return string_entry
->string
;
5448 static int make_script_with_merges(struct pretty_print_context
*pp
,
5449 struct rev_info
*revs
, struct strbuf
*out
,
5452 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5453 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
5454 int root_with_onto
= flags
& TODO_LIST_ROOT_WITH_ONTO
;
5455 int skipped_commit
= 0;
5456 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
5457 struct strbuf label
= STRBUF_INIT
;
5458 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
5459 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
5460 struct commit
*commit
;
5461 struct oidmap commit2todo
= OIDMAP_INIT
;
5462 struct string_entry
*entry
;
5463 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
5464 shown
= OIDSET_INIT
;
5465 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
5467 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
5468 const char *cmd_pick
= abbr
? "p" : "pick",
5469 *cmd_label
= abbr
? "l" : "label",
5470 *cmd_reset
= abbr
? "t" : "reset",
5471 *cmd_merge
= abbr
? "m" : "merge";
5473 oidmap_init(&commit2todo
, 0);
5474 oidmap_init(&state
.commit2label
, 0);
5475 hashmap_init(&state
.labels
, labels_cmp
, NULL
, 0);
5476 strbuf_init(&state
.buf
, 32);
5478 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
5479 struct labels_entry
*onto_label_entry
;
5480 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
5481 FLEX_ALLOC_STR(entry
, string
, "onto");
5482 oidcpy(&entry
->entry
.oid
, oid
);
5483 oidmap_put(&state
.commit2label
, entry
);
5485 FLEX_ALLOC_STR(onto_label_entry
, label
, "onto");
5486 hashmap_entry_init(&onto_label_entry
->entry
, strihash("onto"));
5487 hashmap_add(&state
.labels
, &onto_label_entry
->entry
);
5492 * - get onelines for all commits
5493 * - gather all branch tips (i.e. 2nd or later parents of merges)
5494 * - label all branch tips
5496 while ((commit
= get_revision(revs
))) {
5497 struct commit_list
*to_merge
;
5498 const char *p1
, *p2
;
5499 struct object_id
*oid
;
5502 tail
= &commit_list_insert(commit
, tail
)->next
;
5503 oidset_insert(&interesting
, &commit
->object
.oid
);
5505 is_empty
= is_original_commit_empty(commit
);
5506 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5507 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5508 warning(_("skipped previously applied commit %s"),
5509 short_commit_name(commit
));
5513 if (is_empty
&& !keep_empty
)
5516 strbuf_reset(&oneline
);
5517 pretty_print_commit(pp
, commit
, &oneline
);
5519 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
5521 /* non-merge commit: easy case */
5523 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
5524 oid_to_hex(&commit
->object
.oid
),
5527 strbuf_addf(&buf
, " %c empty",
5530 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5531 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5532 oidmap_put(&commit2todo
, entry
);
5537 /* Create a label */
5538 strbuf_reset(&label
);
5539 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
5540 (p1
= strchr(p1
, '\'')) &&
5541 (p2
= strchr(++p1
, '\'')))
5542 strbuf_add(&label
, p1
, p2
- p1
);
5543 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
5545 (p1
= strstr(p1
, " from ")))
5546 strbuf_addstr(&label
, p1
+ strlen(" from "));
5548 strbuf_addbuf(&label
, &oneline
);
5551 strbuf_addf(&buf
, "%s -C %s",
5552 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
5554 /* label the tips of merged branches */
5555 for (; to_merge
; to_merge
= to_merge
->next
) {
5556 oid
= &to_merge
->item
->object
.oid
;
5557 strbuf_addch(&buf
, ' ');
5559 if (!oidset_contains(&interesting
, oid
)) {
5560 strbuf_addstr(&buf
, label_oid(oid
, NULL
,
5565 tips_tail
= &commit_list_insert(to_merge
->item
,
5568 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
5570 strbuf_addf(&buf
, " # %s", oneline
.buf
);
5572 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5573 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5574 oidmap_put(&commit2todo
, entry
);
5577 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5578 _("use --reapply-cherry-picks to include skipped commits"));
5582 * - label branch points
5583 * - add HEAD to the branch tips
5585 for (iter
= commits
; iter
; iter
= iter
->next
) {
5586 struct commit_list
*parent
= iter
->item
->parents
;
5587 for (; parent
; parent
= parent
->next
) {
5588 struct object_id
*oid
= &parent
->item
->object
.oid
;
5589 if (!oidset_contains(&interesting
, oid
))
5591 if (oidset_insert(&child_seen
, oid
))
5592 label_oid(oid
, "branch-point", &state
);
5595 /* Add HEAD as implicit "tip of branch" */
5597 tips_tail
= &commit_list_insert(iter
->item
,
5602 * Third phase: output the todo list. This is a bit tricky, as we
5603 * want to avoid jumping back and forth between revisions. To
5604 * accomplish that goal, we walk backwards from the branch tips,
5605 * gathering commits not yet shown, reversing the list on the fly,
5606 * then outputting that list (labeling revisions as needed).
5608 strbuf_addf(out
, "%s onto\n", cmd_label
);
5609 for (iter
= tips
; iter
; iter
= iter
->next
) {
5610 struct commit_list
*list
= NULL
, *iter2
;
5612 commit
= iter
->item
;
5613 if (oidset_contains(&shown
, &commit
->object
.oid
))
5615 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
5618 strbuf_addf(out
, "\n%c Branch %s\n", comment_line_char
, entry
->string
);
5620 strbuf_addch(out
, '\n');
5622 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
5623 !oidset_contains(&shown
, &commit
->object
.oid
)) {
5624 commit_list_insert(commit
, &list
);
5625 if (!commit
->parents
) {
5629 commit
= commit
->parents
->item
;
5633 strbuf_addf(out
, "%s %s\n", cmd_reset
,
5634 rebase_cousins
|| root_with_onto
?
5635 "onto" : "[new root]");
5637 const char *to
= NULL
;
5639 entry
= oidmap_get(&state
.commit2label
,
5640 &commit
->object
.oid
);
5643 else if (!rebase_cousins
)
5644 to
= label_oid(&commit
->object
.oid
, NULL
,
5647 if (!to
|| !strcmp(to
, "onto"))
5648 strbuf_addf(out
, "%s onto\n", cmd_reset
);
5650 strbuf_reset(&oneline
);
5651 pretty_print_commit(pp
, commit
, &oneline
);
5652 strbuf_addf(out
, "%s %s # %s\n",
5653 cmd_reset
, to
, oneline
.buf
);
5657 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
5658 struct object_id
*oid
= &iter2
->item
->object
.oid
;
5659 entry
= oidmap_get(&commit2todo
, oid
);
5660 /* only show if not already upstream */
5662 strbuf_addf(out
, "%s\n", entry
->string
);
5663 entry
= oidmap_get(&state
.commit2label
, oid
);
5665 strbuf_addf(out
, "%s %s\n",
5666 cmd_label
, entry
->string
);
5667 oidset_insert(&shown
, oid
);
5670 free_commit_list(list
);
5673 free_commit_list(commits
);
5674 free_commit_list(tips
);
5676 strbuf_release(&label
);
5677 strbuf_release(&oneline
);
5678 strbuf_release(&buf
);
5680 oidmap_free(&commit2todo
, 1);
5681 oidmap_free(&state
.commit2label
, 1);
5682 hashmap_clear_and_free(&state
.labels
, struct labels_entry
, entry
);
5683 strbuf_release(&state
.buf
);
5688 int sequencer_make_script(struct repository
*r
, struct strbuf
*out
, int argc
,
5689 const char **argv
, unsigned flags
)
5691 char *format
= NULL
;
5692 struct pretty_print_context pp
= {0};
5693 struct rev_info revs
;
5694 struct commit
*commit
;
5695 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5696 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
5697 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
5698 int reapply_cherry_picks
= flags
& TODO_LIST_REAPPLY_CHERRY_PICKS
;
5699 int skipped_commit
= 0;
5702 repo_init_revisions(r
, &revs
, NULL
);
5703 revs
.verbose_header
= 1;
5705 revs
.max_parents
= 1;
5706 revs
.cherry_mark
= !reapply_cherry_picks
;
5709 revs
.right_only
= 1;
5710 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
5711 revs
.topo_order
= 1;
5713 revs
.pretty_given
= 1;
5714 git_config_get_string("rebase.instructionFormat", &format
);
5715 if (!format
|| !*format
) {
5717 format
= xstrdup("%s");
5719 get_commit_format(format
, &revs
);
5721 pp
.fmt
= revs
.commit_format
;
5722 pp
.output_encoding
= get_log_output_encoding();
5724 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1) {
5725 ret
= error(_("make_script: unhandled options"));
5729 if (prepare_revision_walk(&revs
) < 0) {
5730 ret
= error(_("make_script: error preparing revisions"));
5734 if (rebase_merges
) {
5735 ret
= make_script_with_merges(&pp
, &revs
, out
, flags
);
5739 while ((commit
= get_revision(&revs
))) {
5740 int is_empty
= is_original_commit_empty(commit
);
5742 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5743 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5744 warning(_("skipped previously applied commit %s"),
5745 short_commit_name(commit
));
5749 if (is_empty
&& !keep_empty
)
5751 strbuf_addf(out
, "%s %s ", insn
,
5752 oid_to_hex(&commit
->object
.oid
));
5753 pretty_print_commit(&pp
, commit
, out
);
5755 strbuf_addf(out
, " %c empty", comment_line_char
);
5756 strbuf_addch(out
, '\n');
5759 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5760 _("use --reapply-cherry-picks to include skipped commits"));
5762 release_revisions(&revs
);
5767 * Add commands after pick and (series of) squash/fixup commands
5770 static void todo_list_add_exec_commands(struct todo_list
*todo_list
,
5771 struct string_list
*commands
)
5773 struct strbuf
*buf
= &todo_list
->buf
;
5774 size_t base_offset
= buf
->len
;
5775 int i
, insert
, nr
= 0, alloc
= 0;
5776 struct todo_item
*items
= NULL
, *base_items
= NULL
;
5778 CALLOC_ARRAY(base_items
, commands
->nr
);
5779 for (i
= 0; i
< commands
->nr
; i
++) {
5780 size_t command_len
= strlen(commands
->items
[i
].string
);
5782 strbuf_addstr(buf
, commands
->items
[i
].string
);
5783 strbuf_addch(buf
, '\n');
5785 base_items
[i
].command
= TODO_EXEC
;
5786 base_items
[i
].offset_in_buf
= base_offset
;
5787 base_items
[i
].arg_offset
= base_offset
;
5788 base_items
[i
].arg_len
= command_len
;
5790 base_offset
+= command_len
+ 1;
5794 * Insert <commands> after every pick. Here, fixup/squash chains
5795 * are considered part of the pick, so we insert the commands *after*
5796 * those chains if there are any.
5798 * As we insert the exec commands immediately after rearranging
5799 * any fixups and before the user edits the list, a fixup chain
5800 * can never contain comments (any comments are empty picks that
5801 * have been commented out because the user did not specify
5802 * --keep-empty). So, it is safe to insert an exec command
5803 * without looking at the command following a comment.
5806 for (i
= 0; i
< todo_list
->nr
; i
++) {
5807 enum todo_command command
= todo_list
->items
[i
].command
;
5808 if (insert
&& !is_fixup(command
)) {
5809 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5810 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5816 ALLOC_GROW(items
, nr
+ 1, alloc
);
5817 items
[nr
++] = todo_list
->items
[i
];
5819 if (command
== TODO_PICK
|| command
== TODO_MERGE
)
5823 /* insert or append final <commands> */
5825 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5826 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5831 FREE_AND_NULL(todo_list
->items
);
5832 todo_list
->items
= items
;
5834 todo_list
->alloc
= alloc
;
5837 static void todo_list_to_strbuf(struct repository
*r
, struct todo_list
*todo_list
,
5838 struct strbuf
*buf
, int num
, unsigned flags
)
5840 struct todo_item
*item
;
5841 int i
, max
= todo_list
->nr
;
5843 if (num
> 0 && num
< max
)
5846 for (item
= todo_list
->items
, i
= 0; i
< max
; i
++, item
++) {
5849 /* if the item is not a command write it and continue */
5850 if (item
->command
>= TODO_COMMENT
) {
5851 strbuf_addf(buf
, "%.*s\n", item
->arg_len
,
5852 todo_item_get_arg(todo_list
, item
));
5856 /* add command to the buffer */
5857 cmd
= command_to_char(item
->command
);
5858 if ((flags
& TODO_LIST_ABBREVIATE_CMDS
) && cmd
)
5859 strbuf_addch(buf
, cmd
);
5861 strbuf_addstr(buf
, command_to_string(item
->command
));
5865 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
5866 short_commit_name(item
->commit
) :
5867 oid_to_hex(&item
->commit
->object
.oid
);
5869 if (item
->command
== TODO_FIXUP
) {
5870 if (item
->flags
& TODO_EDIT_FIXUP_MSG
)
5871 strbuf_addstr(buf
, " -c");
5872 else if (item
->flags
& TODO_REPLACE_FIXUP_MSG
) {
5873 strbuf_addstr(buf
, " -C");
5877 if (item
->command
== TODO_MERGE
) {
5878 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
5879 strbuf_addstr(buf
, " -c");
5881 strbuf_addstr(buf
, " -C");
5884 strbuf_addf(buf
, " %s", oid
);
5887 /* add all the rest */
5889 strbuf_addch(buf
, '\n');
5891 strbuf_addf(buf
, " %.*s\n", item
->arg_len
,
5892 todo_item_get_arg(todo_list
, item
));
5896 int todo_list_write_to_file(struct repository
*r
, struct todo_list
*todo_list
,
5897 const char *file
, const char *shortrevisions
,
5898 const char *shortonto
, int num
, unsigned flags
)
5901 struct strbuf buf
= STRBUF_INIT
;
5903 todo_list_to_strbuf(r
, todo_list
, &buf
, num
, flags
);
5904 if (flags
& TODO_LIST_APPEND_TODO_HELP
)
5905 append_todo_help(count_commands(todo_list
),
5906 shortrevisions
, shortonto
, &buf
);
5908 res
= write_message(buf
.buf
, buf
.len
, file
, 0);
5909 strbuf_release(&buf
);
5914 /* skip picking commits whose parents are unchanged */
5915 static int skip_unnecessary_picks(struct repository
*r
,
5916 struct todo_list
*todo_list
,
5917 struct object_id
*base_oid
)
5919 struct object_id
*parent_oid
;
5922 for (i
= 0; i
< todo_list
->nr
; i
++) {
5923 struct todo_item
*item
= todo_list
->items
+ i
;
5925 if (item
->command
>= TODO_NOOP
)
5927 if (item
->command
!= TODO_PICK
)
5929 if (repo_parse_commit(r
, item
->commit
)) {
5930 return error(_("could not parse commit '%s'"),
5931 oid_to_hex(&item
->commit
->object
.oid
));
5933 if (!item
->commit
->parents
)
5934 break; /* root commit */
5935 if (item
->commit
->parents
->next
)
5936 break; /* merge commit */
5937 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
5938 if (!oideq(parent_oid
, base_oid
))
5940 oidcpy(base_oid
, &item
->commit
->object
.oid
);
5943 const char *done_path
= rebase_path_done();
5945 if (todo_list_write_to_file(r
, todo_list
, done_path
, NULL
, NULL
, i
, 0)) {
5946 error_errno(_("could not write to '%s'"), done_path
);
5950 MOVE_ARRAY(todo_list
->items
, todo_list
->items
+ i
, todo_list
->nr
- i
);
5952 todo_list
->current
= 0;
5953 todo_list
->done_nr
+= i
;
5955 if (is_fixup(peek_command(todo_list
, 0)))
5956 record_in_rewritten(base_oid
, peek_command(todo_list
, 0));
5962 struct todo_add_branch_context
{
5963 struct todo_item
*items
;
5967 struct commit
*commit
;
5968 struct string_list refs_to_oids
;
5971 static int add_decorations_to_list(const struct commit
*commit
,
5972 struct todo_add_branch_context
*ctx
)
5974 const struct name_decoration
*decoration
= get_name_decoration(&commit
->object
);
5975 const char *head_ref
= resolve_ref_unsafe("HEAD",
5976 RESOLVE_REF_READING
,
5980 while (decoration
) {
5981 struct todo_item
*item
;
5983 size_t base_offset
= ctx
->buf
->len
;
5986 * If the branch is the current HEAD, then it will be
5987 * updated by the default rebase behavior.
5989 if (head_ref
&& !strcmp(head_ref
, decoration
->name
)) {
5990 decoration
= decoration
->next
;
5994 ALLOC_GROW(ctx
->items
,
5997 item
= &ctx
->items
[ctx
->items_nr
];
5998 memset(item
, 0, sizeof(*item
));
6000 /* If the branch is checked out, then leave a comment instead. */
6001 if ((path
= branch_checked_out(decoration
->name
))) {
6002 item
->command
= TODO_COMMENT
;
6003 strbuf_addf(ctx
->buf
, "# Ref %s checked out at '%s'\n",
6004 decoration
->name
, path
);
6006 struct string_list_item
*sti
;
6007 item
->command
= TODO_UPDATE_REF
;
6008 strbuf_addf(ctx
->buf
, "%s\n", decoration
->name
);
6010 sti
= string_list_insert(&ctx
->refs_to_oids
,
6012 sti
->util
= init_update_ref_record(decoration
->name
);
6015 item
->offset_in_buf
= base_offset
;
6016 item
->arg_offset
= base_offset
;
6017 item
->arg_len
= ctx
->buf
->len
- base_offset
;
6020 decoration
= decoration
->next
;
6027 * For each 'pick' command, find out if the commit has a decoration in
6028 * refs/heads/. If so, then add a 'label for-update-refs/' command.
6030 static int todo_list_add_update_ref_commands(struct todo_list
*todo_list
)
6033 static struct string_list decorate_refs_exclude
= STRING_LIST_INIT_NODUP
;
6034 static struct string_list decorate_refs_exclude_config
= STRING_LIST_INIT_NODUP
;
6035 static struct string_list decorate_refs_include
= STRING_LIST_INIT_NODUP
;
6036 struct decoration_filter decoration_filter
= {
6037 .include_ref_pattern
= &decorate_refs_include
,
6038 .exclude_ref_pattern
= &decorate_refs_exclude
,
6039 .exclude_ref_config_pattern
= &decorate_refs_exclude_config
,
6041 struct todo_add_branch_context ctx
= {
6042 .buf
= &todo_list
->buf
,
6043 .refs_to_oids
= STRING_LIST_INIT_DUP
,
6046 ctx
.items_alloc
= 2 * todo_list
->nr
+ 1;
6047 ALLOC_ARRAY(ctx
.items
, ctx
.items_alloc
);
6049 string_list_append(&decorate_refs_include
, "refs/heads/");
6050 load_ref_decorations(&decoration_filter
, 0);
6052 for (i
= 0; i
< todo_list
->nr
; ) {
6053 struct todo_item
*item
= &todo_list
->items
[i
];
6055 /* insert ith item into new list */
6056 ALLOC_GROW(ctx
.items
,
6060 ctx
.items
[ctx
.items_nr
++] = todo_list
->items
[i
++];
6063 ctx
.commit
= item
->commit
;
6064 add_decorations_to_list(item
->commit
, &ctx
);
6068 res
= write_update_refs_state(&ctx
.refs_to_oids
);
6070 string_list_clear(&ctx
.refs_to_oids
, 1);
6073 /* we failed, so clean up the new list. */
6078 free(todo_list
->items
);
6079 todo_list
->items
= ctx
.items
;
6080 todo_list
->nr
= ctx
.items_nr
;
6081 todo_list
->alloc
= ctx
.items_alloc
;
6086 int complete_action(struct repository
*r
, struct replay_opts
*opts
, unsigned flags
,
6087 const char *shortrevisions
, const char *onto_name
,
6088 struct commit
*onto
, const struct object_id
*orig_head
,
6089 struct string_list
*commands
, unsigned autosquash
,
6090 unsigned update_refs
,
6091 struct todo_list
*todo_list
)
6093 char shortonto
[GIT_MAX_HEXSZ
+ 1];
6094 const char *todo_file
= rebase_path_todo();
6095 struct todo_list new_todo
= TODO_LIST_INIT
;
6096 struct strbuf
*buf
= &todo_list
->buf
, buf2
= STRBUF_INIT
;
6097 struct object_id oid
= onto
->object
.oid
;
6100 repo_find_unique_abbrev_r(r
, shortonto
, &oid
,
6103 if (buf
->len
== 0) {
6104 struct todo_item
*item
= append_new_todo(todo_list
);
6105 item
->command
= TODO_NOOP
;
6106 item
->commit
= NULL
;
6107 item
->arg_len
= item
->arg_offset
= item
->flags
= item
->offset_in_buf
= 0;
6110 if (update_refs
&& todo_list_add_update_ref_commands(todo_list
))
6113 if (autosquash
&& todo_list_rearrange_squash(todo_list
))
6117 todo_list_add_exec_commands(todo_list
, commands
);
6119 if (count_commands(todo_list
) == 0) {
6120 apply_autostash(rebase_path_autostash());
6121 sequencer_remove_state(opts
);
6123 return error(_("nothing to do"));
6126 res
= edit_todo_list(r
, todo_list
, &new_todo
, shortrevisions
,
6130 else if (res
== -2) {
6131 apply_autostash(rebase_path_autostash());
6132 sequencer_remove_state(opts
);
6135 } else if (res
== -3) {
6136 apply_autostash(rebase_path_autostash());
6137 sequencer_remove_state(opts
);
6138 todo_list_release(&new_todo
);
6140 return error(_("nothing to do"));
6141 } else if (res
== -4) {
6142 checkout_onto(r
, opts
, onto_name
, &onto
->object
.oid
, orig_head
);
6143 todo_list_release(&new_todo
);
6148 /* Expand the commit IDs */
6149 todo_list_to_strbuf(r
, &new_todo
, &buf2
, -1, 0);
6150 strbuf_swap(&new_todo
.buf
, &buf2
);
6151 strbuf_release(&buf2
);
6152 new_todo
.total_nr
-= new_todo
.nr
;
6153 if (todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
) < 0)
6154 BUG("invalid todo list after expanding IDs:\n%s",
6157 if (opts
->allow_ff
&& skip_unnecessary_picks(r
, &new_todo
, &oid
)) {
6158 todo_list_release(&new_todo
);
6159 return error(_("could not skip unnecessary pick commands"));
6162 if (todo_list_write_to_file(r
, &new_todo
, todo_file
, NULL
, NULL
, -1,
6163 flags
& ~(TODO_LIST_SHORTEN_IDS
))) {
6164 todo_list_release(&new_todo
);
6165 return error_errno(_("could not write '%s'"), todo_file
);
6170 if (checkout_onto(r
, opts
, onto_name
, &oid
, orig_head
))
6173 if (require_clean_work_tree(r
, "rebase", "", 1, 1))
6176 todo_list_write_total_nr(&new_todo
);
6177 res
= pick_commits(r
, &new_todo
, opts
);
6180 todo_list_release(&new_todo
);
6185 struct subject2item_entry
{
6186 struct hashmap_entry entry
;
6188 char subject
[FLEX_ARRAY
];
6191 static int subject2item_cmp(const void *fndata UNUSED
,
6192 const struct hashmap_entry
*eptr
,
6193 const struct hashmap_entry
*entry_or_key
,
6196 const struct subject2item_entry
*a
, *b
;
6198 a
= container_of(eptr
, const struct subject2item_entry
, entry
);
6199 b
= container_of(entry_or_key
, const struct subject2item_entry
, entry
);
6201 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
6204 define_commit_slab(commit_todo_item
, struct todo_item
*);
6206 static int skip_fixupish(const char *subject
, const char **p
) {
6207 return skip_prefix(subject
, "fixup! ", p
) ||
6208 skip_prefix(subject
, "amend! ", p
) ||
6209 skip_prefix(subject
, "squash! ", p
);
6213 * Rearrange the todo list that has both "pick commit-id msg" and "pick
6214 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
6215 * after the former, and change "pick" to "fixup"/"squash".
6217 * Note that if the config has specified a custom instruction format, each log
6218 * message will have to be retrieved from the commit (as the oneline in the
6219 * script cannot be trusted) in order to normalize the autosquash arrangement.
6221 int todo_list_rearrange_squash(struct todo_list
*todo_list
)
6223 struct hashmap subject2item
;
6224 int rearranged
= 0, *next
, *tail
, i
, nr
= 0, alloc
= 0;
6226 struct commit_todo_item commit_todo
;
6227 struct todo_item
*items
= NULL
;
6229 init_commit_todo_item(&commit_todo
);
6231 * The hashmap maps onelines to the respective todo list index.
6233 * If any items need to be rearranged, the next[i] value will indicate
6234 * which item was moved directly after the i'th.
6236 * In that case, last[i] will indicate the index of the latest item to
6237 * be moved to appear after the i'th.
6239 hashmap_init(&subject2item
, subject2item_cmp
, NULL
, todo_list
->nr
);
6240 ALLOC_ARRAY(next
, todo_list
->nr
);
6241 ALLOC_ARRAY(tail
, todo_list
->nr
);
6242 ALLOC_ARRAY(subjects
, todo_list
->nr
);
6243 for (i
= 0; i
< todo_list
->nr
; i
++) {
6244 struct strbuf buf
= STRBUF_INIT
;
6245 struct todo_item
*item
= todo_list
->items
+ i
;
6246 const char *commit_buffer
, *subject
, *p
;
6249 struct subject2item_entry
*entry
;
6251 next
[i
] = tail
[i
] = -1;
6252 if (!item
->commit
|| item
->command
== TODO_DROP
) {
6257 if (is_fixup(item
->command
)) {
6258 clear_commit_todo_item(&commit_todo
);
6259 return error(_("the script was already rearranged."));
6262 repo_parse_commit(the_repository
, item
->commit
);
6263 commit_buffer
= repo_logmsg_reencode(the_repository
,
6266 find_commit_subject(commit_buffer
, &subject
);
6267 format_subject(&buf
, subject
, " ");
6268 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
6269 repo_unuse_commit_buffer(the_repository
, item
->commit
,
6271 if (skip_fixupish(subject
, &p
)) {
6272 struct commit
*commit2
;
6277 if (!skip_fixupish(p
, &p
))
6281 entry
= hashmap_get_entry_from_hash(&subject2item
,
6283 struct subject2item_entry
,
6286 /* found by title */
6288 else if (!strchr(p
, ' ') &&
6290 lookup_commit_reference_by_name(p
)) &&
6291 *commit_todo_item_at(&commit_todo
, commit2
))
6292 /* found by commit name */
6293 i2
= *commit_todo_item_at(&commit_todo
, commit2
)
6296 /* copy can be a prefix of the commit subject */
6297 for (i2
= 0; i2
< i
; i2
++)
6299 starts_with(subjects
[i2
], p
))
6307 if (starts_with(subject
, "fixup!")) {
6308 todo_list
->items
[i
].command
= TODO_FIXUP
;
6309 } else if (starts_with(subject
, "amend!")) {
6310 todo_list
->items
[i
].command
= TODO_FIXUP
;
6311 todo_list
->items
[i
].flags
= TODO_REPLACE_FIXUP_MSG
;
6313 todo_list
->items
[i
].command
= TODO_SQUASH
;
6319 next
[i
] = next
[tail
[i2
]];
6323 } else if (!hashmap_get_from_hash(&subject2item
,
6324 strhash(subject
), subject
)) {
6325 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
6327 hashmap_entry_init(&entry
->entry
,
6328 strhash(entry
->subject
));
6329 hashmap_put(&subject2item
, &entry
->entry
);
6332 *commit_todo_item_at(&commit_todo
, item
->commit
) = item
;
6336 for (i
= 0; i
< todo_list
->nr
; i
++) {
6337 enum todo_command command
= todo_list
->items
[i
].command
;
6341 * Initially, all commands are 'pick's. If it is a
6342 * fixup or a squash now, we have rearranged it.
6344 if (is_fixup(command
))
6348 ALLOC_GROW(items
, nr
+ 1, alloc
);
6349 items
[nr
++] = todo_list
->items
[cur
];
6354 FREE_AND_NULL(todo_list
->items
);
6355 todo_list
->items
= items
;
6357 todo_list
->alloc
= alloc
;
6362 for (i
= 0; i
< todo_list
->nr
; i
++)
6365 hashmap_clear_and_free(&subject2item
, struct subject2item_entry
, entry
);
6367 clear_commit_todo_item(&commit_todo
);
6372 int sequencer_determine_whence(struct repository
*r
, enum commit_whence
*whence
)
6374 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
6375 struct object_id cherry_pick_head
, rebase_head
;
6377 if (file_exists(git_path_seq_dir()))
6378 *whence
= FROM_CHERRY_PICK_MULTI
;
6379 if (file_exists(rebase_path()) &&
6380 !repo_get_oid(r
, "REBASE_HEAD", &rebase_head
) &&
6381 !repo_get_oid(r
, "CHERRY_PICK_HEAD", &cherry_pick_head
) &&
6382 oideq(&rebase_head
, &cherry_pick_head
))
6383 *whence
= FROM_REBASE_PICK
;
6385 *whence
= FROM_CHERRY_PICK_SINGLE
;
6393 int sequencer_get_update_refs_state(const char *wt_dir
,
6394 struct string_list
*refs
)
6398 struct strbuf ref
= STRBUF_INIT
;
6399 struct strbuf hash
= STRBUF_INIT
;
6400 struct update_ref_record
*rec
= NULL
;
6402 char *path
= rebase_path_update_refs(wt_dir
);
6404 fp
= fopen(path
, "r");
6408 while (strbuf_getline(&ref
, fp
) != EOF
) {
6409 struct string_list_item
*item
;
6411 CALLOC_ARRAY(rec
, 1);
6413 if (strbuf_getline(&hash
, fp
) == EOF
||
6414 get_oid_hex(hash
.buf
, &rec
->before
)) {
6415 warning(_("update-refs file at '%s' is invalid"),
6421 if (strbuf_getline(&hash
, fp
) == EOF
||
6422 get_oid_hex(hash
.buf
, &rec
->after
)) {
6423 warning(_("update-refs file at '%s' is invalid"),
6429 item
= string_list_insert(refs
, ref
.buf
);
6439 strbuf_release(&ref
);
6440 strbuf_release(&hash
);