6 #include "object-store.h"
11 #include "run-command.h"
15 #include "cache-tree.h"
19 #include "merge-ort.h"
20 #include "merge-ort-wrappers.h"
26 #include "wt-status.h"
28 #include "notes-utils.h"
30 #include "unpack-trees.h"
34 #include "commit-slab.h"
36 #include "commit-reach.h"
37 #include "rebase-interactive.h"
41 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
43 static const char sign_off_header
[] = "Signed-off-by: ";
44 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
46 GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
48 static GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
50 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
51 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
52 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
53 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
55 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
57 * The file containing rebase commands, comments, and empty lines.
58 * This file is created by "git rebase -i" then edited by the user. As
59 * the lines are processed, they are removed from the front of this
60 * file and written to the tail of 'done'.
62 GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
63 GIT_PATH_FUNC(rebase_path_todo_backup
, "rebase-merge/git-rebase-todo.backup")
65 GIT_PATH_FUNC(rebase_path_dropped
, "rebase-merge/dropped")
68 * The rebase command lines that have already been processed. A line
69 * is moved here when it is first handled, before any associated user
72 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
74 * The file to keep track of how many commands were already processed (e.g.
77 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum")
79 * The file to keep track of how many commands are to be processed in total
80 * (e.g. for the prompt).
82 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end")
84 * The commit message that is planned to be used for any changes that
85 * need to be committed following a user interaction.
87 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
89 * The file into which is accumulated the suggested commit message for
90 * squash/fixup commands. When the first of a series of squash/fixups
91 * is seen, the file is created and the commit message from the
92 * previous commit and from the first squash/fixup commit are written
93 * to it. The commit message for each subsequent squash/fixup commit
94 * is appended to the file as it is processed.
96 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
98 * If the current series of squash/fixups has not yet included a squash
99 * command, then this file exists and holds the commit message of the
100 * original "pick" commit. (If the series ends without a "squash"
101 * command, then this can be used as the commit message of the combined
102 * commit without opening the editor.)
104 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
106 * This file contains the list fixup/squash commands that have been
107 * accumulated into message-fixup or message-squash so far.
109 static GIT_PATH_FUNC(rebase_path_current_fixups
, "rebase-merge/current-fixups")
111 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
112 * GIT_AUTHOR_DATE that will be used for the commit that is currently
115 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
117 * When an "edit" rebase command is being processed, the SHA1 of the
118 * commit to be edited is recorded in this file. When "git rebase
119 * --continue" is executed, if there are any staged changes then they
120 * will be amended to the HEAD commit, but only provided the HEAD
121 * commit is still the commit to be edited. When any other rebase
122 * command is processed, this file is deleted.
124 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
126 * When we stop at a given patch via the "edit" command, this file contains
127 * the commit object name of the corresponding patch.
129 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
131 * For the post-rewrite hook, we make a list of rewritten commits and
132 * their new sha1s. The rewritten-pending list keeps the sha1s of
133 * commits that have been processed, but not committed yet,
134 * e.g. because they are waiting for a 'squash' command.
136 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
137 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
138 "rebase-merge/rewritten-pending")
141 * The path of the file containing the OID of the "squash onto" commit, i.e.
142 * the dummy commit used for `reset [new root]`.
144 static GIT_PATH_FUNC(rebase_path_squash_onto
, "rebase-merge/squash-onto")
147 * The path of the file listing refs that need to be deleted after the rebase
148 * finishes. This is used by the `label` command to record the need for cleanup.
150 static GIT_PATH_FUNC(rebase_path_refs_to_delete
, "rebase-merge/refs-to-delete")
153 * The update-refs file stores a list of refs that will be updated at the end
154 * of the rebase sequence. The 'update-ref <ref>' commands in the todo file
155 * update the OIDs for the refs in this file, but the refs are not updated
156 * until the end of the rebase sequence.
158 * rebase_path_update_refs() returns the path to this file for a given
159 * worktree directory. For the current worktree, pass the_repository->gitdir.
161 static char *rebase_path_update_refs(const char *wt_git_dir
)
163 return xstrfmt("%s/rebase-merge/update-refs", wt_git_dir
);
167 * The following files are written by git-rebase just after parsing the
170 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
171 static GIT_PATH_FUNC(rebase_path_cdate_is_adate
, "rebase-merge/cdate_is_adate")
172 static GIT_PATH_FUNC(rebase_path_ignore_date
, "rebase-merge/ignore_date")
173 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
174 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
175 static GIT_PATH_FUNC(rebase_path_quiet
, "rebase-merge/quiet")
176 static GIT_PATH_FUNC(rebase_path_signoff
, "rebase-merge/signoff")
177 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
178 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
179 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
180 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
181 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
182 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
183 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec
, "rebase-merge/reschedule-failed-exec")
184 static GIT_PATH_FUNC(rebase_path_no_reschedule_failed_exec
, "rebase-merge/no-reschedule-failed-exec")
185 static GIT_PATH_FUNC(rebase_path_drop_redundant_commits
, "rebase-merge/drop_redundant_commits")
186 static GIT_PATH_FUNC(rebase_path_keep_redundant_commits
, "rebase-merge/keep_redundant_commits")
189 * A 'struct update_refs_record' represents a value in the update-refs
190 * list. We use a string_list to map refs to these (before, after) pairs.
192 struct update_ref_record
{
193 struct object_id before
;
194 struct object_id after
;
197 static struct update_ref_record
*init_update_ref_record(const char *ref
)
199 struct update_ref_record
*rec
;
201 CALLOC_ARRAY(rec
, 1);
203 oidcpy(&rec
->before
, null_oid());
204 oidcpy(&rec
->after
, null_oid());
206 /* This may fail, but that's fine, we will keep the null OID. */
207 read_ref(ref
, &rec
->before
);
212 static int git_sequencer_config(const char *k
, const char *v
, void *cb
)
214 struct replay_opts
*opts
= cb
;
217 if (!strcmp(k
, "commit.cleanup")) {
220 status
= git_config_string(&s
, k
, v
);
224 if (!strcmp(s
, "verbatim")) {
225 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
226 opts
->explicit_cleanup
= 1;
227 } else if (!strcmp(s
, "whitespace")) {
228 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
229 opts
->explicit_cleanup
= 1;
230 } else if (!strcmp(s
, "strip")) {
231 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_ALL
;
232 opts
->explicit_cleanup
= 1;
233 } else if (!strcmp(s
, "scissors")) {
234 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SCISSORS
;
235 opts
->explicit_cleanup
= 1;
237 warning(_("invalid commit message cleanup mode '%s'"),
245 if (!strcmp(k
, "commit.gpgsign")) {
246 opts
->gpg_sign
= git_config_bool(k
, v
) ? xstrdup("") : NULL
;
250 if (!opts
->default_strategy
&& !strcmp(k
, "pull.twohead")) {
251 int ret
= git_config_string((const char**)&opts
->default_strategy
, k
, v
);
254 * pull.twohead is allowed to be multi-valued; we only
255 * care about the first value.
257 char *tmp
= strchr(opts
->default_strategy
, ' ');
264 if (opts
->action
== REPLAY_REVERT
&& !strcmp(k
, "revert.reference"))
265 opts
->commit_use_reference
= git_config_bool(k
, v
);
267 status
= git_gpg_config(k
, v
, NULL
);
271 return git_diff_basic_config(k
, v
, NULL
);
274 void sequencer_init_config(struct replay_opts
*opts
)
276 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
277 git_config(git_sequencer_config
, opts
);
280 static inline int is_rebase_i(const struct replay_opts
*opts
)
282 return opts
->action
== REPLAY_INTERACTIVE_REBASE
;
285 static const char *get_dir(const struct replay_opts
*opts
)
287 if (is_rebase_i(opts
))
288 return rebase_path();
289 return git_path_seq_dir();
292 static const char *get_todo_path(const struct replay_opts
*opts
)
294 if (is_rebase_i(opts
))
295 return rebase_path_todo();
296 return git_path_todo_file();
300 * Returns 0 for non-conforming footer
301 * Returns 1 for conforming footer
302 * Returns 2 when sob exists within conforming footer
303 * Returns 3 when sob exists within conforming footer as last entry
305 static int has_conforming_footer(struct strbuf
*sb
, struct strbuf
*sob
,
306 size_t ignore_footer
)
308 struct process_trailer_options opts
= PROCESS_TRAILER_OPTIONS_INIT
;
309 struct trailer_info info
;
311 int found_sob
= 0, found_sob_last
= 0;
317 saved_char
= sb
->buf
[sb
->len
- ignore_footer
];
318 sb
->buf
[sb
->len
- ignore_footer
] = '\0';
321 trailer_info_get(&info
, sb
->buf
, &opts
);
324 sb
->buf
[sb
->len
- ignore_footer
] = saved_char
;
326 if (info
.trailer_start
== info
.trailer_end
)
329 for (i
= 0; i
< info
.trailer_nr
; i
++)
330 if (sob
&& !strncmp(info
.trailers
[i
], sob
->buf
, sob
->len
)) {
332 if (i
== info
.trailer_nr
- 1)
336 trailer_info_release(&info
);
345 static const char *gpg_sign_opt_quoted(struct replay_opts
*opts
)
347 static struct strbuf buf
= STRBUF_INIT
;
351 sq_quotef(&buf
, "-S%s", opts
->gpg_sign
);
355 void replay_opts_release(struct replay_opts
*opts
)
357 free(opts
->gpg_sign
);
358 free(opts
->reflog_action
);
359 free(opts
->default_strategy
);
360 free(opts
->strategy
);
361 for (size_t i
= 0; i
< opts
->xopts_nr
; i
++)
362 free(opts
->xopts
[i
]);
364 strbuf_release(&opts
->current_fixups
);
366 release_revisions(opts
->revs
);
370 int sequencer_remove_state(struct replay_opts
*opts
)
372 struct strbuf buf
= STRBUF_INIT
;
375 if (is_rebase_i(opts
) &&
376 strbuf_read_file(&buf
, rebase_path_refs_to_delete(), 0) > 0) {
379 char *eol
= strchr(p
, '\n');
382 if (delete_ref("(rebase) cleanup", p
, NULL
, 0) < 0) {
383 warning(_("could not delete '%s'"), p
);
393 strbuf_addstr(&buf
, get_dir(opts
));
394 if (remove_dir_recursively(&buf
, 0))
395 ret
= error(_("could not remove '%s'"), buf
.buf
);
396 strbuf_release(&buf
);
401 static const char *action_name(const struct replay_opts
*opts
)
403 switch (opts
->action
) {
407 return N_("cherry-pick");
408 case REPLAY_INTERACTIVE_REBASE
:
411 die(_("unknown action: %d"), opts
->action
);
414 struct commit_message
{
421 static const char *short_commit_name(struct commit
*commit
)
423 return find_unique_abbrev(&commit
->object
.oid
, DEFAULT_ABBREV
);
426 static int get_message(struct commit
*commit
, struct commit_message
*out
)
428 const char *abbrev
, *subject
;
431 out
->message
= logmsg_reencode(commit
, NULL
, get_commit_output_encoding());
432 abbrev
= short_commit_name(commit
);
434 subject_len
= find_commit_subject(out
->message
, &subject
);
436 out
->subject
= xmemdupz(subject
, subject_len
);
437 out
->label
= xstrfmt("%s (%s)", abbrev
, out
->subject
);
438 out
->parent_label
= xstrfmt("parent of %s", out
->label
);
443 static void free_message(struct commit
*commit
, struct commit_message
*msg
)
445 free(msg
->parent_label
);
448 unuse_commit_buffer(commit
, msg
->message
);
451 static void print_advice(struct repository
*r
, int show_hint
,
452 struct replay_opts
*opts
)
454 char *msg
= getenv("GIT_CHERRY_PICK_HELP");
459 * A conflict has occurred but the porcelain
460 * (typically rebase --interactive) wants to take care
461 * of the commit itself so remove CHERRY_PICK_HEAD
463 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
470 advise(_("after resolving the conflicts, mark the corrected paths\n"
471 "with 'git add <paths>' or 'git rm <paths>'"));
472 else if (opts
->action
== REPLAY_PICK
)
473 advise(_("After resolving the conflicts, mark them with\n"
474 "\"git add/rm <pathspec>\", then run\n"
475 "\"git cherry-pick --continue\".\n"
476 "You can instead skip this commit with \"git cherry-pick --skip\".\n"
477 "To abort and get back to the state before \"git cherry-pick\",\n"
478 "run \"git cherry-pick --abort\"."));
479 else if (opts
->action
== REPLAY_REVERT
)
480 advise(_("After resolving the conflicts, mark them with\n"
481 "\"git add/rm <pathspec>\", then run\n"
482 "\"git revert --continue\".\n"
483 "You can instead skip this commit with \"git revert --skip\".\n"
484 "To abort and get back to the state before \"git revert\",\n"
485 "run \"git revert --abort\"."));
487 BUG("unexpected pick action in print_advice()");
491 static int write_message(const void *buf
, size_t len
, const char *filename
,
494 struct lock_file msg_file
= LOCK_INIT
;
496 int msg_fd
= hold_lock_file_for_update(&msg_file
, filename
, 0);
498 return error_errno(_("could not lock '%s'"), filename
);
499 if (write_in_full(msg_fd
, buf
, len
) < 0) {
500 error_errno(_("could not write to '%s'"), filename
);
501 rollback_lock_file(&msg_file
);
504 if (append_eol
&& write(msg_fd
, "\n", 1) < 0) {
505 error_errno(_("could not write eol to '%s'"), filename
);
506 rollback_lock_file(&msg_file
);
509 if (commit_lock_file(&msg_file
) < 0)
510 return error(_("failed to finalize '%s'"), filename
);
515 int read_oneliner(struct strbuf
*buf
,
516 const char *path
, unsigned flags
)
518 int orig_len
= buf
->len
;
520 if (strbuf_read_file(buf
, path
, 0) < 0) {
521 if ((flags
& READ_ONELINER_WARN_MISSING
) ||
522 (errno
!= ENOENT
&& errno
!= ENOTDIR
))
523 warning_errno(_("could not read '%s'"), path
);
527 if (buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\n') {
528 if (--buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\r')
530 buf
->buf
[buf
->len
] = '\0';
533 if ((flags
& READ_ONELINER_SKIP_IF_EMPTY
) && buf
->len
== orig_len
)
539 static struct tree
*empty_tree(struct repository
*r
)
541 return lookup_tree(r
, the_hash_algo
->empty_tree
);
544 static int error_dirty_index(struct repository
*repo
, struct replay_opts
*opts
)
546 if (repo_read_index_unmerged(repo
))
547 return error_resolve_conflict(action_name(opts
));
549 error(_("your local changes would be overwritten by %s."),
550 _(action_name(opts
)));
552 if (advice_enabled(ADVICE_COMMIT_BEFORE_MERGE
))
553 advise(_("commit your changes or stash them to proceed."));
557 static void update_abort_safety_file(void)
559 struct object_id head
;
561 /* Do nothing on a single-pick */
562 if (!file_exists(git_path_seq_dir()))
565 if (!get_oid("HEAD", &head
))
566 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head
));
568 write_file(git_path_abort_safety_file(), "%s", "");
571 static int fast_forward_to(struct repository
*r
,
572 const struct object_id
*to
,
573 const struct object_id
*from
,
575 struct replay_opts
*opts
)
577 struct ref_transaction
*transaction
;
578 struct strbuf sb
= STRBUF_INIT
;
579 struct strbuf err
= STRBUF_INIT
;
582 if (checkout_fast_forward(r
, from
, to
, 1))
583 return -1; /* the callee should have complained already */
585 strbuf_addf(&sb
, "%s: fast-forward", action_name(opts
));
587 transaction
= ref_transaction_begin(&err
);
589 ref_transaction_update(transaction
, "HEAD",
590 to
, unborn
&& !is_rebase_i(opts
) ?
593 ref_transaction_commit(transaction
, &err
)) {
594 ref_transaction_free(transaction
);
595 error("%s", err
.buf
);
597 strbuf_release(&err
);
602 strbuf_release(&err
);
603 ref_transaction_free(transaction
);
604 update_abort_safety_file();
608 enum commit_msg_cleanup_mode
get_cleanup_mode(const char *cleanup_arg
,
611 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
612 return use_editor
? COMMIT_MSG_CLEANUP_ALL
:
613 COMMIT_MSG_CLEANUP_SPACE
;
614 else if (!strcmp(cleanup_arg
, "verbatim"))
615 return COMMIT_MSG_CLEANUP_NONE
;
616 else if (!strcmp(cleanup_arg
, "whitespace"))
617 return COMMIT_MSG_CLEANUP_SPACE
;
618 else if (!strcmp(cleanup_arg
, "strip"))
619 return COMMIT_MSG_CLEANUP_ALL
;
620 else if (!strcmp(cleanup_arg
, "scissors"))
621 return use_editor
? COMMIT_MSG_CLEANUP_SCISSORS
:
622 COMMIT_MSG_CLEANUP_SPACE
;
624 die(_("Invalid cleanup mode %s"), cleanup_arg
);
628 * NB using int rather than enum cleanup_mode to stop clang's
629 * -Wtautological-constant-out-of-range-compare complaining that the comparison
632 static const char *describe_cleanup_mode(int cleanup_mode
)
634 static const char *modes
[] = { "whitespace",
639 if (cleanup_mode
< ARRAY_SIZE(modes
))
640 return modes
[cleanup_mode
];
642 BUG("invalid cleanup_mode provided (%d)", cleanup_mode
);
645 void append_conflicts_hint(struct index_state
*istate
,
646 struct strbuf
*msgbuf
, enum commit_msg_cleanup_mode cleanup_mode
)
650 if (cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
) {
651 strbuf_addch(msgbuf
, '\n');
652 wt_status_append_cut_line(msgbuf
);
653 strbuf_addch(msgbuf
, comment_line_char
);
656 strbuf_addch(msgbuf
, '\n');
657 strbuf_commented_addf(msgbuf
, "Conflicts:\n");
658 for (i
= 0; i
< istate
->cache_nr
;) {
659 const struct cache_entry
*ce
= istate
->cache
[i
++];
661 strbuf_commented_addf(msgbuf
, "\t%s\n", ce
->name
);
662 while (i
< istate
->cache_nr
&&
663 !strcmp(ce
->name
, istate
->cache
[i
]->name
))
669 static int do_recursive_merge(struct repository
*r
,
670 struct commit
*base
, struct commit
*next
,
671 const char *base_label
, const char *next_label
,
672 struct object_id
*head
, struct strbuf
*msgbuf
,
673 struct replay_opts
*opts
)
675 struct merge_options o
;
676 struct merge_result result
;
677 struct tree
*next_tree
, *base_tree
, *head_tree
;
678 int clean
, show_output
;
680 struct lock_file index_lock
= LOCK_INIT
;
682 if (repo_hold_locked_index(r
, &index_lock
, LOCK_REPORT_ON_ERROR
) < 0)
687 init_merge_options(&o
, r
);
688 o
.ancestor
= base
? base_label
: "(empty tree)";
690 o
.branch2
= next
? next_label
: "(empty tree)";
691 if (is_rebase_i(opts
))
693 o
.show_rename_progress
= 1;
695 head_tree
= parse_tree_indirect(head
);
696 next_tree
= next
? get_commit_tree(next
) : empty_tree(r
);
697 base_tree
= base
? get_commit_tree(base
) : empty_tree(r
);
699 for (i
= 0; i
< opts
->xopts_nr
; i
++)
700 parse_merge_opt(&o
, opts
->xopts
[i
]);
702 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
703 memset(&result
, 0, sizeof(result
));
704 merge_incore_nonrecursive(&o
, base_tree
, head_tree
, next_tree
,
706 show_output
= !is_rebase_i(opts
) || !result
.clean
;
708 * TODO: merge_switch_to_result will update index/working tree;
709 * we only really want to do that if !result.clean || this is
710 * the final patch to be picked. But determining this is the
711 * final patch would take some work, and "head_tree" would need
712 * to be replace with the tree the index matched before we
713 * started doing any picks.
715 merge_switch_to_result(&o
, head_tree
, &result
, 1, show_output
);
716 clean
= result
.clean
;
718 ensure_full_index(r
->index
);
719 clean
= merge_trees(&o
, head_tree
, next_tree
, base_tree
);
720 if (is_rebase_i(opts
) && clean
<= 0)
721 fputs(o
.obuf
.buf
, stdout
);
722 strbuf_release(&o
.obuf
);
725 rollback_lock_file(&index_lock
);
729 if (write_locked_index(r
->index
, &index_lock
,
730 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
732 * TRANSLATORS: %s will be "revert", "cherry-pick" or
735 return error(_("%s: Unable to write new index file"),
736 _(action_name(opts
)));
739 append_conflicts_hint(r
->index
, msgbuf
,
740 opts
->default_msg_cleanup
);
745 static struct object_id
*get_cache_tree_oid(struct index_state
*istate
)
747 if (!cache_tree_fully_valid(istate
->cache_tree
))
748 if (cache_tree_update(istate
, 0)) {
749 error(_("unable to update cache tree"));
753 return &istate
->cache_tree
->oid
;
756 static int is_index_unchanged(struct repository
*r
)
758 struct object_id head_oid
, *cache_tree_oid
;
759 struct commit
*head_commit
;
760 struct index_state
*istate
= r
->index
;
762 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
763 return error(_("could not resolve HEAD commit"));
765 head_commit
= lookup_commit(r
, &head_oid
);
768 * If head_commit is NULL, check_commit, called from
769 * lookup_commit, would have indicated that head_commit is not
770 * a commit object already. parse_commit() will return failure
771 * without further complaints in such a case. Otherwise, if
772 * the commit is invalid, parse_commit() will complain. So
773 * there is nothing for us to say here. Just return failure.
775 if (parse_commit(head_commit
))
778 if (!(cache_tree_oid
= get_cache_tree_oid(istate
)))
781 return oideq(cache_tree_oid
, get_commit_tree_oid(head_commit
));
784 static int write_author_script(const char *message
)
786 struct strbuf buf
= STRBUF_INIT
;
791 if (!*message
|| starts_with(message
, "\n")) {
793 /* Missing 'author' line? */
794 unlink(rebase_path_author_script());
796 } else if (skip_prefix(message
, "author ", &message
))
798 else if ((eol
= strchr(message
, '\n')))
803 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
804 while (*message
&& *message
!= '\n' && *message
!= '\r')
805 if (skip_prefix(message
, " <", &message
))
807 else if (*message
!= '\'')
808 strbuf_addch(&buf
, *(message
++));
810 strbuf_addf(&buf
, "'\\%c'", *(message
++));
811 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
812 while (*message
&& *message
!= '\n' && *message
!= '\r')
813 if (skip_prefix(message
, "> ", &message
))
815 else if (*message
!= '\'')
816 strbuf_addch(&buf
, *(message
++));
818 strbuf_addf(&buf
, "'\\%c'", *(message
++));
819 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
820 while (*message
&& *message
!= '\n' && *message
!= '\r')
821 if (*message
!= '\'')
822 strbuf_addch(&buf
, *(message
++));
824 strbuf_addf(&buf
, "'\\%c'", *(message
++));
825 strbuf_addch(&buf
, '\'');
826 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
827 strbuf_release(&buf
);
832 * Take a series of KEY='VALUE' lines where VALUE part is
833 * sq-quoted, and append <KEY, VALUE> at the end of the string list
835 static int parse_key_value_squoted(char *buf
, struct string_list
*list
)
838 struct string_list_item
*item
;
840 char *cp
= strchr(buf
, '=');
842 np
= strchrnul(buf
, '\n');
843 return error(_("no key present in '%.*s'"),
844 (int) (np
- buf
), buf
);
846 np
= strchrnul(cp
, '\n');
848 item
= string_list_append(list
, buf
);
850 buf
= np
+ (*np
== '\n');
854 return error(_("unable to dequote value of '%s'"),
856 item
->util
= xstrdup(cp
);
862 * Reads and parses the state directory's "author-script" file, and sets name,
863 * email and date accordingly.
864 * Returns 0 on success, -1 if the file could not be parsed.
866 * The author script is of the format:
868 * GIT_AUTHOR_NAME='$author_name'
869 * GIT_AUTHOR_EMAIL='$author_email'
870 * GIT_AUTHOR_DATE='$author_date'
872 * where $author_name, $author_email and $author_date are quoted. We are strict
873 * with our parsing, as the file was meant to be eval'd in the now-removed
874 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
875 * from what this function expects, it is better to bail out than to do
876 * something that the user does not expect.
878 int read_author_script(const char *path
, char **name
, char **email
, char **date
,
881 struct strbuf buf
= STRBUF_INIT
;
882 struct string_list kv
= STRING_LIST_INIT_DUP
;
883 int retval
= -1; /* assume failure */
884 int i
, name_i
= -2, email_i
= -2, date_i
= -2, err
= 0;
886 if (strbuf_read_file(&buf
, path
, 256) <= 0) {
887 strbuf_release(&buf
);
888 if (errno
== ENOENT
&& allow_missing
)
891 return error_errno(_("could not open '%s' for reading"),
895 if (parse_key_value_squoted(buf
.buf
, &kv
))
898 for (i
= 0; i
< kv
.nr
; i
++) {
899 if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_NAME")) {
901 name_i
= error(_("'GIT_AUTHOR_NAME' already given"));
904 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_EMAIL")) {
906 email_i
= error(_("'GIT_AUTHOR_EMAIL' already given"));
909 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_DATE")) {
911 date_i
= error(_("'GIT_AUTHOR_DATE' already given"));
915 err
= error(_("unknown variable '%s'"),
920 error(_("missing 'GIT_AUTHOR_NAME'"));
922 error(_("missing 'GIT_AUTHOR_EMAIL'"));
924 error(_("missing 'GIT_AUTHOR_DATE'"));
925 if (name_i
< 0 || email_i
< 0 || date_i
< 0 || err
)
927 *name
= kv
.items
[name_i
].util
;
928 *email
= kv
.items
[email_i
].util
;
929 *date
= kv
.items
[date_i
].util
;
932 string_list_clear(&kv
, !!retval
);
933 strbuf_release(&buf
);
938 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
939 * file with shell quoting into struct strvec. Returns -1 on
940 * error, 0 otherwise.
942 static int read_env_script(struct strvec
*env
)
944 char *name
, *email
, *date
;
946 if (read_author_script(rebase_path_author_script(),
947 &name
, &email
, &date
, 0))
950 strvec_pushf(env
, "GIT_AUTHOR_NAME=%s", name
);
951 strvec_pushf(env
, "GIT_AUTHOR_EMAIL=%s", email
);
952 strvec_pushf(env
, "GIT_AUTHOR_DATE=%s", date
);
960 static char *get_author(const char *message
)
965 a
= find_commit_header(message
, "author", &len
);
967 return xmemdupz(a
, len
);
972 static const char *author_date_from_env(const struct strvec
*env
)
977 for (i
= 0; i
< env
->nr
; i
++)
978 if (skip_prefix(env
->v
[i
],
979 "GIT_AUTHOR_DATE=", &date
))
982 * If GIT_AUTHOR_DATE is missing we should have already errored out when
985 BUG("GIT_AUTHOR_DATE missing from author script");
988 static const char staged_changes_advice
[] =
989 N_("you have staged changes in your working tree\n"
990 "If these changes are meant to be squashed into the previous commit, run:\n"
992 " git commit --amend %s\n"
994 "If they are meant to go into a new commit, run:\n"
998 "In both cases, once you're done, continue with:\n"
1000 " git rebase --continue\n");
1002 #define ALLOW_EMPTY (1<<0)
1003 #define EDIT_MSG (1<<1)
1004 #define AMEND_MSG (1<<2)
1005 #define CLEANUP_MSG (1<<3)
1006 #define VERIFY_MSG (1<<4)
1007 #define CREATE_ROOT_COMMIT (1<<5)
1008 #define VERBATIM_MSG (1<<6)
1010 static int run_command_silent_on_success(struct child_process
*cmd
)
1012 struct strbuf buf
= STRBUF_INIT
;
1015 cmd
->stdout_to_stderr
= 1;
1016 rc
= pipe_command(cmd
,
1022 fputs(buf
.buf
, stderr
);
1023 strbuf_release(&buf
);
1028 * If we are cherry-pick, and if the merge did not result in
1029 * hand-editing, we will hit this commit and inherit the original
1030 * author date and name.
1032 * If we are revert, or if our cherry-pick results in a hand merge,
1033 * we had better say that the current user is responsible for that.
1035 * An exception is when run_git_commit() is called during an
1036 * interactive rebase: in that case, we will want to retain the
1039 static int run_git_commit(const char *defmsg
,
1040 struct replay_opts
*opts
,
1043 struct child_process cmd
= CHILD_PROCESS_INIT
;
1045 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1046 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1050 if (is_rebase_i(opts
) &&
1051 ((opts
->committer_date_is_author_date
&& !opts
->ignore_date
) ||
1052 !(!defmsg
&& (flags
& AMEND_MSG
))) &&
1053 read_env_script(&cmd
.env
)) {
1054 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
1056 return error(_(staged_changes_advice
),
1060 strvec_pushf(&cmd
.env
, GIT_REFLOG_ACTION
"=%s", opts
->reflog_message
);
1062 if (opts
->committer_date_is_author_date
)
1063 strvec_pushf(&cmd
.env
, "GIT_COMMITTER_DATE=%s",
1066 author_date_from_env(&cmd
.env
));
1067 if (opts
->ignore_date
)
1068 strvec_push(&cmd
.env
, "GIT_AUTHOR_DATE=");
1070 strvec_push(&cmd
.args
, "commit");
1072 if (!(flags
& VERIFY_MSG
))
1073 strvec_push(&cmd
.args
, "-n");
1074 if ((flags
& AMEND_MSG
))
1075 strvec_push(&cmd
.args
, "--amend");
1077 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
1079 strvec_push(&cmd
.args
, "--no-gpg-sign");
1081 strvec_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
1082 else if (!(flags
& EDIT_MSG
))
1083 strvec_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
1084 if ((flags
& CLEANUP_MSG
))
1085 strvec_push(&cmd
.args
, "--cleanup=strip");
1086 if ((flags
& VERBATIM_MSG
))
1087 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1088 if ((flags
& EDIT_MSG
))
1089 strvec_push(&cmd
.args
, "-e");
1090 else if (!(flags
& CLEANUP_MSG
) &&
1091 !opts
->signoff
&& !opts
->record_origin
&&
1092 !opts
->explicit_cleanup
)
1093 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1095 if ((flags
& ALLOW_EMPTY
))
1096 strvec_push(&cmd
.args
, "--allow-empty");
1098 if (!(flags
& EDIT_MSG
))
1099 strvec_push(&cmd
.args
, "--allow-empty-message");
1101 if (is_rebase_i(opts
) && !(flags
& EDIT_MSG
))
1102 return run_command_silent_on_success(&cmd
);
1104 return run_command(&cmd
);
1107 static int rest_is_empty(const struct strbuf
*sb
, int start
)
1112 /* Check if the rest is just whitespace and Signed-off-by's. */
1113 for (i
= start
; i
< sb
->len
; i
++) {
1114 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1120 if (strlen(sign_off_header
) <= eol
- i
&&
1121 starts_with(sb
->buf
+ i
, sign_off_header
)) {
1126 if (!isspace(sb
->buf
[i
++]))
1133 void cleanup_message(struct strbuf
*msgbuf
,
1134 enum commit_msg_cleanup_mode cleanup_mode
, int verbose
)
1136 if (verbose
|| /* Truncate the message just before the diff, if any. */
1137 cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
1138 strbuf_setlen(msgbuf
, wt_status_locate_end(msgbuf
->buf
, msgbuf
->len
));
1139 if (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
)
1140 strbuf_stripspace(msgbuf
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1144 * Find out if the message in the strbuf contains only whitespace and
1145 * Signed-off-by lines.
1147 int message_is_empty(const struct strbuf
*sb
,
1148 enum commit_msg_cleanup_mode cleanup_mode
)
1150 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1152 return rest_is_empty(sb
, 0);
1156 * See if the user edited the message in the editor or left what
1157 * was in the template intact
1159 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
1160 enum commit_msg_cleanup_mode cleanup_mode
)
1162 struct strbuf tmpl
= STRBUF_INIT
;
1165 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1168 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
1171 strbuf_stripspace(&tmpl
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1172 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
1174 strbuf_release(&tmpl
);
1175 return rest_is_empty(sb
, start
- sb
->buf
);
1178 int update_head_with_reflog(const struct commit
*old_head
,
1179 const struct object_id
*new_head
,
1180 const char *action
, const struct strbuf
*msg
,
1183 struct ref_transaction
*transaction
;
1184 struct strbuf sb
= STRBUF_INIT
;
1189 strbuf_addstr(&sb
, action
);
1190 strbuf_addstr(&sb
, ": ");
1193 nl
= strchr(msg
->buf
, '\n');
1195 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
1197 strbuf_addbuf(&sb
, msg
);
1198 strbuf_addch(&sb
, '\n');
1201 transaction
= ref_transaction_begin(err
);
1203 ref_transaction_update(transaction
, "HEAD", new_head
,
1204 old_head
? &old_head
->object
.oid
: null_oid(),
1206 ref_transaction_commit(transaction
, err
)) {
1209 ref_transaction_free(transaction
);
1210 strbuf_release(&sb
);
1215 static int run_rewrite_hook(const struct object_id
*oldoid
,
1216 const struct object_id
*newoid
)
1218 struct child_process proc
= CHILD_PROCESS_INIT
;
1220 struct strbuf sb
= STRBUF_INIT
;
1221 const char *hook_path
= find_hook("post-rewrite");
1226 strvec_pushl(&proc
.args
, hook_path
, "amend", NULL
);
1228 proc
.stdout_to_stderr
= 1;
1229 proc
.trace2_hook_name
= "post-rewrite";
1231 code
= start_command(&proc
);
1234 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
1235 sigchain_push(SIGPIPE
, SIG_IGN
);
1236 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
1238 strbuf_release(&sb
);
1239 sigchain_pop(SIGPIPE
);
1240 return finish_command(&proc
);
1243 void commit_post_rewrite(struct repository
*r
,
1244 const struct commit
*old_head
,
1245 const struct object_id
*new_head
)
1247 struct notes_rewrite_cfg
*cfg
;
1249 cfg
= init_copy_notes_for_rewrite("amend");
1251 /* we are amending, so old_head is not NULL */
1252 copy_note_for_rewrite(cfg
, &old_head
->object
.oid
, new_head
);
1253 finish_copy_notes_for_rewrite(r
, cfg
, "Notes added by 'git commit --amend'");
1255 run_rewrite_hook(&old_head
->object
.oid
, new_head
);
1258 static int run_prepare_commit_msg_hook(struct repository
*r
,
1263 const char *name
, *arg1
= NULL
, *arg2
= NULL
;
1265 name
= git_path_commit_editmsg();
1266 if (write_message(msg
->buf
, msg
->len
, name
, 0))
1275 if (run_commit_hook(0, r
->index_file
, NULL
, "prepare-commit-msg", name
,
1277 ret
= error(_("'prepare-commit-msg' hook failed"));
1282 static const char implicit_ident_advice_noconfig
[] =
1283 N_("Your name and email address were configured automatically based\n"
1284 "on your username and hostname. Please check that they are accurate.\n"
1285 "You can suppress this message by setting them explicitly. Run the\n"
1286 "following command and follow the instructions in your editor to edit\n"
1287 "your configuration file:\n"
1289 " git config --global --edit\n"
1291 "After doing this, you may fix the identity used for this commit with:\n"
1293 " git commit --amend --reset-author\n");
1295 static const char implicit_ident_advice_config
[] =
1296 N_("Your name and email address were configured automatically based\n"
1297 "on your username and hostname. Please check that they are accurate.\n"
1298 "You can suppress this message by setting them explicitly:\n"
1300 " git config --global user.name \"Your Name\"\n"
1301 " git config --global user.email you@example.com\n"
1303 "After doing this, you may fix the identity used for this commit with:\n"
1305 " git commit --amend --reset-author\n");
1307 static const char *implicit_ident_advice(void)
1309 char *user_config
= interpolate_path("~/.gitconfig", 0);
1310 char *xdg_config
= xdg_config_home("config");
1311 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1317 return _(implicit_ident_advice_config
);
1319 return _(implicit_ident_advice_noconfig
);
1323 void print_commit_summary(struct repository
*r
,
1325 const struct object_id
*oid
,
1328 struct rev_info rev
;
1329 struct commit
*commit
;
1330 struct strbuf format
= STRBUF_INIT
;
1332 struct pretty_print_context pctx
= {0};
1333 struct strbuf author_ident
= STRBUF_INIT
;
1334 struct strbuf committer_ident
= STRBUF_INIT
;
1335 struct ref_store
*refs
;
1337 commit
= lookup_commit(r
, oid
);
1339 die(_("couldn't look up newly created commit"));
1340 if (parse_commit(commit
))
1341 die(_("could not parse newly created commit"));
1343 strbuf_addstr(&format
, "format:%h] %s");
1345 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1346 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1347 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1348 strbuf_addstr(&format
, "\n Author: ");
1349 strbuf_addbuf_percentquote(&format
, &author_ident
);
1351 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
1352 struct strbuf date
= STRBUF_INIT
;
1354 format_commit_message(commit
, "%ad", &date
, &pctx
);
1355 strbuf_addstr(&format
, "\n Date: ");
1356 strbuf_addbuf_percentquote(&format
, &date
);
1357 strbuf_release(&date
);
1359 if (!committer_ident_sufficiently_given()) {
1360 strbuf_addstr(&format
, "\n Committer: ");
1361 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1362 if (advice_enabled(ADVICE_IMPLICIT_IDENTITY
)) {
1363 strbuf_addch(&format
, '\n');
1364 strbuf_addstr(&format
, implicit_ident_advice());
1367 strbuf_release(&author_ident
);
1368 strbuf_release(&committer_ident
);
1370 repo_init_revisions(r
, &rev
, prefix
);
1371 setup_revisions(0, NULL
, &rev
, NULL
);
1374 rev
.diffopt
.output_format
=
1375 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1377 rev
.verbose_header
= 1;
1378 rev
.show_root_diff
= 1;
1379 get_commit_format(format
.buf
, &rev
);
1380 rev
.always_show_header
= 0;
1381 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1382 diff_setup_done(&rev
.diffopt
);
1384 refs
= get_main_ref_store(the_repository
);
1385 head
= refs_resolve_ref_unsafe(refs
, "HEAD", 0, NULL
, NULL
);
1387 die(_("unable to resolve HEAD after creating commit"));
1388 if (!strcmp(head
, "HEAD"))
1389 head
= _("detached HEAD");
1391 skip_prefix(head
, "refs/heads/", &head
);
1392 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1393 _(" (root-commit)") : "");
1395 if (!log_tree_commit(&rev
, commit
)) {
1396 rev
.always_show_header
= 1;
1397 rev
.use_terminator
= 1;
1398 log_tree_commit(&rev
, commit
);
1401 release_revisions(&rev
);
1402 strbuf_release(&format
);
1405 static int parse_head(struct repository
*r
, struct commit
**head
)
1407 struct commit
*current_head
;
1408 struct object_id oid
;
1410 if (get_oid("HEAD", &oid
)) {
1411 current_head
= NULL
;
1413 current_head
= lookup_commit_reference(r
, &oid
);
1415 return error(_("could not parse HEAD"));
1416 if (!oideq(&oid
, ¤t_head
->object
.oid
)) {
1417 warning(_("HEAD %s is not a commit!"),
1420 if (parse_commit(current_head
))
1421 return error(_("could not parse HEAD commit"));
1423 *head
= current_head
;
1429 * Try to commit without forking 'git commit'. In some cases we need
1430 * to run 'git commit' to display an error message
1433 * -1 - error unable to commit
1435 * 1 - run 'git commit'
1437 static int try_to_commit(struct repository
*r
,
1438 struct strbuf
*msg
, const char *author
,
1439 struct replay_opts
*opts
, unsigned int flags
,
1440 struct object_id
*oid
)
1442 struct object_id tree
;
1443 struct commit
*current_head
= NULL
;
1444 struct commit_list
*parents
= NULL
;
1445 struct commit_extra_header
*extra
= NULL
;
1446 struct strbuf err
= STRBUF_INIT
;
1447 struct strbuf commit_msg
= STRBUF_INIT
;
1448 char *amend_author
= NULL
;
1449 const char *committer
= NULL
;
1450 const char *hook_commit
= NULL
;
1451 enum commit_msg_cleanup_mode cleanup
;
1454 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1455 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1457 if (parse_head(r
, ¤t_head
))
1460 if (flags
& AMEND_MSG
) {
1461 const char *exclude_gpgsig
[] = { "gpgsig", "gpgsig-sha256", NULL
};
1462 const char *out_enc
= get_commit_output_encoding();
1463 const char *message
= logmsg_reencode(current_head
, NULL
,
1467 const char *orig_message
= NULL
;
1469 find_commit_subject(message
, &orig_message
);
1471 strbuf_addstr(msg
, orig_message
);
1472 hook_commit
= "HEAD";
1474 author
= amend_author
= get_author(message
);
1475 unuse_commit_buffer(current_head
, message
);
1477 res
= error(_("unable to parse commit author"));
1480 parents
= copy_commit_list(current_head
->parents
);
1481 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1482 } else if (current_head
&&
1483 (!(flags
& CREATE_ROOT_COMMIT
) || (flags
& AMEND_MSG
))) {
1484 commit_list_insert(current_head
, &parents
);
1487 if (write_index_as_tree(&tree
, r
->index
, r
->index_file
, 0, NULL
)) {
1488 res
= error(_("git write-tree failed to write a tree"));
1492 if (!(flags
& ALLOW_EMPTY
)) {
1493 struct commit
*first_parent
= current_head
;
1495 if (flags
& AMEND_MSG
) {
1496 if (current_head
->parents
) {
1497 first_parent
= current_head
->parents
->item
;
1498 if (repo_parse_commit(r
, first_parent
)) {
1499 res
= error(_("could not parse HEAD commit"));
1503 first_parent
= NULL
;
1506 if (oideq(first_parent
1507 ? get_commit_tree_oid(first_parent
)
1508 : the_hash_algo
->empty_tree
,
1510 res
= 1; /* run 'git commit' to display error message */
1515 if (hook_exists("prepare-commit-msg")) {
1516 res
= run_prepare_commit_msg_hook(r
, msg
, hook_commit
);
1519 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1521 res
= error_errno(_("unable to read commit message "
1523 git_path_commit_editmsg());
1529 if (flags
& CLEANUP_MSG
)
1530 cleanup
= COMMIT_MSG_CLEANUP_ALL
;
1531 else if (flags
& VERBATIM_MSG
)
1532 cleanup
= COMMIT_MSG_CLEANUP_NONE
;
1533 else if ((opts
->signoff
|| opts
->record_origin
) &&
1534 !opts
->explicit_cleanup
)
1535 cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
1537 cleanup
= opts
->default_msg_cleanup
;
1539 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1540 strbuf_stripspace(msg
, cleanup
== COMMIT_MSG_CLEANUP_ALL
);
1541 if ((flags
& EDIT_MSG
) && message_is_empty(msg
, cleanup
)) {
1542 res
= 1; /* run 'git commit' to display error message */
1546 if (opts
->committer_date_is_author_date
) {
1547 struct ident_split id
;
1548 struct strbuf date
= STRBUF_INIT
;
1550 if (!opts
->ignore_date
) {
1551 if (split_ident_line(&id
, author
, (int)strlen(author
)) < 0) {
1552 res
= error(_("invalid author identity '%s'"),
1556 if (!id
.date_begin
) {
1558 "corrupt author: missing date information"));
1561 strbuf_addf(&date
, "@%.*s %.*s",
1562 (int)(id
.date_end
- id
.date_begin
),
1564 (int)(id
.tz_end
- id
.tz_begin
),
1569 committer
= fmt_ident(getenv("GIT_COMMITTER_NAME"),
1570 getenv("GIT_COMMITTER_EMAIL"),
1571 WANT_COMMITTER_IDENT
,
1572 opts
->ignore_date
? NULL
: date
.buf
,
1574 strbuf_release(&date
);
1579 if (opts
->ignore_date
) {
1580 struct ident_split id
;
1583 if (split_ident_line(&id
, author
, strlen(author
)) < 0) {
1584 error(_("invalid author identity '%s'"), author
);
1587 name
= xmemdupz(id
.name_begin
, id
.name_end
- id
.name_begin
);
1588 email
= xmemdupz(id
.mail_begin
, id
.mail_end
- id
.mail_begin
);
1589 author
= fmt_ident(name
, email
, WANT_AUTHOR_IDENT
, NULL
,
1595 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
, oid
,
1596 author
, committer
, opts
->gpg_sign
, extra
)) {
1597 res
= error(_("failed to write commit object"));
1601 if (update_head_with_reflog(current_head
, oid
, opts
->reflog_message
,
1603 res
= error("%s", err
.buf
);
1607 run_commit_hook(0, r
->index_file
, NULL
, "post-commit", NULL
);
1608 if (flags
& AMEND_MSG
)
1609 commit_post_rewrite(r
, current_head
, oid
);
1612 free_commit_extra_headers(extra
);
1613 strbuf_release(&err
);
1614 strbuf_release(&commit_msg
);
1620 static int write_rebase_head(struct object_id
*oid
)
1622 if (update_ref("rebase", "REBASE_HEAD", oid
,
1623 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1624 return error(_("could not update %s"), "REBASE_HEAD");
1629 static int do_commit(struct repository
*r
,
1630 const char *msg_file
, const char *author
,
1631 struct replay_opts
*opts
, unsigned int flags
,
1632 struct object_id
*oid
)
1636 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
)) {
1637 struct object_id oid
;
1638 struct strbuf sb
= STRBUF_INIT
;
1640 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1641 return error_errno(_("unable to read commit message "
1645 res
= try_to_commit(r
, msg_file
? &sb
: NULL
,
1646 author
, opts
, flags
, &oid
);
1647 strbuf_release(&sb
);
1649 refs_delete_ref(get_main_ref_store(r
), "",
1650 "CHERRY_PICK_HEAD", NULL
, 0);
1651 unlink(git_path_merge_msg(r
));
1652 if (!is_rebase_i(opts
))
1653 print_commit_summary(r
, NULL
, &oid
,
1654 SUMMARY_SHOW_AUTHOR_DATE
);
1659 if (is_rebase_i(opts
) && oid
)
1660 if (write_rebase_head(oid
))
1662 return run_git_commit(msg_file
, opts
, flags
);
1668 static int is_original_commit_empty(struct commit
*commit
)
1670 const struct object_id
*ptree_oid
;
1672 if (parse_commit(commit
))
1673 return error(_("could not parse commit %s"),
1674 oid_to_hex(&commit
->object
.oid
));
1675 if (commit
->parents
) {
1676 struct commit
*parent
= commit
->parents
->item
;
1677 if (parse_commit(parent
))
1678 return error(_("could not parse parent commit %s"),
1679 oid_to_hex(&parent
->object
.oid
));
1680 ptree_oid
= get_commit_tree_oid(parent
);
1682 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1685 return oideq(ptree_oid
, get_commit_tree_oid(commit
));
1689 * Should empty commits be allowed? Return status:
1690 * <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1691 * 0: Halt on empty commit
1692 * 1: Allow empty commit
1693 * 2: Drop empty commit
1695 static int allow_empty(struct repository
*r
,
1696 struct replay_opts
*opts
,
1697 struct commit
*commit
)
1699 int index_unchanged
, originally_empty
;
1704 * (1) we do not allow empty at all and error out.
1706 * (2) we allow ones that were initially empty, and
1707 * just drop the ones that become empty
1709 * (3) we allow ones that were initially empty, but
1710 * halt for the ones that become empty;
1712 * (4) we allow both.
1714 if (!opts
->allow_empty
)
1715 return 0; /* let "git commit" barf as necessary */
1717 index_unchanged
= is_index_unchanged(r
);
1718 if (index_unchanged
< 0)
1719 return index_unchanged
;
1720 if (!index_unchanged
)
1721 return 0; /* we do not have to say --allow-empty */
1723 if (opts
->keep_redundant_commits
)
1726 originally_empty
= is_original_commit_empty(commit
);
1727 if (originally_empty
< 0)
1728 return originally_empty
;
1729 if (originally_empty
)
1731 else if (opts
->drop_redundant_commits
)
1740 } todo_command_info
[] = {
1741 [TODO_PICK
] = { 'p', "pick" },
1742 [TODO_REVERT
] = { 0, "revert" },
1743 [TODO_EDIT
] = { 'e', "edit" },
1744 [TODO_REWORD
] = { 'r', "reword" },
1745 [TODO_FIXUP
] = { 'f', "fixup" },
1746 [TODO_SQUASH
] = { 's', "squash" },
1747 [TODO_EXEC
] = { 'x', "exec" },
1748 [TODO_BREAK
] = { 'b', "break" },
1749 [TODO_LABEL
] = { 'l', "label" },
1750 [TODO_RESET
] = { 't', "reset" },
1751 [TODO_MERGE
] = { 'm', "merge" },
1752 [TODO_UPDATE_REF
] = { 'u', "update-ref" },
1753 [TODO_NOOP
] = { 0, "noop" },
1754 [TODO_DROP
] = { 'd', "drop" },
1755 [TODO_COMMENT
] = { 0, NULL
},
1758 static const char *command_to_string(const enum todo_command command
)
1760 if (command
< TODO_COMMENT
)
1761 return todo_command_info
[command
].str
;
1762 die(_("unknown command: %d"), command
);
1765 static char command_to_char(const enum todo_command command
)
1767 if (command
< TODO_COMMENT
)
1768 return todo_command_info
[command
].c
;
1769 return comment_line_char
;
1772 static int is_noop(const enum todo_command command
)
1774 return TODO_NOOP
<= command
;
1777 static int is_fixup(enum todo_command command
)
1779 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1782 /* Does this command create a (non-merge) commit? */
1783 static int is_pick_or_similar(enum todo_command command
)
1798 enum todo_item_flags
{
1799 TODO_EDIT_MERGE_MSG
= (1 << 0),
1800 TODO_REPLACE_FIXUP_MSG
= (1 << 1),
1801 TODO_EDIT_FIXUP_MSG
= (1 << 2),
1804 static const char first_commit_msg_str
[] = N_("This is the 1st commit message:");
1805 static const char nth_commit_msg_fmt
[] = N_("This is the commit message #%d:");
1806 static const char skip_first_commit_msg_str
[] = N_("The 1st commit message will be skipped:");
1807 static const char skip_nth_commit_msg_fmt
[] = N_("The commit message #%d will be skipped:");
1808 static const char combined_commit_msg_fmt
[] = N_("This is a combination of %d commits.");
1810 static int is_fixup_flag(enum todo_command command
, unsigned flag
)
1812 return command
== TODO_FIXUP
&& ((flag
& TODO_REPLACE_FIXUP_MSG
) ||
1813 (flag
& TODO_EDIT_FIXUP_MSG
));
1817 * Wrapper around strbuf_add_commented_lines() which avoids double
1818 * commenting commit subjects.
1820 static void add_commented_lines(struct strbuf
*buf
, const void *str
, size_t len
)
1822 const char *s
= str
;
1823 while (len
> 0 && s
[0] == comment_line_char
) {
1825 const char *n
= memchr(s
, '\n', len
);
1830 strbuf_add(buf
, s
, count
);
1834 strbuf_add_commented_lines(buf
, s
, len
);
1837 /* Does the current fixup chain contain a squash command? */
1838 static int seen_squash(struct replay_opts
*opts
)
1840 return starts_with(opts
->current_fixups
.buf
, "squash") ||
1841 strstr(opts
->current_fixups
.buf
, "\nsquash");
1844 static void update_comment_bufs(struct strbuf
*buf1
, struct strbuf
*buf2
, int n
)
1846 strbuf_setlen(buf1
, 2);
1847 strbuf_addf(buf1
, _(nth_commit_msg_fmt
), n
);
1848 strbuf_addch(buf1
, '\n');
1849 strbuf_setlen(buf2
, 2);
1850 strbuf_addf(buf2
, _(skip_nth_commit_msg_fmt
), n
);
1851 strbuf_addch(buf2
, '\n');
1855 * Comment out any un-commented commit messages, updating the message comments
1856 * to say they will be skipped but do not comment out the empty lines that
1857 * surround commit messages and their comments.
1859 static void update_squash_message_for_fixup(struct strbuf
*msg
)
1861 void (*copy_lines
)(struct strbuf
*, const void *, size_t) = strbuf_add
;
1862 struct strbuf buf1
= STRBUF_INIT
, buf2
= STRBUF_INIT
;
1863 const char *s
, *start
;
1865 size_t orig_msg_len
;
1868 strbuf_addf(&buf1
, "# %s\n", _(first_commit_msg_str
));
1869 strbuf_addf(&buf2
, "# %s\n", _(skip_first_commit_msg_str
));
1870 s
= start
= orig_msg
= strbuf_detach(msg
, &orig_msg_len
);
1874 if (skip_prefix(s
, buf1
.buf
, &next
)) {
1876 * Copy the last message, preserving the blank line
1877 * preceding the current line
1879 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1880 copy_lines(msg
, start
, s
- start
- off
);
1882 strbuf_addch(msg
, '\n');
1884 * The next message needs to be commented out but the
1885 * message header is already commented out so just copy
1886 * it and the blank line that follows it.
1888 strbuf_addbuf(msg
, &buf2
);
1890 strbuf_addch(msg
, *next
++);
1892 copy_lines
= add_commented_lines
;
1893 update_comment_bufs(&buf1
, &buf2
, ++i
);
1894 } else if (skip_prefix(s
, buf2
.buf
, &next
)) {
1895 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1896 copy_lines(msg
, start
, s
- start
- off
);
1899 copy_lines
= strbuf_add
;
1900 update_comment_bufs(&buf1
, &buf2
, ++i
);
1902 s
= strchr(s
, '\n');
1907 copy_lines(msg
, start
, orig_msg_len
- (start
- orig_msg
));
1909 strbuf_release(&buf1
);
1910 strbuf_release(&buf2
);
1913 static int append_squash_message(struct strbuf
*buf
, const char *body
,
1914 enum todo_command command
, struct replay_opts
*opts
,
1917 const char *fixup_msg
;
1918 size_t commented_len
= 0, fixup_off
;
1920 * amend is non-interactive and not normally used with fixup!
1921 * or squash! commits, so only comment out those subjects when
1922 * squashing commit messages.
1924 if (starts_with(body
, "amend!") ||
1925 ((command
== TODO_SQUASH
|| seen_squash(opts
)) &&
1926 (starts_with(body
, "squash!") || starts_with(body
, "fixup!"))))
1927 commented_len
= commit_subject_length(body
);
1929 strbuf_addf(buf
, "\n%c ", comment_line_char
);
1930 strbuf_addf(buf
, _(nth_commit_msg_fmt
),
1931 ++opts
->current_fixup_count
+ 1);
1932 strbuf_addstr(buf
, "\n\n");
1933 strbuf_add_commented_lines(buf
, body
, commented_len
);
1934 /* buf->buf may be reallocated so store an offset into the buffer */
1935 fixup_off
= buf
->len
;
1936 strbuf_addstr(buf
, body
+ commented_len
);
1938 /* fixup -C after squash behaves like squash */
1939 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
)) {
1941 * We're replacing the commit message so we need to
1942 * append the Signed-off-by: trailer if the user
1943 * requested '--signoff'.
1946 append_signoff(buf
, 0, 0);
1948 if ((command
== TODO_FIXUP
) &&
1949 (flag
& TODO_REPLACE_FIXUP_MSG
) &&
1950 (file_exists(rebase_path_fixup_msg()) ||
1951 !file_exists(rebase_path_squash_msg()))) {
1952 fixup_msg
= skip_blank_lines(buf
->buf
+ fixup_off
);
1953 if (write_message(fixup_msg
, strlen(fixup_msg
),
1954 rebase_path_fixup_msg(), 0) < 0)
1955 return error(_("cannot write '%s'"),
1956 rebase_path_fixup_msg());
1958 unlink(rebase_path_fixup_msg());
1961 unlink(rebase_path_fixup_msg());
1967 static int update_squash_messages(struct repository
*r
,
1968 enum todo_command command
,
1969 struct commit
*commit
,
1970 struct replay_opts
*opts
,
1973 struct strbuf buf
= STRBUF_INIT
;
1975 const char *message
, *body
;
1976 const char *encoding
= get_commit_output_encoding();
1978 if (opts
->current_fixup_count
> 0) {
1979 struct strbuf header
= STRBUF_INIT
;
1982 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
1983 return error(_("could not read '%s'"),
1984 rebase_path_squash_msg());
1986 eol
= buf
.buf
[0] != comment_line_char
?
1987 buf
.buf
: strchrnul(buf
.buf
, '\n');
1989 strbuf_addf(&header
, "%c ", comment_line_char
);
1990 strbuf_addf(&header
, _(combined_commit_msg_fmt
),
1991 opts
->current_fixup_count
+ 2);
1992 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
1993 strbuf_release(&header
);
1994 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
))
1995 update_squash_message_for_fixup(&buf
);
1997 struct object_id head
;
1998 struct commit
*head_commit
;
1999 const char *head_message
, *body
;
2001 if (get_oid("HEAD", &head
))
2002 return error(_("need a HEAD to fixup"));
2003 if (!(head_commit
= lookup_commit_reference(r
, &head
)))
2004 return error(_("could not read HEAD"));
2005 if (!(head_message
= logmsg_reencode(head_commit
, NULL
, encoding
)))
2006 return error(_("could not read HEAD's commit message"));
2008 find_commit_subject(head_message
, &body
);
2009 if (command
== TODO_FIXUP
&& !flag
&& write_message(body
, strlen(body
),
2010 rebase_path_fixup_msg(), 0) < 0) {
2011 unuse_commit_buffer(head_commit
, head_message
);
2012 return error(_("cannot write '%s'"), rebase_path_fixup_msg());
2014 strbuf_addf(&buf
, "%c ", comment_line_char
);
2015 strbuf_addf(&buf
, _(combined_commit_msg_fmt
), 2);
2016 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
2017 strbuf_addstr(&buf
, is_fixup_flag(command
, flag
) ?
2018 _(skip_first_commit_msg_str
) :
2019 _(first_commit_msg_str
));
2020 strbuf_addstr(&buf
, "\n\n");
2021 if (is_fixup_flag(command
, flag
))
2022 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
2024 strbuf_addstr(&buf
, body
);
2026 unuse_commit_buffer(head_commit
, head_message
);
2029 if (!(message
= logmsg_reencode(commit
, NULL
, encoding
)))
2030 return error(_("could not read commit message of %s"),
2031 oid_to_hex(&commit
->object
.oid
));
2032 find_commit_subject(message
, &body
);
2034 if (command
== TODO_SQUASH
|| is_fixup_flag(command
, flag
)) {
2035 res
= append_squash_message(&buf
, body
, command
, opts
, flag
);
2036 } else if (command
== TODO_FIXUP
) {
2037 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
2038 strbuf_addf(&buf
, _(skip_nth_commit_msg_fmt
),
2039 ++opts
->current_fixup_count
+ 1);
2040 strbuf_addstr(&buf
, "\n\n");
2041 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
2043 return error(_("unknown command: %d"), command
);
2044 unuse_commit_buffer(commit
, message
);
2047 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(),
2049 strbuf_release(&buf
);
2052 strbuf_addf(&opts
->current_fixups
, "%s%s %s",
2053 opts
->current_fixups
.len
? "\n" : "",
2054 command_to_string(command
),
2055 oid_to_hex(&commit
->object
.oid
));
2056 res
= write_message(opts
->current_fixups
.buf
,
2057 opts
->current_fixups
.len
,
2058 rebase_path_current_fixups(), 0);
2064 static void flush_rewritten_pending(void)
2066 struct strbuf buf
= STRBUF_INIT
;
2067 struct object_id newoid
;
2070 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
2071 !get_oid("HEAD", &newoid
) &&
2072 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
2073 char *bol
= buf
.buf
, *eol
;
2076 eol
= strchrnul(bol
, '\n');
2077 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
2078 bol
, oid_to_hex(&newoid
));
2084 unlink(rebase_path_rewritten_pending());
2086 strbuf_release(&buf
);
2089 static void record_in_rewritten(struct object_id
*oid
,
2090 enum todo_command next_command
)
2092 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
2097 fprintf(out
, "%s\n", oid_to_hex(oid
));
2100 if (!is_fixup(next_command
))
2101 flush_rewritten_pending();
2104 static int should_edit(struct replay_opts
*opts
) {
2107 * Note that we only handle the case of non-conflicted
2108 * commits; continue_single_pick() handles the conflicted
2109 * commits itself instead of calling this function.
2111 return (opts
->action
== REPLAY_REVERT
&& isatty(0)) ? 1 : 0;
2115 static void refer_to_commit(struct replay_opts
*opts
,
2116 struct strbuf
*msgbuf
, struct commit
*commit
)
2118 if (opts
->commit_use_reference
) {
2119 struct pretty_print_context ctx
= {
2120 .abbrev
= DEFAULT_ABBREV
,
2121 .date_mode
.type
= DATE_SHORT
,
2123 format_commit_message(commit
, "%h (%s, %ad)", msgbuf
, &ctx
);
2125 strbuf_addstr(msgbuf
, oid_to_hex(&commit
->object
.oid
));
2129 static int do_pick_commit(struct repository
*r
,
2130 struct todo_item
*item
,
2131 struct replay_opts
*opts
,
2132 int final_fixup
, int *check_todo
)
2134 unsigned int flags
= should_edit(opts
) ? EDIT_MSG
: 0;
2135 const char *msg_file
= should_edit(opts
) ? NULL
: git_path_merge_msg(r
);
2136 struct object_id head
;
2137 struct commit
*base
, *next
, *parent
;
2138 const char *base_label
, *next_label
;
2139 char *author
= NULL
;
2140 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
2141 struct strbuf msgbuf
= STRBUF_INIT
;
2142 int res
, unborn
= 0, reword
= 0, allow
, drop_commit
;
2143 enum todo_command command
= item
->command
;
2144 struct commit
*commit
= item
->commit
;
2146 if (opts
->no_commit
) {
2148 * We do not intend to commit immediately. We just want to
2149 * merge the differences in, so let's compute the tree
2150 * that represents the "current" state for the merge machinery
2153 if (write_index_as_tree(&head
, r
->index
, r
->index_file
, 0, NULL
))
2154 return error(_("your index file is unmerged."));
2156 unborn
= get_oid("HEAD", &head
);
2157 /* Do we want to generate a root commit? */
2158 if (is_pick_or_similar(command
) && opts
->have_squash_onto
&&
2159 oideq(&head
, &opts
->squash_onto
)) {
2160 if (is_fixup(command
))
2161 return error(_("cannot fixup root commit"));
2162 flags
|= CREATE_ROOT_COMMIT
;
2165 oidcpy(&head
, the_hash_algo
->empty_tree
);
2166 if (index_differs_from(r
, unborn
? empty_tree_oid_hex() : "HEAD",
2168 return error_dirty_index(r
, opts
);
2170 discard_index(r
->index
);
2172 if (!commit
->parents
)
2174 else if (commit
->parents
->next
) {
2175 /* Reverting or cherry-picking a merge commit */
2177 struct commit_list
*p
;
2179 if (!opts
->mainline
)
2180 return error(_("commit %s is a merge but no -m option was given."),
2181 oid_to_hex(&commit
->object
.oid
));
2183 for (cnt
= 1, p
= commit
->parents
;
2184 cnt
!= opts
->mainline
&& p
;
2187 if (cnt
!= opts
->mainline
|| !p
)
2188 return error(_("commit %s does not have parent %d"),
2189 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2191 } else if (1 < opts
->mainline
)
2193 * Non-first parent explicitly specified as mainline for
2196 return error(_("commit %s does not have parent %d"),
2197 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2199 parent
= commit
->parents
->item
;
2201 if (get_message(commit
, &msg
) != 0)
2202 return error(_("cannot get commit message for %s"),
2203 oid_to_hex(&commit
->object
.oid
));
2205 if (opts
->allow_ff
&& !is_fixup(command
) &&
2206 ((parent
&& oideq(&parent
->object
.oid
, &head
)) ||
2207 (!parent
&& unborn
))) {
2208 if (is_rebase_i(opts
))
2209 write_author_script(msg
.message
);
2210 res
= fast_forward_to(r
, &commit
->object
.oid
, &head
, unborn
,
2212 if (res
|| command
!= TODO_REWORD
)
2216 goto fast_forward_edit
;
2218 if (parent
&& parse_commit(parent
) < 0)
2219 /* TRANSLATORS: The first %s will be a "todo" command like
2220 "revert" or "pick", the second %s a SHA1. */
2221 return error(_("%s: cannot parse parent commit %s"),
2222 command_to_string(command
),
2223 oid_to_hex(&parent
->object
.oid
));
2226 * "commit" is an existing commit. We would want to apply
2227 * the difference it introduces since its first parent "prev"
2228 * on top of the current HEAD if we are cherry-pick. Or the
2229 * reverse of it if we are revert.
2232 if (command
== TODO_REVERT
) {
2234 base_label
= msg
.label
;
2236 next_label
= msg
.parent_label
;
2237 if (opts
->commit_use_reference
) {
2238 strbuf_addstr(&msgbuf
,
2239 "# *** SAY WHY WE ARE REVERTING ON THE TITLE LINE ***");
2241 strbuf_addstr(&msgbuf
, "Revert \"");
2242 strbuf_addstr(&msgbuf
, msg
.subject
);
2243 strbuf_addstr(&msgbuf
, "\"");
2245 strbuf_addstr(&msgbuf
, "\n\nThis reverts commit ");
2246 refer_to_commit(opts
, &msgbuf
, commit
);
2248 if (commit
->parents
&& commit
->parents
->next
) {
2249 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
2250 refer_to_commit(opts
, &msgbuf
, parent
);
2252 strbuf_addstr(&msgbuf
, ".\n");
2257 base_label
= msg
.parent_label
;
2259 next_label
= msg
.label
;
2261 /* Append the commit log message to msgbuf. */
2262 if (find_commit_subject(msg
.message
, &p
))
2263 strbuf_addstr(&msgbuf
, p
);
2265 if (opts
->record_origin
) {
2266 strbuf_complete_line(&msgbuf
);
2267 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
2268 strbuf_addch(&msgbuf
, '\n');
2269 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
2270 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
2271 strbuf_addstr(&msgbuf
, ")\n");
2273 if (!is_fixup(command
))
2274 author
= get_author(msg
.message
);
2277 if (command
== TODO_REWORD
)
2279 else if (is_fixup(command
)) {
2280 if (update_squash_messages(r
, command
, commit
,
2281 opts
, item
->flags
)) {
2287 msg_file
= rebase_path_squash_msg();
2288 else if (file_exists(rebase_path_fixup_msg())) {
2289 flags
|= VERBATIM_MSG
;
2290 msg_file
= rebase_path_fixup_msg();
2292 const char *dest
= git_path_squash_msg(r
);
2294 if (copy_file(dest
, rebase_path_squash_msg(), 0666)) {
2295 res
= error(_("could not rename '%s' to '%s'"),
2296 rebase_path_squash_msg(), dest
);
2299 unlink(git_path_merge_msg(r
));
2305 if (opts
->signoff
&& !is_fixup(command
))
2306 append_signoff(&msgbuf
, 0, 0);
2308 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
2310 else if (!opts
->strategy
||
2311 !strcmp(opts
->strategy
, "recursive") ||
2312 !strcmp(opts
->strategy
, "ort") ||
2313 command
== TODO_REVERT
) {
2314 res
= do_recursive_merge(r
, base
, next
, base_label
, next_label
,
2315 &head
, &msgbuf
, opts
);
2319 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
2320 git_path_merge_msg(r
), 0);
2322 struct commit_list
*common
= NULL
;
2323 struct commit_list
*remotes
= NULL
;
2325 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
2326 git_path_merge_msg(r
), 0);
2328 commit_list_insert(base
, &common
);
2329 commit_list_insert(next
, &remotes
);
2330 res
|= try_merge_command(r
, opts
->strategy
,
2331 opts
->xopts_nr
, (const char **)opts
->xopts
,
2332 common
, oid_to_hex(&head
), remotes
);
2333 free_commit_list(common
);
2334 free_commit_list(remotes
);
2338 * If the merge was clean or if it failed due to conflict, we write
2339 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
2340 * However, if the merge did not even start, then we don't want to
2343 if ((command
== TODO_PICK
|| command
== TODO_REWORD
||
2344 command
== TODO_EDIT
) && !opts
->no_commit
&&
2345 (res
== 0 || res
== 1) &&
2346 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
2347 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2349 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
2350 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
2351 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2355 error(command
== TODO_REVERT
2356 ? _("could not revert %s... %s")
2357 : _("could not apply %s... %s"),
2358 short_commit_name(commit
), msg
.subject
);
2359 print_advice(r
, res
== 1, opts
);
2360 repo_rerere(r
, opts
->allow_rerere_auto
);
2365 allow
= allow_empty(r
, opts
, commit
);
2369 } else if (allow
== 1) {
2370 flags
|= ALLOW_EMPTY
;
2371 } else if (allow
== 2) {
2373 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
2375 unlink(git_path_merge_msg(r
));
2376 unlink(git_path_auto_merge(r
));
2378 _("dropping %s %s -- patch contents already upstream\n"),
2379 oid_to_hex(&commit
->object
.oid
), msg
.subject
);
2380 } /* else allow == 0 and there's nothing special to do */
2381 if (!opts
->no_commit
&& !drop_commit
) {
2382 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
2383 res
= do_commit(r
, msg_file
, author
, opts
, flags
,
2384 commit
? &commit
->object
.oid
: NULL
);
2386 res
= error(_("unable to parse commit author"));
2387 *check_todo
= !!(flags
& EDIT_MSG
);
2388 if (!res
&& reword
) {
2390 res
= run_git_commit(NULL
, opts
, EDIT_MSG
|
2391 VERIFY_MSG
| AMEND_MSG
|
2392 (flags
& ALLOW_EMPTY
));
2398 if (!res
&& final_fixup
) {
2399 unlink(rebase_path_fixup_msg());
2400 unlink(rebase_path_squash_msg());
2401 unlink(rebase_path_current_fixups());
2402 strbuf_reset(&opts
->current_fixups
);
2403 opts
->current_fixup_count
= 0;
2407 free_message(commit
, &msg
);
2409 strbuf_release(&msgbuf
);
2410 update_abort_safety_file();
2415 static int prepare_revs(struct replay_opts
*opts
)
2418 * picking (but not reverting) ranges (but not individual revisions)
2419 * should be done in reverse
2421 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
2422 opts
->revs
->reverse
^= 1;
2424 if (prepare_revision_walk(opts
->revs
))
2425 return error(_("revision walk setup failed"));
2430 static int read_and_refresh_cache(struct repository
*r
,
2431 struct replay_opts
*opts
)
2433 struct lock_file index_lock
= LOCK_INIT
;
2434 int index_fd
= repo_hold_locked_index(r
, &index_lock
, 0);
2435 if (repo_read_index(r
) < 0) {
2436 rollback_lock_file(&index_lock
);
2437 return error(_("git %s: failed to read the index"),
2440 refresh_index(r
->index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
2442 if (index_fd
>= 0) {
2443 if (write_locked_index(r
->index
, &index_lock
,
2444 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
2445 return error(_("git %s: failed to refresh the index"),
2451 * If we are resolving merges in any way other than "ort", then
2452 * expand the sparse index.
2454 if (opts
->strategy
&& strcmp(opts
->strategy
, "ort"))
2455 ensure_full_index(r
->index
);
2459 void todo_list_release(struct todo_list
*todo_list
)
2461 strbuf_release(&todo_list
->buf
);
2462 FREE_AND_NULL(todo_list
->items
);
2463 todo_list
->nr
= todo_list
->alloc
= 0;
2466 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
2468 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
2469 todo_list
->total_nr
++;
2470 return todo_list
->items
+ todo_list
->nr
++;
2473 const char *todo_item_get_arg(struct todo_list
*todo_list
,
2474 struct todo_item
*item
)
2476 return todo_list
->buf
.buf
+ item
->arg_offset
;
2479 static int is_command(enum todo_command command
, const char **bol
)
2481 const char *str
= todo_command_info
[command
].str
;
2482 const char nick
= todo_command_info
[command
].c
;
2483 const char *p
= *bol
+ 1;
2485 return skip_prefix(*bol
, str
, bol
) ||
2486 ((nick
&& **bol
== nick
) &&
2487 (*p
== ' ' || *p
== '\t' || *p
== '\n' || *p
== '\r' || !*p
) &&
2491 static int parse_insn_line(struct repository
*r
, struct todo_item
*item
,
2492 const char *buf
, const char *bol
, char *eol
)
2494 struct object_id commit_oid
;
2495 char *end_of_object_name
;
2496 int i
, saved
, status
, padding
;
2501 bol
+= strspn(bol
, " \t");
2503 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
2504 item
->command
= TODO_COMMENT
;
2505 item
->commit
= NULL
;
2506 item
->arg_offset
= bol
- buf
;
2507 item
->arg_len
= eol
- bol
;
2511 for (i
= 0; i
< TODO_COMMENT
; i
++)
2512 if (is_command(i
, &bol
)) {
2516 if (i
>= TODO_COMMENT
)
2519 /* Eat up extra spaces/ tabs before object name */
2520 padding
= strspn(bol
, " \t");
2523 if (item
->command
== TODO_NOOP
|| item
->command
== TODO_BREAK
) {
2525 return error(_("%s does not accept arguments: '%s'"),
2526 command_to_string(item
->command
), bol
);
2527 item
->commit
= NULL
;
2528 item
->arg_offset
= bol
- buf
;
2529 item
->arg_len
= eol
- bol
;
2534 return error(_("missing arguments for %s"),
2535 command_to_string(item
->command
));
2537 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
2538 item
->command
== TODO_RESET
|| item
->command
== TODO_UPDATE_REF
) {
2539 item
->commit
= NULL
;
2540 item
->arg_offset
= bol
- buf
;
2541 item
->arg_len
= (int)(eol
- bol
);
2545 if (item
->command
== TODO_FIXUP
) {
2546 if (skip_prefix(bol
, "-C", &bol
) &&
2547 (*bol
== ' ' || *bol
== '\t')) {
2548 bol
+= strspn(bol
, " \t");
2549 item
->flags
|= TODO_REPLACE_FIXUP_MSG
;
2550 } else if (skip_prefix(bol
, "-c", &bol
) &&
2551 (*bol
== ' ' || *bol
== '\t')) {
2552 bol
+= strspn(bol
, " \t");
2553 item
->flags
|= TODO_EDIT_FIXUP_MSG
;
2557 if (item
->command
== TODO_MERGE
) {
2558 if (skip_prefix(bol
, "-C", &bol
))
2559 bol
+= strspn(bol
, " \t");
2560 else if (skip_prefix(bol
, "-c", &bol
)) {
2561 bol
+= strspn(bol
, " \t");
2562 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2564 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2565 item
->commit
= NULL
;
2566 item
->arg_offset
= bol
- buf
;
2567 item
->arg_len
= (int)(eol
- bol
);
2572 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
2573 saved
= *end_of_object_name
;
2574 *end_of_object_name
= '\0';
2575 status
= get_oid(bol
, &commit_oid
);
2577 error(_("could not parse '%s'"), bol
); /* return later */
2578 *end_of_object_name
= saved
;
2580 bol
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2581 item
->arg_offset
= bol
- buf
;
2582 item
->arg_len
= (int)(eol
- bol
);
2587 item
->commit
= lookup_commit_reference(r
, &commit_oid
);
2588 return item
->commit
? 0 : -1;
2591 int sequencer_get_last_command(struct repository
*r
, enum replay_action
*action
)
2593 const char *todo_file
, *bol
;
2594 struct strbuf buf
= STRBUF_INIT
;
2597 todo_file
= git_path_todo_file();
2598 if (strbuf_read_file(&buf
, todo_file
, 0) < 0) {
2599 if (errno
== ENOENT
|| errno
== ENOTDIR
)
2602 return error_errno("unable to open '%s'", todo_file
);
2604 bol
= buf
.buf
+ strspn(buf
.buf
, " \t\r\n");
2605 if (is_command(TODO_PICK
, &bol
) && (*bol
== ' ' || *bol
== '\t'))
2606 *action
= REPLAY_PICK
;
2607 else if (is_command(TODO_REVERT
, &bol
) &&
2608 (*bol
== ' ' || *bol
== '\t'))
2609 *action
= REPLAY_REVERT
;
2613 strbuf_release(&buf
);
2618 int todo_list_parse_insn_buffer(struct repository
*r
, char *buf
,
2619 struct todo_list
*todo_list
)
2621 struct todo_item
*item
;
2622 char *p
= buf
, *next_p
;
2623 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2625 todo_list
->current
= todo_list
->nr
= 0;
2627 for (i
= 1; *p
; i
++, p
= next_p
) {
2628 char *eol
= strchrnul(p
, '\n');
2630 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2632 if (p
!= eol
&& eol
[-1] == '\r')
2633 eol
--; /* strip Carriage Return */
2635 item
= append_new_todo(todo_list
);
2636 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2637 if (parse_insn_line(r
, item
, buf
, p
, eol
)) {
2638 res
= error(_("invalid line %d: %.*s"),
2639 i
, (int)(eol
- p
), p
);
2640 item
->command
= TODO_COMMENT
+ 1;
2641 item
->arg_offset
= p
- buf
;
2642 item
->arg_len
= (int)(eol
- p
);
2643 item
->commit
= NULL
;
2648 else if (is_fixup(item
->command
))
2649 return error(_("cannot '%s' without a previous commit"),
2650 command_to_string(item
->command
));
2651 else if (!is_noop(item
->command
))
2658 static int count_commands(struct todo_list
*todo_list
)
2662 for (i
= 0; i
< todo_list
->nr
; i
++)
2663 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2669 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2671 return index
< todo_list
->nr
?
2672 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2675 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2677 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2680 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2682 return get_item_line_offset(todo_list
, index
+ 1)
2683 - get_item_line_offset(todo_list
, index
);
2686 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2691 fd
= open(path
, O_RDONLY
);
2693 return error_errno(_("could not open '%s'"), path
);
2694 len
= strbuf_read(sb
, fd
, 0);
2697 return error(_("could not read '%s'."), path
);
2701 static int have_finished_the_last_pick(void)
2703 struct strbuf buf
= STRBUF_INIT
;
2705 const char *todo_path
= git_path_todo_file();
2708 if (strbuf_read_file(&buf
, todo_path
, 0) < 0) {
2709 if (errno
== ENOENT
) {
2712 error_errno("unable to open '%s'", todo_path
);
2716 /* If there is only one line then we are done */
2717 eol
= strchr(buf
.buf
, '\n');
2718 if (!eol
|| !eol
[1])
2721 strbuf_release(&buf
);
2726 void sequencer_post_commit_cleanup(struct repository
*r
, int verbose
)
2728 struct replay_opts opts
= REPLAY_OPTS_INIT
;
2729 int need_cleanup
= 0;
2731 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
2732 if (!refs_delete_ref(get_main_ref_store(r
), "",
2733 "CHERRY_PICK_HEAD", NULL
, 0) &&
2735 warning(_("cancelling a cherry picking in progress"));
2736 opts
.action
= REPLAY_PICK
;
2740 if (refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
2741 if (!refs_delete_ref(get_main_ref_store(r
), "", "REVERT_HEAD",
2744 warning(_("cancelling a revert in progress"));
2745 opts
.action
= REPLAY_REVERT
;
2749 unlink(git_path_auto_merge(r
));
2754 if (!have_finished_the_last_pick())
2757 sequencer_remove_state(&opts
);
2760 static void todo_list_write_total_nr(struct todo_list
*todo_list
)
2762 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2765 fprintf(f
, "%d\n", todo_list
->total_nr
);
2770 static int read_populate_todo(struct repository
*r
,
2771 struct todo_list
*todo_list
,
2772 struct replay_opts
*opts
)
2774 const char *todo_file
= get_todo_path(opts
);
2777 strbuf_reset(&todo_list
->buf
);
2778 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2781 res
= todo_list_parse_insn_buffer(r
, todo_list
->buf
.buf
, todo_list
);
2783 if (is_rebase_i(opts
))
2784 return error(_("please fix this using "
2785 "'git rebase --edit-todo'."));
2786 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2789 if (!todo_list
->nr
&&
2790 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2791 return error(_("no commits parsed."));
2793 if (!is_rebase_i(opts
)) {
2794 enum todo_command valid
=
2795 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2798 for (i
= 0; i
< todo_list
->nr
; i
++)
2799 if (valid
== todo_list
->items
[i
].command
)
2801 else if (valid
== TODO_PICK
)
2802 return error(_("cannot cherry-pick during a revert."));
2804 return error(_("cannot revert during a cherry-pick."));
2807 if (is_rebase_i(opts
)) {
2808 struct todo_list done
= TODO_LIST_INIT
;
2810 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2811 !todo_list_parse_insn_buffer(r
, done
.buf
.buf
, &done
))
2812 todo_list
->done_nr
= count_commands(&done
);
2814 todo_list
->done_nr
= 0;
2816 todo_list
->total_nr
= todo_list
->done_nr
2817 + count_commands(todo_list
);
2818 todo_list_release(&done
);
2820 todo_list_write_total_nr(todo_list
);
2826 static int git_config_string_dup(char **dest
,
2827 const char *var
, const char *value
)
2830 return config_error_nonbool(var
);
2832 *dest
= xstrdup(value
);
2836 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
2838 struct replay_opts
*opts
= data
;
2843 else if (!strcmp(key
, "options.no-commit"))
2844 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
2845 else if (!strcmp(key
, "options.edit"))
2846 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
2847 else if (!strcmp(key
, "options.allow-empty"))
2849 git_config_bool_or_int(key
, value
, &error_flag
);
2850 else if (!strcmp(key
, "options.allow-empty-message"))
2851 opts
->allow_empty_message
=
2852 git_config_bool_or_int(key
, value
, &error_flag
);
2853 else if (!strcmp(key
, "options.keep-redundant-commits"))
2854 opts
->keep_redundant_commits
=
2855 git_config_bool_or_int(key
, value
, &error_flag
);
2856 else if (!strcmp(key
, "options.signoff"))
2857 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
2858 else if (!strcmp(key
, "options.record-origin"))
2859 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
2860 else if (!strcmp(key
, "options.allow-ff"))
2861 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
2862 else if (!strcmp(key
, "options.mainline"))
2863 opts
->mainline
= git_config_int(key
, value
);
2864 else if (!strcmp(key
, "options.strategy"))
2865 git_config_string_dup(&opts
->strategy
, key
, value
);
2866 else if (!strcmp(key
, "options.gpg-sign"))
2867 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
2868 else if (!strcmp(key
, "options.strategy-option")) {
2869 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
2870 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(value
);
2871 } else if (!strcmp(key
, "options.allow-rerere-auto"))
2872 opts
->allow_rerere_auto
=
2873 git_config_bool_or_int(key
, value
, &error_flag
) ?
2874 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
2875 else if (!strcmp(key
, "options.default-msg-cleanup")) {
2876 opts
->explicit_cleanup
= 1;
2877 opts
->default_msg_cleanup
= get_cleanup_mode(value
, 1);
2879 return error(_("invalid key: %s"), key
);
2882 return error(_("invalid value for '%s': '%s'"), key
, value
);
2887 void parse_strategy_opts(struct replay_opts
*opts
, char *raw_opts
)
2890 char *strategy_opts_string
= raw_opts
;
2892 if (*strategy_opts_string
== ' ')
2893 strategy_opts_string
++;
2895 opts
->xopts_nr
= split_cmdline(strategy_opts_string
,
2896 (const char ***)&opts
->xopts
);
2897 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
2898 const char *arg
= opts
->xopts
[i
];
2900 skip_prefix(arg
, "--", &arg
);
2901 opts
->xopts
[i
] = xstrdup(arg
);
2905 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2908 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2910 free(opts
->strategy
);
2911 opts
->strategy
= strbuf_detach(buf
, NULL
);
2912 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2915 parse_strategy_opts(opts
, buf
->buf
);
2918 static int read_populate_opts(struct replay_opts
*opts
)
2920 if (is_rebase_i(opts
)) {
2921 struct strbuf buf
= STRBUF_INIT
;
2924 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(),
2925 READ_ONELINER_SKIP_IF_EMPTY
)) {
2926 if (!starts_with(buf
.buf
, "-S"))
2929 free(opts
->gpg_sign
);
2930 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2935 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(),
2936 READ_ONELINER_SKIP_IF_EMPTY
)) {
2937 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2938 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2939 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2940 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2944 if (file_exists(rebase_path_verbose()))
2947 if (file_exists(rebase_path_quiet()))
2950 if (file_exists(rebase_path_signoff())) {
2955 if (file_exists(rebase_path_cdate_is_adate())) {
2957 opts
->committer_date_is_author_date
= 1;
2960 if (file_exists(rebase_path_ignore_date())) {
2962 opts
->ignore_date
= 1;
2965 if (file_exists(rebase_path_reschedule_failed_exec()))
2966 opts
->reschedule_failed_exec
= 1;
2967 else if (file_exists(rebase_path_no_reschedule_failed_exec()))
2968 opts
->reschedule_failed_exec
= 0;
2970 if (file_exists(rebase_path_drop_redundant_commits()))
2971 opts
->drop_redundant_commits
= 1;
2973 if (file_exists(rebase_path_keep_redundant_commits()))
2974 opts
->keep_redundant_commits
= 1;
2976 read_strategy_opts(opts
, &buf
);
2979 if (read_oneliner(&opts
->current_fixups
,
2980 rebase_path_current_fixups(),
2981 READ_ONELINER_SKIP_IF_EMPTY
)) {
2982 const char *p
= opts
->current_fixups
.buf
;
2983 opts
->current_fixup_count
= 1;
2984 while ((p
= strchr(p
, '\n'))) {
2985 opts
->current_fixup_count
++;
2990 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
2991 if (get_oid_committish(buf
.buf
, &opts
->squash_onto
) < 0) {
2992 ret
= error(_("unusable squash-onto"));
2995 opts
->have_squash_onto
= 1;
2999 strbuf_release(&buf
);
3003 if (!file_exists(git_path_opts_file()))
3006 * The function git_parse_source(), called from git_config_from_file(),
3007 * may die() in case of a syntactically incorrect file. We do not care
3008 * about this case, though, because we wrote that file ourselves, so we
3009 * are pretty certain that it is syntactically correct.
3011 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
3012 return error(_("malformed options sheet: '%s'"),
3013 git_path_opts_file());
3017 static void write_strategy_opts(struct replay_opts
*opts
)
3020 struct strbuf buf
= STRBUF_INIT
;
3022 for (i
= 0; i
< opts
->xopts_nr
; ++i
)
3023 strbuf_addf(&buf
, " --%s", opts
->xopts
[i
]);
3025 write_file(rebase_path_strategy_opts(), "%s\n", buf
.buf
);
3026 strbuf_release(&buf
);
3029 int write_basic_state(struct replay_opts
*opts
, const char *head_name
,
3030 struct commit
*onto
, const struct object_id
*orig_head
)
3033 write_file(rebase_path_head_name(), "%s\n", head_name
);
3035 write_file(rebase_path_onto(), "%s\n",
3036 oid_to_hex(&onto
->object
.oid
));
3038 write_file(rebase_path_orig_head(), "%s\n",
3039 oid_to_hex(orig_head
));
3042 write_file(rebase_path_quiet(), "%s", "");
3044 write_file(rebase_path_verbose(), "%s", "");
3046 write_file(rebase_path_strategy(), "%s\n", opts
->strategy
);
3047 if (opts
->xopts_nr
> 0)
3048 write_strategy_opts(opts
);
3050 if (opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
)
3051 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
3052 else if (opts
->allow_rerere_auto
== RERERE_NOAUTOUPDATE
)
3053 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
3056 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts
->gpg_sign
);
3058 write_file(rebase_path_signoff(), "--signoff\n");
3059 if (opts
->drop_redundant_commits
)
3060 write_file(rebase_path_drop_redundant_commits(), "%s", "");
3061 if (opts
->keep_redundant_commits
)
3062 write_file(rebase_path_keep_redundant_commits(), "%s", "");
3063 if (opts
->committer_date_is_author_date
)
3064 write_file(rebase_path_cdate_is_adate(), "%s", "");
3065 if (opts
->ignore_date
)
3066 write_file(rebase_path_ignore_date(), "%s", "");
3067 if (opts
->reschedule_failed_exec
)
3068 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
3070 write_file(rebase_path_no_reschedule_failed_exec(), "%s", "");
3075 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
3076 struct replay_opts
*opts
)
3078 enum todo_command command
= opts
->action
== REPLAY_PICK
?
3079 TODO_PICK
: TODO_REVERT
;
3080 const char *command_string
= todo_command_info
[command
].str
;
3081 const char *encoding
;
3082 struct commit
*commit
;
3084 if (prepare_revs(opts
))
3087 encoding
= get_log_output_encoding();
3089 while ((commit
= get_revision(opts
->revs
))) {
3090 struct todo_item
*item
= append_new_todo(todo_list
);
3091 const char *commit_buffer
= logmsg_reencode(commit
, NULL
, encoding
);
3092 const char *subject
;
3095 item
->command
= command
;
3096 item
->commit
= commit
;
3097 item
->arg_offset
= 0;
3099 item
->offset_in_buf
= todo_list
->buf
.len
;
3100 subject_len
= find_commit_subject(commit_buffer
, &subject
);
3101 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
3102 short_commit_name(commit
), subject_len
, subject
);
3103 unuse_commit_buffer(commit
, commit_buffer
);
3107 return error(_("empty commit set passed"));
3112 static int create_seq_dir(struct repository
*r
)
3114 enum replay_action action
;
3115 const char *in_progress_error
= NULL
;
3116 const char *in_progress_advice
= NULL
;
3117 unsigned int advise_skip
=
3118 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD") ||
3119 refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD");
3121 if (!sequencer_get_last_command(r
, &action
)) {
3124 in_progress_error
= _("revert is already in progress");
3125 in_progress_advice
=
3126 _("try \"git revert (--continue | %s--abort | --quit)\"");
3129 in_progress_error
= _("cherry-pick is already in progress");
3130 in_progress_advice
=
3131 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
3134 BUG("unexpected action in create_seq_dir");
3137 if (in_progress_error
) {
3138 error("%s", in_progress_error
);
3139 if (advice_enabled(ADVICE_SEQUENCER_IN_USE
))
3140 advise(in_progress_advice
,
3141 advise_skip
? "--skip | " : "");
3144 if (mkdir(git_path_seq_dir(), 0777) < 0)
3145 return error_errno(_("could not create sequencer directory '%s'"),
3146 git_path_seq_dir());
3151 static int save_head(const char *head
)
3153 struct lock_file head_lock
= LOCK_INIT
;
3154 struct strbuf buf
= STRBUF_INIT
;
3158 fd
= hold_lock_file_for_update(&head_lock
, git_path_head_file(), 0);
3160 return error_errno(_("could not lock HEAD"));
3161 strbuf_addf(&buf
, "%s\n", head
);
3162 written
= write_in_full(fd
, buf
.buf
, buf
.len
);
3163 strbuf_release(&buf
);
3165 error_errno(_("could not write to '%s'"), git_path_head_file());
3166 rollback_lock_file(&head_lock
);
3169 if (commit_lock_file(&head_lock
) < 0)
3170 return error(_("failed to finalize '%s'"), git_path_head_file());
3174 static int rollback_is_safe(void)
3176 struct strbuf sb
= STRBUF_INIT
;
3177 struct object_id expected_head
, actual_head
;
3179 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
3181 if (get_oid_hex(sb
.buf
, &expected_head
)) {
3182 strbuf_release(&sb
);
3183 die(_("could not parse %s"), git_path_abort_safety_file());
3185 strbuf_release(&sb
);
3187 else if (errno
== ENOENT
)
3188 oidclr(&expected_head
);
3190 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
3192 if (get_oid("HEAD", &actual_head
))
3193 oidclr(&actual_head
);
3195 return oideq(&actual_head
, &expected_head
);
3198 static int reset_merge(const struct object_id
*oid
)
3200 struct child_process cmd
= CHILD_PROCESS_INIT
;
3203 strvec_pushl(&cmd
.args
, "reset", "--merge", NULL
);
3205 if (!is_null_oid(oid
))
3206 strvec_push(&cmd
.args
, oid_to_hex(oid
));
3208 return run_command(&cmd
);
3211 static int rollback_single_pick(struct repository
*r
)
3213 struct object_id head_oid
;
3215 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
3216 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
3217 return error(_("no cherry-pick or revert in progress"));
3218 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
3219 return error(_("cannot resolve HEAD"));
3220 if (is_null_oid(&head_oid
))
3221 return error(_("cannot abort from a branch yet to be born"));
3222 return reset_merge(&head_oid
);
3225 static int skip_single_pick(void)
3227 struct object_id head
;
3229 if (read_ref_full("HEAD", 0, &head
, NULL
))
3230 return error(_("cannot resolve HEAD"));
3231 return reset_merge(&head
);
3234 int sequencer_rollback(struct repository
*r
, struct replay_opts
*opts
)
3237 struct object_id oid
;
3238 struct strbuf buf
= STRBUF_INIT
;
3241 f
= fopen(git_path_head_file(), "r");
3242 if (!f
&& errno
== ENOENT
) {
3244 * There is no multiple-cherry-pick in progress.
3245 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
3246 * a single-cherry-pick in progress, abort that.
3248 return rollback_single_pick(r
);
3251 return error_errno(_("cannot open '%s'"), git_path_head_file());
3252 if (strbuf_getline_lf(&buf
, f
)) {
3253 error(_("cannot read '%s': %s"), git_path_head_file(),
3254 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
3259 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
3260 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
3261 git_path_head_file());
3264 if (is_null_oid(&oid
)) {
3265 error(_("cannot abort from a branch yet to be born"));
3269 if (!rollback_is_safe()) {
3270 /* Do not error, just do not rollback */
3271 warning(_("You seem to have moved HEAD. "
3272 "Not rewinding, check your HEAD!"));
3274 if (reset_merge(&oid
))
3276 strbuf_release(&buf
);
3277 return sequencer_remove_state(opts
);
3279 strbuf_release(&buf
);
3283 int sequencer_skip(struct repository
*r
, struct replay_opts
*opts
)
3285 enum replay_action action
= -1;
3286 sequencer_get_last_command(r
, &action
);
3289 * Check whether the subcommand requested to skip the commit is actually
3290 * in progress and that it's safe to skip the commit.
3292 * opts->action tells us which subcommand requested to skip the commit.
3293 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
3294 * action is in progress and we can skip the commit.
3296 * Otherwise we check that the last instruction was related to the
3297 * particular subcommand we're trying to execute and barf if that's not
3300 * Finally we check that the rollback is "safe", i.e., has the HEAD
3301 * moved? In this case, it doesn't make sense to "reset the merge" and
3302 * "skip the commit" as the user already handled this by committing. But
3303 * we'd not want to barf here, instead give advice on how to proceed. We
3304 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
3305 * it gets removed when the user commits, so if it still exists we're
3306 * sure the user can't have committed before.
3308 switch (opts
->action
) {
3310 if (!refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
3311 if (action
!= REPLAY_REVERT
)
3312 return error(_("no revert in progress"));
3313 if (!rollback_is_safe())
3318 if (!refs_ref_exists(get_main_ref_store(r
),
3319 "CHERRY_PICK_HEAD")) {
3320 if (action
!= REPLAY_PICK
)
3321 return error(_("no cherry-pick in progress"));
3322 if (!rollback_is_safe())
3327 BUG("unexpected action in sequencer_skip");
3330 if (skip_single_pick())
3331 return error(_("failed to skip the commit"));
3332 if (!is_directory(git_path_seq_dir()))
3335 return sequencer_continue(r
, opts
);
3338 error(_("there is nothing to skip"));
3340 if (advice_enabled(ADVICE_RESOLVE_CONFLICT
)) {
3341 advise(_("have you committed already?\n"
3342 "try \"git %s --continue\""),
3343 action
== REPLAY_REVERT
? "revert" : "cherry-pick");
3348 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
3350 struct lock_file todo_lock
= LOCK_INIT
;
3351 const char *todo_path
= get_todo_path(opts
);
3352 int next
= todo_list
->current
, offset
, fd
;
3355 * rebase -i writes "git-rebase-todo" without the currently executing
3356 * command, appending it to "done" instead.
3358 if (is_rebase_i(opts
))
3361 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
3363 return error_errno(_("could not lock '%s'"), todo_path
);
3364 offset
= get_item_line_offset(todo_list
, next
);
3365 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
3366 todo_list
->buf
.len
- offset
) < 0)
3367 return error_errno(_("could not write to '%s'"), todo_path
);
3368 if (commit_lock_file(&todo_lock
) < 0)
3369 return error(_("failed to finalize '%s'"), todo_path
);
3371 if (is_rebase_i(opts
) && next
> 0) {
3372 const char *done
= rebase_path_done();
3373 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
3378 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
3379 get_item_line_length(todo_list
, next
- 1))
3381 ret
= error_errno(_("could not write to '%s'"), done
);
3383 ret
= error_errno(_("failed to finalize '%s'"), done
);
3389 static int save_opts(struct replay_opts
*opts
)
3391 const char *opts_file
= git_path_opts_file();
3394 if (opts
->no_commit
)
3395 res
|= git_config_set_in_file_gently(opts_file
,
3396 "options.no-commit", "true");
3397 if (opts
->edit
>= 0)
3398 res
|= git_config_set_in_file_gently(opts_file
, "options.edit",
3399 opts
->edit
? "true" : "false");
3400 if (opts
->allow_empty
)
3401 res
|= git_config_set_in_file_gently(opts_file
,
3402 "options.allow-empty", "true");
3403 if (opts
->allow_empty_message
)
3404 res
|= git_config_set_in_file_gently(opts_file
,
3405 "options.allow-empty-message", "true");
3406 if (opts
->keep_redundant_commits
)
3407 res
|= git_config_set_in_file_gently(opts_file
,
3408 "options.keep-redundant-commits", "true");
3410 res
|= git_config_set_in_file_gently(opts_file
,
3411 "options.signoff", "true");
3412 if (opts
->record_origin
)
3413 res
|= git_config_set_in_file_gently(opts_file
,
3414 "options.record-origin", "true");
3416 res
|= git_config_set_in_file_gently(opts_file
,
3417 "options.allow-ff", "true");
3418 if (opts
->mainline
) {
3419 struct strbuf buf
= STRBUF_INIT
;
3420 strbuf_addf(&buf
, "%d", opts
->mainline
);
3421 res
|= git_config_set_in_file_gently(opts_file
,
3422 "options.mainline", buf
.buf
);
3423 strbuf_release(&buf
);
3426 res
|= git_config_set_in_file_gently(opts_file
,
3427 "options.strategy", opts
->strategy
);
3429 res
|= git_config_set_in_file_gently(opts_file
,
3430 "options.gpg-sign", opts
->gpg_sign
);
3433 for (i
= 0; i
< opts
->xopts_nr
; i
++)
3434 res
|= git_config_set_multivar_in_file_gently(opts_file
,
3435 "options.strategy-option",
3436 opts
->xopts
[i
], "^$", 0);
3438 if (opts
->allow_rerere_auto
)
3439 res
|= git_config_set_in_file_gently(opts_file
,
3440 "options.allow-rerere-auto",
3441 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
3444 if (opts
->explicit_cleanup
)
3445 res
|= git_config_set_in_file_gently(opts_file
,
3446 "options.default-msg-cleanup",
3447 describe_cleanup_mode(opts
->default_msg_cleanup
));
3451 static int make_patch(struct repository
*r
,
3452 struct commit
*commit
,
3453 struct replay_opts
*opts
)
3455 struct strbuf buf
= STRBUF_INIT
;
3456 struct rev_info log_tree_opt
;
3457 const char *subject
;
3458 char hex
[GIT_MAX_HEXSZ
+ 1];
3461 oid_to_hex_r(hex
, &commit
->object
.oid
);
3462 if (write_message(hex
, strlen(hex
), rebase_path_stopped_sha(), 1) < 0)
3464 res
|= write_rebase_head(&commit
->object
.oid
);
3466 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
3467 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3468 repo_init_revisions(r
, &log_tree_opt
, NULL
);
3469 log_tree_opt
.abbrev
= 0;
3470 log_tree_opt
.diff
= 1;
3471 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
3472 log_tree_opt
.disable_stdin
= 1;
3473 log_tree_opt
.no_commit_id
= 1;
3474 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
3475 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
3476 if (!log_tree_opt
.diffopt
.file
)
3477 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
3479 res
|= log_tree_commit(&log_tree_opt
, commit
);
3480 fclose(log_tree_opt
.diffopt
.file
);
3484 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
3485 if (!file_exists(buf
.buf
)) {
3486 const char *encoding
= get_commit_output_encoding();
3487 const char *commit_buffer
= logmsg_reencode(commit
, NULL
, encoding
);
3488 find_commit_subject(commit_buffer
, &subject
);
3489 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
3490 unuse_commit_buffer(commit
, commit_buffer
);
3492 strbuf_release(&buf
);
3493 release_revisions(&log_tree_opt
);
3498 static int intend_to_amend(void)
3500 struct object_id head
;
3503 if (get_oid("HEAD", &head
))
3504 return error(_("cannot read HEAD"));
3506 p
= oid_to_hex(&head
);
3507 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
3510 static int error_with_patch(struct repository
*r
,
3511 struct commit
*commit
,
3512 const char *subject
, int subject_len
,
3513 struct replay_opts
*opts
,
3514 int exit_code
, int to_amend
)
3517 if (make_patch(r
, commit
, opts
))
3519 } else if (copy_file(rebase_path_message(),
3520 git_path_merge_msg(r
), 0666))
3521 return error(_("unable to copy '%s' to '%s'"),
3522 git_path_merge_msg(r
), rebase_path_message());
3525 if (intend_to_amend())
3529 _("You can amend the commit now, with\n"
3531 " git commit --amend %s\n"
3533 "Once you are satisfied with your changes, run\n"
3535 " git rebase --continue\n"),
3536 gpg_sign_opt_quoted(opts
));
3537 } else if (exit_code
) {
3539 fprintf_ln(stderr
, _("Could not apply %s... %.*s"),
3540 short_commit_name(commit
), subject_len
, subject
);
3543 * We don't have the hash of the parent so
3544 * just print the line from the todo file.
3546 fprintf_ln(stderr
, _("Could not merge %.*s"),
3547 subject_len
, subject
);
3553 static int error_failed_squash(struct repository
*r
,
3554 struct commit
*commit
,
3555 struct replay_opts
*opts
,
3557 const char *subject
)
3559 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3560 return error(_("could not copy '%s' to '%s'"),
3561 rebase_path_squash_msg(), rebase_path_message());
3562 unlink(git_path_merge_msg(r
));
3563 if (copy_file(git_path_merge_msg(r
), rebase_path_message(), 0666))
3564 return error(_("could not copy '%s' to '%s'"),
3565 rebase_path_message(),
3566 git_path_merge_msg(r
));
3567 return error_with_patch(r
, commit
, subject
, subject_len
, opts
, 1, 0);
3570 static int do_exec(struct repository
*r
, const char *command_line
)
3572 struct child_process cmd
= CHILD_PROCESS_INIT
;
3575 fprintf(stderr
, _("Executing: %s\n"), command_line
);
3577 strvec_push(&cmd
.args
, command_line
);
3578 status
= run_command(&cmd
);
3580 /* force re-reading of the cache */
3581 discard_index(r
->index
);
3582 if (repo_read_index(r
) < 0)
3583 return error(_("could not read index"));
3585 dirty
= require_clean_work_tree(r
, "rebase", NULL
, 1, 1);
3588 warning(_("execution failed: %s\n%s"
3589 "You can fix the problem, and then run\n"
3591 " git rebase --continue\n"
3594 dirty
? N_("and made changes to the index and/or the "
3595 "working tree\n") : "");
3597 /* command not found */
3600 warning(_("execution succeeded: %s\nbut "
3601 "left changes to the index and/or the working tree\n"
3602 "Commit or stash your changes, and then run\n"
3604 " git rebase --continue\n"
3605 "\n"), command_line
);
3612 __attribute__((format (printf
, 2, 3)))
3613 static int safe_append(const char *filename
, const char *fmt
, ...)
3616 struct lock_file lock
= LOCK_INIT
;
3617 int fd
= hold_lock_file_for_update(&lock
, filename
,
3618 LOCK_REPORT_ON_ERROR
);
3619 struct strbuf buf
= STRBUF_INIT
;
3624 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
3625 error_errno(_("could not read '%s'"), filename
);
3626 rollback_lock_file(&lock
);
3629 strbuf_complete(&buf
, '\n');
3631 strbuf_vaddf(&buf
, fmt
, ap
);
3634 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
3635 error_errno(_("could not write to '%s'"), filename
);
3636 strbuf_release(&buf
);
3637 rollback_lock_file(&lock
);
3640 if (commit_lock_file(&lock
) < 0) {
3641 strbuf_release(&buf
);
3642 rollback_lock_file(&lock
);
3643 return error(_("failed to finalize '%s'"), filename
);
3646 strbuf_release(&buf
);
3650 static int do_label(struct repository
*r
, const char *name
, int len
)
3652 struct ref_store
*refs
= get_main_ref_store(r
);
3653 struct ref_transaction
*transaction
;
3654 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
3655 struct strbuf msg
= STRBUF_INIT
;
3657 struct object_id head_oid
;
3659 if (len
== 1 && *name
== '#')
3660 return error(_("illegal label name: '%.*s'"), len
, name
);
3662 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3663 strbuf_addf(&msg
, "rebase (label) '%.*s'", len
, name
);
3665 transaction
= ref_store_transaction_begin(refs
, &err
);
3667 error("%s", err
.buf
);
3669 } else if (get_oid("HEAD", &head_oid
)) {
3670 error(_("could not read HEAD"));
3672 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
3673 NULL
, 0, msg
.buf
, &err
) < 0 ||
3674 ref_transaction_commit(transaction
, &err
)) {
3675 error("%s", err
.buf
);
3678 ref_transaction_free(transaction
);
3679 strbuf_release(&err
);
3680 strbuf_release(&msg
);
3683 ret
= safe_append(rebase_path_refs_to_delete(),
3684 "%s\n", ref_name
.buf
);
3685 strbuf_release(&ref_name
);
3690 static const char *sequencer_reflog_action(struct replay_opts
*opts
)
3692 if (!opts
->reflog_action
) {
3693 opts
->reflog_action
= getenv(GIT_REFLOG_ACTION
);
3694 opts
->reflog_action
=
3695 xstrdup(opts
->reflog_action
? opts
->reflog_action
3696 : action_name(opts
));
3699 return opts
->reflog_action
;
3702 __attribute__((format (printf
, 3, 4)))
3703 static const char *reflog_message(struct replay_opts
*opts
,
3704 const char *sub_action
, const char *fmt
, ...)
3707 static struct strbuf buf
= STRBUF_INIT
;
3711 strbuf_addstr(&buf
, sequencer_reflog_action(opts
));
3713 strbuf_addf(&buf
, " (%s)", sub_action
);
3715 strbuf_addstr(&buf
, ": ");
3716 strbuf_vaddf(&buf
, fmt
, ap
);
3723 static struct commit
*lookup_label(struct repository
*r
, const char *label
,
3724 int len
, struct strbuf
*buf
)
3726 struct commit
*commit
;
3727 struct object_id oid
;
3730 strbuf_addf(buf
, "refs/rewritten/%.*s", len
, label
);
3731 if (!read_ref(buf
->buf
, &oid
)) {
3732 commit
= lookup_commit_object(r
, &oid
);
3734 /* fall back to non-rewritten ref or commit */
3735 strbuf_splice(buf
, 0, strlen("refs/rewritten/"), "", 0);
3736 commit
= lookup_commit_reference_by_name(buf
->buf
);
3740 error(_("could not resolve '%s'"), buf
->buf
);
3745 static int do_reset(struct repository
*r
,
3746 const char *name
, int len
,
3747 struct replay_opts
*opts
)
3749 struct strbuf ref_name
= STRBUF_INIT
;
3750 struct object_id oid
;
3751 struct lock_file lock
= LOCK_INIT
;
3752 struct tree_desc desc
= { 0 };
3754 struct unpack_trees_options unpack_tree_opts
= { 0 };
3757 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0)
3760 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
3761 if (!opts
->have_squash_onto
) {
3763 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
3764 NULL
, &opts
->squash_onto
,
3766 return error(_("writing fake root commit"));
3767 opts
->have_squash_onto
= 1;
3768 hex
= oid_to_hex(&opts
->squash_onto
);
3769 if (write_message(hex
, strlen(hex
),
3770 rebase_path_squash_onto(), 0))
3771 return error(_("writing squash-onto"));
3773 oidcpy(&oid
, &opts
->squash_onto
);
3776 struct commit
*commit
;
3778 /* Determine the length of the label */
3779 for (i
= 0; i
< len
; i
++)
3780 if (isspace(name
[i
]))
3784 commit
= lookup_label(r
, name
, len
, &ref_name
);
3789 oid
= commit
->object
.oid
;
3792 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
3793 unpack_tree_opts
.head_idx
= 1;
3794 unpack_tree_opts
.src_index
= r
->index
;
3795 unpack_tree_opts
.dst_index
= r
->index
;
3796 unpack_tree_opts
.fn
= oneway_merge
;
3797 unpack_tree_opts
.merge
= 1;
3798 unpack_tree_opts
.update
= 1;
3799 unpack_tree_opts
.preserve_ignored
= 0; /* FIXME: !overwrite_ignore */
3800 unpack_tree_opts
.skip_cache_tree_update
= 1;
3801 init_checkout_metadata(&unpack_tree_opts
.meta
, name
, &oid
, NULL
);
3803 if (repo_read_index_unmerged(r
)) {
3804 ret
= error_resolve_conflict(action_name(opts
));
3808 if (!fill_tree_descriptor(r
, &desc
, &oid
)) {
3809 ret
= error(_("failed to find tree of %s"), oid_to_hex(&oid
));
3813 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
3818 tree
= parse_tree_indirect(&oid
);
3819 prime_cache_tree(r
, r
->index
, tree
);
3821 if (write_locked_index(r
->index
, &lock
, COMMIT_LOCK
) < 0)
3822 ret
= error(_("could not write index"));
3825 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
3826 len
, name
), "HEAD", &oid
,
3827 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3829 free((void *)desc
.buffer
);
3831 rollback_lock_file(&lock
);
3832 strbuf_release(&ref_name
);
3833 clear_unpack_trees_porcelain(&unpack_tree_opts
);
3837 static int do_merge(struct repository
*r
,
3838 struct commit
*commit
,
3839 const char *arg
, int arg_len
,
3840 int flags
, int *check_todo
, struct replay_opts
*opts
)
3842 int run_commit_flags
= 0;
3843 struct strbuf ref_name
= STRBUF_INIT
;
3844 struct commit
*head_commit
, *merge_commit
, *i
;
3845 struct commit_list
*bases
, *j
;
3846 struct commit_list
*to_merge
= NULL
, **tail
= &to_merge
;
3847 const char *strategy
= !opts
->xopts_nr
&&
3849 !strcmp(opts
->strategy
, "recursive") ||
3850 !strcmp(opts
->strategy
, "ort")) ?
3851 NULL
: opts
->strategy
;
3852 struct merge_options o
;
3853 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
, k
;
3854 static struct lock_file lock
;
3857 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0) {
3862 head_commit
= lookup_commit_reference_by_name("HEAD");
3864 ret
= error(_("cannot merge without a current revision"));
3869 * For octopus merges, the arg starts with the list of revisions to be
3870 * merged. The list is optionally followed by '#' and the oneline.
3872 merge_arg_len
= oneline_offset
= arg_len
;
3873 for (p
= arg
; p
- arg
< arg_len
; p
+= strspn(p
, " \t\n")) {
3876 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
3877 p
+= 1 + strspn(p
+ 1, " \t\n");
3878 oneline_offset
= p
- arg
;
3881 k
= strcspn(p
, " \t\n");
3884 merge_commit
= lookup_label(r
, p
, k
, &ref_name
);
3885 if (!merge_commit
) {
3886 ret
= error(_("unable to parse '%.*s'"), k
, p
);
3889 tail
= &commit_list_insert(merge_commit
, tail
)->next
;
3891 merge_arg_len
= p
- arg
;
3895 ret
= error(_("nothing to merge: '%.*s'"), arg_len
, arg
);
3899 if (opts
->have_squash_onto
&&
3900 oideq(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
3902 * When the user tells us to "merge" something into a
3903 * "[new root]", let's simply fast-forward to the merge head.
3905 rollback_lock_file(&lock
);
3907 ret
= error(_("octopus merge cannot be executed on "
3908 "top of a [new root]"));
3910 ret
= fast_forward_to(r
, &to_merge
->item
->object
.oid
,
3911 &head_commit
->object
.oid
, 0,
3917 * If HEAD is not identical to the first parent of the original merge
3918 * commit, we cannot fast-forward.
3920 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
3921 oideq(&commit
->parents
->item
->object
.oid
,
3922 &head_commit
->object
.oid
);
3925 * If any merge head is different from the original one, we cannot
3928 if (can_fast_forward
) {
3929 struct commit_list
*p
= commit
->parents
->next
;
3931 for (j
= to_merge
; j
&& p
; j
= j
->next
, p
= p
->next
)
3932 if (!oideq(&j
->item
->object
.oid
,
3933 &p
->item
->object
.oid
)) {
3934 can_fast_forward
= 0;
3938 * If the number of merge heads differs from the original merge
3939 * commit, we cannot fast-forward.
3942 can_fast_forward
= 0;
3945 if (can_fast_forward
) {
3946 rollback_lock_file(&lock
);
3947 ret
= fast_forward_to(r
, &commit
->object
.oid
,
3948 &head_commit
->object
.oid
, 0, opts
);
3949 if (flags
& TODO_EDIT_MERGE_MSG
)
3950 goto fast_forward_edit
;
3956 const char *encoding
= get_commit_output_encoding();
3957 const char *message
= logmsg_reencode(commit
, NULL
, encoding
);
3962 ret
= error(_("could not get commit message of '%s'"),
3963 oid_to_hex(&commit
->object
.oid
));
3966 write_author_script(message
);
3967 find_commit_subject(message
, &body
);
3969 ret
= write_message(body
, len
, git_path_merge_msg(r
), 0);
3970 unuse_commit_buffer(commit
, message
);
3972 error_errno(_("could not write '%s'"),
3973 git_path_merge_msg(r
));
3977 struct strbuf buf
= STRBUF_INIT
;
3980 strbuf_addf(&buf
, "author %s", git_author_info(0));
3981 write_author_script(buf
.buf
);
3984 if (oneline_offset
< arg_len
) {
3985 p
= arg
+ oneline_offset
;
3986 len
= arg_len
- oneline_offset
;
3988 strbuf_addf(&buf
, "Merge %s '%.*s'",
3989 to_merge
->next
? "branches" : "branch",
3990 merge_arg_len
, arg
);
3995 ret
= write_message(p
, len
, git_path_merge_msg(r
), 0);
3996 strbuf_release(&buf
);
3998 error_errno(_("could not write '%s'"),
3999 git_path_merge_msg(r
));
4004 if (strategy
|| to_merge
->next
) {
4006 struct child_process cmd
= CHILD_PROCESS_INIT
;
4008 if (read_env_script(&cmd
.env
)) {
4009 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
4011 ret
= error(_(staged_changes_advice
), gpg_opt
, gpg_opt
);
4015 if (opts
->committer_date_is_author_date
)
4016 strvec_pushf(&cmd
.env
, "GIT_COMMITTER_DATE=%s",
4019 author_date_from_env(&cmd
.env
));
4020 if (opts
->ignore_date
)
4021 strvec_push(&cmd
.env
, "GIT_AUTHOR_DATE=");
4024 strvec_push(&cmd
.args
, "merge");
4025 strvec_push(&cmd
.args
, "-s");
4027 strvec_push(&cmd
.args
, "octopus");
4029 strvec_push(&cmd
.args
, strategy
);
4030 for (k
= 0; k
< opts
->xopts_nr
; k
++)
4031 strvec_pushf(&cmd
.args
,
4032 "-X%s", opts
->xopts
[k
]);
4034 if (!(flags
& TODO_EDIT_MERGE_MSG
))
4035 strvec_push(&cmd
.args
, "--no-edit");
4037 strvec_push(&cmd
.args
, "--edit");
4038 strvec_push(&cmd
.args
, "--no-ff");
4039 strvec_push(&cmd
.args
, "--no-log");
4040 strvec_push(&cmd
.args
, "--no-stat");
4041 strvec_push(&cmd
.args
, "-F");
4042 strvec_push(&cmd
.args
, git_path_merge_msg(r
));
4044 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
4046 strvec_push(&cmd
.args
, "--no-gpg-sign");
4048 /* Add the tips to be merged */
4049 for (j
= to_merge
; j
; j
= j
->next
)
4050 strvec_push(&cmd
.args
,
4051 oid_to_hex(&j
->item
->object
.oid
));
4053 strbuf_release(&ref_name
);
4054 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
4056 rollback_lock_file(&lock
);
4058 ret
= run_command(&cmd
);
4060 /* force re-reading of the cache */
4062 discard_index(r
->index
);
4063 if (repo_read_index(r
) < 0)
4064 ret
= error(_("could not read index"));
4069 merge_commit
= to_merge
->item
;
4070 bases
= get_merge_bases(head_commit
, merge_commit
);
4071 if (bases
&& oideq(&merge_commit
->object
.oid
,
4072 &bases
->item
->object
.oid
)) {
4074 /* skip merging an ancestor of HEAD */
4078 write_message(oid_to_hex(&merge_commit
->object
.oid
), the_hash_algo
->hexsz
,
4079 git_path_merge_head(r
), 0);
4080 write_message("no-ff", 5, git_path_merge_mode(r
), 0);
4082 bases
= reverse_commit_list(bases
);
4085 init_merge_options(&o
, r
);
4087 o
.branch2
= ref_name
.buf
;
4088 o
.buffer_output
= 2;
4090 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
4092 * TODO: Should use merge_incore_recursive() and
4093 * merge_switch_to_result(), skipping the call to
4094 * merge_switch_to_result() when we don't actually need to
4095 * update the index and working copy immediately.
4097 ret
= merge_ort_recursive(&o
,
4098 head_commit
, merge_commit
, bases
,
4101 ret
= merge_recursive(&o
, head_commit
, merge_commit
, bases
,
4105 fputs(o
.obuf
.buf
, stdout
);
4106 strbuf_release(&o
.obuf
);
4108 error(_("could not even attempt to merge '%.*s'"),
4109 merge_arg_len
, arg
);
4113 * The return value of merge_recursive() is 1 on clean, and 0 on
4116 * Let's reverse that, so that do_merge() returns 0 upon success and
4117 * 1 upon failed merge (keeping the return value -1 for the cases where
4118 * we will want to reschedule the `merge` command).
4122 if (r
->index
->cache_changed
&&
4123 write_locked_index(r
->index
, &lock
, COMMIT_LOCK
)) {
4124 ret
= error(_("merge: Unable to write new index file"));
4128 rollback_lock_file(&lock
);
4130 repo_rerere(r
, opts
->allow_rerere_auto
);
4133 * In case of problems, we now want to return a positive
4134 * value (a negative one would indicate that the `merge`
4135 * command needs to be rescheduled).
4137 ret
= !!run_git_commit(git_path_merge_msg(r
), opts
,
4140 if (!ret
&& flags
& TODO_EDIT_MERGE_MSG
) {
4143 run_commit_flags
|= AMEND_MSG
| EDIT_MSG
| VERIFY_MSG
;
4144 ret
= !!run_git_commit(NULL
, opts
, run_commit_flags
);
4149 strbuf_release(&ref_name
);
4150 rollback_lock_file(&lock
);
4151 free_commit_list(to_merge
);
4155 static int write_update_refs_state(struct string_list
*refs_to_oids
)
4158 struct lock_file lock
= LOCK_INIT
;
4160 struct string_list_item
*item
;
4163 path
= rebase_path_update_refs(the_repository
->gitdir
);
4165 if (!refs_to_oids
->nr
) {
4166 if (unlink(path
) && errno
!= ENOENT
)
4167 result
= error_errno(_("could not unlink: %s"), path
);
4171 if (safe_create_leading_directories(path
)) {
4172 result
= error(_("unable to create leading directories of %s"),
4177 if (hold_lock_file_for_update(&lock
, path
, 0) < 0) {
4178 result
= error(_("another 'rebase' process appears to be running; "
4179 "'%s.lock' already exists"),
4184 fp
= fdopen_lock_file(&lock
, "w");
4186 result
= error_errno(_("could not open '%s' for writing"), path
);
4187 rollback_lock_file(&lock
);
4191 for_each_string_list_item(item
, refs_to_oids
) {
4192 struct update_ref_record
*rec
= item
->util
;
4193 fprintf(fp
, "%s\n%s\n%s\n", item
->string
,
4194 oid_to_hex(&rec
->before
), oid_to_hex(&rec
->after
));
4197 result
= commit_lock_file(&lock
);
4205 * Parse the update-refs file for the current rebase, then remove the
4206 * refs that do not appear in the todo_list (and have not had updated
4207 * values stored) and add refs that are in the todo_list but not
4208 * represented in the update-refs file.
4210 * If there are changes to the update-refs list, then write the new state
4213 void todo_list_filter_update_refs(struct repository
*r
,
4214 struct todo_list
*todo_list
)
4218 struct string_list update_refs
= STRING_LIST_INIT_DUP
;
4220 sequencer_get_update_refs_state(r
->gitdir
, &update_refs
);
4223 * For each item in the update_refs list, if it has no updated
4224 * value and does not appear in the todo_list, then remove it
4225 * from the update_refs list.
4227 for (i
= 0; i
< update_refs
.nr
; i
++) {
4230 const char *ref
= update_refs
.items
[i
].string
;
4231 size_t reflen
= strlen(ref
);
4232 struct update_ref_record
*rec
= update_refs
.items
[i
].util
;
4234 /* OID already stored as updated. */
4235 if (!is_null_oid(&rec
->after
))
4238 for (j
= 0; !found
&& j
< todo_list
->total_nr
; j
++) {
4239 struct todo_item
*item
= &todo_list
->items
[j
];
4240 const char *arg
= todo_list
->buf
.buf
+ item
->arg_offset
;
4242 if (item
->command
!= TODO_UPDATE_REF
)
4245 if (item
->arg_len
!= reflen
||
4246 strncmp(arg
, ref
, reflen
))
4253 free(update_refs
.items
[i
].string
);
4254 free(update_refs
.items
[i
].util
);
4257 MOVE_ARRAY(update_refs
.items
+ i
, update_refs
.items
+ i
+ 1, update_refs
.nr
- i
);
4265 * For each todo_item, check if its ref is in the update_refs list.
4266 * If not, then add it as an un-updated ref.
4268 for (i
= 0; i
< todo_list
->total_nr
; i
++) {
4269 struct todo_item
*item
= &todo_list
->items
[i
];
4270 const char *arg
= todo_list
->buf
.buf
+ item
->arg_offset
;
4273 if (item
->command
!= TODO_UPDATE_REF
)
4276 for (j
= 0; !found
&& j
< update_refs
.nr
; j
++) {
4277 const char *ref
= update_refs
.items
[j
].string
;
4279 found
= strlen(ref
) == item
->arg_len
&&
4280 !strncmp(ref
, arg
, item
->arg_len
);
4284 struct string_list_item
*inserted
;
4285 struct strbuf argref
= STRBUF_INIT
;
4287 strbuf_add(&argref
, arg
, item
->arg_len
);
4288 inserted
= string_list_insert(&update_refs
, argref
.buf
);
4289 inserted
->util
= init_update_ref_record(argref
.buf
);
4290 strbuf_release(&argref
);
4296 write_update_refs_state(&update_refs
);
4297 string_list_clear(&update_refs
, 1);
4300 static int do_update_ref(struct repository
*r
, const char *refname
)
4302 struct string_list_item
*item
;
4303 struct string_list list
= STRING_LIST_INIT_DUP
;
4305 if (sequencer_get_update_refs_state(r
->gitdir
, &list
))
4308 for_each_string_list_item(item
, &list
) {
4309 if (!strcmp(item
->string
, refname
)) {
4310 struct update_ref_record
*rec
= item
->util
;
4311 if (read_ref("HEAD", &rec
->after
))
4317 write_update_refs_state(&list
);
4318 string_list_clear(&list
, 1);
4322 static int do_update_refs(struct repository
*r
, int quiet
)
4325 struct string_list_item
*item
;
4326 struct string_list refs_to_oids
= STRING_LIST_INIT_DUP
;
4327 struct ref_store
*refs
= get_main_ref_store(r
);
4328 struct strbuf update_msg
= STRBUF_INIT
;
4329 struct strbuf error_msg
= STRBUF_INIT
;
4331 if ((res
= sequencer_get_update_refs_state(r
->gitdir
, &refs_to_oids
)))
4334 for_each_string_list_item(item
, &refs_to_oids
) {
4335 struct update_ref_record
*rec
= item
->util
;
4338 loop_res
= refs_update_ref(refs
, "rewritten during rebase",
4340 &rec
->after
, &rec
->before
,
4341 0, UPDATE_REFS_MSG_ON_ERR
);
4348 strbuf_addf(&error_msg
, "\t%s\n", item
->string
);
4350 strbuf_addf(&update_msg
, "\t%s\n", item
->string
);
4354 (update_msg
.len
|| error_msg
.len
)) {
4356 _("Updated the following refs with %s:\n%s"),
4362 _("Failed to update the following refs with %s:\n%s"),
4367 string_list_clear(&refs_to_oids
, 1);
4368 strbuf_release(&update_msg
);
4369 strbuf_release(&error_msg
);
4373 static int is_final_fixup(struct todo_list
*todo_list
)
4375 int i
= todo_list
->current
;
4377 if (!is_fixup(todo_list
->items
[i
].command
))
4380 while (++i
< todo_list
->nr
)
4381 if (is_fixup(todo_list
->items
[i
].command
))
4383 else if (!is_noop(todo_list
->items
[i
].command
))
4388 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
4392 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
4393 if (!is_noop(todo_list
->items
[i
].command
))
4394 return todo_list
->items
[i
].command
;
4399 void create_autostash(struct repository
*r
, const char *path
)
4401 struct strbuf buf
= STRBUF_INIT
;
4402 struct lock_file lock_file
= LOCK_INIT
;
4405 fd
= repo_hold_locked_index(r
, &lock_file
, 0);
4406 refresh_index(r
->index
, REFRESH_QUIET
, NULL
, NULL
, NULL
);
4408 repo_update_index_if_able(r
, &lock_file
);
4409 rollback_lock_file(&lock_file
);
4411 if (has_unstaged_changes(r
, 1) ||
4412 has_uncommitted_changes(r
, 1)) {
4413 struct child_process stash
= CHILD_PROCESS_INIT
;
4414 struct reset_head_opts ropts
= { .flags
= RESET_HEAD_HARD
};
4415 struct object_id oid
;
4417 strvec_pushl(&stash
.args
,
4418 "stash", "create", "autostash", NULL
);
4422 if (capture_command(&stash
, &buf
, GIT_MAX_HEXSZ
))
4423 die(_("Cannot autostash"));
4424 strbuf_trim_trailing_newline(&buf
);
4425 if (get_oid(buf
.buf
, &oid
))
4426 die(_("Unexpected stash response: '%s'"),
4429 strbuf_add_unique_abbrev(&buf
, &oid
, DEFAULT_ABBREV
);
4431 if (safe_create_leading_directories_const(path
))
4432 die(_("Could not create directory for '%s'"),
4434 write_file(path
, "%s", oid_to_hex(&oid
));
4435 printf(_("Created autostash: %s\n"), buf
.buf
);
4436 if (reset_head(r
, &ropts
) < 0)
4437 die(_("could not reset --hard"));
4438 discard_index(r
->index
);
4439 if (repo_read_index(r
) < 0)
4440 die(_("could not read index"));
4442 strbuf_release(&buf
);
4445 static int apply_save_autostash_oid(const char *stash_oid
, int attempt_apply
)
4447 struct child_process child
= CHILD_PROCESS_INIT
;
4450 if (attempt_apply
) {
4452 child
.no_stdout
= 1;
4453 child
.no_stderr
= 1;
4454 strvec_push(&child
.args
, "stash");
4455 strvec_push(&child
.args
, "apply");
4456 strvec_push(&child
.args
, stash_oid
);
4457 ret
= run_command(&child
);
4460 if (attempt_apply
&& !ret
)
4461 fprintf(stderr
, _("Applied autostash.\n"));
4463 struct child_process store
= CHILD_PROCESS_INIT
;
4466 strvec_push(&store
.args
, "stash");
4467 strvec_push(&store
.args
, "store");
4468 strvec_push(&store
.args
, "-m");
4469 strvec_push(&store
.args
, "autostash");
4470 strvec_push(&store
.args
, "-q");
4471 strvec_push(&store
.args
, stash_oid
);
4472 if (run_command(&store
))
4473 ret
= error(_("cannot store %s"), stash_oid
);
4477 "Your changes are safe in the stash.\n"
4478 "You can run \"git stash pop\" or"
4479 " \"git stash drop\" at any time.\n"),
4481 _("Applying autostash resulted in conflicts.") :
4482 _("Autostash exists; creating a new stash entry."));
4488 static int apply_save_autostash(const char *path
, int attempt_apply
)
4490 struct strbuf stash_oid
= STRBUF_INIT
;
4493 if (!read_oneliner(&stash_oid
, path
,
4494 READ_ONELINER_SKIP_IF_EMPTY
)) {
4495 strbuf_release(&stash_oid
);
4498 strbuf_trim(&stash_oid
);
4500 ret
= apply_save_autostash_oid(stash_oid
.buf
, attempt_apply
);
4503 strbuf_release(&stash_oid
);
4507 int save_autostash(const char *path
)
4509 return apply_save_autostash(path
, 0);
4512 int apply_autostash(const char *path
)
4514 return apply_save_autostash(path
, 1);
4517 int apply_autostash_oid(const char *stash_oid
)
4519 return apply_save_autostash_oid(stash_oid
, 1);
4522 static int checkout_onto(struct repository
*r
, struct replay_opts
*opts
,
4523 const char *onto_name
, const struct object_id
*onto
,
4524 const struct object_id
*orig_head
)
4526 struct reset_head_opts ropts
= {
4528 .orig_head
= orig_head
,
4529 .flags
= RESET_HEAD_DETACH
| RESET_ORIG_HEAD
|
4530 RESET_HEAD_RUN_POST_CHECKOUT_HOOK
,
4531 .head_msg
= reflog_message(opts
, "start", "checkout %s",
4533 .default_reflog_action
= sequencer_reflog_action(opts
)
4535 if (reset_head(r
, &ropts
)) {
4536 apply_autostash(rebase_path_autostash());
4537 sequencer_remove_state(opts
);
4538 return error(_("could not detach HEAD"));
4544 static int stopped_at_head(struct repository
*r
)
4546 struct object_id head
;
4547 struct commit
*commit
;
4548 struct commit_message message
;
4550 if (get_oid("HEAD", &head
) ||
4551 !(commit
= lookup_commit(r
, &head
)) ||
4552 parse_commit(commit
) || get_message(commit
, &message
))
4553 fprintf(stderr
, _("Stopped at HEAD\n"));
4555 fprintf(stderr
, _("Stopped at %s\n"), message
.label
);
4556 free_message(commit
, &message
);
4562 static int reread_todo_if_changed(struct repository
*r
,
4563 struct todo_list
*todo_list
,
4564 struct replay_opts
*opts
)
4567 struct strbuf buf
= STRBUF_INIT
;
4569 if (strbuf_read_file_or_whine(&buf
, get_todo_path(opts
)) < 0)
4571 offset
= get_item_line_offset(todo_list
, todo_list
->current
+ 1);
4572 if (buf
.len
!= todo_list
->buf
.len
- offset
||
4573 memcmp(buf
.buf
, todo_list
->buf
.buf
+ offset
, buf
.len
)) {
4574 /* Reread the todo file if it has changed. */
4575 todo_list_release(todo_list
);
4576 if (read_populate_todo(r
, todo_list
, opts
))
4577 return -1; /* message was printed */
4578 /* `current` will be incremented on return */
4579 todo_list
->current
= -1;
4581 strbuf_release(&buf
);
4586 static const char rescheduled_advice
[] =
4587 N_("Could not execute the todo command\n"
4591 "It has been rescheduled; To edit the command before continuing, please\n"
4592 "edit the todo list first:\n"
4594 " git rebase --edit-todo\n"
4595 " git rebase --continue\n");
4597 static int pick_commits(struct repository
*r
,
4598 struct todo_list
*todo_list
,
4599 struct replay_opts
*opts
)
4601 int res
= 0, reschedule
= 0;
4603 opts
->reflog_message
= sequencer_reflog_action(opts
);
4605 assert(!(opts
->signoff
|| opts
->no_commit
||
4606 opts
->record_origin
|| should_edit(opts
) ||
4607 opts
->committer_date_is_author_date
||
4608 opts
->ignore_date
));
4609 if (read_and_refresh_cache(r
, opts
))
4612 while (todo_list
->current
< todo_list
->nr
) {
4613 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
4614 const char *arg
= todo_item_get_arg(todo_list
, item
);
4617 if (save_todo(todo_list
, opts
))
4619 if (is_rebase_i(opts
)) {
4620 if (item
->command
!= TODO_COMMENT
) {
4621 FILE *f
= fopen(rebase_path_msgnum(), "w");
4623 todo_list
->done_nr
++;
4626 fprintf(f
, "%d\n", todo_list
->done_nr
);
4630 fprintf(stderr
, _("Rebasing (%d/%d)%s"),
4632 todo_list
->total_nr
,
4633 opts
->verbose
? "\n" : "\r");
4635 unlink(rebase_path_message());
4636 unlink(rebase_path_author_script());
4637 unlink(rebase_path_stopped_sha());
4638 unlink(rebase_path_amend());
4639 unlink(git_path_merge_head(r
));
4640 unlink(git_path_auto_merge(r
));
4641 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
4643 if (item
->command
== TODO_BREAK
) {
4646 return stopped_at_head(r
);
4649 if (item
->command
<= TODO_SQUASH
) {
4650 if (is_rebase_i(opts
))
4651 opts
->reflog_message
= reflog_message(opts
,
4652 command_to_string(item
->command
), NULL
);
4654 res
= do_pick_commit(r
, item
, opts
,
4655 is_final_fixup(todo_list
),
4657 if (is_rebase_i(opts
) && res
< 0) {
4659 advise(_(rescheduled_advice
),
4660 get_item_line_length(todo_list
,
4661 todo_list
->current
),
4662 get_item_line(todo_list
,
4663 todo_list
->current
));
4664 todo_list
->current
--;
4665 if (save_todo(todo_list
, opts
))
4668 if (item
->command
== TODO_EDIT
) {
4669 struct commit
*commit
= item
->commit
;
4674 _("Stopped at %s... %.*s\n"),
4675 short_commit_name(commit
),
4676 item
->arg_len
, arg
);
4678 return error_with_patch(r
, commit
,
4679 arg
, item
->arg_len
, opts
, res
, !res
);
4681 if (is_rebase_i(opts
) && !res
)
4682 record_in_rewritten(&item
->commit
->object
.oid
,
4683 peek_command(todo_list
, 1));
4684 if (res
&& is_fixup(item
->command
)) {
4687 return error_failed_squash(r
, item
->commit
, opts
,
4688 item
->arg_len
, arg
);
4689 } else if (res
&& is_rebase_i(opts
) && item
->commit
) {
4691 struct object_id oid
;
4694 * If we are rewording and have either
4695 * fast-forwarded already, or are about to
4696 * create a new root commit, we want to amend,
4697 * otherwise we do not.
4699 if (item
->command
== TODO_REWORD
&&
4700 !get_oid("HEAD", &oid
) &&
4701 (oideq(&item
->commit
->object
.oid
, &oid
) ||
4702 (opts
->have_squash_onto
&&
4703 oideq(&opts
->squash_onto
, &oid
))))
4706 return res
| error_with_patch(r
, item
->commit
,
4707 arg
, item
->arg_len
, opts
,
4710 } else if (item
->command
== TODO_EXEC
) {
4711 char *end_of_arg
= (char *)(arg
+ item
->arg_len
);
4712 int saved
= *end_of_arg
;
4717 res
= do_exec(r
, arg
);
4718 *end_of_arg
= saved
;
4721 if (opts
->reschedule_failed_exec
)
4725 } else if (item
->command
== TODO_LABEL
) {
4726 if ((res
= do_label(r
, arg
, item
->arg_len
)))
4728 } else if (item
->command
== TODO_RESET
) {
4729 if ((res
= do_reset(r
, arg
, item
->arg_len
, opts
)))
4731 } else if (item
->command
== TODO_MERGE
) {
4732 if ((res
= do_merge(r
, item
->commit
, arg
, item
->arg_len
,
4733 item
->flags
, &check_todo
, opts
)) < 0)
4735 else if (item
->commit
)
4736 record_in_rewritten(&item
->commit
->object
.oid
,
4737 peek_command(todo_list
, 1));
4739 /* failed with merge conflicts */
4740 return error_with_patch(r
, item
->commit
,
4743 } else if (item
->command
== TODO_UPDATE_REF
) {
4744 struct strbuf ref
= STRBUF_INIT
;
4745 strbuf_add(&ref
, arg
, item
->arg_len
);
4746 if ((res
= do_update_ref(r
, ref
.buf
)))
4748 strbuf_release(&ref
);
4749 } else if (!is_noop(item
->command
))
4750 return error(_("unknown command %d"), item
->command
);
4753 advise(_(rescheduled_advice
),
4754 get_item_line_length(todo_list
,
4755 todo_list
->current
),
4756 get_item_line(todo_list
, todo_list
->current
));
4757 todo_list
->current
--;
4758 if (save_todo(todo_list
, opts
))
4761 return error_with_patch(r
,
4765 } else if (is_rebase_i(opts
) && check_todo
&& !res
&&
4766 reread_todo_if_changed(r
, todo_list
, opts
)) {
4770 todo_list
->current
++;
4775 if (is_rebase_i(opts
)) {
4776 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
4779 /* Stopped in the middle, as planned? */
4780 if (todo_list
->current
< todo_list
->nr
)
4783 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
4784 starts_with(head_ref
.buf
, "refs/")) {
4786 struct object_id head
, orig
;
4789 if (get_oid("HEAD", &head
)) {
4790 res
= error(_("cannot read HEAD"));
4792 strbuf_release(&head_ref
);
4793 strbuf_release(&buf
);
4796 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
4797 get_oid_hex(buf
.buf
, &orig
)) {
4798 res
= error(_("could not read orig-head"));
4799 goto cleanup_head_ref
;
4802 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
4803 res
= error(_("could not read 'onto'"));
4804 goto cleanup_head_ref
;
4806 msg
= reflog_message(opts
, "finish", "%s onto %s",
4807 head_ref
.buf
, buf
.buf
);
4808 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
4809 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
4810 res
= error(_("could not update %s"),
4812 goto cleanup_head_ref
;
4814 msg
= reflog_message(opts
, "finish", "returning to %s",
4816 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
4817 res
= error(_("could not update HEAD to %s"),
4819 goto cleanup_head_ref
;
4824 if (opts
->verbose
) {
4825 struct rev_info log_tree_opt
;
4826 struct object_id orig
, head
;
4828 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
4829 repo_init_revisions(r
, &log_tree_opt
, NULL
);
4830 log_tree_opt
.diff
= 1;
4831 log_tree_opt
.diffopt
.output_format
=
4832 DIFF_FORMAT_DIFFSTAT
;
4833 log_tree_opt
.disable_stdin
= 1;
4835 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
4836 !get_oid(buf
.buf
, &orig
) &&
4837 !get_oid("HEAD", &head
)) {
4838 diff_tree_oid(&orig
, &head
, "",
4839 &log_tree_opt
.diffopt
);
4840 log_tree_diff_flush(&log_tree_opt
);
4842 release_revisions(&log_tree_opt
);
4844 flush_rewritten_pending();
4845 if (!stat(rebase_path_rewritten_list(), &st
) &&
4847 struct child_process child
= CHILD_PROCESS_INIT
;
4848 struct run_hooks_opt hook_opt
= RUN_HOOKS_OPT_INIT
;
4850 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
4852 strvec_push(&child
.args
, "notes");
4853 strvec_push(&child
.args
, "copy");
4854 strvec_push(&child
.args
, "--for-rewrite=rebase");
4855 /* we don't care if this copying failed */
4856 run_command(&child
);
4858 hook_opt
.path_to_stdin
= rebase_path_rewritten_list();
4859 strvec_push(&hook_opt
.args
, "rebase");
4860 run_hooks_opt("post-rewrite", &hook_opt
);
4862 apply_autostash(rebase_path_autostash());
4868 _("Successfully rebased and updated %s.\n"),
4872 strbuf_release(&buf
);
4873 strbuf_release(&head_ref
);
4875 if (do_update_refs(r
, opts
->quiet
))
4880 * Sequence of picks finished successfully; cleanup by
4881 * removing the .git/sequencer directory
4883 return sequencer_remove_state(opts
);
4886 static int continue_single_pick(struct repository
*r
, struct replay_opts
*opts
)
4888 struct child_process cmd
= CHILD_PROCESS_INIT
;
4890 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
4891 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
4892 return error(_("no cherry-pick or revert in progress"));
4895 strvec_push(&cmd
.args
, "commit");
4898 * continue_single_pick() handles the case of recovering from a
4899 * conflict. should_edit() doesn't handle that case; for a conflict,
4900 * we want to edit if the user asked for it, or if they didn't specify
4901 * and stdin is a tty.
4903 if (!opts
->edit
|| (opts
->edit
< 0 && !isatty(0)))
4905 * Include --cleanup=strip as well because we don't want the
4906 * "# Conflicts:" messages.
4908 strvec_pushl(&cmd
.args
, "--no-edit", "--cleanup=strip", NULL
);
4910 return run_command(&cmd
);
4913 static int commit_staged_changes(struct repository
*r
,
4914 struct replay_opts
*opts
,
4915 struct todo_list
*todo_list
)
4917 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
4918 unsigned int final_fixup
= 0, is_clean
;
4920 if (has_unstaged_changes(r
, 1))
4921 return error(_("cannot rebase: You have unstaged changes."));
4923 is_clean
= !has_uncommitted_changes(r
, 0);
4925 if (file_exists(rebase_path_amend())) {
4926 struct strbuf rev
= STRBUF_INIT
;
4927 struct object_id head
, to_amend
;
4929 if (get_oid("HEAD", &head
))
4930 return error(_("cannot amend non-existing commit"));
4931 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
4932 return error(_("invalid file: '%s'"), rebase_path_amend());
4933 if (get_oid_hex(rev
.buf
, &to_amend
))
4934 return error(_("invalid contents: '%s'"),
4935 rebase_path_amend());
4936 if (!is_clean
&& !oideq(&head
, &to_amend
))
4937 return error(_("\nYou have uncommitted changes in your "
4938 "working tree. Please, commit them\n"
4939 "first and then run 'git rebase "
4940 "--continue' again."));
4942 * When skipping a failed fixup/squash, we need to edit the
4943 * commit message, the current fixup list and count, and if it
4944 * was the last fixup/squash in the chain, we need to clean up
4945 * the commit message and if there was a squash, let the user
4948 if (!is_clean
|| !opts
->current_fixup_count
)
4949 ; /* this is not the final fixup */
4950 else if (!oideq(&head
, &to_amend
) ||
4951 !file_exists(rebase_path_stopped_sha())) {
4952 /* was a final fixup or squash done manually? */
4953 if (!is_fixup(peek_command(todo_list
, 0))) {
4954 unlink(rebase_path_fixup_msg());
4955 unlink(rebase_path_squash_msg());
4956 unlink(rebase_path_current_fixups());
4957 strbuf_reset(&opts
->current_fixups
);
4958 opts
->current_fixup_count
= 0;
4961 /* we are in a fixup/squash chain */
4962 const char *p
= opts
->current_fixups
.buf
;
4963 int len
= opts
->current_fixups
.len
;
4965 opts
->current_fixup_count
--;
4967 BUG("Incorrect current_fixups:\n%s", p
);
4968 while (len
&& p
[len
- 1] != '\n')
4970 strbuf_setlen(&opts
->current_fixups
, len
);
4971 if (write_message(p
, len
, rebase_path_current_fixups(),
4973 return error(_("could not write file: '%s'"),
4974 rebase_path_current_fixups());
4977 * If a fixup/squash in a fixup/squash chain failed, the
4978 * commit message is already correct, no need to commit
4981 * Only if it is the final command in the fixup/squash
4982 * chain, and only if the chain is longer than a single
4983 * fixup/squash command (which was just skipped), do we
4984 * actually need to re-commit with a cleaned up commit
4987 if (opts
->current_fixup_count
> 0 &&
4988 !is_fixup(peek_command(todo_list
, 0))) {
4991 * If there was not a single "squash" in the
4992 * chain, we only need to clean up the commit
4993 * message, no need to bother the user with
4994 * opening the commit message in the editor.
4996 if (!starts_with(p
, "squash ") &&
4997 !strstr(p
, "\nsquash "))
4998 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
4999 } else if (is_fixup(peek_command(todo_list
, 0))) {
5001 * We need to update the squash message to skip
5002 * the latest commit message.
5004 struct commit
*commit
;
5005 const char *path
= rebase_path_squash_msg();
5006 const char *encoding
= get_commit_output_encoding();
5008 if (parse_head(r
, &commit
) ||
5009 !(p
= logmsg_reencode(commit
, NULL
, encoding
)) ||
5010 write_message(p
, strlen(p
), path
, 0)) {
5011 unuse_commit_buffer(commit
, p
);
5012 return error(_("could not write file: "
5015 unuse_commit_buffer(commit
, p
);
5019 strbuf_release(&rev
);
5024 if (refs_ref_exists(get_main_ref_store(r
),
5025 "CHERRY_PICK_HEAD") &&
5026 refs_delete_ref(get_main_ref_store(r
), "",
5027 "CHERRY_PICK_HEAD", NULL
, 0))
5028 return error(_("could not remove CHERRY_PICK_HEAD"));
5029 if (unlink(git_path_merge_msg(r
)) && errno
!= ENOENT
)
5030 return error_errno(_("could not remove '%s'"),
5031 git_path_merge_msg(r
));
5036 if (run_git_commit(final_fixup
? NULL
: rebase_path_message(),
5038 return error(_("could not commit staged changes."));
5039 unlink(rebase_path_amend());
5040 unlink(git_path_merge_head(r
));
5041 unlink(git_path_auto_merge(r
));
5043 unlink(rebase_path_fixup_msg());
5044 unlink(rebase_path_squash_msg());
5046 if (opts
->current_fixup_count
> 0) {
5048 * Whether final fixup or not, we just cleaned up the commit
5051 unlink(rebase_path_current_fixups());
5052 strbuf_reset(&opts
->current_fixups
);
5053 opts
->current_fixup_count
= 0;
5058 int sequencer_continue(struct repository
*r
, struct replay_opts
*opts
)
5060 struct todo_list todo_list
= TODO_LIST_INIT
;
5063 if (read_and_refresh_cache(r
, opts
))
5066 if (read_populate_opts(opts
))
5068 if (is_rebase_i(opts
)) {
5069 if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
5070 goto release_todo_list
;
5072 if (file_exists(rebase_path_dropped())) {
5073 if ((res
= todo_list_check_against_backup(r
, &todo_list
)))
5074 goto release_todo_list
;
5076 unlink(rebase_path_dropped());
5079 opts
->reflog_message
= reflog_message(opts
, "continue", NULL
);
5080 if (commit_staged_changes(r
, opts
, &todo_list
)) {
5082 goto release_todo_list
;
5084 } else if (!file_exists(get_todo_path(opts
)))
5085 return continue_single_pick(r
, opts
);
5086 else if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
5087 goto release_todo_list
;
5089 if (!is_rebase_i(opts
)) {
5090 /* Verify that the conflict has been resolved */
5091 if (refs_ref_exists(get_main_ref_store(r
),
5092 "CHERRY_PICK_HEAD") ||
5093 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
5094 res
= continue_single_pick(r
, opts
);
5096 goto release_todo_list
;
5098 if (index_differs_from(r
, "HEAD", NULL
, 0)) {
5099 res
= error_dirty_index(r
, opts
);
5100 goto release_todo_list
;
5102 todo_list
.current
++;
5103 } else if (file_exists(rebase_path_stopped_sha())) {
5104 struct strbuf buf
= STRBUF_INIT
;
5105 struct object_id oid
;
5107 if (read_oneliner(&buf
, rebase_path_stopped_sha(),
5108 READ_ONELINER_SKIP_IF_EMPTY
) &&
5109 !get_oid_hex(buf
.buf
, &oid
))
5110 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
5111 strbuf_release(&buf
);
5114 res
= pick_commits(r
, &todo_list
, opts
);
5116 todo_list_release(&todo_list
);
5120 static int single_pick(struct repository
*r
,
5121 struct commit
*cmit
,
5122 struct replay_opts
*opts
)
5125 struct todo_item item
;
5127 item
.command
= opts
->action
== REPLAY_PICK
?
5128 TODO_PICK
: TODO_REVERT
;
5131 opts
->reflog_message
= sequencer_reflog_action(opts
);
5132 return do_pick_commit(r
, &item
, opts
, 0, &check_todo
);
5135 int sequencer_pick_revisions(struct repository
*r
,
5136 struct replay_opts
*opts
)
5138 struct todo_list todo_list
= TODO_LIST_INIT
;
5139 struct object_id oid
;
5143 if (read_and_refresh_cache(r
, opts
))
5146 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
5147 struct object_id oid
;
5148 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
5150 /* This happens when using --stdin. */
5154 if (!get_oid(name
, &oid
)) {
5155 if (!lookup_commit_reference_gently(r
, &oid
, 1)) {
5156 enum object_type type
= oid_object_info(r
,
5159 return error(_("%s: can't cherry-pick a %s"),
5160 name
, type_name(type
));
5163 return error(_("%s: bad revision"), name
);
5167 * If we were called as "git cherry-pick <commit>", just
5168 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
5169 * REVERT_HEAD, and don't touch the sequencer state.
5170 * This means it is possible to cherry-pick in the middle
5171 * of a cherry-pick sequence.
5173 if (opts
->revs
->cmdline
.nr
== 1 &&
5174 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
5175 opts
->revs
->no_walk
&&
5176 !opts
->revs
->cmdline
.rev
->flags
) {
5177 struct commit
*cmit
;
5178 if (prepare_revision_walk(opts
->revs
))
5179 return error(_("revision walk setup failed"));
5180 cmit
= get_revision(opts
->revs
);
5182 return error(_("empty commit set passed"));
5183 if (get_revision(opts
->revs
))
5184 BUG("unexpected extra commit from walk");
5185 return single_pick(r
, cmit
, opts
);
5189 * Start a new cherry-pick/ revert sequence; but
5190 * first, make sure that an existing one isn't in
5194 if (walk_revs_populate_todo(&todo_list
, opts
) ||
5195 create_seq_dir(r
) < 0)
5197 if (get_oid("HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
5198 return error(_("can't revert as initial commit"));
5199 if (save_head(oid_to_hex(&oid
)))
5201 if (save_opts(opts
))
5203 update_abort_safety_file();
5204 res
= pick_commits(r
, &todo_list
, opts
);
5205 todo_list_release(&todo_list
);
5209 void append_signoff(struct strbuf
*msgbuf
, size_t ignore_footer
, unsigned flag
)
5211 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
5212 struct strbuf sob
= STRBUF_INIT
;
5215 strbuf_addstr(&sob
, sign_off_header
);
5216 strbuf_addstr(&sob
, fmt_name(WANT_COMMITTER_IDENT
));
5217 strbuf_addch(&sob
, '\n');
5220 strbuf_complete_line(msgbuf
);
5223 * If the whole message buffer is equal to the sob, pretend that we
5224 * found a conforming footer with a matching sob
5226 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
5227 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
5230 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
5233 const char *append_newlines
= NULL
;
5234 size_t len
= msgbuf
->len
- ignore_footer
;
5238 * The buffer is completely empty. Leave foom for
5239 * the title and body to be filled in by the user.
5241 append_newlines
= "\n\n";
5242 } else if (len
== 1) {
5244 * Buffer contains a single newline. Add another
5245 * so that we leave room for the title and body.
5247 append_newlines
= "\n";
5248 } else if (msgbuf
->buf
[len
- 2] != '\n') {
5250 * Buffer ends with a single newline. Add another
5251 * so that there is an empty line between the message
5254 append_newlines
= "\n";
5255 } /* else, the buffer already ends with two newlines. */
5257 if (append_newlines
)
5258 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
5259 append_newlines
, strlen(append_newlines
));
5262 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
5263 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
5266 strbuf_release(&sob
);
5269 struct labels_entry
{
5270 struct hashmap_entry entry
;
5271 char label
[FLEX_ARRAY
];
5274 static int labels_cmp(const void *fndata UNUSED
,
5275 const struct hashmap_entry
*eptr
,
5276 const struct hashmap_entry
*entry_or_key
, const void *key
)
5278 const struct labels_entry
*a
, *b
;
5280 a
= container_of(eptr
, const struct labels_entry
, entry
);
5281 b
= container_of(entry_or_key
, const struct labels_entry
, entry
);
5283 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
5286 struct string_entry
{
5287 struct oidmap_entry entry
;
5288 char string
[FLEX_ARRAY
];
5291 struct label_state
{
5292 struct oidmap commit2label
;
5293 struct hashmap labels
;
5297 static const char *label_oid(struct object_id
*oid
, const char *label
,
5298 struct label_state
*state
)
5300 struct labels_entry
*labels_entry
;
5301 struct string_entry
*string_entry
;
5302 struct object_id dummy
;
5305 string_entry
= oidmap_get(&state
->commit2label
, oid
);
5307 return string_entry
->string
;
5310 * For "uninteresting" commits, i.e. commits that are not to be
5311 * rebased, and which can therefore not be labeled, we use a unique
5312 * abbreviation of the commit name. This is slightly more complicated
5313 * than calling find_unique_abbrev() because we also need to make
5314 * sure that the abbreviation does not conflict with any other
5317 * We disallow "interesting" commits to be labeled by a string that
5318 * is a valid full-length hash, to ensure that we always can find an
5319 * abbreviation for any uninteresting commit's names that does not
5320 * clash with any other label.
5322 strbuf_reset(&state
->buf
);
5326 strbuf_grow(&state
->buf
, GIT_MAX_HEXSZ
);
5327 label
= p
= state
->buf
.buf
;
5329 find_unique_abbrev_r(p
, oid
, default_abbrev
);
5332 * We may need to extend the abbreviated hash so that there is
5333 * no conflicting label.
5335 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
5336 size_t i
= strlen(p
) + 1;
5338 oid_to_hex_r(p
, oid
);
5339 for (; i
< the_hash_algo
->hexsz
; i
++) {
5342 if (!hashmap_get_from_hash(&state
->labels
,
5349 struct strbuf
*buf
= &state
->buf
;
5352 * Sanitize labels by replacing non-alpha-numeric characters
5353 * (including white-space ones) by dashes, as they might be
5354 * illegal in file names (and hence in ref names).
5356 * Note that we retain non-ASCII UTF-8 characters (identified
5357 * via the most significant bit). They should be all acceptable
5358 * in file names. We do not validate the UTF-8 here, that's not
5359 * the job of this function.
5361 for (; *label
; label
++)
5362 if ((*label
& 0x80) || isalnum(*label
))
5363 strbuf_addch(buf
, *label
);
5364 /* avoid leading dash and double-dashes */
5365 else if (buf
->len
&& buf
->buf
[buf
->len
- 1] != '-')
5366 strbuf_addch(buf
, '-');
5368 strbuf_addstr(buf
, "rev-");
5369 strbuf_add_unique_abbrev(buf
, oid
, default_abbrev
);
5373 if ((buf
->len
== the_hash_algo
->hexsz
&&
5374 !get_oid_hex(label
, &dummy
)) ||
5375 (buf
->len
== 1 && *label
== '#') ||
5376 hashmap_get_from_hash(&state
->labels
,
5377 strihash(label
), label
)) {
5379 * If the label already exists, or if the label is a
5380 * valid full OID, or the label is a '#' (which we use
5381 * as a separator between merge heads and oneline), we
5382 * append a dash and a number to make it unique.
5384 size_t len
= buf
->len
;
5386 for (i
= 2; ; i
++) {
5387 strbuf_setlen(buf
, len
);
5388 strbuf_addf(buf
, "-%d", i
);
5389 if (!hashmap_get_from_hash(&state
->labels
,
5399 FLEX_ALLOC_STR(labels_entry
, label
, label
);
5400 hashmap_entry_init(&labels_entry
->entry
, strihash(label
));
5401 hashmap_add(&state
->labels
, &labels_entry
->entry
);
5403 FLEX_ALLOC_STR(string_entry
, string
, label
);
5404 oidcpy(&string_entry
->entry
.oid
, oid
);
5405 oidmap_put(&state
->commit2label
, string_entry
);
5407 return string_entry
->string
;
5410 static int make_script_with_merges(struct pretty_print_context
*pp
,
5411 struct rev_info
*revs
, struct strbuf
*out
,
5414 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5415 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
5416 int root_with_onto
= flags
& TODO_LIST_ROOT_WITH_ONTO
;
5417 int skipped_commit
= 0;
5418 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
5419 struct strbuf label
= STRBUF_INIT
;
5420 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
5421 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
5422 struct commit
*commit
;
5423 struct oidmap commit2todo
= OIDMAP_INIT
;
5424 struct string_entry
*entry
;
5425 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
5426 shown
= OIDSET_INIT
;
5427 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
5429 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
5430 const char *cmd_pick
= abbr
? "p" : "pick",
5431 *cmd_label
= abbr
? "l" : "label",
5432 *cmd_reset
= abbr
? "t" : "reset",
5433 *cmd_merge
= abbr
? "m" : "merge";
5435 oidmap_init(&commit2todo
, 0);
5436 oidmap_init(&state
.commit2label
, 0);
5437 hashmap_init(&state
.labels
, labels_cmp
, NULL
, 0);
5438 strbuf_init(&state
.buf
, 32);
5440 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
5441 struct labels_entry
*onto_label_entry
;
5442 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
5443 FLEX_ALLOC_STR(entry
, string
, "onto");
5444 oidcpy(&entry
->entry
.oid
, oid
);
5445 oidmap_put(&state
.commit2label
, entry
);
5447 FLEX_ALLOC_STR(onto_label_entry
, label
, "onto");
5448 hashmap_entry_init(&onto_label_entry
->entry
, strihash("onto"));
5449 hashmap_add(&state
.labels
, &onto_label_entry
->entry
);
5454 * - get onelines for all commits
5455 * - gather all branch tips (i.e. 2nd or later parents of merges)
5456 * - label all branch tips
5458 while ((commit
= get_revision(revs
))) {
5459 struct commit_list
*to_merge
;
5460 const char *p1
, *p2
;
5461 struct object_id
*oid
;
5464 tail
= &commit_list_insert(commit
, tail
)->next
;
5465 oidset_insert(&interesting
, &commit
->object
.oid
);
5467 is_empty
= is_original_commit_empty(commit
);
5468 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5469 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5470 warning(_("skipped previously applied commit %s"),
5471 short_commit_name(commit
));
5475 if (is_empty
&& !keep_empty
)
5478 strbuf_reset(&oneline
);
5479 pretty_print_commit(pp
, commit
, &oneline
);
5481 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
5483 /* non-merge commit: easy case */
5485 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
5486 oid_to_hex(&commit
->object
.oid
),
5489 strbuf_addf(&buf
, " %c empty",
5492 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5493 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5494 oidmap_put(&commit2todo
, entry
);
5499 /* Create a label */
5500 strbuf_reset(&label
);
5501 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
5502 (p1
= strchr(p1
, '\'')) &&
5503 (p2
= strchr(++p1
, '\'')))
5504 strbuf_add(&label
, p1
, p2
- p1
);
5505 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
5507 (p1
= strstr(p1
, " from ")))
5508 strbuf_addstr(&label
, p1
+ strlen(" from "));
5510 strbuf_addbuf(&label
, &oneline
);
5513 strbuf_addf(&buf
, "%s -C %s",
5514 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
5516 /* label the tips of merged branches */
5517 for (; to_merge
; to_merge
= to_merge
->next
) {
5518 oid
= &to_merge
->item
->object
.oid
;
5519 strbuf_addch(&buf
, ' ');
5521 if (!oidset_contains(&interesting
, oid
)) {
5522 strbuf_addstr(&buf
, label_oid(oid
, NULL
,
5527 tips_tail
= &commit_list_insert(to_merge
->item
,
5530 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
5532 strbuf_addf(&buf
, " # %s", oneline
.buf
);
5534 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5535 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5536 oidmap_put(&commit2todo
, entry
);
5539 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5540 _("use --reapply-cherry-picks to include skipped commits"));
5544 * - label branch points
5545 * - add HEAD to the branch tips
5547 for (iter
= commits
; iter
; iter
= iter
->next
) {
5548 struct commit_list
*parent
= iter
->item
->parents
;
5549 for (; parent
; parent
= parent
->next
) {
5550 struct object_id
*oid
= &parent
->item
->object
.oid
;
5551 if (!oidset_contains(&interesting
, oid
))
5553 if (oidset_insert(&child_seen
, oid
))
5554 label_oid(oid
, "branch-point", &state
);
5557 /* Add HEAD as implicit "tip of branch" */
5559 tips_tail
= &commit_list_insert(iter
->item
,
5564 * Third phase: output the todo list. This is a bit tricky, as we
5565 * want to avoid jumping back and forth between revisions. To
5566 * accomplish that goal, we walk backwards from the branch tips,
5567 * gathering commits not yet shown, reversing the list on the fly,
5568 * then outputting that list (labeling revisions as needed).
5570 strbuf_addf(out
, "%s onto\n", cmd_label
);
5571 for (iter
= tips
; iter
; iter
= iter
->next
) {
5572 struct commit_list
*list
= NULL
, *iter2
;
5574 commit
= iter
->item
;
5575 if (oidset_contains(&shown
, &commit
->object
.oid
))
5577 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
5580 strbuf_addf(out
, "\n%c Branch %s\n", comment_line_char
, entry
->string
);
5582 strbuf_addch(out
, '\n');
5584 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
5585 !oidset_contains(&shown
, &commit
->object
.oid
)) {
5586 commit_list_insert(commit
, &list
);
5587 if (!commit
->parents
) {
5591 commit
= commit
->parents
->item
;
5595 strbuf_addf(out
, "%s %s\n", cmd_reset
,
5596 rebase_cousins
|| root_with_onto
?
5597 "onto" : "[new root]");
5599 const char *to
= NULL
;
5601 entry
= oidmap_get(&state
.commit2label
,
5602 &commit
->object
.oid
);
5605 else if (!rebase_cousins
)
5606 to
= label_oid(&commit
->object
.oid
, NULL
,
5609 if (!to
|| !strcmp(to
, "onto"))
5610 strbuf_addf(out
, "%s onto\n", cmd_reset
);
5612 strbuf_reset(&oneline
);
5613 pretty_print_commit(pp
, commit
, &oneline
);
5614 strbuf_addf(out
, "%s %s # %s\n",
5615 cmd_reset
, to
, oneline
.buf
);
5619 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
5620 struct object_id
*oid
= &iter2
->item
->object
.oid
;
5621 entry
= oidmap_get(&commit2todo
, oid
);
5622 /* only show if not already upstream */
5624 strbuf_addf(out
, "%s\n", entry
->string
);
5625 entry
= oidmap_get(&state
.commit2label
, oid
);
5627 strbuf_addf(out
, "%s %s\n",
5628 cmd_label
, entry
->string
);
5629 oidset_insert(&shown
, oid
);
5632 free_commit_list(list
);
5635 free_commit_list(commits
);
5636 free_commit_list(tips
);
5638 strbuf_release(&label
);
5639 strbuf_release(&oneline
);
5640 strbuf_release(&buf
);
5642 oidmap_free(&commit2todo
, 1);
5643 oidmap_free(&state
.commit2label
, 1);
5644 hashmap_clear_and_free(&state
.labels
, struct labels_entry
, entry
);
5645 strbuf_release(&state
.buf
);
5650 int sequencer_make_script(struct repository
*r
, struct strbuf
*out
, int argc
,
5651 const char **argv
, unsigned flags
)
5653 char *format
= NULL
;
5654 struct pretty_print_context pp
= {0};
5655 struct rev_info revs
;
5656 struct commit
*commit
;
5657 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5658 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
5659 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
5660 int reapply_cherry_picks
= flags
& TODO_LIST_REAPPLY_CHERRY_PICKS
;
5661 int skipped_commit
= 0;
5664 repo_init_revisions(r
, &revs
, NULL
);
5665 revs
.verbose_header
= 1;
5667 revs
.max_parents
= 1;
5668 revs
.cherry_mark
= !reapply_cherry_picks
;
5671 revs
.right_only
= 1;
5672 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
5673 revs
.topo_order
= 1;
5675 revs
.pretty_given
= 1;
5676 git_config_get_string("rebase.instructionFormat", &format
);
5677 if (!format
|| !*format
) {
5679 format
= xstrdup("%s");
5681 get_commit_format(format
, &revs
);
5683 pp
.fmt
= revs
.commit_format
;
5684 pp
.output_encoding
= get_log_output_encoding();
5686 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1) {
5687 ret
= error(_("make_script: unhandled options"));
5691 if (prepare_revision_walk(&revs
) < 0) {
5692 ret
= error(_("make_script: error preparing revisions"));
5696 if (rebase_merges
) {
5697 ret
= make_script_with_merges(&pp
, &revs
, out
, flags
);
5701 while ((commit
= get_revision(&revs
))) {
5702 int is_empty
= is_original_commit_empty(commit
);
5704 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5705 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5706 warning(_("skipped previously applied commit %s"),
5707 short_commit_name(commit
));
5711 if (is_empty
&& !keep_empty
)
5713 strbuf_addf(out
, "%s %s ", insn
,
5714 oid_to_hex(&commit
->object
.oid
));
5715 pretty_print_commit(&pp
, commit
, out
);
5717 strbuf_addf(out
, " %c empty", comment_line_char
);
5718 strbuf_addch(out
, '\n');
5721 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5722 _("use --reapply-cherry-picks to include skipped commits"));
5724 release_revisions(&revs
);
5729 * Add commands after pick and (series of) squash/fixup commands
5732 static void todo_list_add_exec_commands(struct todo_list
*todo_list
,
5733 struct string_list
*commands
)
5735 struct strbuf
*buf
= &todo_list
->buf
;
5736 size_t base_offset
= buf
->len
;
5737 int i
, insert
, nr
= 0, alloc
= 0;
5738 struct todo_item
*items
= NULL
, *base_items
= NULL
;
5740 CALLOC_ARRAY(base_items
, commands
->nr
);
5741 for (i
= 0; i
< commands
->nr
; i
++) {
5742 size_t command_len
= strlen(commands
->items
[i
].string
);
5744 strbuf_addstr(buf
, commands
->items
[i
].string
);
5745 strbuf_addch(buf
, '\n');
5747 base_items
[i
].command
= TODO_EXEC
;
5748 base_items
[i
].offset_in_buf
= base_offset
;
5749 base_items
[i
].arg_offset
= base_offset
;
5750 base_items
[i
].arg_len
= command_len
;
5752 base_offset
+= command_len
+ 1;
5756 * Insert <commands> after every pick. Here, fixup/squash chains
5757 * are considered part of the pick, so we insert the commands *after*
5758 * those chains if there are any.
5760 * As we insert the exec commands immediately after rearranging
5761 * any fixups and before the user edits the list, a fixup chain
5762 * can never contain comments (any comments are empty picks that
5763 * have been commented out because the user did not specify
5764 * --keep-empty). So, it is safe to insert an exec command
5765 * without looking at the command following a comment.
5768 for (i
= 0; i
< todo_list
->nr
; i
++) {
5769 enum todo_command command
= todo_list
->items
[i
].command
;
5770 if (insert
&& !is_fixup(command
)) {
5771 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5772 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5778 ALLOC_GROW(items
, nr
+ 1, alloc
);
5779 items
[nr
++] = todo_list
->items
[i
];
5781 if (command
== TODO_PICK
|| command
== TODO_MERGE
)
5785 /* insert or append final <commands> */
5787 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5788 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5793 FREE_AND_NULL(todo_list
->items
);
5794 todo_list
->items
= items
;
5796 todo_list
->alloc
= alloc
;
5799 static void todo_list_to_strbuf(struct repository
*r
, struct todo_list
*todo_list
,
5800 struct strbuf
*buf
, int num
, unsigned flags
)
5802 struct todo_item
*item
;
5803 int i
, max
= todo_list
->nr
;
5805 if (num
> 0 && num
< max
)
5808 for (item
= todo_list
->items
, i
= 0; i
< max
; i
++, item
++) {
5811 /* if the item is not a command write it and continue */
5812 if (item
->command
>= TODO_COMMENT
) {
5813 strbuf_addf(buf
, "%.*s\n", item
->arg_len
,
5814 todo_item_get_arg(todo_list
, item
));
5818 /* add command to the buffer */
5819 cmd
= command_to_char(item
->command
);
5820 if ((flags
& TODO_LIST_ABBREVIATE_CMDS
) && cmd
)
5821 strbuf_addch(buf
, cmd
);
5823 strbuf_addstr(buf
, command_to_string(item
->command
));
5827 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
5828 short_commit_name(item
->commit
) :
5829 oid_to_hex(&item
->commit
->object
.oid
);
5831 if (item
->command
== TODO_FIXUP
) {
5832 if (item
->flags
& TODO_EDIT_FIXUP_MSG
)
5833 strbuf_addstr(buf
, " -c");
5834 else if (item
->flags
& TODO_REPLACE_FIXUP_MSG
) {
5835 strbuf_addstr(buf
, " -C");
5839 if (item
->command
== TODO_MERGE
) {
5840 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
5841 strbuf_addstr(buf
, " -c");
5843 strbuf_addstr(buf
, " -C");
5846 strbuf_addf(buf
, " %s", oid
);
5849 /* add all the rest */
5851 strbuf_addch(buf
, '\n');
5853 strbuf_addf(buf
, " %.*s\n", item
->arg_len
,
5854 todo_item_get_arg(todo_list
, item
));
5858 int todo_list_write_to_file(struct repository
*r
, struct todo_list
*todo_list
,
5859 const char *file
, const char *shortrevisions
,
5860 const char *shortonto
, int num
, unsigned flags
)
5863 struct strbuf buf
= STRBUF_INIT
;
5865 todo_list_to_strbuf(r
, todo_list
, &buf
, num
, flags
);
5866 if (flags
& TODO_LIST_APPEND_TODO_HELP
)
5867 append_todo_help(count_commands(todo_list
),
5868 shortrevisions
, shortonto
, &buf
);
5870 res
= write_message(buf
.buf
, buf
.len
, file
, 0);
5871 strbuf_release(&buf
);
5876 /* skip picking commits whose parents are unchanged */
5877 static int skip_unnecessary_picks(struct repository
*r
,
5878 struct todo_list
*todo_list
,
5879 struct object_id
*base_oid
)
5881 struct object_id
*parent_oid
;
5884 for (i
= 0; i
< todo_list
->nr
; i
++) {
5885 struct todo_item
*item
= todo_list
->items
+ i
;
5887 if (item
->command
>= TODO_NOOP
)
5889 if (item
->command
!= TODO_PICK
)
5891 if (parse_commit(item
->commit
)) {
5892 return error(_("could not parse commit '%s'"),
5893 oid_to_hex(&item
->commit
->object
.oid
));
5895 if (!item
->commit
->parents
)
5896 break; /* root commit */
5897 if (item
->commit
->parents
->next
)
5898 break; /* merge commit */
5899 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
5900 if (!oideq(parent_oid
, base_oid
))
5902 oidcpy(base_oid
, &item
->commit
->object
.oid
);
5905 const char *done_path
= rebase_path_done();
5907 if (todo_list_write_to_file(r
, todo_list
, done_path
, NULL
, NULL
, i
, 0)) {
5908 error_errno(_("could not write to '%s'"), done_path
);
5912 MOVE_ARRAY(todo_list
->items
, todo_list
->items
+ i
, todo_list
->nr
- i
);
5914 todo_list
->current
= 0;
5915 todo_list
->done_nr
+= i
;
5917 if (is_fixup(peek_command(todo_list
, 0)))
5918 record_in_rewritten(base_oid
, peek_command(todo_list
, 0));
5924 struct todo_add_branch_context
{
5925 struct todo_item
*items
;
5929 struct commit
*commit
;
5930 struct string_list refs_to_oids
;
5933 static int add_decorations_to_list(const struct commit
*commit
,
5934 struct todo_add_branch_context
*ctx
)
5936 const struct name_decoration
*decoration
= get_name_decoration(&commit
->object
);
5937 const char *head_ref
= resolve_ref_unsafe("HEAD",
5938 RESOLVE_REF_READING
,
5942 while (decoration
) {
5943 struct todo_item
*item
;
5945 size_t base_offset
= ctx
->buf
->len
;
5948 * If the branch is the current HEAD, then it will be
5949 * updated by the default rebase behavior.
5951 if (head_ref
&& !strcmp(head_ref
, decoration
->name
)) {
5952 decoration
= decoration
->next
;
5956 ALLOC_GROW(ctx
->items
,
5959 item
= &ctx
->items
[ctx
->items_nr
];
5960 memset(item
, 0, sizeof(*item
));
5962 /* If the branch is checked out, then leave a comment instead. */
5963 if ((path
= branch_checked_out(decoration
->name
))) {
5964 item
->command
= TODO_COMMENT
;
5965 strbuf_addf(ctx
->buf
, "# Ref %s checked out at '%s'\n",
5966 decoration
->name
, path
);
5968 struct string_list_item
*sti
;
5969 item
->command
= TODO_UPDATE_REF
;
5970 strbuf_addf(ctx
->buf
, "%s\n", decoration
->name
);
5972 sti
= string_list_insert(&ctx
->refs_to_oids
,
5974 sti
->util
= init_update_ref_record(decoration
->name
);
5977 item
->offset_in_buf
= base_offset
;
5978 item
->arg_offset
= base_offset
;
5979 item
->arg_len
= ctx
->buf
->len
- base_offset
;
5982 decoration
= decoration
->next
;
5989 * For each 'pick' command, find out if the commit has a decoration in
5990 * refs/heads/. If so, then add a 'label for-update-refs/' command.
5992 static int todo_list_add_update_ref_commands(struct todo_list
*todo_list
)
5995 static struct string_list decorate_refs_exclude
= STRING_LIST_INIT_NODUP
;
5996 static struct string_list decorate_refs_exclude_config
= STRING_LIST_INIT_NODUP
;
5997 static struct string_list decorate_refs_include
= STRING_LIST_INIT_NODUP
;
5998 struct decoration_filter decoration_filter
= {
5999 .include_ref_pattern
= &decorate_refs_include
,
6000 .exclude_ref_pattern
= &decorate_refs_exclude
,
6001 .exclude_ref_config_pattern
= &decorate_refs_exclude_config
,
6003 struct todo_add_branch_context ctx
= {
6004 .buf
= &todo_list
->buf
,
6005 .refs_to_oids
= STRING_LIST_INIT_DUP
,
6008 ctx
.items_alloc
= 2 * todo_list
->nr
+ 1;
6009 ALLOC_ARRAY(ctx
.items
, ctx
.items_alloc
);
6011 string_list_append(&decorate_refs_include
, "refs/heads/");
6012 load_ref_decorations(&decoration_filter
, 0);
6014 for (i
= 0; i
< todo_list
->nr
; ) {
6015 struct todo_item
*item
= &todo_list
->items
[i
];
6017 /* insert ith item into new list */
6018 ALLOC_GROW(ctx
.items
,
6022 ctx
.items
[ctx
.items_nr
++] = todo_list
->items
[i
++];
6025 ctx
.commit
= item
->commit
;
6026 add_decorations_to_list(item
->commit
, &ctx
);
6030 res
= write_update_refs_state(&ctx
.refs_to_oids
);
6032 string_list_clear(&ctx
.refs_to_oids
, 1);
6035 /* we failed, so clean up the new list. */
6040 free(todo_list
->items
);
6041 todo_list
->items
= ctx
.items
;
6042 todo_list
->nr
= ctx
.items_nr
;
6043 todo_list
->alloc
= ctx
.items_alloc
;
6048 int complete_action(struct repository
*r
, struct replay_opts
*opts
, unsigned flags
,
6049 const char *shortrevisions
, const char *onto_name
,
6050 struct commit
*onto
, const struct object_id
*orig_head
,
6051 struct string_list
*commands
, unsigned autosquash
,
6052 unsigned update_refs
,
6053 struct todo_list
*todo_list
)
6055 char shortonto
[GIT_MAX_HEXSZ
+ 1];
6056 const char *todo_file
= rebase_path_todo();
6057 struct todo_list new_todo
= TODO_LIST_INIT
;
6058 struct strbuf
*buf
= &todo_list
->buf
, buf2
= STRBUF_INIT
;
6059 struct object_id oid
= onto
->object
.oid
;
6062 find_unique_abbrev_r(shortonto
, &oid
, DEFAULT_ABBREV
);
6064 if (buf
->len
== 0) {
6065 struct todo_item
*item
= append_new_todo(todo_list
);
6066 item
->command
= TODO_NOOP
;
6067 item
->commit
= NULL
;
6068 item
->arg_len
= item
->arg_offset
= item
->flags
= item
->offset_in_buf
= 0;
6071 if (update_refs
&& todo_list_add_update_ref_commands(todo_list
))
6074 if (autosquash
&& todo_list_rearrange_squash(todo_list
))
6078 todo_list_add_exec_commands(todo_list
, commands
);
6080 if (count_commands(todo_list
) == 0) {
6081 apply_autostash(rebase_path_autostash());
6082 sequencer_remove_state(opts
);
6084 return error(_("nothing to do"));
6087 res
= edit_todo_list(r
, todo_list
, &new_todo
, shortrevisions
,
6091 else if (res
== -2) {
6092 apply_autostash(rebase_path_autostash());
6093 sequencer_remove_state(opts
);
6096 } else if (res
== -3) {
6097 apply_autostash(rebase_path_autostash());
6098 sequencer_remove_state(opts
);
6099 todo_list_release(&new_todo
);
6101 return error(_("nothing to do"));
6102 } else if (res
== -4) {
6103 checkout_onto(r
, opts
, onto_name
, &onto
->object
.oid
, orig_head
);
6104 todo_list_release(&new_todo
);
6109 /* Expand the commit IDs */
6110 todo_list_to_strbuf(r
, &new_todo
, &buf2
, -1, 0);
6111 strbuf_swap(&new_todo
.buf
, &buf2
);
6112 strbuf_release(&buf2
);
6113 new_todo
.total_nr
-= new_todo
.nr
;
6114 if (todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
) < 0)
6115 BUG("invalid todo list after expanding IDs:\n%s",
6118 if (opts
->allow_ff
&& skip_unnecessary_picks(r
, &new_todo
, &oid
)) {
6119 todo_list_release(&new_todo
);
6120 return error(_("could not skip unnecessary pick commands"));
6123 if (todo_list_write_to_file(r
, &new_todo
, todo_file
, NULL
, NULL
, -1,
6124 flags
& ~(TODO_LIST_SHORTEN_IDS
))) {
6125 todo_list_release(&new_todo
);
6126 return error_errno(_("could not write '%s'"), todo_file
);
6131 if (checkout_onto(r
, opts
, onto_name
, &oid
, orig_head
))
6134 if (require_clean_work_tree(r
, "rebase", "", 1, 1))
6137 todo_list_write_total_nr(&new_todo
);
6138 res
= pick_commits(r
, &new_todo
, opts
);
6141 todo_list_release(&new_todo
);
6146 struct subject2item_entry
{
6147 struct hashmap_entry entry
;
6149 char subject
[FLEX_ARRAY
];
6152 static int subject2item_cmp(const void *fndata UNUSED
,
6153 const struct hashmap_entry
*eptr
,
6154 const struct hashmap_entry
*entry_or_key
,
6157 const struct subject2item_entry
*a
, *b
;
6159 a
= container_of(eptr
, const struct subject2item_entry
, entry
);
6160 b
= container_of(entry_or_key
, const struct subject2item_entry
, entry
);
6162 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
6165 define_commit_slab(commit_todo_item
, struct todo_item
*);
6167 static int skip_fixupish(const char *subject
, const char **p
) {
6168 return skip_prefix(subject
, "fixup! ", p
) ||
6169 skip_prefix(subject
, "amend! ", p
) ||
6170 skip_prefix(subject
, "squash! ", p
);
6174 * Rearrange the todo list that has both "pick commit-id msg" and "pick
6175 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
6176 * after the former, and change "pick" to "fixup"/"squash".
6178 * Note that if the config has specified a custom instruction format, each log
6179 * message will have to be retrieved from the commit (as the oneline in the
6180 * script cannot be trusted) in order to normalize the autosquash arrangement.
6182 int todo_list_rearrange_squash(struct todo_list
*todo_list
)
6184 struct hashmap subject2item
;
6185 int rearranged
= 0, *next
, *tail
, i
, nr
= 0, alloc
= 0;
6187 struct commit_todo_item commit_todo
;
6188 struct todo_item
*items
= NULL
;
6190 init_commit_todo_item(&commit_todo
);
6192 * The hashmap maps onelines to the respective todo list index.
6194 * If any items need to be rearranged, the next[i] value will indicate
6195 * which item was moved directly after the i'th.
6197 * In that case, last[i] will indicate the index of the latest item to
6198 * be moved to appear after the i'th.
6200 hashmap_init(&subject2item
, subject2item_cmp
, NULL
, todo_list
->nr
);
6201 ALLOC_ARRAY(next
, todo_list
->nr
);
6202 ALLOC_ARRAY(tail
, todo_list
->nr
);
6203 ALLOC_ARRAY(subjects
, todo_list
->nr
);
6204 for (i
= 0; i
< todo_list
->nr
; i
++) {
6205 struct strbuf buf
= STRBUF_INIT
;
6206 struct todo_item
*item
= todo_list
->items
+ i
;
6207 const char *commit_buffer
, *subject
, *p
;
6210 struct subject2item_entry
*entry
;
6212 next
[i
] = tail
[i
] = -1;
6213 if (!item
->commit
|| item
->command
== TODO_DROP
) {
6218 if (is_fixup(item
->command
)) {
6219 clear_commit_todo_item(&commit_todo
);
6220 return error(_("the script was already rearranged."));
6223 parse_commit(item
->commit
);
6224 commit_buffer
= logmsg_reencode(item
->commit
, NULL
, "UTF-8");
6225 find_commit_subject(commit_buffer
, &subject
);
6226 format_subject(&buf
, subject
, " ");
6227 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
6228 unuse_commit_buffer(item
->commit
, commit_buffer
);
6229 if (skip_fixupish(subject
, &p
)) {
6230 struct commit
*commit2
;
6235 if (!skip_fixupish(p
, &p
))
6239 entry
= hashmap_get_entry_from_hash(&subject2item
,
6241 struct subject2item_entry
,
6244 /* found by title */
6246 else if (!strchr(p
, ' ') &&
6248 lookup_commit_reference_by_name(p
)) &&
6249 *commit_todo_item_at(&commit_todo
, commit2
))
6250 /* found by commit name */
6251 i2
= *commit_todo_item_at(&commit_todo
, commit2
)
6254 /* copy can be a prefix of the commit subject */
6255 for (i2
= 0; i2
< i
; i2
++)
6257 starts_with(subjects
[i2
], p
))
6265 if (starts_with(subject
, "fixup!")) {
6266 todo_list
->items
[i
].command
= TODO_FIXUP
;
6267 } else if (starts_with(subject
, "amend!")) {
6268 todo_list
->items
[i
].command
= TODO_FIXUP
;
6269 todo_list
->items
[i
].flags
= TODO_REPLACE_FIXUP_MSG
;
6271 todo_list
->items
[i
].command
= TODO_SQUASH
;
6277 next
[i
] = next
[tail
[i2
]];
6281 } else if (!hashmap_get_from_hash(&subject2item
,
6282 strhash(subject
), subject
)) {
6283 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
6285 hashmap_entry_init(&entry
->entry
,
6286 strhash(entry
->subject
));
6287 hashmap_put(&subject2item
, &entry
->entry
);
6290 *commit_todo_item_at(&commit_todo
, item
->commit
) = item
;
6294 for (i
= 0; i
< todo_list
->nr
; i
++) {
6295 enum todo_command command
= todo_list
->items
[i
].command
;
6299 * Initially, all commands are 'pick's. If it is a
6300 * fixup or a squash now, we have rearranged it.
6302 if (is_fixup(command
))
6306 ALLOC_GROW(items
, nr
+ 1, alloc
);
6307 items
[nr
++] = todo_list
->items
[cur
];
6312 FREE_AND_NULL(todo_list
->items
);
6313 todo_list
->items
= items
;
6315 todo_list
->alloc
= alloc
;
6320 for (i
= 0; i
< todo_list
->nr
; i
++)
6323 hashmap_clear_and_free(&subject2item
, struct subject2item_entry
, entry
);
6325 clear_commit_todo_item(&commit_todo
);
6330 int sequencer_determine_whence(struct repository
*r
, enum commit_whence
*whence
)
6332 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
6333 struct object_id cherry_pick_head
, rebase_head
;
6335 if (file_exists(git_path_seq_dir()))
6336 *whence
= FROM_CHERRY_PICK_MULTI
;
6337 if (file_exists(rebase_path()) &&
6338 !get_oid("REBASE_HEAD", &rebase_head
) &&
6339 !get_oid("CHERRY_PICK_HEAD", &cherry_pick_head
) &&
6340 oideq(&rebase_head
, &cherry_pick_head
))
6341 *whence
= FROM_REBASE_PICK
;
6343 *whence
= FROM_CHERRY_PICK_SINGLE
;
6351 int sequencer_get_update_refs_state(const char *wt_dir
,
6352 struct string_list
*refs
)
6356 struct strbuf ref
= STRBUF_INIT
;
6357 struct strbuf hash
= STRBUF_INIT
;
6358 struct update_ref_record
*rec
= NULL
;
6360 char *path
= rebase_path_update_refs(wt_dir
);
6362 fp
= fopen(path
, "r");
6366 while (strbuf_getline(&ref
, fp
) != EOF
) {
6367 struct string_list_item
*item
;
6369 CALLOC_ARRAY(rec
, 1);
6371 if (strbuf_getline(&hash
, fp
) == EOF
||
6372 get_oid_hex(hash
.buf
, &rec
->before
)) {
6373 warning(_("update-refs file at '%s' is invalid"),
6379 if (strbuf_getline(&hash
, fp
) == EOF
||
6380 get_oid_hex(hash
.buf
, &rec
->after
)) {
6381 warning(_("update-refs file at '%s' is invalid"),
6387 item
= string_list_insert(refs
, ref
.buf
);
6397 strbuf_release(&ref
);
6398 strbuf_release(&hash
);