5 #include "object-store.h"
10 #include "run-command.h"
13 #include "cache-tree.h"
17 #include "merge-ort.h"
18 #include "merge-ort-wrappers.h"
24 #include "wt-status.h"
26 #include "notes-utils.h"
28 #include "unpack-trees.h"
32 #include "commit-slab.h"
34 #include "commit-reach.h"
35 #include "rebase-interactive.h"
38 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
40 static const char sign_off_header
[] = "Signed-off-by: ";
41 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
43 GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
45 static GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
47 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
48 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
49 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
50 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
52 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
54 * The file containing rebase commands, comments, and empty lines.
55 * This file is created by "git rebase -i" then edited by the user. As
56 * the lines are processed, they are removed from the front of this
57 * file and written to the tail of 'done'.
59 GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
60 GIT_PATH_FUNC(rebase_path_todo_backup
, "rebase-merge/git-rebase-todo.backup")
62 GIT_PATH_FUNC(rebase_path_dropped
, "rebase-merge/dropped")
65 * The rebase command lines that have already been processed. A line
66 * is moved here when it is first handled, before any associated user
69 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
71 * The file to keep track of how many commands were already processed (e.g.
74 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum")
76 * The file to keep track of how many commands are to be processed in total
77 * (e.g. for the prompt).
79 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end")
81 * The commit message that is planned to be used for any changes that
82 * need to be committed following a user interaction.
84 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
86 * The file into which is accumulated the suggested commit message for
87 * squash/fixup commands. When the first of a series of squash/fixups
88 * is seen, the file is created and the commit message from the
89 * previous commit and from the first squash/fixup commit are written
90 * to it. The commit message for each subsequent squash/fixup commit
91 * is appended to the file as it is processed.
93 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
95 * If the current series of squash/fixups has not yet included a squash
96 * command, then this file exists and holds the commit message of the
97 * original "pick" commit. (If the series ends without a "squash"
98 * command, then this can be used as the commit message of the combined
99 * commit without opening the editor.)
101 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
103 * This file contains the list fixup/squash commands that have been
104 * accumulated into message-fixup or message-squash so far.
106 static GIT_PATH_FUNC(rebase_path_current_fixups
, "rebase-merge/current-fixups")
108 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
109 * GIT_AUTHOR_DATE that will be used for the commit that is currently
112 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
114 * When an "edit" rebase command is being processed, the SHA1 of the
115 * commit to be edited is recorded in this file. When "git rebase
116 * --continue" is executed, if there are any staged changes then they
117 * will be amended to the HEAD commit, but only provided the HEAD
118 * commit is still the commit to be edited. When any other rebase
119 * command is processed, this file is deleted.
121 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
123 * When we stop at a given patch via the "edit" command, this file contains
124 * the commit object name of the corresponding patch.
126 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
128 * For the post-rewrite hook, we make a list of rewritten commits and
129 * their new sha1s. The rewritten-pending list keeps the sha1s of
130 * commits that have been processed, but not committed yet,
131 * e.g. because they are waiting for a 'squash' command.
133 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
134 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
135 "rebase-merge/rewritten-pending")
138 * The path of the file containing the OID of the "squash onto" commit, i.e.
139 * the dummy commit used for `reset [new root]`.
141 static GIT_PATH_FUNC(rebase_path_squash_onto
, "rebase-merge/squash-onto")
144 * The path of the file listing refs that need to be deleted after the rebase
145 * finishes. This is used by the `label` command to record the need for cleanup.
147 static GIT_PATH_FUNC(rebase_path_refs_to_delete
, "rebase-merge/refs-to-delete")
150 * The following files are written by git-rebase just after parsing the
153 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
154 static GIT_PATH_FUNC(rebase_path_cdate_is_adate
, "rebase-merge/cdate_is_adate")
155 static GIT_PATH_FUNC(rebase_path_ignore_date
, "rebase-merge/ignore_date")
156 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
157 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
158 static GIT_PATH_FUNC(rebase_path_quiet
, "rebase-merge/quiet")
159 static GIT_PATH_FUNC(rebase_path_signoff
, "rebase-merge/signoff")
160 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
161 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
162 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
163 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
164 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
165 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
166 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec
, "rebase-merge/reschedule-failed-exec")
167 static GIT_PATH_FUNC(rebase_path_drop_redundant_commits
, "rebase-merge/drop_redundant_commits")
168 static GIT_PATH_FUNC(rebase_path_keep_redundant_commits
, "rebase-merge/keep_redundant_commits")
170 static int git_sequencer_config(const char *k
, const char *v
, void *cb
)
172 struct replay_opts
*opts
= cb
;
175 if (!strcmp(k
, "commit.cleanup")) {
178 status
= git_config_string(&s
, k
, v
);
182 if (!strcmp(s
, "verbatim")) {
183 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
184 opts
->explicit_cleanup
= 1;
185 } else if (!strcmp(s
, "whitespace")) {
186 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
187 opts
->explicit_cleanup
= 1;
188 } else if (!strcmp(s
, "strip")) {
189 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_ALL
;
190 opts
->explicit_cleanup
= 1;
191 } else if (!strcmp(s
, "scissors")) {
192 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SCISSORS
;
193 opts
->explicit_cleanup
= 1;
195 warning(_("invalid commit message cleanup mode '%s'"),
203 if (!strcmp(k
, "commit.gpgsign")) {
204 opts
->gpg_sign
= git_config_bool(k
, v
) ? xstrdup("") : NULL
;
208 if (!opts
->default_strategy
&& !strcmp(k
, "pull.twohead")) {
209 int ret
= git_config_string((const char**)&opts
->default_strategy
, k
, v
);
212 * pull.twohead is allowed to be multi-valued; we only
213 * care about the first value.
215 char *tmp
= strchr(opts
->default_strategy
, ' ');
222 status
= git_gpg_config(k
, v
, NULL
);
226 return git_diff_basic_config(k
, v
, NULL
);
229 void sequencer_init_config(struct replay_opts
*opts
)
231 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
232 git_config(git_sequencer_config
, opts
);
235 static inline int is_rebase_i(const struct replay_opts
*opts
)
237 return opts
->action
== REPLAY_INTERACTIVE_REBASE
;
240 static const char *get_dir(const struct replay_opts
*opts
)
242 if (is_rebase_i(opts
))
243 return rebase_path();
244 return git_path_seq_dir();
247 static const char *get_todo_path(const struct replay_opts
*opts
)
249 if (is_rebase_i(opts
))
250 return rebase_path_todo();
251 return git_path_todo_file();
255 * Returns 0 for non-conforming footer
256 * Returns 1 for conforming footer
257 * Returns 2 when sob exists within conforming footer
258 * Returns 3 when sob exists within conforming footer as last entry
260 static int has_conforming_footer(struct strbuf
*sb
, struct strbuf
*sob
,
261 size_t ignore_footer
)
263 struct process_trailer_options opts
= PROCESS_TRAILER_OPTIONS_INIT
;
264 struct trailer_info info
;
266 int found_sob
= 0, found_sob_last
= 0;
272 saved_char
= sb
->buf
[sb
->len
- ignore_footer
];
273 sb
->buf
[sb
->len
- ignore_footer
] = '\0';
276 trailer_info_get(&info
, sb
->buf
, &opts
);
279 sb
->buf
[sb
->len
- ignore_footer
] = saved_char
;
281 if (info
.trailer_start
== info
.trailer_end
)
284 for (i
= 0; i
< info
.trailer_nr
; i
++)
285 if (sob
&& !strncmp(info
.trailers
[i
], sob
->buf
, sob
->len
)) {
287 if (i
== info
.trailer_nr
- 1)
291 trailer_info_release(&info
);
300 static const char *gpg_sign_opt_quoted(struct replay_opts
*opts
)
302 static struct strbuf buf
= STRBUF_INIT
;
306 sq_quotef(&buf
, "-S%s", opts
->gpg_sign
);
310 int sequencer_remove_state(struct replay_opts
*opts
)
312 struct strbuf buf
= STRBUF_INIT
;
315 if (is_rebase_i(opts
) &&
316 strbuf_read_file(&buf
, rebase_path_refs_to_delete(), 0) > 0) {
319 char *eol
= strchr(p
, '\n');
322 if (delete_ref("(rebase) cleanup", p
, NULL
, 0) < 0) {
323 warning(_("could not delete '%s'"), p
);
332 free(opts
->gpg_sign
);
333 free(opts
->default_strategy
);
334 free(opts
->strategy
);
335 for (i
= 0; i
< opts
->xopts_nr
; i
++)
336 free(opts
->xopts
[i
]);
338 strbuf_release(&opts
->current_fixups
);
341 strbuf_addstr(&buf
, get_dir(opts
));
342 if (remove_dir_recursively(&buf
, 0))
343 ret
= error(_("could not remove '%s'"), buf
.buf
);
344 strbuf_release(&buf
);
349 static const char *action_name(const struct replay_opts
*opts
)
351 switch (opts
->action
) {
355 return N_("cherry-pick");
356 case REPLAY_INTERACTIVE_REBASE
:
359 die(_("unknown action: %d"), opts
->action
);
362 struct commit_message
{
369 static const char *short_commit_name(struct commit
*commit
)
371 return find_unique_abbrev(&commit
->object
.oid
, DEFAULT_ABBREV
);
374 static int get_message(struct commit
*commit
, struct commit_message
*out
)
376 const char *abbrev
, *subject
;
379 out
->message
= logmsg_reencode(commit
, NULL
, get_commit_output_encoding());
380 abbrev
= short_commit_name(commit
);
382 subject_len
= find_commit_subject(out
->message
, &subject
);
384 out
->subject
= xmemdupz(subject
, subject_len
);
385 out
->label
= xstrfmt("%s (%s)", abbrev
, out
->subject
);
386 out
->parent_label
= xstrfmt("parent of %s", out
->label
);
391 static void free_message(struct commit
*commit
, struct commit_message
*msg
)
393 free(msg
->parent_label
);
396 unuse_commit_buffer(commit
, msg
->message
);
399 static void print_advice(struct repository
*r
, int show_hint
,
400 struct replay_opts
*opts
)
402 char *msg
= getenv("GIT_CHERRY_PICK_HELP");
405 fprintf(stderr
, "%s\n", msg
);
407 * A conflict has occurred but the porcelain
408 * (typically rebase --interactive) wants to take care
409 * of the commit itself so remove CHERRY_PICK_HEAD
411 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
418 advise(_("after resolving the conflicts, mark the corrected paths\n"
419 "with 'git add <paths>' or 'git rm <paths>'"));
421 advise(_("after resolving the conflicts, mark the corrected paths\n"
422 "with 'git add <paths>' or 'git rm <paths>'\n"
423 "and commit the result with 'git commit'"));
427 static int write_message(const void *buf
, size_t len
, const char *filename
,
430 struct lock_file msg_file
= LOCK_INIT
;
432 int msg_fd
= hold_lock_file_for_update(&msg_file
, filename
, 0);
434 return error_errno(_("could not lock '%s'"), filename
);
435 if (write_in_full(msg_fd
, buf
, len
) < 0) {
436 error_errno(_("could not write to '%s'"), filename
);
437 rollback_lock_file(&msg_file
);
440 if (append_eol
&& write(msg_fd
, "\n", 1) < 0) {
441 error_errno(_("could not write eol to '%s'"), filename
);
442 rollback_lock_file(&msg_file
);
445 if (commit_lock_file(&msg_file
) < 0)
446 return error(_("failed to finalize '%s'"), filename
);
451 int read_oneliner(struct strbuf
*buf
,
452 const char *path
, unsigned flags
)
454 int orig_len
= buf
->len
;
456 if (strbuf_read_file(buf
, path
, 0) < 0) {
457 if ((flags
& READ_ONELINER_WARN_MISSING
) ||
458 (errno
!= ENOENT
&& errno
!= ENOTDIR
))
459 warning_errno(_("could not read '%s'"), path
);
463 if (buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\n') {
464 if (--buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\r')
466 buf
->buf
[buf
->len
] = '\0';
469 if ((flags
& READ_ONELINER_SKIP_IF_EMPTY
) && buf
->len
== orig_len
)
475 static struct tree
*empty_tree(struct repository
*r
)
477 return lookup_tree(r
, the_hash_algo
->empty_tree
);
480 static int error_dirty_index(struct repository
*repo
, struct replay_opts
*opts
)
482 if (repo_read_index_unmerged(repo
))
483 return error_resolve_conflict(_(action_name(opts
)));
485 error(_("your local changes would be overwritten by %s."),
486 _(action_name(opts
)));
488 if (advice_commit_before_merge
)
489 advise(_("commit your changes or stash them to proceed."));
493 static void update_abort_safety_file(void)
495 struct object_id head
;
497 /* Do nothing on a single-pick */
498 if (!file_exists(git_path_seq_dir()))
501 if (!get_oid("HEAD", &head
))
502 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head
));
504 write_file(git_path_abort_safety_file(), "%s", "");
507 static int fast_forward_to(struct repository
*r
,
508 const struct object_id
*to
,
509 const struct object_id
*from
,
511 struct replay_opts
*opts
)
513 struct ref_transaction
*transaction
;
514 struct strbuf sb
= STRBUF_INIT
;
515 struct strbuf err
= STRBUF_INIT
;
518 if (checkout_fast_forward(r
, from
, to
, 1))
519 return -1; /* the callee should have complained already */
521 strbuf_addf(&sb
, _("%s: fast-forward"), _(action_name(opts
)));
523 transaction
= ref_transaction_begin(&err
);
525 ref_transaction_update(transaction
, "HEAD",
526 to
, unborn
&& !is_rebase_i(opts
) ?
529 ref_transaction_commit(transaction
, &err
)) {
530 ref_transaction_free(transaction
);
531 error("%s", err
.buf
);
533 strbuf_release(&err
);
538 strbuf_release(&err
);
539 ref_transaction_free(transaction
);
540 update_abort_safety_file();
544 enum commit_msg_cleanup_mode
get_cleanup_mode(const char *cleanup_arg
,
547 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
548 return use_editor
? COMMIT_MSG_CLEANUP_ALL
:
549 COMMIT_MSG_CLEANUP_SPACE
;
550 else if (!strcmp(cleanup_arg
, "verbatim"))
551 return COMMIT_MSG_CLEANUP_NONE
;
552 else if (!strcmp(cleanup_arg
, "whitespace"))
553 return COMMIT_MSG_CLEANUP_SPACE
;
554 else if (!strcmp(cleanup_arg
, "strip"))
555 return COMMIT_MSG_CLEANUP_ALL
;
556 else if (!strcmp(cleanup_arg
, "scissors"))
557 return use_editor
? COMMIT_MSG_CLEANUP_SCISSORS
:
558 COMMIT_MSG_CLEANUP_SPACE
;
560 die(_("Invalid cleanup mode %s"), cleanup_arg
);
564 * NB using int rather than enum cleanup_mode to stop clang's
565 * -Wtautological-constant-out-of-range-compare complaining that the comparison
568 static const char *describe_cleanup_mode(int cleanup_mode
)
570 static const char *modes
[] = { "whitespace",
575 if (cleanup_mode
< ARRAY_SIZE(modes
))
576 return modes
[cleanup_mode
];
578 BUG("invalid cleanup_mode provided (%d)", cleanup_mode
);
581 void append_conflicts_hint(struct index_state
*istate
,
582 struct strbuf
*msgbuf
, enum commit_msg_cleanup_mode cleanup_mode
)
586 if (cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
) {
587 strbuf_addch(msgbuf
, '\n');
588 wt_status_append_cut_line(msgbuf
);
589 strbuf_addch(msgbuf
, comment_line_char
);
592 strbuf_addch(msgbuf
, '\n');
593 strbuf_commented_addf(msgbuf
, "Conflicts:\n");
594 for (i
= 0; i
< istate
->cache_nr
;) {
595 const struct cache_entry
*ce
= istate
->cache
[i
++];
597 strbuf_commented_addf(msgbuf
, "\t%s\n", ce
->name
);
598 while (i
< istate
->cache_nr
&&
599 !strcmp(ce
->name
, istate
->cache
[i
]->name
))
605 static int do_recursive_merge(struct repository
*r
,
606 struct commit
*base
, struct commit
*next
,
607 const char *base_label
, const char *next_label
,
608 struct object_id
*head
, struct strbuf
*msgbuf
,
609 struct replay_opts
*opts
)
611 struct merge_options o
;
612 struct merge_result result
;
613 struct tree
*next_tree
, *base_tree
, *head_tree
;
614 int clean
, show_output
;
616 struct lock_file index_lock
= LOCK_INIT
;
618 if (repo_hold_locked_index(r
, &index_lock
, LOCK_REPORT_ON_ERROR
) < 0)
623 init_merge_options(&o
, r
);
624 o
.ancestor
= base
? base_label
: "(empty tree)";
626 o
.branch2
= next
? next_label
: "(empty tree)";
627 if (is_rebase_i(opts
))
629 o
.show_rename_progress
= 1;
631 head_tree
= parse_tree_indirect(head
);
632 next_tree
= next
? get_commit_tree(next
) : empty_tree(r
);
633 base_tree
= base
? get_commit_tree(base
) : empty_tree(r
);
635 for (i
= 0; i
< opts
->xopts_nr
; i
++)
636 parse_merge_opt(&o
, opts
->xopts
[i
]);
638 if (opts
->strategy
&& !strcmp(opts
->strategy
, "ort")) {
639 memset(&result
, 0, sizeof(result
));
640 merge_incore_nonrecursive(&o
, base_tree
, head_tree
, next_tree
,
642 show_output
= !is_rebase_i(opts
) || !result
.clean
;
644 * TODO: merge_switch_to_result will update index/working tree;
645 * we only really want to do that if !result.clean || this is
646 * the final patch to be picked. But determining this is the
647 * final patch would take some work, and "head_tree" would need
648 * to be replace with the tree the index matched before we
649 * started doing any picks.
651 merge_switch_to_result(&o
, head_tree
, &result
, 1, show_output
);
652 clean
= result
.clean
;
654 clean
= merge_trees(&o
, head_tree
, next_tree
, base_tree
);
655 if (is_rebase_i(opts
) && clean
<= 0)
656 fputs(o
.obuf
.buf
, stdout
);
657 strbuf_release(&o
.obuf
);
660 rollback_lock_file(&index_lock
);
664 if (write_locked_index(r
->index
, &index_lock
,
665 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
667 * TRANSLATORS: %s will be "revert", "cherry-pick" or
670 return error(_("%s: Unable to write new index file"),
671 _(action_name(opts
)));
674 append_conflicts_hint(r
->index
, msgbuf
,
675 opts
->default_msg_cleanup
);
680 static struct object_id
*get_cache_tree_oid(struct index_state
*istate
)
682 if (!cache_tree_fully_valid(istate
->cache_tree
))
683 if (cache_tree_update(istate
, 0)) {
684 error(_("unable to update cache tree"));
688 return &istate
->cache_tree
->oid
;
691 static int is_index_unchanged(struct repository
*r
)
693 struct object_id head_oid
, *cache_tree_oid
;
694 struct commit
*head_commit
;
695 struct index_state
*istate
= r
->index
;
697 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
698 return error(_("could not resolve HEAD commit"));
700 head_commit
= lookup_commit(r
, &head_oid
);
703 * If head_commit is NULL, check_commit, called from
704 * lookup_commit, would have indicated that head_commit is not
705 * a commit object already. parse_commit() will return failure
706 * without further complaints in such a case. Otherwise, if
707 * the commit is invalid, parse_commit() will complain. So
708 * there is nothing for us to say here. Just return failure.
710 if (parse_commit(head_commit
))
713 if (!(cache_tree_oid
= get_cache_tree_oid(istate
)))
716 return oideq(cache_tree_oid
, get_commit_tree_oid(head_commit
));
719 static int write_author_script(const char *message
)
721 struct strbuf buf
= STRBUF_INIT
;
726 if (!*message
|| starts_with(message
, "\n")) {
728 /* Missing 'author' line? */
729 unlink(rebase_path_author_script());
731 } else if (skip_prefix(message
, "author ", &message
))
733 else if ((eol
= strchr(message
, '\n')))
738 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
739 while (*message
&& *message
!= '\n' && *message
!= '\r')
740 if (skip_prefix(message
, " <", &message
))
742 else if (*message
!= '\'')
743 strbuf_addch(&buf
, *(message
++));
745 strbuf_addf(&buf
, "'\\%c'", *(message
++));
746 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
747 while (*message
&& *message
!= '\n' && *message
!= '\r')
748 if (skip_prefix(message
, "> ", &message
))
750 else if (*message
!= '\'')
751 strbuf_addch(&buf
, *(message
++));
753 strbuf_addf(&buf
, "'\\%c'", *(message
++));
754 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
755 while (*message
&& *message
!= '\n' && *message
!= '\r')
756 if (*message
!= '\'')
757 strbuf_addch(&buf
, *(message
++));
759 strbuf_addf(&buf
, "'\\%c'", *(message
++));
760 strbuf_addch(&buf
, '\'');
761 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
762 strbuf_release(&buf
);
767 * Take a series of KEY='VALUE' lines where VALUE part is
768 * sq-quoted, and append <KEY, VALUE> at the end of the string list
770 static int parse_key_value_squoted(char *buf
, struct string_list
*list
)
773 struct string_list_item
*item
;
775 char *cp
= strchr(buf
, '=');
777 np
= strchrnul(buf
, '\n');
778 return error(_("no key present in '%.*s'"),
779 (int) (np
- buf
), buf
);
781 np
= strchrnul(cp
, '\n');
783 item
= string_list_append(list
, buf
);
785 buf
= np
+ (*np
== '\n');
789 return error(_("unable to dequote value of '%s'"),
791 item
->util
= xstrdup(cp
);
797 * Reads and parses the state directory's "author-script" file, and sets name,
798 * email and date accordingly.
799 * Returns 0 on success, -1 if the file could not be parsed.
801 * The author script is of the format:
803 * GIT_AUTHOR_NAME='$author_name'
804 * GIT_AUTHOR_EMAIL='$author_email'
805 * GIT_AUTHOR_DATE='$author_date'
807 * where $author_name, $author_email and $author_date are quoted. We are strict
808 * with our parsing, as the file was meant to be eval'd in the now-removed
809 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
810 * from what this function expects, it is better to bail out than to do
811 * something that the user does not expect.
813 int read_author_script(const char *path
, char **name
, char **email
, char **date
,
816 struct strbuf buf
= STRBUF_INIT
;
817 struct string_list kv
= STRING_LIST_INIT_DUP
;
818 int retval
= -1; /* assume failure */
819 int i
, name_i
= -2, email_i
= -2, date_i
= -2, err
= 0;
821 if (strbuf_read_file(&buf
, path
, 256) <= 0) {
822 strbuf_release(&buf
);
823 if (errno
== ENOENT
&& allow_missing
)
826 return error_errno(_("could not open '%s' for reading"),
830 if (parse_key_value_squoted(buf
.buf
, &kv
))
833 for (i
= 0; i
< kv
.nr
; i
++) {
834 if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_NAME")) {
836 name_i
= error(_("'GIT_AUTHOR_NAME' already given"));
839 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_EMAIL")) {
841 email_i
= error(_("'GIT_AUTHOR_EMAIL' already given"));
844 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_DATE")) {
846 date_i
= error(_("'GIT_AUTHOR_DATE' already given"));
850 err
= error(_("unknown variable '%s'"),
855 error(_("missing 'GIT_AUTHOR_NAME'"));
857 error(_("missing 'GIT_AUTHOR_EMAIL'"));
859 error(_("missing 'GIT_AUTHOR_DATE'"));
860 if (date_i
< 0 || email_i
< 0 || date_i
< 0 || err
)
862 *name
= kv
.items
[name_i
].util
;
863 *email
= kv
.items
[email_i
].util
;
864 *date
= kv
.items
[date_i
].util
;
867 string_list_clear(&kv
, !!retval
);
868 strbuf_release(&buf
);
873 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
874 * file with shell quoting into struct strvec. Returns -1 on
875 * error, 0 otherwise.
877 static int read_env_script(struct strvec
*env
)
879 char *name
, *email
, *date
;
881 if (read_author_script(rebase_path_author_script(),
882 &name
, &email
, &date
, 0))
885 strvec_pushf(env
, "GIT_AUTHOR_NAME=%s", name
);
886 strvec_pushf(env
, "GIT_AUTHOR_EMAIL=%s", email
);
887 strvec_pushf(env
, "GIT_AUTHOR_DATE=%s", date
);
895 static char *get_author(const char *message
)
900 a
= find_commit_header(message
, "author", &len
);
902 return xmemdupz(a
, len
);
907 static const char *author_date_from_env_array(const struct strvec
*env
)
912 for (i
= 0; i
< env
->nr
; i
++)
913 if (skip_prefix(env
->v
[i
],
914 "GIT_AUTHOR_DATE=", &date
))
917 * If GIT_AUTHOR_DATE is missing we should have already errored out when
920 BUG("GIT_AUTHOR_DATE missing from author script");
923 static const char staged_changes_advice
[] =
924 N_("you have staged changes in your working tree\n"
925 "If these changes are meant to be squashed into the previous commit, run:\n"
927 " git commit --amend %s\n"
929 "If they are meant to go into a new commit, run:\n"
933 "In both cases, once you're done, continue with:\n"
935 " git rebase --continue\n");
937 #define ALLOW_EMPTY (1<<0)
938 #define EDIT_MSG (1<<1)
939 #define AMEND_MSG (1<<2)
940 #define CLEANUP_MSG (1<<3)
941 #define VERIFY_MSG (1<<4)
942 #define CREATE_ROOT_COMMIT (1<<5)
943 #define VERBATIM_MSG (1<<6)
945 static int run_command_silent_on_success(struct child_process
*cmd
)
947 struct strbuf buf
= STRBUF_INIT
;
950 cmd
->stdout_to_stderr
= 1;
951 rc
= pipe_command(cmd
,
957 fputs(buf
.buf
, stderr
);
958 strbuf_release(&buf
);
963 * If we are cherry-pick, and if the merge did not result in
964 * hand-editing, we will hit this commit and inherit the original
965 * author date and name.
967 * If we are revert, or if our cherry-pick results in a hand merge,
968 * we had better say that the current user is responsible for that.
970 * An exception is when run_git_commit() is called during an
971 * interactive rebase: in that case, we will want to retain the
974 static int run_git_commit(const char *defmsg
,
975 struct replay_opts
*opts
,
978 struct child_process cmd
= CHILD_PROCESS_INIT
;
980 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
981 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
985 if (is_rebase_i(opts
) && read_env_script(&cmd
.env_array
)) {
986 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
988 return error(_(staged_changes_advice
),
992 if (opts
->committer_date_is_author_date
)
993 strvec_pushf(&cmd
.env_array
, "GIT_COMMITTER_DATE=%s",
996 author_date_from_env_array(&cmd
.env_array
));
997 if (opts
->ignore_date
)
998 strvec_push(&cmd
.env_array
, "GIT_AUTHOR_DATE=");
1000 strvec_push(&cmd
.args
, "commit");
1002 if (!(flags
& VERIFY_MSG
))
1003 strvec_push(&cmd
.args
, "-n");
1004 if ((flags
& AMEND_MSG
))
1005 strvec_push(&cmd
.args
, "--amend");
1007 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
1009 strvec_push(&cmd
.args
, "--no-gpg-sign");
1011 strvec_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
1012 else if (!(flags
& EDIT_MSG
))
1013 strvec_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
1014 if ((flags
& CLEANUP_MSG
))
1015 strvec_push(&cmd
.args
, "--cleanup=strip");
1016 if ((flags
& VERBATIM_MSG
))
1017 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1018 if ((flags
& EDIT_MSG
))
1019 strvec_push(&cmd
.args
, "-e");
1020 else if (!(flags
& CLEANUP_MSG
) &&
1021 !opts
->signoff
&& !opts
->record_origin
&&
1022 !opts
->explicit_cleanup
)
1023 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1025 if ((flags
& ALLOW_EMPTY
))
1026 strvec_push(&cmd
.args
, "--allow-empty");
1028 if (!(flags
& EDIT_MSG
))
1029 strvec_push(&cmd
.args
, "--allow-empty-message");
1031 if (is_rebase_i(opts
) && !(flags
& EDIT_MSG
))
1032 return run_command_silent_on_success(&cmd
);
1034 return run_command(&cmd
);
1037 static int rest_is_empty(const struct strbuf
*sb
, int start
)
1042 /* Check if the rest is just whitespace and Signed-off-by's. */
1043 for (i
= start
; i
< sb
->len
; i
++) {
1044 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1050 if (strlen(sign_off_header
) <= eol
- i
&&
1051 starts_with(sb
->buf
+ i
, sign_off_header
)) {
1056 if (!isspace(sb
->buf
[i
++]))
1063 void cleanup_message(struct strbuf
*msgbuf
,
1064 enum commit_msg_cleanup_mode cleanup_mode
, int verbose
)
1066 if (verbose
|| /* Truncate the message just before the diff, if any. */
1067 cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
1068 strbuf_setlen(msgbuf
, wt_status_locate_end(msgbuf
->buf
, msgbuf
->len
));
1069 if (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
)
1070 strbuf_stripspace(msgbuf
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1074 * Find out if the message in the strbuf contains only whitespace and
1075 * Signed-off-by lines.
1077 int message_is_empty(const struct strbuf
*sb
,
1078 enum commit_msg_cleanup_mode cleanup_mode
)
1080 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1082 return rest_is_empty(sb
, 0);
1086 * See if the user edited the message in the editor or left what
1087 * was in the template intact
1089 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
1090 enum commit_msg_cleanup_mode cleanup_mode
)
1092 struct strbuf tmpl
= STRBUF_INIT
;
1095 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1098 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
1101 strbuf_stripspace(&tmpl
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1102 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
1104 strbuf_release(&tmpl
);
1105 return rest_is_empty(sb
, start
- sb
->buf
);
1108 int update_head_with_reflog(const struct commit
*old_head
,
1109 const struct object_id
*new_head
,
1110 const char *action
, const struct strbuf
*msg
,
1113 struct ref_transaction
*transaction
;
1114 struct strbuf sb
= STRBUF_INIT
;
1119 strbuf_addstr(&sb
, action
);
1120 strbuf_addstr(&sb
, ": ");
1123 nl
= strchr(msg
->buf
, '\n');
1125 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
1127 strbuf_addbuf(&sb
, msg
);
1128 strbuf_addch(&sb
, '\n');
1131 transaction
= ref_transaction_begin(err
);
1133 ref_transaction_update(transaction
, "HEAD", new_head
,
1134 old_head
? &old_head
->object
.oid
: &null_oid
,
1136 ref_transaction_commit(transaction
, err
)) {
1139 ref_transaction_free(transaction
);
1140 strbuf_release(&sb
);
1145 static int run_rewrite_hook(const struct object_id
*oldoid
,
1146 const struct object_id
*newoid
)
1148 struct child_process proc
= CHILD_PROCESS_INIT
;
1149 const char *argv
[3];
1151 struct strbuf sb
= STRBUF_INIT
;
1153 argv
[0] = find_hook("post-rewrite");
1162 proc
.stdout_to_stderr
= 1;
1163 proc
.trace2_hook_name
= "post-rewrite";
1165 code
= start_command(&proc
);
1168 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
1169 sigchain_push(SIGPIPE
, SIG_IGN
);
1170 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
1172 strbuf_release(&sb
);
1173 sigchain_pop(SIGPIPE
);
1174 return finish_command(&proc
);
1177 void commit_post_rewrite(struct repository
*r
,
1178 const struct commit
*old_head
,
1179 const struct object_id
*new_head
)
1181 struct notes_rewrite_cfg
*cfg
;
1183 cfg
= init_copy_notes_for_rewrite("amend");
1185 /* we are amending, so old_head is not NULL */
1186 copy_note_for_rewrite(cfg
, &old_head
->object
.oid
, new_head
);
1187 finish_copy_notes_for_rewrite(r
, cfg
, "Notes added by 'git commit --amend'");
1189 run_rewrite_hook(&old_head
->object
.oid
, new_head
);
1192 static int run_prepare_commit_msg_hook(struct repository
*r
,
1197 const char *name
, *arg1
= NULL
, *arg2
= NULL
;
1199 name
= git_path_commit_editmsg();
1200 if (write_message(msg
->buf
, msg
->len
, name
, 0))
1209 if (run_commit_hook(0, r
->index_file
, "prepare-commit-msg", name
,
1211 ret
= error(_("'prepare-commit-msg' hook failed"));
1216 static const char implicit_ident_advice_noconfig
[] =
1217 N_("Your name and email address were configured automatically based\n"
1218 "on your username and hostname. Please check that they are accurate.\n"
1219 "You can suppress this message by setting them explicitly. Run the\n"
1220 "following command and follow the instructions in your editor to edit\n"
1221 "your configuration file:\n"
1223 " git config --global --edit\n"
1225 "After doing this, you may fix the identity used for this commit with:\n"
1227 " git commit --amend --reset-author\n");
1229 static const char implicit_ident_advice_config
[] =
1230 N_("Your name and email address were configured automatically based\n"
1231 "on your username and hostname. Please check that they are accurate.\n"
1232 "You can suppress this message by setting them explicitly:\n"
1234 " git config --global user.name \"Your Name\"\n"
1235 " git config --global user.email you@example.com\n"
1237 "After doing this, you may fix the identity used for this commit with:\n"
1239 " git commit --amend --reset-author\n");
1241 static const char *implicit_ident_advice(void)
1243 char *user_config
= expand_user_path("~/.gitconfig", 0);
1244 char *xdg_config
= xdg_config_home("config");
1245 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1251 return _(implicit_ident_advice_config
);
1253 return _(implicit_ident_advice_noconfig
);
1257 void print_commit_summary(struct repository
*r
,
1259 const struct object_id
*oid
,
1262 struct rev_info rev
;
1263 struct commit
*commit
;
1264 struct strbuf format
= STRBUF_INIT
;
1266 struct pretty_print_context pctx
= {0};
1267 struct strbuf author_ident
= STRBUF_INIT
;
1268 struct strbuf committer_ident
= STRBUF_INIT
;
1270 commit
= lookup_commit(r
, oid
);
1272 die(_("couldn't look up newly created commit"));
1273 if (parse_commit(commit
))
1274 die(_("could not parse newly created commit"));
1276 strbuf_addstr(&format
, "format:%h] %s");
1278 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1279 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1280 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1281 strbuf_addstr(&format
, "\n Author: ");
1282 strbuf_addbuf_percentquote(&format
, &author_ident
);
1284 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
1285 struct strbuf date
= STRBUF_INIT
;
1287 format_commit_message(commit
, "%ad", &date
, &pctx
);
1288 strbuf_addstr(&format
, "\n Date: ");
1289 strbuf_addbuf_percentquote(&format
, &date
);
1290 strbuf_release(&date
);
1292 if (!committer_ident_sufficiently_given()) {
1293 strbuf_addstr(&format
, "\n Committer: ");
1294 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1295 if (advice_implicit_identity
) {
1296 strbuf_addch(&format
, '\n');
1297 strbuf_addstr(&format
, implicit_ident_advice());
1300 strbuf_release(&author_ident
);
1301 strbuf_release(&committer_ident
);
1303 repo_init_revisions(r
, &rev
, prefix
);
1304 setup_revisions(0, NULL
, &rev
, NULL
);
1307 rev
.diffopt
.output_format
=
1308 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1310 rev
.verbose_header
= 1;
1311 rev
.show_root_diff
= 1;
1312 get_commit_format(format
.buf
, &rev
);
1313 rev
.always_show_header
= 0;
1314 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1315 rev
.diffopt
.break_opt
= 0;
1316 diff_setup_done(&rev
.diffopt
);
1318 head
= resolve_ref_unsafe("HEAD", 0, NULL
, NULL
);
1320 die_errno(_("unable to resolve HEAD after creating commit"));
1321 if (!strcmp(head
, "HEAD"))
1322 head
= _("detached HEAD");
1324 skip_prefix(head
, "refs/heads/", &head
);
1325 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1326 _(" (root-commit)") : "");
1328 if (!log_tree_commit(&rev
, commit
)) {
1329 rev
.always_show_header
= 1;
1330 rev
.use_terminator
= 1;
1331 log_tree_commit(&rev
, commit
);
1334 strbuf_release(&format
);
1337 static int parse_head(struct repository
*r
, struct commit
**head
)
1339 struct commit
*current_head
;
1340 struct object_id oid
;
1342 if (get_oid("HEAD", &oid
)) {
1343 current_head
= NULL
;
1345 current_head
= lookup_commit_reference(r
, &oid
);
1347 return error(_("could not parse HEAD"));
1348 if (!oideq(&oid
, ¤t_head
->object
.oid
)) {
1349 warning(_("HEAD %s is not a commit!"),
1352 if (parse_commit(current_head
))
1353 return error(_("could not parse HEAD commit"));
1355 *head
= current_head
;
1361 * Try to commit without forking 'git commit'. In some cases we need
1362 * to run 'git commit' to display an error message
1365 * -1 - error unable to commit
1367 * 1 - run 'git commit'
1369 static int try_to_commit(struct repository
*r
,
1370 struct strbuf
*msg
, const char *author
,
1371 struct replay_opts
*opts
, unsigned int flags
,
1372 struct object_id
*oid
)
1374 struct object_id tree
;
1375 struct commit
*current_head
= NULL
;
1376 struct commit_list
*parents
= NULL
;
1377 struct commit_extra_header
*extra
= NULL
;
1378 struct strbuf err
= STRBUF_INIT
;
1379 struct strbuf commit_msg
= STRBUF_INIT
;
1380 char *amend_author
= NULL
;
1381 const char *committer
= NULL
;
1382 const char *hook_commit
= NULL
;
1383 enum commit_msg_cleanup_mode cleanup
;
1386 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1387 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1389 if (parse_head(r
, ¤t_head
))
1392 if (flags
& AMEND_MSG
) {
1393 const char *exclude_gpgsig
[] = { "gpgsig", "gpgsig-sha256", NULL
};
1394 const char *out_enc
= get_commit_output_encoding();
1395 const char *message
= logmsg_reencode(current_head
, NULL
,
1399 const char *orig_message
= NULL
;
1401 find_commit_subject(message
, &orig_message
);
1403 strbuf_addstr(msg
, orig_message
);
1404 hook_commit
= "HEAD";
1406 author
= amend_author
= get_author(message
);
1407 unuse_commit_buffer(current_head
, message
);
1409 res
= error(_("unable to parse commit author"));
1412 parents
= copy_commit_list(current_head
->parents
);
1413 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1414 } else if (current_head
&&
1415 (!(flags
& CREATE_ROOT_COMMIT
) || (flags
& AMEND_MSG
))) {
1416 commit_list_insert(current_head
, &parents
);
1419 if (write_index_as_tree(&tree
, r
->index
, r
->index_file
, 0, NULL
)) {
1420 res
= error(_("git write-tree failed to write a tree"));
1424 if (!(flags
& ALLOW_EMPTY
)) {
1425 struct commit
*first_parent
= current_head
;
1427 if (flags
& AMEND_MSG
) {
1428 if (current_head
->parents
) {
1429 first_parent
= current_head
->parents
->item
;
1430 if (repo_parse_commit(r
, first_parent
)) {
1431 res
= error(_("could not parse HEAD commit"));
1435 first_parent
= NULL
;
1438 if (oideq(first_parent
1439 ? get_commit_tree_oid(first_parent
)
1440 : the_hash_algo
->empty_tree
,
1442 res
= 1; /* run 'git commit' to display error message */
1447 if (find_hook("prepare-commit-msg")) {
1448 res
= run_prepare_commit_msg_hook(r
, msg
, hook_commit
);
1451 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1453 res
= error_errno(_("unable to read commit message "
1455 git_path_commit_editmsg());
1461 if (flags
& CLEANUP_MSG
)
1462 cleanup
= COMMIT_MSG_CLEANUP_ALL
;
1463 else if (flags
& VERBATIM_MSG
)
1464 cleanup
= COMMIT_MSG_CLEANUP_NONE
;
1465 else if ((opts
->signoff
|| opts
->record_origin
) &&
1466 !opts
->explicit_cleanup
)
1467 cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
1469 cleanup
= opts
->default_msg_cleanup
;
1471 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1472 strbuf_stripspace(msg
, cleanup
== COMMIT_MSG_CLEANUP_ALL
);
1473 if ((flags
& EDIT_MSG
) && message_is_empty(msg
, cleanup
)) {
1474 res
= 1; /* run 'git commit' to display error message */
1478 if (opts
->committer_date_is_author_date
) {
1479 struct ident_split id
;
1480 struct strbuf date
= STRBUF_INIT
;
1482 if (!opts
->ignore_date
) {
1483 if (split_ident_line(&id
, author
, (int)strlen(author
)) < 0) {
1484 res
= error(_("invalid author identity '%s'"),
1488 if (!id
.date_begin
) {
1490 "corrupt author: missing date information"));
1493 strbuf_addf(&date
, "@%.*s %.*s",
1494 (int)(id
.date_end
- id
.date_begin
),
1496 (int)(id
.tz_end
- id
.tz_begin
),
1501 committer
= fmt_ident(getenv("GIT_COMMITTER_NAME"),
1502 getenv("GIT_COMMITTER_EMAIL"),
1503 WANT_COMMITTER_IDENT
,
1504 opts
->ignore_date
? NULL
: date
.buf
,
1506 strbuf_release(&date
);
1511 if (opts
->ignore_date
) {
1512 struct ident_split id
;
1515 if (split_ident_line(&id
, author
, strlen(author
)) < 0) {
1516 error(_("invalid author identity '%s'"), author
);
1519 name
= xmemdupz(id
.name_begin
, id
.name_end
- id
.name_begin
);
1520 email
= xmemdupz(id
.mail_begin
, id
.mail_end
- id
.mail_begin
);
1521 author
= fmt_ident(name
, email
, WANT_AUTHOR_IDENT
, NULL
,
1527 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
, oid
,
1528 author
, committer
, opts
->gpg_sign
, extra
)) {
1529 res
= error(_("failed to write commit object"));
1533 if (update_head_with_reflog(current_head
, oid
,
1534 getenv("GIT_REFLOG_ACTION"), msg
, &err
)) {
1535 res
= error("%s", err
.buf
);
1539 run_commit_hook(0, r
->index_file
, "post-commit", NULL
);
1540 if (flags
& AMEND_MSG
)
1541 commit_post_rewrite(r
, current_head
, oid
);
1544 free_commit_extra_headers(extra
);
1545 strbuf_release(&err
);
1546 strbuf_release(&commit_msg
);
1552 static int write_rebase_head(struct object_id
*oid
)
1554 if (update_ref("rebase", "REBASE_HEAD", oid
,
1555 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1556 return error(_("could not update %s"), "REBASE_HEAD");
1561 static int do_commit(struct repository
*r
,
1562 const char *msg_file
, const char *author
,
1563 struct replay_opts
*opts
, unsigned int flags
,
1564 struct object_id
*oid
)
1568 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
)) {
1569 struct object_id oid
;
1570 struct strbuf sb
= STRBUF_INIT
;
1572 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1573 return error_errno(_("unable to read commit message "
1577 res
= try_to_commit(r
, msg_file
? &sb
: NULL
,
1578 author
, opts
, flags
, &oid
);
1579 strbuf_release(&sb
);
1581 refs_delete_ref(get_main_ref_store(r
), "",
1582 "CHERRY_PICK_HEAD", NULL
, 0);
1583 unlink(git_path_merge_msg(r
));
1584 if (!is_rebase_i(opts
))
1585 print_commit_summary(r
, NULL
, &oid
,
1586 SUMMARY_SHOW_AUTHOR_DATE
);
1591 if (is_rebase_i(opts
) && oid
)
1592 if (write_rebase_head(oid
))
1594 return run_git_commit(msg_file
, opts
, flags
);
1600 static int is_original_commit_empty(struct commit
*commit
)
1602 const struct object_id
*ptree_oid
;
1604 if (parse_commit(commit
))
1605 return error(_("could not parse commit %s"),
1606 oid_to_hex(&commit
->object
.oid
));
1607 if (commit
->parents
) {
1608 struct commit
*parent
= commit
->parents
->item
;
1609 if (parse_commit(parent
))
1610 return error(_("could not parse parent commit %s"),
1611 oid_to_hex(&parent
->object
.oid
));
1612 ptree_oid
= get_commit_tree_oid(parent
);
1614 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1617 return oideq(ptree_oid
, get_commit_tree_oid(commit
));
1621 * Should empty commits be allowed? Return status:
1622 * <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1623 * 0: Halt on empty commit
1624 * 1: Allow empty commit
1625 * 2: Drop empty commit
1627 static int allow_empty(struct repository
*r
,
1628 struct replay_opts
*opts
,
1629 struct commit
*commit
)
1631 int index_unchanged
, originally_empty
;
1636 * (1) we do not allow empty at all and error out.
1638 * (2) we allow ones that were initially empty, and
1639 * just drop the ones that become empty
1641 * (3) we allow ones that were initially empty, but
1642 * halt for the ones that become empty;
1644 * (4) we allow both.
1646 if (!opts
->allow_empty
)
1647 return 0; /* let "git commit" barf as necessary */
1649 index_unchanged
= is_index_unchanged(r
);
1650 if (index_unchanged
< 0)
1651 return index_unchanged
;
1652 if (!index_unchanged
)
1653 return 0; /* we do not have to say --allow-empty */
1655 if (opts
->keep_redundant_commits
)
1658 originally_empty
= is_original_commit_empty(commit
);
1659 if (originally_empty
< 0)
1660 return originally_empty
;
1661 if (originally_empty
)
1663 else if (opts
->drop_redundant_commits
)
1672 } todo_command_info
[] = {
1689 static const char *command_to_string(const enum todo_command command
)
1691 if (command
< TODO_COMMENT
)
1692 return todo_command_info
[command
].str
;
1693 die(_("unknown command: %d"), command
);
1696 static char command_to_char(const enum todo_command command
)
1698 if (command
< TODO_COMMENT
)
1699 return todo_command_info
[command
].c
;
1700 return comment_line_char
;
1703 static int is_noop(const enum todo_command command
)
1705 return TODO_NOOP
<= command
;
1708 static int is_fixup(enum todo_command command
)
1710 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1713 /* Does this command create a (non-merge) commit? */
1714 static int is_pick_or_similar(enum todo_command command
)
1729 static int update_squash_messages(struct repository
*r
,
1730 enum todo_command command
,
1731 struct commit
*commit
,
1732 struct replay_opts
*opts
)
1734 struct strbuf buf
= STRBUF_INIT
;
1736 const char *message
, *body
;
1737 const char *encoding
= get_commit_output_encoding();
1739 if (opts
->current_fixup_count
> 0) {
1740 struct strbuf header
= STRBUF_INIT
;
1743 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
1744 return error(_("could not read '%s'"),
1745 rebase_path_squash_msg());
1747 eol
= buf
.buf
[0] != comment_line_char
?
1748 buf
.buf
: strchrnul(buf
.buf
, '\n');
1750 strbuf_addf(&header
, "%c ", comment_line_char
);
1751 strbuf_addf(&header
, _("This is a combination of %d commits."),
1752 opts
->current_fixup_count
+ 2);
1753 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
1754 strbuf_release(&header
);
1756 struct object_id head
;
1757 struct commit
*head_commit
;
1758 const char *head_message
, *body
;
1760 if (get_oid("HEAD", &head
))
1761 return error(_("need a HEAD to fixup"));
1762 if (!(head_commit
= lookup_commit_reference(r
, &head
)))
1763 return error(_("could not read HEAD"));
1764 if (!(head_message
= logmsg_reencode(head_commit
, NULL
, encoding
)))
1765 return error(_("could not read HEAD's commit message"));
1767 find_commit_subject(head_message
, &body
);
1768 if (write_message(body
, strlen(body
),
1769 rebase_path_fixup_msg(), 0)) {
1770 unuse_commit_buffer(head_commit
, head_message
);
1771 return error(_("cannot write '%s'"),
1772 rebase_path_fixup_msg());
1775 strbuf_addf(&buf
, "%c ", comment_line_char
);
1776 strbuf_addf(&buf
, _("This is a combination of %d commits."), 2);
1777 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1778 strbuf_addstr(&buf
, _("This is the 1st commit message:"));
1779 strbuf_addstr(&buf
, "\n\n");
1780 strbuf_addstr(&buf
, body
);
1782 unuse_commit_buffer(head_commit
, head_message
);
1785 if (!(message
= logmsg_reencode(commit
, NULL
, encoding
)))
1786 return error(_("could not read commit message of %s"),
1787 oid_to_hex(&commit
->object
.oid
));
1788 find_commit_subject(message
, &body
);
1790 if (command
== TODO_SQUASH
) {
1791 unlink(rebase_path_fixup_msg());
1792 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1793 strbuf_addf(&buf
, _("This is the commit message #%d:"),
1794 ++opts
->current_fixup_count
+ 1);
1795 strbuf_addstr(&buf
, "\n\n");
1796 strbuf_addstr(&buf
, body
);
1797 } else if (command
== TODO_FIXUP
) {
1798 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1799 strbuf_addf(&buf
, _("The commit message #%d will be skipped:"),
1800 ++opts
->current_fixup_count
+ 1);
1801 strbuf_addstr(&buf
, "\n\n");
1802 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
1804 return error(_("unknown command: %d"), command
);
1805 unuse_commit_buffer(commit
, message
);
1807 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(), 0);
1808 strbuf_release(&buf
);
1811 strbuf_addf(&opts
->current_fixups
, "%s%s %s",
1812 opts
->current_fixups
.len
? "\n" : "",
1813 command_to_string(command
),
1814 oid_to_hex(&commit
->object
.oid
));
1815 res
= write_message(opts
->current_fixups
.buf
,
1816 opts
->current_fixups
.len
,
1817 rebase_path_current_fixups(), 0);
1823 static void flush_rewritten_pending(void)
1825 struct strbuf buf
= STRBUF_INIT
;
1826 struct object_id newoid
;
1829 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
1830 !get_oid("HEAD", &newoid
) &&
1831 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1832 char *bol
= buf
.buf
, *eol
;
1835 eol
= strchrnul(bol
, '\n');
1836 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
1837 bol
, oid_to_hex(&newoid
));
1843 unlink(rebase_path_rewritten_pending());
1845 strbuf_release(&buf
);
1848 static void record_in_rewritten(struct object_id
*oid
,
1849 enum todo_command next_command
)
1851 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
1856 fprintf(out
, "%s\n", oid_to_hex(oid
));
1859 if (!is_fixup(next_command
))
1860 flush_rewritten_pending();
1863 static int do_pick_commit(struct repository
*r
,
1864 enum todo_command command
,
1865 struct commit
*commit
,
1866 struct replay_opts
*opts
,
1867 int final_fixup
, int *check_todo
)
1869 unsigned int flags
= opts
->edit
? EDIT_MSG
: 0;
1870 const char *msg_file
= opts
->edit
? NULL
: git_path_merge_msg(r
);
1871 struct object_id head
;
1872 struct commit
*base
, *next
, *parent
;
1873 const char *base_label
, *next_label
;
1874 char *author
= NULL
;
1875 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
1876 struct strbuf msgbuf
= STRBUF_INIT
;
1877 int res
, unborn
= 0, reword
= 0, allow
, drop_commit
;
1879 if (opts
->no_commit
) {
1881 * We do not intend to commit immediately. We just want to
1882 * merge the differences in, so let's compute the tree
1883 * that represents the "current" state for merge-recursive
1886 if (write_index_as_tree(&head
, r
->index
, r
->index_file
, 0, NULL
))
1887 return error(_("your index file is unmerged."));
1889 unborn
= get_oid("HEAD", &head
);
1890 /* Do we want to generate a root commit? */
1891 if (is_pick_or_similar(command
) && opts
->have_squash_onto
&&
1892 oideq(&head
, &opts
->squash_onto
)) {
1893 if (is_fixup(command
))
1894 return error(_("cannot fixup root commit"));
1895 flags
|= CREATE_ROOT_COMMIT
;
1898 oidcpy(&head
, the_hash_algo
->empty_tree
);
1899 if (index_differs_from(r
, unborn
? empty_tree_oid_hex() : "HEAD",
1901 return error_dirty_index(r
, opts
);
1903 discard_index(r
->index
);
1905 if (!commit
->parents
)
1907 else if (commit
->parents
->next
) {
1908 /* Reverting or cherry-picking a merge commit */
1910 struct commit_list
*p
;
1912 if (!opts
->mainline
)
1913 return error(_("commit %s is a merge but no -m option was given."),
1914 oid_to_hex(&commit
->object
.oid
));
1916 for (cnt
= 1, p
= commit
->parents
;
1917 cnt
!= opts
->mainline
&& p
;
1920 if (cnt
!= opts
->mainline
|| !p
)
1921 return error(_("commit %s does not have parent %d"),
1922 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
1924 } else if (1 < opts
->mainline
)
1926 * Non-first parent explicitly specified as mainline for
1929 return error(_("commit %s does not have parent %d"),
1930 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
1932 parent
= commit
->parents
->item
;
1934 if (get_message(commit
, &msg
) != 0)
1935 return error(_("cannot get commit message for %s"),
1936 oid_to_hex(&commit
->object
.oid
));
1938 if (opts
->allow_ff
&& !is_fixup(command
) &&
1939 ((parent
&& oideq(&parent
->object
.oid
, &head
)) ||
1940 (!parent
&& unborn
))) {
1941 if (is_rebase_i(opts
))
1942 write_author_script(msg
.message
);
1943 res
= fast_forward_to(r
, &commit
->object
.oid
, &head
, unborn
,
1945 if (res
|| command
!= TODO_REWORD
)
1949 goto fast_forward_edit
;
1951 if (parent
&& parse_commit(parent
) < 0)
1952 /* TRANSLATORS: The first %s will be a "todo" command like
1953 "revert" or "pick", the second %s a SHA1. */
1954 return error(_("%s: cannot parse parent commit %s"),
1955 command_to_string(command
),
1956 oid_to_hex(&parent
->object
.oid
));
1959 * "commit" is an existing commit. We would want to apply
1960 * the difference it introduces since its first parent "prev"
1961 * on top of the current HEAD if we are cherry-pick. Or the
1962 * reverse of it if we are revert.
1965 if (command
== TODO_REVERT
) {
1967 base_label
= msg
.label
;
1969 next_label
= msg
.parent_label
;
1970 strbuf_addstr(&msgbuf
, "Revert \"");
1971 strbuf_addstr(&msgbuf
, msg
.subject
);
1972 strbuf_addstr(&msgbuf
, "\"\n\nThis reverts commit ");
1973 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
1975 if (commit
->parents
&& commit
->parents
->next
) {
1976 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
1977 strbuf_addstr(&msgbuf
, oid_to_hex(&parent
->object
.oid
));
1979 strbuf_addstr(&msgbuf
, ".\n");
1984 base_label
= msg
.parent_label
;
1986 next_label
= msg
.label
;
1988 /* Append the commit log message to msgbuf. */
1989 if (find_commit_subject(msg
.message
, &p
))
1990 strbuf_addstr(&msgbuf
, p
);
1992 if (opts
->record_origin
) {
1993 strbuf_complete_line(&msgbuf
);
1994 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
1995 strbuf_addch(&msgbuf
, '\n');
1996 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
1997 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
1998 strbuf_addstr(&msgbuf
, ")\n");
2000 if (!is_fixup(command
))
2001 author
= get_author(msg
.message
);
2004 if (command
== TODO_REWORD
)
2006 else if (is_fixup(command
)) {
2007 if (update_squash_messages(r
, command
, commit
, opts
))
2011 msg_file
= rebase_path_squash_msg();
2012 else if (file_exists(rebase_path_fixup_msg())) {
2013 flags
|= VERBATIM_MSG
;
2014 msg_file
= rebase_path_fixup_msg();
2016 const char *dest
= git_path_squash_msg(r
);
2018 if (copy_file(dest
, rebase_path_squash_msg(), 0666))
2019 return error(_("could not rename '%s' to '%s'"),
2020 rebase_path_squash_msg(), dest
);
2021 unlink(git_path_merge_msg(r
));
2027 if (opts
->signoff
&& !is_fixup(command
))
2028 append_signoff(&msgbuf
, 0, 0);
2030 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
2032 else if (!opts
->strategy
||
2033 !strcmp(opts
->strategy
, "recursive") ||
2034 !strcmp(opts
->strategy
, "ort") ||
2035 command
== TODO_REVERT
) {
2036 res
= do_recursive_merge(r
, base
, next
, base_label
, next_label
,
2037 &head
, &msgbuf
, opts
);
2041 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
2042 git_path_merge_msg(r
), 0);
2044 struct commit_list
*common
= NULL
;
2045 struct commit_list
*remotes
= NULL
;
2047 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
2048 git_path_merge_msg(r
), 0);
2050 commit_list_insert(base
, &common
);
2051 commit_list_insert(next
, &remotes
);
2052 res
|= try_merge_command(r
, opts
->strategy
,
2053 opts
->xopts_nr
, (const char **)opts
->xopts
,
2054 common
, oid_to_hex(&head
), remotes
);
2055 free_commit_list(common
);
2056 free_commit_list(remotes
);
2058 strbuf_release(&msgbuf
);
2061 * If the merge was clean or if it failed due to conflict, we write
2062 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
2063 * However, if the merge did not even start, then we don't want to
2066 if ((command
== TODO_PICK
|| command
== TODO_REWORD
||
2067 command
== TODO_EDIT
) && !opts
->no_commit
&&
2068 (res
== 0 || res
== 1) &&
2069 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
2070 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2072 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
2073 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
2074 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2078 error(command
== TODO_REVERT
2079 ? _("could not revert %s... %s")
2080 : _("could not apply %s... %s"),
2081 short_commit_name(commit
), msg
.subject
);
2082 print_advice(r
, res
== 1, opts
);
2083 repo_rerere(r
, opts
->allow_rerere_auto
);
2088 allow
= allow_empty(r
, opts
, commit
);
2092 } else if (allow
== 1) {
2093 flags
|= ALLOW_EMPTY
;
2094 } else if (allow
== 2) {
2096 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
2098 unlink(git_path_merge_msg(r
));
2099 unlink(git_path_auto_merge(r
));
2101 _("dropping %s %s -- patch contents already upstream\n"),
2102 oid_to_hex(&commit
->object
.oid
), msg
.subject
);
2103 } /* else allow == 0 and there's nothing special to do */
2104 if (!opts
->no_commit
&& !drop_commit
) {
2105 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
2106 res
= do_commit(r
, msg_file
, author
, opts
, flags
,
2107 commit
? &commit
->object
.oid
: NULL
);
2109 res
= error(_("unable to parse commit author"));
2110 *check_todo
= !!(flags
& EDIT_MSG
);
2111 if (!res
&& reword
) {
2113 res
= run_git_commit(NULL
, opts
, EDIT_MSG
|
2114 VERIFY_MSG
| AMEND_MSG
|
2115 (flags
& ALLOW_EMPTY
));
2121 if (!res
&& final_fixup
) {
2122 unlink(rebase_path_fixup_msg());
2123 unlink(rebase_path_squash_msg());
2124 unlink(rebase_path_current_fixups());
2125 strbuf_reset(&opts
->current_fixups
);
2126 opts
->current_fixup_count
= 0;
2130 free_message(commit
, &msg
);
2132 update_abort_safety_file();
2137 static int prepare_revs(struct replay_opts
*opts
)
2140 * picking (but not reverting) ranges (but not individual revisions)
2141 * should be done in reverse
2143 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
2144 opts
->revs
->reverse
^= 1;
2146 if (prepare_revision_walk(opts
->revs
))
2147 return error(_("revision walk setup failed"));
2152 static int read_and_refresh_cache(struct repository
*r
,
2153 struct replay_opts
*opts
)
2155 struct lock_file index_lock
= LOCK_INIT
;
2156 int index_fd
= repo_hold_locked_index(r
, &index_lock
, 0);
2157 if (repo_read_index(r
) < 0) {
2158 rollback_lock_file(&index_lock
);
2159 return error(_("git %s: failed to read the index"),
2160 _(action_name(opts
)));
2162 refresh_index(r
->index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
2163 if (index_fd
>= 0) {
2164 if (write_locked_index(r
->index
, &index_lock
,
2165 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
2166 return error(_("git %s: failed to refresh the index"),
2167 _(action_name(opts
)));
2173 enum todo_item_flags
{
2174 TODO_EDIT_MERGE_MSG
= 1
2177 void todo_list_release(struct todo_list
*todo_list
)
2179 strbuf_release(&todo_list
->buf
);
2180 FREE_AND_NULL(todo_list
->items
);
2181 todo_list
->nr
= todo_list
->alloc
= 0;
2184 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
2186 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
2187 todo_list
->total_nr
++;
2188 return todo_list
->items
+ todo_list
->nr
++;
2191 const char *todo_item_get_arg(struct todo_list
*todo_list
,
2192 struct todo_item
*item
)
2194 return todo_list
->buf
.buf
+ item
->arg_offset
;
2197 static int is_command(enum todo_command command
, const char **bol
)
2199 const char *str
= todo_command_info
[command
].str
;
2200 const char nick
= todo_command_info
[command
].c
;
2201 const char *p
= *bol
+ 1;
2203 return skip_prefix(*bol
, str
, bol
) ||
2204 ((nick
&& **bol
== nick
) &&
2205 (*p
== ' ' || *p
== '\t' || *p
== '\n' || *p
== '\r' || !*p
) &&
2209 static int parse_insn_line(struct repository
*r
, struct todo_item
*item
,
2210 const char *buf
, const char *bol
, char *eol
)
2212 struct object_id commit_oid
;
2213 char *end_of_object_name
;
2214 int i
, saved
, status
, padding
;
2219 bol
+= strspn(bol
, " \t");
2221 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
2222 item
->command
= TODO_COMMENT
;
2223 item
->commit
= NULL
;
2224 item
->arg_offset
= bol
- buf
;
2225 item
->arg_len
= eol
- bol
;
2229 for (i
= 0; i
< TODO_COMMENT
; i
++)
2230 if (is_command(i
, &bol
)) {
2234 if (i
>= TODO_COMMENT
)
2237 /* Eat up extra spaces/ tabs before object name */
2238 padding
= strspn(bol
, " \t");
2241 if (item
->command
== TODO_NOOP
|| item
->command
== TODO_BREAK
) {
2243 return error(_("%s does not accept arguments: '%s'"),
2244 command_to_string(item
->command
), bol
);
2245 item
->commit
= NULL
;
2246 item
->arg_offset
= bol
- buf
;
2247 item
->arg_len
= eol
- bol
;
2252 return error(_("missing arguments for %s"),
2253 command_to_string(item
->command
));
2255 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
2256 item
->command
== TODO_RESET
) {
2257 item
->commit
= NULL
;
2258 item
->arg_offset
= bol
- buf
;
2259 item
->arg_len
= (int)(eol
- bol
);
2263 if (item
->command
== TODO_MERGE
) {
2264 if (skip_prefix(bol
, "-C", &bol
))
2265 bol
+= strspn(bol
, " \t");
2266 else if (skip_prefix(bol
, "-c", &bol
)) {
2267 bol
+= strspn(bol
, " \t");
2268 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2270 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2271 item
->commit
= NULL
;
2272 item
->arg_offset
= bol
- buf
;
2273 item
->arg_len
= (int)(eol
- bol
);
2278 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
2279 saved
= *end_of_object_name
;
2280 *end_of_object_name
= '\0';
2281 status
= get_oid(bol
, &commit_oid
);
2283 error(_("could not parse '%s'"), bol
); /* return later */
2284 *end_of_object_name
= saved
;
2286 bol
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2287 item
->arg_offset
= bol
- buf
;
2288 item
->arg_len
= (int)(eol
- bol
);
2293 item
->commit
= lookup_commit_reference(r
, &commit_oid
);
2294 return item
->commit
? 0 : -1;
2297 int sequencer_get_last_command(struct repository
*r
, enum replay_action
*action
)
2299 const char *todo_file
, *bol
;
2300 struct strbuf buf
= STRBUF_INIT
;
2303 todo_file
= git_path_todo_file();
2304 if (strbuf_read_file(&buf
, todo_file
, 0) < 0) {
2305 if (errno
== ENOENT
|| errno
== ENOTDIR
)
2308 return error_errno("unable to open '%s'", todo_file
);
2310 bol
= buf
.buf
+ strspn(buf
.buf
, " \t\r\n");
2311 if (is_command(TODO_PICK
, &bol
) && (*bol
== ' ' || *bol
== '\t'))
2312 *action
= REPLAY_PICK
;
2313 else if (is_command(TODO_REVERT
, &bol
) &&
2314 (*bol
== ' ' || *bol
== '\t'))
2315 *action
= REPLAY_REVERT
;
2319 strbuf_release(&buf
);
2324 int todo_list_parse_insn_buffer(struct repository
*r
, char *buf
,
2325 struct todo_list
*todo_list
)
2327 struct todo_item
*item
;
2328 char *p
= buf
, *next_p
;
2329 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2331 todo_list
->current
= todo_list
->nr
= 0;
2333 for (i
= 1; *p
; i
++, p
= next_p
) {
2334 char *eol
= strchrnul(p
, '\n');
2336 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2338 if (p
!= eol
&& eol
[-1] == '\r')
2339 eol
--; /* strip Carriage Return */
2341 item
= append_new_todo(todo_list
);
2342 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2343 if (parse_insn_line(r
, item
, buf
, p
, eol
)) {
2344 res
= error(_("invalid line %d: %.*s"),
2345 i
, (int)(eol
- p
), p
);
2346 item
->command
= TODO_COMMENT
+ 1;
2347 item
->arg_offset
= p
- buf
;
2348 item
->arg_len
= (int)(eol
- p
);
2349 item
->commit
= NULL
;
2354 else if (is_fixup(item
->command
))
2355 return error(_("cannot '%s' without a previous commit"),
2356 command_to_string(item
->command
));
2357 else if (!is_noop(item
->command
))
2364 static int count_commands(struct todo_list
*todo_list
)
2368 for (i
= 0; i
< todo_list
->nr
; i
++)
2369 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2375 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2377 return index
< todo_list
->nr
?
2378 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2381 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2383 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2386 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2388 return get_item_line_offset(todo_list
, index
+ 1)
2389 - get_item_line_offset(todo_list
, index
);
2392 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2397 fd
= open(path
, O_RDONLY
);
2399 return error_errno(_("could not open '%s'"), path
);
2400 len
= strbuf_read(sb
, fd
, 0);
2403 return error(_("could not read '%s'."), path
);
2407 static int have_finished_the_last_pick(void)
2409 struct strbuf buf
= STRBUF_INIT
;
2411 const char *todo_path
= git_path_todo_file();
2414 if (strbuf_read_file(&buf
, todo_path
, 0) < 0) {
2415 if (errno
== ENOENT
) {
2418 error_errno("unable to open '%s'", todo_path
);
2422 /* If there is only one line then we are done */
2423 eol
= strchr(buf
.buf
, '\n');
2424 if (!eol
|| !eol
[1])
2427 strbuf_release(&buf
);
2432 void sequencer_post_commit_cleanup(struct repository
*r
, int verbose
)
2434 struct replay_opts opts
= REPLAY_OPTS_INIT
;
2435 int need_cleanup
= 0;
2437 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
2438 if (!refs_delete_ref(get_main_ref_store(r
), "",
2439 "CHERRY_PICK_HEAD", NULL
, 0) &&
2441 warning(_("cancelling a cherry picking in progress"));
2442 opts
.action
= REPLAY_PICK
;
2446 if (refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
2447 if (!refs_delete_ref(get_main_ref_store(r
), "", "REVERT_HEAD",
2450 warning(_("cancelling a revert in progress"));
2451 opts
.action
= REPLAY_REVERT
;
2455 unlink(git_path_auto_merge(r
));
2460 if (!have_finished_the_last_pick())
2463 sequencer_remove_state(&opts
);
2466 static void todo_list_write_total_nr(struct todo_list
*todo_list
)
2468 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2471 fprintf(f
, "%d\n", todo_list
->total_nr
);
2476 static int read_populate_todo(struct repository
*r
,
2477 struct todo_list
*todo_list
,
2478 struct replay_opts
*opts
)
2481 const char *todo_file
= get_todo_path(opts
);
2484 strbuf_reset(&todo_list
->buf
);
2485 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2488 res
= stat(todo_file
, &st
);
2490 return error(_("could not stat '%s'"), todo_file
);
2491 fill_stat_data(&todo_list
->stat
, &st
);
2493 res
= todo_list_parse_insn_buffer(r
, todo_list
->buf
.buf
, todo_list
);
2495 if (is_rebase_i(opts
))
2496 return error(_("please fix this using "
2497 "'git rebase --edit-todo'."));
2498 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2501 if (!todo_list
->nr
&&
2502 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2503 return error(_("no commits parsed."));
2505 if (!is_rebase_i(opts
)) {
2506 enum todo_command valid
=
2507 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2510 for (i
= 0; i
< todo_list
->nr
; i
++)
2511 if (valid
== todo_list
->items
[i
].command
)
2513 else if (valid
== TODO_PICK
)
2514 return error(_("cannot cherry-pick during a revert."));
2516 return error(_("cannot revert during a cherry-pick."));
2519 if (is_rebase_i(opts
)) {
2520 struct todo_list done
= TODO_LIST_INIT
;
2522 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2523 !todo_list_parse_insn_buffer(r
, done
.buf
.buf
, &done
))
2524 todo_list
->done_nr
= count_commands(&done
);
2526 todo_list
->done_nr
= 0;
2528 todo_list
->total_nr
= todo_list
->done_nr
2529 + count_commands(todo_list
);
2530 todo_list_release(&done
);
2532 todo_list_write_total_nr(todo_list
);
2538 static int git_config_string_dup(char **dest
,
2539 const char *var
, const char *value
)
2542 return config_error_nonbool(var
);
2544 *dest
= xstrdup(value
);
2548 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
2550 struct replay_opts
*opts
= data
;
2555 else if (!strcmp(key
, "options.no-commit"))
2556 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
2557 else if (!strcmp(key
, "options.edit"))
2558 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
2559 else if (!strcmp(key
, "options.allow-empty"))
2561 git_config_bool_or_int(key
, value
, &error_flag
);
2562 else if (!strcmp(key
, "options.allow-empty-message"))
2563 opts
->allow_empty_message
=
2564 git_config_bool_or_int(key
, value
, &error_flag
);
2565 else if (!strcmp(key
, "options.keep-redundant-commits"))
2566 opts
->keep_redundant_commits
=
2567 git_config_bool_or_int(key
, value
, &error_flag
);
2568 else if (!strcmp(key
, "options.signoff"))
2569 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
2570 else if (!strcmp(key
, "options.record-origin"))
2571 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
2572 else if (!strcmp(key
, "options.allow-ff"))
2573 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
2574 else if (!strcmp(key
, "options.mainline"))
2575 opts
->mainline
= git_config_int(key
, value
);
2576 else if (!strcmp(key
, "options.strategy"))
2577 git_config_string_dup(&opts
->strategy
, key
, value
);
2578 else if (!strcmp(key
, "options.gpg-sign"))
2579 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
2580 else if (!strcmp(key
, "options.strategy-option")) {
2581 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
2582 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(value
);
2583 } else if (!strcmp(key
, "options.allow-rerere-auto"))
2584 opts
->allow_rerere_auto
=
2585 git_config_bool_or_int(key
, value
, &error_flag
) ?
2586 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
2587 else if (!strcmp(key
, "options.default-msg-cleanup")) {
2588 opts
->explicit_cleanup
= 1;
2589 opts
->default_msg_cleanup
= get_cleanup_mode(value
, 1);
2591 return error(_("invalid key: %s"), key
);
2594 return error(_("invalid value for %s: %s"), key
, value
);
2599 void parse_strategy_opts(struct replay_opts
*opts
, char *raw_opts
)
2602 char *strategy_opts_string
= raw_opts
;
2604 if (*strategy_opts_string
== ' ')
2605 strategy_opts_string
++;
2607 opts
->xopts_nr
= split_cmdline(strategy_opts_string
,
2608 (const char ***)&opts
->xopts
);
2609 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
2610 const char *arg
= opts
->xopts
[i
];
2612 skip_prefix(arg
, "--", &arg
);
2613 opts
->xopts
[i
] = xstrdup(arg
);
2617 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2620 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2622 opts
->strategy
= strbuf_detach(buf
, NULL
);
2623 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2626 parse_strategy_opts(opts
, buf
->buf
);
2629 static int read_populate_opts(struct replay_opts
*opts
)
2631 if (is_rebase_i(opts
)) {
2632 struct strbuf buf
= STRBUF_INIT
;
2635 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(),
2636 READ_ONELINER_SKIP_IF_EMPTY
)) {
2637 if (!starts_with(buf
.buf
, "-S"))
2640 free(opts
->gpg_sign
);
2641 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2646 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(),
2647 READ_ONELINER_SKIP_IF_EMPTY
)) {
2648 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2649 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2650 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2651 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2655 if (file_exists(rebase_path_verbose()))
2658 if (file_exists(rebase_path_quiet()))
2661 if (file_exists(rebase_path_signoff())) {
2666 if (file_exists(rebase_path_cdate_is_adate())) {
2668 opts
->committer_date_is_author_date
= 1;
2671 if (file_exists(rebase_path_ignore_date())) {
2673 opts
->ignore_date
= 1;
2676 if (file_exists(rebase_path_reschedule_failed_exec()))
2677 opts
->reschedule_failed_exec
= 1;
2679 if (file_exists(rebase_path_drop_redundant_commits()))
2680 opts
->drop_redundant_commits
= 1;
2682 if (file_exists(rebase_path_keep_redundant_commits()))
2683 opts
->keep_redundant_commits
= 1;
2685 read_strategy_opts(opts
, &buf
);
2688 if (read_oneliner(&opts
->current_fixups
,
2689 rebase_path_current_fixups(),
2690 READ_ONELINER_SKIP_IF_EMPTY
)) {
2691 const char *p
= opts
->current_fixups
.buf
;
2692 opts
->current_fixup_count
= 1;
2693 while ((p
= strchr(p
, '\n'))) {
2694 opts
->current_fixup_count
++;
2699 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
2700 if (get_oid_committish(buf
.buf
, &opts
->squash_onto
) < 0) {
2701 ret
= error(_("unusable squash-onto"));
2704 opts
->have_squash_onto
= 1;
2708 strbuf_release(&buf
);
2712 if (!file_exists(git_path_opts_file()))
2715 * The function git_parse_source(), called from git_config_from_file(),
2716 * may die() in case of a syntactically incorrect file. We do not care
2717 * about this case, though, because we wrote that file ourselves, so we
2718 * are pretty certain that it is syntactically correct.
2720 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
2721 return error(_("malformed options sheet: '%s'"),
2722 git_path_opts_file());
2726 static void write_strategy_opts(struct replay_opts
*opts
)
2729 struct strbuf buf
= STRBUF_INIT
;
2731 for (i
= 0; i
< opts
->xopts_nr
; ++i
)
2732 strbuf_addf(&buf
, " --%s", opts
->xopts
[i
]);
2734 write_file(rebase_path_strategy_opts(), "%s\n", buf
.buf
);
2735 strbuf_release(&buf
);
2738 int write_basic_state(struct replay_opts
*opts
, const char *head_name
,
2739 struct commit
*onto
, const struct object_id
*orig_head
)
2742 write_file(rebase_path_head_name(), "%s\n", head_name
);
2744 write_file(rebase_path_onto(), "%s\n",
2745 oid_to_hex(&onto
->object
.oid
));
2747 write_file(rebase_path_orig_head(), "%s\n",
2748 oid_to_hex(orig_head
));
2751 write_file(rebase_path_quiet(), "%s", "");
2753 write_file(rebase_path_verbose(), "%s", "");
2755 write_file(rebase_path_strategy(), "%s\n", opts
->strategy
);
2756 if (opts
->xopts_nr
> 0)
2757 write_strategy_opts(opts
);
2759 if (opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
)
2760 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2761 else if (opts
->allow_rerere_auto
== RERERE_NOAUTOUPDATE
)
2762 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2765 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts
->gpg_sign
);
2767 write_file(rebase_path_signoff(), "--signoff\n");
2768 if (opts
->drop_redundant_commits
)
2769 write_file(rebase_path_drop_redundant_commits(), "%s", "");
2770 if (opts
->keep_redundant_commits
)
2771 write_file(rebase_path_keep_redundant_commits(), "%s", "");
2772 if (opts
->committer_date_is_author_date
)
2773 write_file(rebase_path_cdate_is_adate(), "%s", "");
2774 if (opts
->ignore_date
)
2775 write_file(rebase_path_ignore_date(), "%s", "");
2776 if (opts
->reschedule_failed_exec
)
2777 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
2782 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
2783 struct replay_opts
*opts
)
2785 enum todo_command command
= opts
->action
== REPLAY_PICK
?
2786 TODO_PICK
: TODO_REVERT
;
2787 const char *command_string
= todo_command_info
[command
].str
;
2788 const char *encoding
;
2789 struct commit
*commit
;
2791 if (prepare_revs(opts
))
2794 encoding
= get_log_output_encoding();
2796 while ((commit
= get_revision(opts
->revs
))) {
2797 struct todo_item
*item
= append_new_todo(todo_list
);
2798 const char *commit_buffer
= logmsg_reencode(commit
, NULL
, encoding
);
2799 const char *subject
;
2802 item
->command
= command
;
2803 item
->commit
= commit
;
2804 item
->arg_offset
= 0;
2806 item
->offset_in_buf
= todo_list
->buf
.len
;
2807 subject_len
= find_commit_subject(commit_buffer
, &subject
);
2808 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
2809 short_commit_name(commit
), subject_len
, subject
);
2810 unuse_commit_buffer(commit
, commit_buffer
);
2814 return error(_("empty commit set passed"));
2819 static int create_seq_dir(struct repository
*r
)
2821 enum replay_action action
;
2822 const char *in_progress_error
= NULL
;
2823 const char *in_progress_advice
= NULL
;
2824 unsigned int advise_skip
=
2825 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD") ||
2826 refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD");
2828 if (!sequencer_get_last_command(r
, &action
)) {
2831 in_progress_error
= _("revert is already in progress");
2832 in_progress_advice
=
2833 _("try \"git revert (--continue | %s--abort | --quit)\"");
2836 in_progress_error
= _("cherry-pick is already in progress");
2837 in_progress_advice
=
2838 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
2841 BUG("unexpected action in create_seq_dir");
2844 if (in_progress_error
) {
2845 error("%s", in_progress_error
);
2846 if (advice_sequencer_in_use
)
2847 advise(in_progress_advice
,
2848 advise_skip
? "--skip | " : "");
2851 if (mkdir(git_path_seq_dir(), 0777) < 0)
2852 return error_errno(_("could not create sequencer directory '%s'"),
2853 git_path_seq_dir());
2858 static int save_head(const char *head
)
2860 struct lock_file head_lock
= LOCK_INIT
;
2861 struct strbuf buf
= STRBUF_INIT
;
2865 fd
= hold_lock_file_for_update(&head_lock
, git_path_head_file(), 0);
2867 return error_errno(_("could not lock HEAD"));
2868 strbuf_addf(&buf
, "%s\n", head
);
2869 written
= write_in_full(fd
, buf
.buf
, buf
.len
);
2870 strbuf_release(&buf
);
2872 error_errno(_("could not write to '%s'"), git_path_head_file());
2873 rollback_lock_file(&head_lock
);
2876 if (commit_lock_file(&head_lock
) < 0)
2877 return error(_("failed to finalize '%s'"), git_path_head_file());
2881 static int rollback_is_safe(void)
2883 struct strbuf sb
= STRBUF_INIT
;
2884 struct object_id expected_head
, actual_head
;
2886 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
2888 if (get_oid_hex(sb
.buf
, &expected_head
)) {
2889 strbuf_release(&sb
);
2890 die(_("could not parse %s"), git_path_abort_safety_file());
2892 strbuf_release(&sb
);
2894 else if (errno
== ENOENT
)
2895 oidclr(&expected_head
);
2897 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2899 if (get_oid("HEAD", &actual_head
))
2900 oidclr(&actual_head
);
2902 return oideq(&actual_head
, &expected_head
);
2905 static int reset_merge(const struct object_id
*oid
)
2908 struct strvec argv
= STRVEC_INIT
;
2910 strvec_pushl(&argv
, "reset", "--merge", NULL
);
2912 if (!is_null_oid(oid
))
2913 strvec_push(&argv
, oid_to_hex(oid
));
2915 ret
= run_command_v_opt(argv
.v
, RUN_GIT_CMD
);
2916 strvec_clear(&argv
);
2921 static int rollback_single_pick(struct repository
*r
)
2923 struct object_id head_oid
;
2925 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
2926 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
2927 return error(_("no cherry-pick or revert in progress"));
2928 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
2929 return error(_("cannot resolve HEAD"));
2930 if (is_null_oid(&head_oid
))
2931 return error(_("cannot abort from a branch yet to be born"));
2932 return reset_merge(&head_oid
);
2935 static int skip_single_pick(void)
2937 struct object_id head
;
2939 if (read_ref_full("HEAD", 0, &head
, NULL
))
2940 return error(_("cannot resolve HEAD"));
2941 return reset_merge(&head
);
2944 int sequencer_rollback(struct repository
*r
, struct replay_opts
*opts
)
2947 struct object_id oid
;
2948 struct strbuf buf
= STRBUF_INIT
;
2951 f
= fopen(git_path_head_file(), "r");
2952 if (!f
&& errno
== ENOENT
) {
2954 * There is no multiple-cherry-pick in progress.
2955 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2956 * a single-cherry-pick in progress, abort that.
2958 return rollback_single_pick(r
);
2961 return error_errno(_("cannot open '%s'"), git_path_head_file());
2962 if (strbuf_getline_lf(&buf
, f
)) {
2963 error(_("cannot read '%s': %s"), git_path_head_file(),
2964 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
2969 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
2970 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2971 git_path_head_file());
2974 if (is_null_oid(&oid
)) {
2975 error(_("cannot abort from a branch yet to be born"));
2979 if (!rollback_is_safe()) {
2980 /* Do not error, just do not rollback */
2981 warning(_("You seem to have moved HEAD. "
2982 "Not rewinding, check your HEAD!"));
2984 if (reset_merge(&oid
))
2986 strbuf_release(&buf
);
2987 return sequencer_remove_state(opts
);
2989 strbuf_release(&buf
);
2993 int sequencer_skip(struct repository
*r
, struct replay_opts
*opts
)
2995 enum replay_action action
= -1;
2996 sequencer_get_last_command(r
, &action
);
2999 * Check whether the subcommand requested to skip the commit is actually
3000 * in progress and that it's safe to skip the commit.
3002 * opts->action tells us which subcommand requested to skip the commit.
3003 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
3004 * action is in progress and we can skip the commit.
3006 * Otherwise we check that the last instruction was related to the
3007 * particular subcommand we're trying to execute and barf if that's not
3010 * Finally we check that the rollback is "safe", i.e., has the HEAD
3011 * moved? In this case, it doesn't make sense to "reset the merge" and
3012 * "skip the commit" as the user already handled this by committing. But
3013 * we'd not want to barf here, instead give advice on how to proceed. We
3014 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
3015 * it gets removed when the user commits, so if it still exists we're
3016 * sure the user can't have committed before.
3018 switch (opts
->action
) {
3020 if (!refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
3021 if (action
!= REPLAY_REVERT
)
3022 return error(_("no revert in progress"));
3023 if (!rollback_is_safe())
3028 if (!refs_ref_exists(get_main_ref_store(r
),
3029 "CHERRY_PICK_HEAD")) {
3030 if (action
!= REPLAY_PICK
)
3031 return error(_("no cherry-pick in progress"));
3032 if (!rollback_is_safe())
3037 BUG("unexpected action in sequencer_skip");
3040 if (skip_single_pick())
3041 return error(_("failed to skip the commit"));
3042 if (!is_directory(git_path_seq_dir()))
3045 return sequencer_continue(r
, opts
);
3048 error(_("there is nothing to skip"));
3050 if (advice_resolve_conflict
) {
3051 advise(_("have you committed already?\n"
3052 "try \"git %s --continue\""),
3053 action
== REPLAY_REVERT
? "revert" : "cherry-pick");
3058 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
3060 struct lock_file todo_lock
= LOCK_INIT
;
3061 const char *todo_path
= get_todo_path(opts
);
3062 int next
= todo_list
->current
, offset
, fd
;
3065 * rebase -i writes "git-rebase-todo" without the currently executing
3066 * command, appending it to "done" instead.
3068 if (is_rebase_i(opts
))
3071 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
3073 return error_errno(_("could not lock '%s'"), todo_path
);
3074 offset
= get_item_line_offset(todo_list
, next
);
3075 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
3076 todo_list
->buf
.len
- offset
) < 0)
3077 return error_errno(_("could not write to '%s'"), todo_path
);
3078 if (commit_lock_file(&todo_lock
) < 0)
3079 return error(_("failed to finalize '%s'"), todo_path
);
3081 if (is_rebase_i(opts
) && next
> 0) {
3082 const char *done
= rebase_path_done();
3083 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
3088 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
3089 get_item_line_length(todo_list
, next
- 1))
3091 ret
= error_errno(_("could not write to '%s'"), done
);
3093 ret
= error_errno(_("failed to finalize '%s'"), done
);
3099 static int save_opts(struct replay_opts
*opts
)
3101 const char *opts_file
= git_path_opts_file();
3104 if (opts
->no_commit
)
3105 res
|= git_config_set_in_file_gently(opts_file
,
3106 "options.no-commit", "true");
3108 res
|= git_config_set_in_file_gently(opts_file
,
3109 "options.edit", "true");
3110 if (opts
->allow_empty
)
3111 res
|= git_config_set_in_file_gently(opts_file
,
3112 "options.allow-empty", "true");
3113 if (opts
->allow_empty_message
)
3114 res
|= git_config_set_in_file_gently(opts_file
,
3115 "options.allow-empty-message", "true");
3116 if (opts
->keep_redundant_commits
)
3117 res
|= git_config_set_in_file_gently(opts_file
,
3118 "options.keep-redundant-commits", "true");
3120 res
|= git_config_set_in_file_gently(opts_file
,
3121 "options.signoff", "true");
3122 if (opts
->record_origin
)
3123 res
|= git_config_set_in_file_gently(opts_file
,
3124 "options.record-origin", "true");
3126 res
|= git_config_set_in_file_gently(opts_file
,
3127 "options.allow-ff", "true");
3128 if (opts
->mainline
) {
3129 struct strbuf buf
= STRBUF_INIT
;
3130 strbuf_addf(&buf
, "%d", opts
->mainline
);
3131 res
|= git_config_set_in_file_gently(opts_file
,
3132 "options.mainline", buf
.buf
);
3133 strbuf_release(&buf
);
3136 res
|= git_config_set_in_file_gently(opts_file
,
3137 "options.strategy", opts
->strategy
);
3139 res
|= git_config_set_in_file_gently(opts_file
,
3140 "options.gpg-sign", opts
->gpg_sign
);
3143 for (i
= 0; i
< opts
->xopts_nr
; i
++)
3144 res
|= git_config_set_multivar_in_file_gently(opts_file
,
3145 "options.strategy-option",
3146 opts
->xopts
[i
], "^$", 0);
3148 if (opts
->allow_rerere_auto
)
3149 res
|= git_config_set_in_file_gently(opts_file
,
3150 "options.allow-rerere-auto",
3151 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
3154 if (opts
->explicit_cleanup
)
3155 res
|= git_config_set_in_file_gently(opts_file
,
3156 "options.default-msg-cleanup",
3157 describe_cleanup_mode(opts
->default_msg_cleanup
));
3161 static int make_patch(struct repository
*r
,
3162 struct commit
*commit
,
3163 struct replay_opts
*opts
)
3165 struct strbuf buf
= STRBUF_INIT
;
3166 struct rev_info log_tree_opt
;
3167 const char *subject
;
3168 char hex
[GIT_MAX_HEXSZ
+ 1];
3171 oid_to_hex_r(hex
, &commit
->object
.oid
);
3172 if (write_message(hex
, strlen(hex
), rebase_path_stopped_sha(), 1) < 0)
3174 res
|= write_rebase_head(&commit
->object
.oid
);
3176 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
3177 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3178 repo_init_revisions(r
, &log_tree_opt
, NULL
);
3179 log_tree_opt
.abbrev
= 0;
3180 log_tree_opt
.diff
= 1;
3181 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
3182 log_tree_opt
.disable_stdin
= 1;
3183 log_tree_opt
.no_commit_id
= 1;
3184 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
3185 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
3186 if (!log_tree_opt
.diffopt
.file
)
3187 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
3189 res
|= log_tree_commit(&log_tree_opt
, commit
);
3190 fclose(log_tree_opt
.diffopt
.file
);
3194 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
3195 if (!file_exists(buf
.buf
)) {
3196 const char *encoding
= get_commit_output_encoding();
3197 const char *commit_buffer
= logmsg_reencode(commit
, NULL
, encoding
);
3198 find_commit_subject(commit_buffer
, &subject
);
3199 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
3200 unuse_commit_buffer(commit
, commit_buffer
);
3202 strbuf_release(&buf
);
3207 static int intend_to_amend(void)
3209 struct object_id head
;
3212 if (get_oid("HEAD", &head
))
3213 return error(_("cannot read HEAD"));
3215 p
= oid_to_hex(&head
);
3216 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
3219 static int error_with_patch(struct repository
*r
,
3220 struct commit
*commit
,
3221 const char *subject
, int subject_len
,
3222 struct replay_opts
*opts
,
3223 int exit_code
, int to_amend
)
3226 if (make_patch(r
, commit
, opts
))
3228 } else if (copy_file(rebase_path_message(),
3229 git_path_merge_msg(r
), 0666))
3230 return error(_("unable to copy '%s' to '%s'"),
3231 git_path_merge_msg(r
), rebase_path_message());
3234 if (intend_to_amend())
3238 _("You can amend the commit now, with\n"
3240 " git commit --amend %s\n"
3242 "Once you are satisfied with your changes, run\n"
3244 " git rebase --continue\n"),
3245 gpg_sign_opt_quoted(opts
));
3246 } else if (exit_code
) {
3248 fprintf_ln(stderr
, _("Could not apply %s... %.*s"),
3249 short_commit_name(commit
), subject_len
, subject
);
3252 * We don't have the hash of the parent so
3253 * just print the line from the todo file.
3255 fprintf_ln(stderr
, _("Could not merge %.*s"),
3256 subject_len
, subject
);
3262 static int error_failed_squash(struct repository
*r
,
3263 struct commit
*commit
,
3264 struct replay_opts
*opts
,
3266 const char *subject
)
3268 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3269 return error(_("could not copy '%s' to '%s'"),
3270 rebase_path_squash_msg(), rebase_path_message());
3271 unlink(git_path_merge_msg(r
));
3272 if (copy_file(git_path_merge_msg(r
), rebase_path_message(), 0666))
3273 return error(_("could not copy '%s' to '%s'"),
3274 rebase_path_message(),
3275 git_path_merge_msg(r
));
3276 return error_with_patch(r
, commit
, subject
, subject_len
, opts
, 1, 0);
3279 static int do_exec(struct repository
*r
, const char *command_line
)
3281 struct strvec child_env
= STRVEC_INIT
;
3282 const char *child_argv
[] = { NULL
, NULL
};
3285 fprintf(stderr
, _("Executing: %s\n"), command_line
);
3286 child_argv
[0] = command_line
;
3287 strvec_pushf(&child_env
, "GIT_DIR=%s", absolute_path(get_git_dir()));
3288 strvec_pushf(&child_env
, "GIT_WORK_TREE=%s",
3289 absolute_path(get_git_work_tree()));
3290 status
= run_command_v_opt_cd_env(child_argv
, RUN_USING_SHELL
, NULL
,
3293 /* force re-reading of the cache */
3294 if (discard_index(r
->index
) < 0 || repo_read_index(r
) < 0)
3295 return error(_("could not read index"));
3297 dirty
= require_clean_work_tree(r
, "rebase", NULL
, 1, 1);
3300 warning(_("execution failed: %s\n%s"
3301 "You can fix the problem, and then run\n"
3303 " git rebase --continue\n"
3306 dirty
? N_("and made changes to the index and/or the "
3307 "working tree\n") : "");
3309 /* command not found */
3312 warning(_("execution succeeded: %s\nbut "
3313 "left changes to the index and/or the working tree\n"
3314 "Commit or stash your changes, and then run\n"
3316 " git rebase --continue\n"
3317 "\n"), command_line
);
3321 strvec_clear(&child_env
);
3326 static int safe_append(const char *filename
, const char *fmt
, ...)
3329 struct lock_file lock
= LOCK_INIT
;
3330 int fd
= hold_lock_file_for_update(&lock
, filename
,
3331 LOCK_REPORT_ON_ERROR
);
3332 struct strbuf buf
= STRBUF_INIT
;
3337 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
3338 error_errno(_("could not read '%s'"), filename
);
3339 rollback_lock_file(&lock
);
3342 strbuf_complete(&buf
, '\n');
3344 strbuf_vaddf(&buf
, fmt
, ap
);
3347 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
3348 error_errno(_("could not write to '%s'"), filename
);
3349 strbuf_release(&buf
);
3350 rollback_lock_file(&lock
);
3353 if (commit_lock_file(&lock
) < 0) {
3354 strbuf_release(&buf
);
3355 rollback_lock_file(&lock
);
3356 return error(_("failed to finalize '%s'"), filename
);
3359 strbuf_release(&buf
);
3363 static int do_label(struct repository
*r
, const char *name
, int len
)
3365 struct ref_store
*refs
= get_main_ref_store(r
);
3366 struct ref_transaction
*transaction
;
3367 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
3368 struct strbuf msg
= STRBUF_INIT
;
3370 struct object_id head_oid
;
3372 if (len
== 1 && *name
== '#')
3373 return error(_("illegal label name: '%.*s'"), len
, name
);
3375 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3376 strbuf_addf(&msg
, "rebase (label) '%.*s'", len
, name
);
3378 transaction
= ref_store_transaction_begin(refs
, &err
);
3380 error("%s", err
.buf
);
3382 } else if (get_oid("HEAD", &head_oid
)) {
3383 error(_("could not read HEAD"));
3385 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
3386 NULL
, 0, msg
.buf
, &err
) < 0 ||
3387 ref_transaction_commit(transaction
, &err
)) {
3388 error("%s", err
.buf
);
3391 ref_transaction_free(transaction
);
3392 strbuf_release(&err
);
3393 strbuf_release(&msg
);
3396 ret
= safe_append(rebase_path_refs_to_delete(),
3397 "%s\n", ref_name
.buf
);
3398 strbuf_release(&ref_name
);
3403 static const char *reflog_message(struct replay_opts
*opts
,
3404 const char *sub_action
, const char *fmt
, ...);
3406 static int do_reset(struct repository
*r
,
3407 const char *name
, int len
,
3408 struct replay_opts
*opts
)
3410 struct strbuf ref_name
= STRBUF_INIT
;
3411 struct object_id oid
;
3412 struct lock_file lock
= LOCK_INIT
;
3413 struct tree_desc desc
;
3415 struct unpack_trees_options unpack_tree_opts
;
3418 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0)
3421 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
3422 if (!opts
->have_squash_onto
) {
3424 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
3425 NULL
, &opts
->squash_onto
,
3427 return error(_("writing fake root commit"));
3428 opts
->have_squash_onto
= 1;
3429 hex
= oid_to_hex(&opts
->squash_onto
);
3430 if (write_message(hex
, strlen(hex
),
3431 rebase_path_squash_onto(), 0))
3432 return error(_("writing squash-onto"));
3434 oidcpy(&oid
, &opts
->squash_onto
);
3438 /* Determine the length of the label */
3439 for (i
= 0; i
< len
; i
++)
3440 if (isspace(name
[i
]))
3444 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3445 if (get_oid(ref_name
.buf
, &oid
) &&
3446 get_oid(ref_name
.buf
+ strlen("refs/rewritten/"), &oid
)) {
3447 error(_("could not read '%s'"), ref_name
.buf
);
3448 rollback_lock_file(&lock
);
3449 strbuf_release(&ref_name
);
3454 memset(&unpack_tree_opts
, 0, sizeof(unpack_tree_opts
));
3455 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
3456 unpack_tree_opts
.head_idx
= 1;
3457 unpack_tree_opts
.src_index
= r
->index
;
3458 unpack_tree_opts
.dst_index
= r
->index
;
3459 unpack_tree_opts
.fn
= oneway_merge
;
3460 unpack_tree_opts
.merge
= 1;
3461 unpack_tree_opts
.update
= 1;
3462 init_checkout_metadata(&unpack_tree_opts
.meta
, name
, &oid
, NULL
);
3464 if (repo_read_index_unmerged(r
)) {
3465 rollback_lock_file(&lock
);
3466 strbuf_release(&ref_name
);
3467 return error_resolve_conflict(_(action_name(opts
)));
3470 if (!fill_tree_descriptor(r
, &desc
, &oid
)) {
3471 error(_("failed to find tree of %s"), oid_to_hex(&oid
));
3472 rollback_lock_file(&lock
);
3473 free((void *)desc
.buffer
);
3474 strbuf_release(&ref_name
);
3478 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
3479 rollback_lock_file(&lock
);
3480 free((void *)desc
.buffer
);
3481 strbuf_release(&ref_name
);
3485 tree
= parse_tree_indirect(&oid
);
3486 prime_cache_tree(r
, r
->index
, tree
);
3488 if (write_locked_index(r
->index
, &lock
, COMMIT_LOCK
) < 0)
3489 ret
= error(_("could not write index"));
3490 free((void *)desc
.buffer
);
3493 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
3494 len
, name
), "HEAD", &oid
,
3495 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3497 strbuf_release(&ref_name
);
3501 static struct commit
*lookup_label(const char *label
, int len
,
3504 struct commit
*commit
;
3507 strbuf_addf(buf
, "refs/rewritten/%.*s", len
, label
);
3508 commit
= lookup_commit_reference_by_name(buf
->buf
);
3510 /* fall back to non-rewritten ref or commit */
3511 strbuf_splice(buf
, 0, strlen("refs/rewritten/"), "", 0);
3512 commit
= lookup_commit_reference_by_name(buf
->buf
);
3516 error(_("could not resolve '%s'"), buf
->buf
);
3521 static int do_merge(struct repository
*r
,
3522 struct commit
*commit
,
3523 const char *arg
, int arg_len
,
3524 int flags
, struct replay_opts
*opts
)
3526 int run_commit_flags
= (flags
& TODO_EDIT_MERGE_MSG
) ?
3527 EDIT_MSG
| VERIFY_MSG
: 0;
3528 struct strbuf ref_name
= STRBUF_INIT
;
3529 struct commit
*head_commit
, *merge_commit
, *i
;
3530 struct commit_list
*bases
, *j
, *reversed
= NULL
;
3531 struct commit_list
*to_merge
= NULL
, **tail
= &to_merge
;
3532 const char *strategy
= !opts
->xopts_nr
&&
3534 !strcmp(opts
->strategy
, "recursive") ||
3535 !strcmp(opts
->strategy
, "ort")) ?
3536 NULL
: opts
->strategy
;
3537 struct merge_options o
;
3538 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
, k
;
3539 static struct lock_file lock
;
3542 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0) {
3547 head_commit
= lookup_commit_reference_by_name("HEAD");
3549 ret
= error(_("cannot merge without a current revision"));
3554 * For octopus merges, the arg starts with the list of revisions to be
3555 * merged. The list is optionally followed by '#' and the oneline.
3557 merge_arg_len
= oneline_offset
= arg_len
;
3558 for (p
= arg
; p
- arg
< arg_len
; p
+= strspn(p
, " \t\n")) {
3561 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
3562 p
+= 1 + strspn(p
+ 1, " \t\n");
3563 oneline_offset
= p
- arg
;
3566 k
= strcspn(p
, " \t\n");
3569 merge_commit
= lookup_label(p
, k
, &ref_name
);
3570 if (!merge_commit
) {
3571 ret
= error(_("unable to parse '%.*s'"), k
, p
);
3574 tail
= &commit_list_insert(merge_commit
, tail
)->next
;
3576 merge_arg_len
= p
- arg
;
3580 ret
= error(_("nothing to merge: '%.*s'"), arg_len
, arg
);
3584 if (opts
->have_squash_onto
&&
3585 oideq(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
3587 * When the user tells us to "merge" something into a
3588 * "[new root]", let's simply fast-forward to the merge head.
3590 rollback_lock_file(&lock
);
3592 ret
= error(_("octopus merge cannot be executed on "
3593 "top of a [new root]"));
3595 ret
= fast_forward_to(r
, &to_merge
->item
->object
.oid
,
3596 &head_commit
->object
.oid
, 0,
3602 const char *encoding
= get_commit_output_encoding();
3603 const char *message
= logmsg_reencode(commit
, NULL
, encoding
);
3608 ret
= error(_("could not get commit message of '%s'"),
3609 oid_to_hex(&commit
->object
.oid
));
3612 write_author_script(message
);
3613 find_commit_subject(message
, &body
);
3615 ret
= write_message(body
, len
, git_path_merge_msg(r
), 0);
3616 unuse_commit_buffer(commit
, message
);
3618 error_errno(_("could not write '%s'"),
3619 git_path_merge_msg(r
));
3623 struct strbuf buf
= STRBUF_INIT
;
3626 strbuf_addf(&buf
, "author %s", git_author_info(0));
3627 write_author_script(buf
.buf
);
3630 if (oneline_offset
< arg_len
) {
3631 p
= arg
+ oneline_offset
;
3632 len
= arg_len
- oneline_offset
;
3634 strbuf_addf(&buf
, "Merge %s '%.*s'",
3635 to_merge
->next
? "branches" : "branch",
3636 merge_arg_len
, arg
);
3641 ret
= write_message(p
, len
, git_path_merge_msg(r
), 0);
3642 strbuf_release(&buf
);
3644 error_errno(_("could not write '%s'"),
3645 git_path_merge_msg(r
));
3651 * If HEAD is not identical to the first parent of the original merge
3652 * commit, we cannot fast-forward.
3654 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
3655 oideq(&commit
->parents
->item
->object
.oid
,
3656 &head_commit
->object
.oid
);
3659 * If any merge head is different from the original one, we cannot
3662 if (can_fast_forward
) {
3663 struct commit_list
*p
= commit
->parents
->next
;
3665 for (j
= to_merge
; j
&& p
; j
= j
->next
, p
= p
->next
)
3666 if (!oideq(&j
->item
->object
.oid
,
3667 &p
->item
->object
.oid
)) {
3668 can_fast_forward
= 0;
3672 * If the number of merge heads differs from the original merge
3673 * commit, we cannot fast-forward.
3676 can_fast_forward
= 0;
3679 if (can_fast_forward
) {
3680 rollback_lock_file(&lock
);
3681 ret
= fast_forward_to(r
, &commit
->object
.oid
,
3682 &head_commit
->object
.oid
, 0, opts
);
3683 if (flags
& TODO_EDIT_MERGE_MSG
) {
3684 run_commit_flags
|= AMEND_MSG
;
3685 goto fast_forward_edit
;
3690 if (strategy
|| to_merge
->next
) {
3692 struct child_process cmd
= CHILD_PROCESS_INIT
;
3694 if (read_env_script(&cmd
.env_array
)) {
3695 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
3697 ret
= error(_(staged_changes_advice
), gpg_opt
, gpg_opt
);
3701 if (opts
->committer_date_is_author_date
)
3702 strvec_pushf(&cmd
.env_array
, "GIT_COMMITTER_DATE=%s",
3705 author_date_from_env_array(&cmd
.env_array
));
3706 if (opts
->ignore_date
)
3707 strvec_push(&cmd
.env_array
, "GIT_AUTHOR_DATE=");
3710 strvec_push(&cmd
.args
, "merge");
3711 strvec_push(&cmd
.args
, "-s");
3713 strvec_push(&cmd
.args
, "octopus");
3715 strvec_push(&cmd
.args
, strategy
);
3716 for (k
= 0; k
< opts
->xopts_nr
; k
++)
3717 strvec_pushf(&cmd
.args
,
3718 "-X%s", opts
->xopts
[k
]);
3720 strvec_push(&cmd
.args
, "--no-edit");
3721 strvec_push(&cmd
.args
, "--no-ff");
3722 strvec_push(&cmd
.args
, "--no-log");
3723 strvec_push(&cmd
.args
, "--no-stat");
3724 strvec_push(&cmd
.args
, "-F");
3725 strvec_push(&cmd
.args
, git_path_merge_msg(r
));
3727 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
3729 strvec_push(&cmd
.args
, "--no-gpg-sign");
3731 /* Add the tips to be merged */
3732 for (j
= to_merge
; j
; j
= j
->next
)
3733 strvec_push(&cmd
.args
,
3734 oid_to_hex(&j
->item
->object
.oid
));
3736 strbuf_release(&ref_name
);
3737 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
3739 rollback_lock_file(&lock
);
3741 ret
= run_command(&cmd
);
3743 /* force re-reading of the cache */
3744 if (!ret
&& (discard_index(r
->index
) < 0 ||
3745 repo_read_index(r
) < 0))
3746 ret
= error(_("could not read index"));
3750 merge_commit
= to_merge
->item
;
3751 bases
= get_merge_bases(head_commit
, merge_commit
);
3752 if (bases
&& oideq(&merge_commit
->object
.oid
,
3753 &bases
->item
->object
.oid
)) {
3755 /* skip merging an ancestor of HEAD */
3759 write_message(oid_to_hex(&merge_commit
->object
.oid
), the_hash_algo
->hexsz
,
3760 git_path_merge_head(r
), 0);
3761 write_message("no-ff", 5, git_path_merge_mode(r
), 0);
3763 for (j
= bases
; j
; j
= j
->next
)
3764 commit_list_insert(j
->item
, &reversed
);
3765 free_commit_list(bases
);
3768 init_merge_options(&o
, r
);
3770 o
.branch2
= ref_name
.buf
;
3771 o
.buffer_output
= 2;
3773 if (opts
->strategy
&& !strcmp(opts
->strategy
, "ort")) {
3775 * TODO: Should use merge_incore_recursive() and
3776 * merge_switch_to_result(), skipping the call to
3777 * merge_switch_to_result() when we don't actually need to
3778 * update the index and working copy immediately.
3780 ret
= merge_ort_recursive(&o
,
3781 head_commit
, merge_commit
, reversed
,
3784 ret
= merge_recursive(&o
, head_commit
, merge_commit
, reversed
,
3788 fputs(o
.obuf
.buf
, stdout
);
3789 strbuf_release(&o
.obuf
);
3791 error(_("could not even attempt to merge '%.*s'"),
3792 merge_arg_len
, arg
);
3796 * The return value of merge_recursive() is 1 on clean, and 0 on
3799 * Let's reverse that, so that do_merge() returns 0 upon success and
3800 * 1 upon failed merge (keeping the return value -1 for the cases where
3801 * we will want to reschedule the `merge` command).
3805 if (r
->index
->cache_changed
&&
3806 write_locked_index(r
->index
, &lock
, COMMIT_LOCK
)) {
3807 ret
= error(_("merge: Unable to write new index file"));
3811 rollback_lock_file(&lock
);
3813 repo_rerere(r
, opts
->allow_rerere_auto
);
3816 * In case of problems, we now want to return a positive
3817 * value (a negative one would indicate that the `merge`
3818 * command needs to be rescheduled).
3821 ret
= !!run_git_commit(git_path_merge_msg(r
), opts
,
3825 strbuf_release(&ref_name
);
3826 rollback_lock_file(&lock
);
3827 free_commit_list(to_merge
);
3831 static int is_final_fixup(struct todo_list
*todo_list
)
3833 int i
= todo_list
->current
;
3835 if (!is_fixup(todo_list
->items
[i
].command
))
3838 while (++i
< todo_list
->nr
)
3839 if (is_fixup(todo_list
->items
[i
].command
))
3841 else if (!is_noop(todo_list
->items
[i
].command
))
3846 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
3850 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
3851 if (!is_noop(todo_list
->items
[i
].command
))
3852 return todo_list
->items
[i
].command
;
3857 void create_autostash(struct repository
*r
, const char *path
,
3858 const char *default_reflog_action
)
3860 struct strbuf buf
= STRBUF_INIT
;
3861 struct lock_file lock_file
= LOCK_INIT
;
3864 fd
= repo_hold_locked_index(r
, &lock_file
, 0);
3865 refresh_index(r
->index
, REFRESH_QUIET
, NULL
, NULL
, NULL
);
3867 repo_update_index_if_able(r
, &lock_file
);
3868 rollback_lock_file(&lock_file
);
3870 if (has_unstaged_changes(r
, 1) ||
3871 has_uncommitted_changes(r
, 1)) {
3872 struct child_process stash
= CHILD_PROCESS_INIT
;
3873 struct object_id oid
;
3875 strvec_pushl(&stash
.args
,
3876 "stash", "create", "autostash", NULL
);
3880 if (capture_command(&stash
, &buf
, GIT_MAX_HEXSZ
))
3881 die(_("Cannot autostash"));
3882 strbuf_trim_trailing_newline(&buf
);
3883 if (get_oid(buf
.buf
, &oid
))
3884 die(_("Unexpected stash response: '%s'"),
3887 strbuf_add_unique_abbrev(&buf
, &oid
, DEFAULT_ABBREV
);
3889 if (safe_create_leading_directories_const(path
))
3890 die(_("Could not create directory for '%s'"),
3892 write_file(path
, "%s", oid_to_hex(&oid
));
3893 printf(_("Created autostash: %s\n"), buf
.buf
);
3894 if (reset_head(r
, NULL
, "reset --hard",
3895 NULL
, RESET_HEAD_HARD
, NULL
, NULL
,
3896 default_reflog_action
) < 0)
3897 die(_("could not reset --hard"));
3899 if (discard_index(r
->index
) < 0 ||
3900 repo_read_index(r
) < 0)
3901 die(_("could not read index"));
3903 strbuf_release(&buf
);
3906 static int apply_save_autostash_oid(const char *stash_oid
, int attempt_apply
)
3908 struct child_process child
= CHILD_PROCESS_INIT
;
3911 if (attempt_apply
) {
3913 child
.no_stdout
= 1;
3914 child
.no_stderr
= 1;
3915 strvec_push(&child
.args
, "stash");
3916 strvec_push(&child
.args
, "apply");
3917 strvec_push(&child
.args
, stash_oid
);
3918 ret
= run_command(&child
);
3921 if (attempt_apply
&& !ret
)
3922 fprintf(stderr
, _("Applied autostash.\n"));
3924 struct child_process store
= CHILD_PROCESS_INIT
;
3927 strvec_push(&store
.args
, "stash");
3928 strvec_push(&store
.args
, "store");
3929 strvec_push(&store
.args
, "-m");
3930 strvec_push(&store
.args
, "autostash");
3931 strvec_push(&store
.args
, "-q");
3932 strvec_push(&store
.args
, stash_oid
);
3933 if (run_command(&store
))
3934 ret
= error(_("cannot store %s"), stash_oid
);
3938 "Your changes are safe in the stash.\n"
3939 "You can run \"git stash pop\" or"
3940 " \"git stash drop\" at any time.\n"),
3942 _("Applying autostash resulted in conflicts.") :
3943 _("Autostash exists; creating a new stash entry."));
3949 static int apply_save_autostash(const char *path
, int attempt_apply
)
3951 struct strbuf stash_oid
= STRBUF_INIT
;
3954 if (!read_oneliner(&stash_oid
, path
,
3955 READ_ONELINER_SKIP_IF_EMPTY
)) {
3956 strbuf_release(&stash_oid
);
3959 strbuf_trim(&stash_oid
);
3961 ret
= apply_save_autostash_oid(stash_oid
.buf
, attempt_apply
);
3964 strbuf_release(&stash_oid
);
3968 int save_autostash(const char *path
)
3970 return apply_save_autostash(path
, 0);
3973 int apply_autostash(const char *path
)
3975 return apply_save_autostash(path
, 1);
3978 int apply_autostash_oid(const char *stash_oid
)
3980 return apply_save_autostash_oid(stash_oid
, 1);
3983 static const char *reflog_message(struct replay_opts
*opts
,
3984 const char *sub_action
, const char *fmt
, ...)
3987 static struct strbuf buf
= STRBUF_INIT
;
3988 char *reflog_action
= getenv(GIT_REFLOG_ACTION
);
3992 strbuf_addstr(&buf
, reflog_action
? reflog_action
: action_name(opts
));
3994 strbuf_addf(&buf
, " (%s)", sub_action
);
3996 strbuf_addstr(&buf
, ": ");
3997 strbuf_vaddf(&buf
, fmt
, ap
);
4004 static int run_git_checkout(struct repository
*r
, struct replay_opts
*opts
,
4005 const char *commit
, const char *action
)
4007 struct child_process cmd
= CHILD_PROCESS_INIT
;
4012 strvec_push(&cmd
.args
, "checkout");
4013 strvec_push(&cmd
.args
, commit
);
4014 strvec_pushf(&cmd
.env_array
, GIT_REFLOG_ACTION
"=%s", action
);
4017 ret
= run_command(&cmd
);
4019 ret
= run_command_silent_on_success(&cmd
);
4022 discard_index(r
->index
);
4027 static int checkout_onto(struct repository
*r
, struct replay_opts
*opts
,
4028 const char *onto_name
, const struct object_id
*onto
,
4029 const struct object_id
*orig_head
)
4031 const char *action
= reflog_message(opts
, "start", "checkout %s", onto_name
);
4033 if (run_git_checkout(r
, opts
, oid_to_hex(onto
), action
)) {
4034 apply_autostash(rebase_path_autostash());
4035 sequencer_remove_state(opts
);
4036 return error(_("could not detach HEAD"));
4039 return update_ref(NULL
, "ORIG_HEAD", orig_head
, NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
4042 static int stopped_at_head(struct repository
*r
)
4044 struct object_id head
;
4045 struct commit
*commit
;
4046 struct commit_message message
;
4048 if (get_oid("HEAD", &head
) ||
4049 !(commit
= lookup_commit(r
, &head
)) ||
4050 parse_commit(commit
) || get_message(commit
, &message
))
4051 fprintf(stderr
, _("Stopped at HEAD\n"));
4053 fprintf(stderr
, _("Stopped at %s\n"), message
.label
);
4054 free_message(commit
, &message
);
4060 static const char rescheduled_advice
[] =
4061 N_("Could not execute the todo command\n"
4065 "It has been rescheduled; To edit the command before continuing, please\n"
4066 "edit the todo list first:\n"
4068 " git rebase --edit-todo\n"
4069 " git rebase --continue\n");
4071 static int pick_commits(struct repository
*r
,
4072 struct todo_list
*todo_list
,
4073 struct replay_opts
*opts
)
4075 int res
= 0, reschedule
= 0;
4076 char *prev_reflog_action
;
4078 /* Note that 0 for 3rd parameter of setenv means set only if not set */
4079 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
4080 prev_reflog_action
= xstrdup(getenv(GIT_REFLOG_ACTION
));
4082 assert(!(opts
->signoff
|| opts
->no_commit
||
4083 opts
->record_origin
|| opts
->edit
||
4084 opts
->committer_date_is_author_date
||
4085 opts
->ignore_date
));
4086 if (read_and_refresh_cache(r
, opts
))
4089 while (todo_list
->current
< todo_list
->nr
) {
4090 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
4091 const char *arg
= todo_item_get_arg(todo_list
, item
);
4094 if (save_todo(todo_list
, opts
))
4096 if (is_rebase_i(opts
)) {
4097 if (item
->command
!= TODO_COMMENT
) {
4098 FILE *f
= fopen(rebase_path_msgnum(), "w");
4100 todo_list
->done_nr
++;
4103 fprintf(f
, "%d\n", todo_list
->done_nr
);
4107 fprintf(stderr
, _("Rebasing (%d/%d)%s"),
4109 todo_list
->total_nr
,
4110 opts
->verbose
? "\n" : "\r");
4112 unlink(rebase_path_message());
4113 unlink(rebase_path_author_script());
4114 unlink(rebase_path_stopped_sha());
4115 unlink(rebase_path_amend());
4116 unlink(git_path_merge_head(r
));
4117 unlink(git_path_auto_merge(r
));
4118 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
4120 if (item
->command
== TODO_BREAK
) {
4123 return stopped_at_head(r
);
4126 if (item
->command
<= TODO_SQUASH
) {
4127 if (is_rebase_i(opts
))
4128 setenv(GIT_REFLOG_ACTION
, reflog_message(opts
,
4129 command_to_string(item
->command
), NULL
),
4131 res
= do_pick_commit(r
, item
->command
, item
->commit
,
4132 opts
, is_final_fixup(todo_list
),
4134 if (is_rebase_i(opts
))
4135 setenv(GIT_REFLOG_ACTION
, prev_reflog_action
, 1);
4136 if (is_rebase_i(opts
) && res
< 0) {
4138 advise(_(rescheduled_advice
),
4139 get_item_line_length(todo_list
,
4140 todo_list
->current
),
4141 get_item_line(todo_list
,
4142 todo_list
->current
));
4143 todo_list
->current
--;
4144 if (save_todo(todo_list
, opts
))
4147 if (item
->command
== TODO_EDIT
) {
4148 struct commit
*commit
= item
->commit
;
4153 _("Stopped at %s... %.*s\n"),
4154 short_commit_name(commit
),
4155 item
->arg_len
, arg
);
4157 return error_with_patch(r
, commit
,
4158 arg
, item
->arg_len
, opts
, res
, !res
);
4160 if (is_rebase_i(opts
) && !res
)
4161 record_in_rewritten(&item
->commit
->object
.oid
,
4162 peek_command(todo_list
, 1));
4163 if (res
&& is_fixup(item
->command
)) {
4166 return error_failed_squash(r
, item
->commit
, opts
,
4167 item
->arg_len
, arg
);
4168 } else if (res
&& is_rebase_i(opts
) && item
->commit
) {
4170 struct object_id oid
;
4173 * If we are rewording and have either
4174 * fast-forwarded already, or are about to
4175 * create a new root commit, we want to amend,
4176 * otherwise we do not.
4178 if (item
->command
== TODO_REWORD
&&
4179 !get_oid("HEAD", &oid
) &&
4180 (oideq(&item
->commit
->object
.oid
, &oid
) ||
4181 (opts
->have_squash_onto
&&
4182 oideq(&opts
->squash_onto
, &oid
))))
4185 return res
| error_with_patch(r
, item
->commit
,
4186 arg
, item
->arg_len
, opts
,
4189 } else if (item
->command
== TODO_EXEC
) {
4190 char *end_of_arg
= (char *)(arg
+ item
->arg_len
);
4191 int saved
= *end_of_arg
;
4196 res
= do_exec(r
, arg
);
4197 *end_of_arg
= saved
;
4200 if (opts
->reschedule_failed_exec
)
4204 } else if (item
->command
== TODO_LABEL
) {
4205 if ((res
= do_label(r
, arg
, item
->arg_len
)))
4207 } else if (item
->command
== TODO_RESET
) {
4208 if ((res
= do_reset(r
, arg
, item
->arg_len
, opts
)))
4210 } else if (item
->command
== TODO_MERGE
) {
4211 if ((res
= do_merge(r
, item
->commit
,
4213 item
->flags
, opts
)) < 0)
4215 else if (item
->commit
)
4216 record_in_rewritten(&item
->commit
->object
.oid
,
4217 peek_command(todo_list
, 1));
4219 /* failed with merge conflicts */
4220 return error_with_patch(r
, item
->commit
,
4223 } else if (!is_noop(item
->command
))
4224 return error(_("unknown command %d"), item
->command
);
4227 advise(_(rescheduled_advice
),
4228 get_item_line_length(todo_list
,
4229 todo_list
->current
),
4230 get_item_line(todo_list
, todo_list
->current
));
4231 todo_list
->current
--;
4232 if (save_todo(todo_list
, opts
))
4235 return error_with_patch(r
,
4239 } else if (is_rebase_i(opts
) && check_todo
&& !res
) {
4242 if (stat(get_todo_path(opts
), &st
)) {
4243 res
= error_errno(_("could not stat '%s'"),
4244 get_todo_path(opts
));
4245 } else if (match_stat_data(&todo_list
->stat
, &st
)) {
4246 /* Reread the todo file if it has changed. */
4247 todo_list_release(todo_list
);
4248 if (read_populate_todo(r
, todo_list
, opts
))
4249 res
= -1; /* message was printed */
4250 /* `current` will be incremented below */
4251 todo_list
->current
= -1;
4255 todo_list
->current
++;
4260 if (is_rebase_i(opts
)) {
4261 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
4264 /* Stopped in the middle, as planned? */
4265 if (todo_list
->current
< todo_list
->nr
)
4268 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
4269 starts_with(head_ref
.buf
, "refs/")) {
4271 struct object_id head
, orig
;
4274 if (get_oid("HEAD", &head
)) {
4275 res
= error(_("cannot read HEAD"));
4277 strbuf_release(&head_ref
);
4278 strbuf_release(&buf
);
4281 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
4282 get_oid_hex(buf
.buf
, &orig
)) {
4283 res
= error(_("could not read orig-head"));
4284 goto cleanup_head_ref
;
4287 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
4288 res
= error(_("could not read 'onto'"));
4289 goto cleanup_head_ref
;
4291 msg
= reflog_message(opts
, "finish", "%s onto %s",
4292 head_ref
.buf
, buf
.buf
);
4293 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
4294 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
4295 res
= error(_("could not update %s"),
4297 goto cleanup_head_ref
;
4299 msg
= reflog_message(opts
, "finish", "returning to %s",
4301 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
4302 res
= error(_("could not update HEAD to %s"),
4304 goto cleanup_head_ref
;
4309 if (opts
->verbose
) {
4310 struct rev_info log_tree_opt
;
4311 struct object_id orig
, head
;
4313 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
4314 repo_init_revisions(r
, &log_tree_opt
, NULL
);
4315 log_tree_opt
.diff
= 1;
4316 log_tree_opt
.diffopt
.output_format
=
4317 DIFF_FORMAT_DIFFSTAT
;
4318 log_tree_opt
.disable_stdin
= 1;
4320 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
4321 !get_oid(buf
.buf
, &orig
) &&
4322 !get_oid("HEAD", &head
)) {
4323 diff_tree_oid(&orig
, &head
, "",
4324 &log_tree_opt
.diffopt
);
4325 log_tree_diff_flush(&log_tree_opt
);
4328 flush_rewritten_pending();
4329 if (!stat(rebase_path_rewritten_list(), &st
) &&
4331 struct child_process child
= CHILD_PROCESS_INIT
;
4332 const char *post_rewrite_hook
=
4333 find_hook("post-rewrite");
4335 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
4337 strvec_push(&child
.args
, "notes");
4338 strvec_push(&child
.args
, "copy");
4339 strvec_push(&child
.args
, "--for-rewrite=rebase");
4340 /* we don't care if this copying failed */
4341 run_command(&child
);
4343 if (post_rewrite_hook
) {
4344 struct child_process hook
= CHILD_PROCESS_INIT
;
4346 hook
.in
= open(rebase_path_rewritten_list(),
4348 hook
.stdout_to_stderr
= 1;
4349 hook
.trace2_hook_name
= "post-rewrite";
4350 strvec_push(&hook
.args
, post_rewrite_hook
);
4351 strvec_push(&hook
.args
, "rebase");
4352 /* we don't care if this hook failed */
4356 apply_autostash(rebase_path_autostash());
4362 _("Successfully rebased and updated %s.\n"),
4366 strbuf_release(&buf
);
4367 strbuf_release(&head_ref
);
4371 * Sequence of picks finished successfully; cleanup by
4372 * removing the .git/sequencer directory
4374 return sequencer_remove_state(opts
);
4377 static int continue_single_pick(struct repository
*r
)
4379 const char *argv
[] = { "commit", NULL
};
4381 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
4382 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
4383 return error(_("no cherry-pick or revert in progress"));
4384 return run_command_v_opt(argv
, RUN_GIT_CMD
);
4387 static int commit_staged_changes(struct repository
*r
,
4388 struct replay_opts
*opts
,
4389 struct todo_list
*todo_list
)
4391 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
4392 unsigned int final_fixup
= 0, is_clean
;
4394 if (has_unstaged_changes(r
, 1))
4395 return error(_("cannot rebase: You have unstaged changes."));
4397 is_clean
= !has_uncommitted_changes(r
, 0);
4399 if (file_exists(rebase_path_amend())) {
4400 struct strbuf rev
= STRBUF_INIT
;
4401 struct object_id head
, to_amend
;
4403 if (get_oid("HEAD", &head
))
4404 return error(_("cannot amend non-existing commit"));
4405 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
4406 return error(_("invalid file: '%s'"), rebase_path_amend());
4407 if (get_oid_hex(rev
.buf
, &to_amend
))
4408 return error(_("invalid contents: '%s'"),
4409 rebase_path_amend());
4410 if (!is_clean
&& !oideq(&head
, &to_amend
))
4411 return error(_("\nYou have uncommitted changes in your "
4412 "working tree. Please, commit them\n"
4413 "first and then run 'git rebase "
4414 "--continue' again."));
4416 * When skipping a failed fixup/squash, we need to edit the
4417 * commit message, the current fixup list and count, and if it
4418 * was the last fixup/squash in the chain, we need to clean up
4419 * the commit message and if there was a squash, let the user
4422 if (!is_clean
|| !opts
->current_fixup_count
)
4423 ; /* this is not the final fixup */
4424 else if (!oideq(&head
, &to_amend
) ||
4425 !file_exists(rebase_path_stopped_sha())) {
4426 /* was a final fixup or squash done manually? */
4427 if (!is_fixup(peek_command(todo_list
, 0))) {
4428 unlink(rebase_path_fixup_msg());
4429 unlink(rebase_path_squash_msg());
4430 unlink(rebase_path_current_fixups());
4431 strbuf_reset(&opts
->current_fixups
);
4432 opts
->current_fixup_count
= 0;
4435 /* we are in a fixup/squash chain */
4436 const char *p
= opts
->current_fixups
.buf
;
4437 int len
= opts
->current_fixups
.len
;
4439 opts
->current_fixup_count
--;
4441 BUG("Incorrect current_fixups:\n%s", p
);
4442 while (len
&& p
[len
- 1] != '\n')
4444 strbuf_setlen(&opts
->current_fixups
, len
);
4445 if (write_message(p
, len
, rebase_path_current_fixups(),
4447 return error(_("could not write file: '%s'"),
4448 rebase_path_current_fixups());
4451 * If a fixup/squash in a fixup/squash chain failed, the
4452 * commit message is already correct, no need to commit
4455 * Only if it is the final command in the fixup/squash
4456 * chain, and only if the chain is longer than a single
4457 * fixup/squash command (which was just skipped), do we
4458 * actually need to re-commit with a cleaned up commit
4461 if (opts
->current_fixup_count
> 0 &&
4462 !is_fixup(peek_command(todo_list
, 0))) {
4465 * If there was not a single "squash" in the
4466 * chain, we only need to clean up the commit
4467 * message, no need to bother the user with
4468 * opening the commit message in the editor.
4470 if (!starts_with(p
, "squash ") &&
4471 !strstr(p
, "\nsquash "))
4472 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
4473 } else if (is_fixup(peek_command(todo_list
, 0))) {
4475 * We need to update the squash message to skip
4476 * the latest commit message.
4478 struct commit
*commit
;
4479 const char *path
= rebase_path_squash_msg();
4480 const char *encoding
= get_commit_output_encoding();
4482 if (parse_head(r
, &commit
) ||
4483 !(p
= logmsg_reencode(commit
, NULL
, encoding
)) ||
4484 write_message(p
, strlen(p
), path
, 0)) {
4485 unuse_commit_buffer(commit
, p
);
4486 return error(_("could not write file: "
4489 unuse_commit_buffer(commit
, p
);
4493 strbuf_release(&rev
);
4498 if (refs_ref_exists(get_main_ref_store(r
),
4499 "CHERRY_PICK_HEAD") &&
4500 refs_delete_ref(get_main_ref_store(r
), "",
4501 "CHERRY_PICK_HEAD", NULL
, 0))
4502 return error(_("could not remove CHERRY_PICK_HEAD"));
4507 if (run_git_commit(final_fixup
? NULL
: rebase_path_message(),
4509 return error(_("could not commit staged changes."));
4510 unlink(rebase_path_amend());
4511 unlink(git_path_merge_head(r
));
4512 unlink(git_path_auto_merge(r
));
4514 unlink(rebase_path_fixup_msg());
4515 unlink(rebase_path_squash_msg());
4517 if (opts
->current_fixup_count
> 0) {
4519 * Whether final fixup or not, we just cleaned up the commit
4522 unlink(rebase_path_current_fixups());
4523 strbuf_reset(&opts
->current_fixups
);
4524 opts
->current_fixup_count
= 0;
4529 int sequencer_continue(struct repository
*r
, struct replay_opts
*opts
)
4531 struct todo_list todo_list
= TODO_LIST_INIT
;
4534 if (read_and_refresh_cache(r
, opts
))
4537 if (read_populate_opts(opts
))
4539 if (is_rebase_i(opts
)) {
4540 if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
4541 goto release_todo_list
;
4543 if (file_exists(rebase_path_dropped())) {
4544 if ((res
= todo_list_check_against_backup(r
, &todo_list
)))
4545 goto release_todo_list
;
4547 unlink(rebase_path_dropped());
4550 if (commit_staged_changes(r
, opts
, &todo_list
)) {
4552 goto release_todo_list
;
4554 } else if (!file_exists(get_todo_path(opts
)))
4555 return continue_single_pick(r
);
4556 else if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
4557 goto release_todo_list
;
4559 if (!is_rebase_i(opts
)) {
4560 /* Verify that the conflict has been resolved */
4561 if (refs_ref_exists(get_main_ref_store(r
),
4562 "CHERRY_PICK_HEAD") ||
4563 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
4564 res
= continue_single_pick(r
);
4566 goto release_todo_list
;
4568 if (index_differs_from(r
, "HEAD", NULL
, 0)) {
4569 res
= error_dirty_index(r
, opts
);
4570 goto release_todo_list
;
4572 todo_list
.current
++;
4573 } else if (file_exists(rebase_path_stopped_sha())) {
4574 struct strbuf buf
= STRBUF_INIT
;
4575 struct object_id oid
;
4577 if (read_oneliner(&buf
, rebase_path_stopped_sha(),
4578 READ_ONELINER_SKIP_IF_EMPTY
) &&
4579 !get_oid_hex(buf
.buf
, &oid
))
4580 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
4581 strbuf_release(&buf
);
4584 res
= pick_commits(r
, &todo_list
, opts
);
4586 todo_list_release(&todo_list
);
4590 static int single_pick(struct repository
*r
,
4591 struct commit
*cmit
,
4592 struct replay_opts
*opts
)
4596 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
4597 return do_pick_commit(r
, opts
->action
== REPLAY_PICK
?
4598 TODO_PICK
: TODO_REVERT
, cmit
, opts
, 0,
4602 int sequencer_pick_revisions(struct repository
*r
,
4603 struct replay_opts
*opts
)
4605 struct todo_list todo_list
= TODO_LIST_INIT
;
4606 struct object_id oid
;
4610 if (read_and_refresh_cache(r
, opts
))
4613 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
4614 struct object_id oid
;
4615 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
4617 /* This happens when using --stdin. */
4621 if (!get_oid(name
, &oid
)) {
4622 if (!lookup_commit_reference_gently(r
, &oid
, 1)) {
4623 enum object_type type
= oid_object_info(r
,
4626 return error(_("%s: can't cherry-pick a %s"),
4627 name
, type_name(type
));
4630 return error(_("%s: bad revision"), name
);
4634 * If we were called as "git cherry-pick <commit>", just
4635 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4636 * REVERT_HEAD, and don't touch the sequencer state.
4637 * This means it is possible to cherry-pick in the middle
4638 * of a cherry-pick sequence.
4640 if (opts
->revs
->cmdline
.nr
== 1 &&
4641 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
4642 opts
->revs
->no_walk
&&
4643 !opts
->revs
->cmdline
.rev
->flags
) {
4644 struct commit
*cmit
;
4645 if (prepare_revision_walk(opts
->revs
))
4646 return error(_("revision walk setup failed"));
4647 cmit
= get_revision(opts
->revs
);
4649 return error(_("empty commit set passed"));
4650 if (get_revision(opts
->revs
))
4651 BUG("unexpected extra commit from walk");
4652 return single_pick(r
, cmit
, opts
);
4656 * Start a new cherry-pick/ revert sequence; but
4657 * first, make sure that an existing one isn't in
4661 if (walk_revs_populate_todo(&todo_list
, opts
) ||
4662 create_seq_dir(r
) < 0)
4664 if (get_oid("HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
4665 return error(_("can't revert as initial commit"));
4666 if (save_head(oid_to_hex(&oid
)))
4668 if (save_opts(opts
))
4670 update_abort_safety_file();
4671 res
= pick_commits(r
, &todo_list
, opts
);
4672 todo_list_release(&todo_list
);
4676 void append_signoff(struct strbuf
*msgbuf
, size_t ignore_footer
, unsigned flag
)
4678 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
4679 struct strbuf sob
= STRBUF_INIT
;
4682 strbuf_addstr(&sob
, sign_off_header
);
4683 strbuf_addstr(&sob
, fmt_name(WANT_COMMITTER_IDENT
));
4684 strbuf_addch(&sob
, '\n');
4687 strbuf_complete_line(msgbuf
);
4690 * If the whole message buffer is equal to the sob, pretend that we
4691 * found a conforming footer with a matching sob
4693 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
4694 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
4697 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
4700 const char *append_newlines
= NULL
;
4701 size_t len
= msgbuf
->len
- ignore_footer
;
4705 * The buffer is completely empty. Leave foom for
4706 * the title and body to be filled in by the user.
4708 append_newlines
= "\n\n";
4709 } else if (len
== 1) {
4711 * Buffer contains a single newline. Add another
4712 * so that we leave room for the title and body.
4714 append_newlines
= "\n";
4715 } else if (msgbuf
->buf
[len
- 2] != '\n') {
4717 * Buffer ends with a single newline. Add another
4718 * so that there is an empty line between the message
4721 append_newlines
= "\n";
4722 } /* else, the buffer already ends with two newlines. */
4724 if (append_newlines
)
4725 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
4726 append_newlines
, strlen(append_newlines
));
4729 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
4730 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
4733 strbuf_release(&sob
);
4736 struct labels_entry
{
4737 struct hashmap_entry entry
;
4738 char label
[FLEX_ARRAY
];
4741 static int labels_cmp(const void *fndata
, const struct hashmap_entry
*eptr
,
4742 const struct hashmap_entry
*entry_or_key
, const void *key
)
4744 const struct labels_entry
*a
, *b
;
4746 a
= container_of(eptr
, const struct labels_entry
, entry
);
4747 b
= container_of(entry_or_key
, const struct labels_entry
, entry
);
4749 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
4752 struct string_entry
{
4753 struct oidmap_entry entry
;
4754 char string
[FLEX_ARRAY
];
4757 struct label_state
{
4758 struct oidmap commit2label
;
4759 struct hashmap labels
;
4763 static const char *label_oid(struct object_id
*oid
, const char *label
,
4764 struct label_state
*state
)
4766 struct labels_entry
*labels_entry
;
4767 struct string_entry
*string_entry
;
4768 struct object_id dummy
;
4771 string_entry
= oidmap_get(&state
->commit2label
, oid
);
4773 return string_entry
->string
;
4776 * For "uninteresting" commits, i.e. commits that are not to be
4777 * rebased, and which can therefore not be labeled, we use a unique
4778 * abbreviation of the commit name. This is slightly more complicated
4779 * than calling find_unique_abbrev() because we also need to make
4780 * sure that the abbreviation does not conflict with any other
4783 * We disallow "interesting" commits to be labeled by a string that
4784 * is a valid full-length hash, to ensure that we always can find an
4785 * abbreviation for any uninteresting commit's names that does not
4786 * clash with any other label.
4788 strbuf_reset(&state
->buf
);
4792 strbuf_grow(&state
->buf
, GIT_MAX_HEXSZ
);
4793 label
= p
= state
->buf
.buf
;
4795 find_unique_abbrev_r(p
, oid
, default_abbrev
);
4798 * We may need to extend the abbreviated hash so that there is
4799 * no conflicting label.
4801 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
4802 size_t i
= strlen(p
) + 1;
4804 oid_to_hex_r(p
, oid
);
4805 for (; i
< the_hash_algo
->hexsz
; i
++) {
4808 if (!hashmap_get_from_hash(&state
->labels
,
4815 struct strbuf
*buf
= &state
->buf
;
4818 * Sanitize labels by replacing non-alpha-numeric characters
4819 * (including white-space ones) by dashes, as they might be
4820 * illegal in file names (and hence in ref names).
4822 * Note that we retain non-ASCII UTF-8 characters (identified
4823 * via the most significant bit). They should be all acceptable
4824 * in file names. We do not validate the UTF-8 here, that's not
4825 * the job of this function.
4827 for (; *label
; label
++)
4828 if ((*label
& 0x80) || isalnum(*label
))
4829 strbuf_addch(buf
, *label
);
4830 /* avoid leading dash and double-dashes */
4831 else if (buf
->len
&& buf
->buf
[buf
->len
- 1] != '-')
4832 strbuf_addch(buf
, '-');
4834 strbuf_addstr(buf
, "rev-");
4835 strbuf_add_unique_abbrev(buf
, oid
, default_abbrev
);
4839 if ((buf
->len
== the_hash_algo
->hexsz
&&
4840 !get_oid_hex(label
, &dummy
)) ||
4841 (buf
->len
== 1 && *label
== '#') ||
4842 hashmap_get_from_hash(&state
->labels
,
4843 strihash(label
), label
)) {
4845 * If the label already exists, or if the label is a
4846 * valid full OID, or the label is a '#' (which we use
4847 * as a separator between merge heads and oneline), we
4848 * append a dash and a number to make it unique.
4850 size_t len
= buf
->len
;
4852 for (i
= 2; ; i
++) {
4853 strbuf_setlen(buf
, len
);
4854 strbuf_addf(buf
, "-%d", i
);
4855 if (!hashmap_get_from_hash(&state
->labels
,
4865 FLEX_ALLOC_STR(labels_entry
, label
, label
);
4866 hashmap_entry_init(&labels_entry
->entry
, strihash(label
));
4867 hashmap_add(&state
->labels
, &labels_entry
->entry
);
4869 FLEX_ALLOC_STR(string_entry
, string
, label
);
4870 oidcpy(&string_entry
->entry
.oid
, oid
);
4871 oidmap_put(&state
->commit2label
, string_entry
);
4873 return string_entry
->string
;
4876 static int make_script_with_merges(struct pretty_print_context
*pp
,
4877 struct rev_info
*revs
, struct strbuf
*out
,
4880 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
4881 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
4882 int root_with_onto
= flags
& TODO_LIST_ROOT_WITH_ONTO
;
4883 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
4884 struct strbuf label
= STRBUF_INIT
;
4885 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
4886 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
4887 struct commit
*commit
;
4888 struct oidmap commit2todo
= OIDMAP_INIT
;
4889 struct string_entry
*entry
;
4890 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
4891 shown
= OIDSET_INIT
;
4892 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
4894 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
4895 const char *cmd_pick
= abbr
? "p" : "pick",
4896 *cmd_label
= abbr
? "l" : "label",
4897 *cmd_reset
= abbr
? "t" : "reset",
4898 *cmd_merge
= abbr
? "m" : "merge";
4900 oidmap_init(&commit2todo
, 0);
4901 oidmap_init(&state
.commit2label
, 0);
4902 hashmap_init(&state
.labels
, labels_cmp
, NULL
, 0);
4903 strbuf_init(&state
.buf
, 32);
4905 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
4906 struct labels_entry
*onto_label_entry
;
4907 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
4908 FLEX_ALLOC_STR(entry
, string
, "onto");
4909 oidcpy(&entry
->entry
.oid
, oid
);
4910 oidmap_put(&state
.commit2label
, entry
);
4912 FLEX_ALLOC_STR(onto_label_entry
, label
, "onto");
4913 hashmap_entry_init(&onto_label_entry
->entry
, strihash("onto"));
4914 hashmap_add(&state
.labels
, &onto_label_entry
->entry
);
4919 * - get onelines for all commits
4920 * - gather all branch tips (i.e. 2nd or later parents of merges)
4921 * - label all branch tips
4923 while ((commit
= get_revision(revs
))) {
4924 struct commit_list
*to_merge
;
4925 const char *p1
, *p2
;
4926 struct object_id
*oid
;
4929 tail
= &commit_list_insert(commit
, tail
)->next
;
4930 oidset_insert(&interesting
, &commit
->object
.oid
);
4932 is_empty
= is_original_commit_empty(commit
);
4933 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
))
4935 if (is_empty
&& !keep_empty
)
4938 strbuf_reset(&oneline
);
4939 pretty_print_commit(pp
, commit
, &oneline
);
4941 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
4943 /* non-merge commit: easy case */
4945 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
4946 oid_to_hex(&commit
->object
.oid
),
4949 strbuf_addf(&buf
, " %c empty",
4952 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
4953 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
4954 oidmap_put(&commit2todo
, entry
);
4959 /* Create a label */
4960 strbuf_reset(&label
);
4961 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
4962 (p1
= strchr(p1
, '\'')) &&
4963 (p2
= strchr(++p1
, '\'')))
4964 strbuf_add(&label
, p1
, p2
- p1
);
4965 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
4967 (p1
= strstr(p1
, " from ")))
4968 strbuf_addstr(&label
, p1
+ strlen(" from "));
4970 strbuf_addbuf(&label
, &oneline
);
4973 strbuf_addf(&buf
, "%s -C %s",
4974 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
4976 /* label the tips of merged branches */
4977 for (; to_merge
; to_merge
= to_merge
->next
) {
4978 oid
= &to_merge
->item
->object
.oid
;
4979 strbuf_addch(&buf
, ' ');
4981 if (!oidset_contains(&interesting
, oid
)) {
4982 strbuf_addstr(&buf
, label_oid(oid
, NULL
,
4987 tips_tail
= &commit_list_insert(to_merge
->item
,
4990 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
4992 strbuf_addf(&buf
, " # %s", oneline
.buf
);
4994 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
4995 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
4996 oidmap_put(&commit2todo
, entry
);
5001 * - label branch points
5002 * - add HEAD to the branch tips
5004 for (iter
= commits
; iter
; iter
= iter
->next
) {
5005 struct commit_list
*parent
= iter
->item
->parents
;
5006 for (; parent
; parent
= parent
->next
) {
5007 struct object_id
*oid
= &parent
->item
->object
.oid
;
5008 if (!oidset_contains(&interesting
, oid
))
5010 if (oidset_insert(&child_seen
, oid
))
5011 label_oid(oid
, "branch-point", &state
);
5014 /* Add HEAD as implicit "tip of branch" */
5016 tips_tail
= &commit_list_insert(iter
->item
,
5021 * Third phase: output the todo list. This is a bit tricky, as we
5022 * want to avoid jumping back and forth between revisions. To
5023 * accomplish that goal, we walk backwards from the branch tips,
5024 * gathering commits not yet shown, reversing the list on the fly,
5025 * then outputting that list (labeling revisions as needed).
5027 strbuf_addf(out
, "%s onto\n", cmd_label
);
5028 for (iter
= tips
; iter
; iter
= iter
->next
) {
5029 struct commit_list
*list
= NULL
, *iter2
;
5031 commit
= iter
->item
;
5032 if (oidset_contains(&shown
, &commit
->object
.oid
))
5034 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
5037 strbuf_addf(out
, "\n%c Branch %s\n", comment_line_char
, entry
->string
);
5039 strbuf_addch(out
, '\n');
5041 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
5042 !oidset_contains(&shown
, &commit
->object
.oid
)) {
5043 commit_list_insert(commit
, &list
);
5044 if (!commit
->parents
) {
5048 commit
= commit
->parents
->item
;
5052 strbuf_addf(out
, "%s %s\n", cmd_reset
,
5053 rebase_cousins
|| root_with_onto
?
5054 "onto" : "[new root]");
5056 const char *to
= NULL
;
5058 entry
= oidmap_get(&state
.commit2label
,
5059 &commit
->object
.oid
);
5062 else if (!rebase_cousins
)
5063 to
= label_oid(&commit
->object
.oid
, NULL
,
5066 if (!to
|| !strcmp(to
, "onto"))
5067 strbuf_addf(out
, "%s onto\n", cmd_reset
);
5069 strbuf_reset(&oneline
);
5070 pretty_print_commit(pp
, commit
, &oneline
);
5071 strbuf_addf(out
, "%s %s # %s\n",
5072 cmd_reset
, to
, oneline
.buf
);
5076 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
5077 struct object_id
*oid
= &iter2
->item
->object
.oid
;
5078 entry
= oidmap_get(&commit2todo
, oid
);
5079 /* only show if not already upstream */
5081 strbuf_addf(out
, "%s\n", entry
->string
);
5082 entry
= oidmap_get(&state
.commit2label
, oid
);
5084 strbuf_addf(out
, "%s %s\n",
5085 cmd_label
, entry
->string
);
5086 oidset_insert(&shown
, oid
);
5089 free_commit_list(list
);
5092 free_commit_list(commits
);
5093 free_commit_list(tips
);
5095 strbuf_release(&label
);
5096 strbuf_release(&oneline
);
5097 strbuf_release(&buf
);
5099 oidmap_free(&commit2todo
, 1);
5100 oidmap_free(&state
.commit2label
, 1);
5101 hashmap_clear_and_free(&state
.labels
, struct labels_entry
, entry
);
5102 strbuf_release(&state
.buf
);
5107 int sequencer_make_script(struct repository
*r
, struct strbuf
*out
, int argc
,
5108 const char **argv
, unsigned flags
)
5110 char *format
= NULL
;
5111 struct pretty_print_context pp
= {0};
5112 struct rev_info revs
;
5113 struct commit
*commit
;
5114 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5115 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
5116 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
5117 int reapply_cherry_picks
= flags
& TODO_LIST_REAPPLY_CHERRY_PICKS
;
5119 repo_init_revisions(r
, &revs
, NULL
);
5120 revs
.verbose_header
= 1;
5122 revs
.max_parents
= 1;
5123 revs
.cherry_mark
= !reapply_cherry_picks
;
5126 revs
.right_only
= 1;
5127 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
5128 revs
.topo_order
= 1;
5130 revs
.pretty_given
= 1;
5131 git_config_get_string("rebase.instructionFormat", &format
);
5132 if (!format
|| !*format
) {
5134 format
= xstrdup("%s");
5136 get_commit_format(format
, &revs
);
5138 pp
.fmt
= revs
.commit_format
;
5139 pp
.output_encoding
= get_log_output_encoding();
5141 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1)
5142 return error(_("make_script: unhandled options"));
5144 if (prepare_revision_walk(&revs
) < 0)
5145 return error(_("make_script: error preparing revisions"));
5148 return make_script_with_merges(&pp
, &revs
, out
, flags
);
5150 while ((commit
= get_revision(&revs
))) {
5151 int is_empty
= is_original_commit_empty(commit
);
5153 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
))
5155 if (is_empty
&& !keep_empty
)
5157 strbuf_addf(out
, "%s %s ", insn
,
5158 oid_to_hex(&commit
->object
.oid
));
5159 pretty_print_commit(&pp
, commit
, out
);
5161 strbuf_addf(out
, " %c empty", comment_line_char
);
5162 strbuf_addch(out
, '\n');
5168 * Add commands after pick and (series of) squash/fixup commands
5171 void todo_list_add_exec_commands(struct todo_list
*todo_list
,
5172 struct string_list
*commands
)
5174 struct strbuf
*buf
= &todo_list
->buf
;
5175 size_t base_offset
= buf
->len
;
5176 int i
, insert
, nr
= 0, alloc
= 0;
5177 struct todo_item
*items
= NULL
, *base_items
= NULL
;
5179 base_items
= xcalloc(commands
->nr
, sizeof(struct todo_item
));
5180 for (i
= 0; i
< commands
->nr
; i
++) {
5181 size_t command_len
= strlen(commands
->items
[i
].string
);
5183 strbuf_addstr(buf
, commands
->items
[i
].string
);
5184 strbuf_addch(buf
, '\n');
5186 base_items
[i
].command
= TODO_EXEC
;
5187 base_items
[i
].offset_in_buf
= base_offset
;
5188 base_items
[i
].arg_offset
= base_offset
+ strlen("exec ");
5189 base_items
[i
].arg_len
= command_len
- strlen("exec ");
5191 base_offset
+= command_len
+ 1;
5195 * Insert <commands> after every pick. Here, fixup/squash chains
5196 * are considered part of the pick, so we insert the commands *after*
5197 * those chains if there are any.
5199 * As we insert the exec commands immediately after rearranging
5200 * any fixups and before the user edits the list, a fixup chain
5201 * can never contain comments (any comments are empty picks that
5202 * have been commented out because the user did not specify
5203 * --keep-empty). So, it is safe to insert an exec command
5204 * without looking at the command following a comment.
5207 for (i
= 0; i
< todo_list
->nr
; i
++) {
5208 enum todo_command command
= todo_list
->items
[i
].command
;
5209 if (insert
&& !is_fixup(command
)) {
5210 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5211 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5217 ALLOC_GROW(items
, nr
+ 1, alloc
);
5218 items
[nr
++] = todo_list
->items
[i
];
5220 if (command
== TODO_PICK
|| command
== TODO_MERGE
)
5224 /* insert or append final <commands> */
5225 if (insert
|| nr
== todo_list
->nr
) {
5226 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5227 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5232 FREE_AND_NULL(todo_list
->items
);
5233 todo_list
->items
= items
;
5235 todo_list
->alloc
= alloc
;
5238 static void todo_list_to_strbuf(struct repository
*r
, struct todo_list
*todo_list
,
5239 struct strbuf
*buf
, int num
, unsigned flags
)
5241 struct todo_item
*item
;
5242 int i
, max
= todo_list
->nr
;
5244 if (num
> 0 && num
< max
)
5247 for (item
= todo_list
->items
, i
= 0; i
< max
; i
++, item
++) {
5250 /* if the item is not a command write it and continue */
5251 if (item
->command
>= TODO_COMMENT
) {
5252 strbuf_addf(buf
, "%.*s\n", item
->arg_len
,
5253 todo_item_get_arg(todo_list
, item
));
5257 /* add command to the buffer */
5258 cmd
= command_to_char(item
->command
);
5259 if ((flags
& TODO_LIST_ABBREVIATE_CMDS
) && cmd
)
5260 strbuf_addch(buf
, cmd
);
5262 strbuf_addstr(buf
, command_to_string(item
->command
));
5266 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
5267 short_commit_name(item
->commit
) :
5268 oid_to_hex(&item
->commit
->object
.oid
);
5270 if (item
->command
== TODO_MERGE
) {
5271 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
5272 strbuf_addstr(buf
, " -c");
5274 strbuf_addstr(buf
, " -C");
5277 strbuf_addf(buf
, " %s", oid
);
5280 /* add all the rest */
5282 strbuf_addch(buf
, '\n');
5284 strbuf_addf(buf
, " %.*s\n", item
->arg_len
,
5285 todo_item_get_arg(todo_list
, item
));
5289 int todo_list_write_to_file(struct repository
*r
, struct todo_list
*todo_list
,
5290 const char *file
, const char *shortrevisions
,
5291 const char *shortonto
, int num
, unsigned flags
)
5294 struct strbuf buf
= STRBUF_INIT
;
5296 todo_list_to_strbuf(r
, todo_list
, &buf
, num
, flags
);
5297 if (flags
& TODO_LIST_APPEND_TODO_HELP
)
5298 append_todo_help(count_commands(todo_list
),
5299 shortrevisions
, shortonto
, &buf
);
5301 res
= write_message(buf
.buf
, buf
.len
, file
, 0);
5302 strbuf_release(&buf
);
5307 /* skip picking commits whose parents are unchanged */
5308 static int skip_unnecessary_picks(struct repository
*r
,
5309 struct todo_list
*todo_list
,
5310 struct object_id
*base_oid
)
5312 struct object_id
*parent_oid
;
5315 for (i
= 0; i
< todo_list
->nr
; i
++) {
5316 struct todo_item
*item
= todo_list
->items
+ i
;
5318 if (item
->command
>= TODO_NOOP
)
5320 if (item
->command
!= TODO_PICK
)
5322 if (parse_commit(item
->commit
)) {
5323 return error(_("could not parse commit '%s'"),
5324 oid_to_hex(&item
->commit
->object
.oid
));
5326 if (!item
->commit
->parents
)
5327 break; /* root commit */
5328 if (item
->commit
->parents
->next
)
5329 break; /* merge commit */
5330 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
5331 if (!oideq(parent_oid
, base_oid
))
5333 oidcpy(base_oid
, &item
->commit
->object
.oid
);
5336 const char *done_path
= rebase_path_done();
5338 if (todo_list_write_to_file(r
, todo_list
, done_path
, NULL
, NULL
, i
, 0)) {
5339 error_errno(_("could not write to '%s'"), done_path
);
5343 MOVE_ARRAY(todo_list
->items
, todo_list
->items
+ i
, todo_list
->nr
- i
);
5345 todo_list
->current
= 0;
5346 todo_list
->done_nr
+= i
;
5348 if (is_fixup(peek_command(todo_list
, 0)))
5349 record_in_rewritten(base_oid
, peek_command(todo_list
, 0));
5355 int complete_action(struct repository
*r
, struct replay_opts
*opts
, unsigned flags
,
5356 const char *shortrevisions
, const char *onto_name
,
5357 struct commit
*onto
, const struct object_id
*orig_head
,
5358 struct string_list
*commands
, unsigned autosquash
,
5359 struct todo_list
*todo_list
)
5361 char shortonto
[GIT_MAX_HEXSZ
+ 1];
5362 const char *todo_file
= rebase_path_todo();
5363 struct todo_list new_todo
= TODO_LIST_INIT
;
5364 struct strbuf
*buf
= &todo_list
->buf
, buf2
= STRBUF_INIT
;
5365 struct object_id oid
= onto
->object
.oid
;
5368 find_unique_abbrev_r(shortonto
, &oid
, DEFAULT_ABBREV
);
5370 if (buf
->len
== 0) {
5371 struct todo_item
*item
= append_new_todo(todo_list
);
5372 item
->command
= TODO_NOOP
;
5373 item
->commit
= NULL
;
5374 item
->arg_len
= item
->arg_offset
= item
->flags
= item
->offset_in_buf
= 0;
5377 if (autosquash
&& todo_list_rearrange_squash(todo_list
))
5381 todo_list_add_exec_commands(todo_list
, commands
);
5383 if (count_commands(todo_list
) == 0) {
5384 apply_autostash(rebase_path_autostash());
5385 sequencer_remove_state(opts
);
5387 return error(_("nothing to do"));
5390 res
= edit_todo_list(r
, todo_list
, &new_todo
, shortrevisions
,
5394 else if (res
== -2) {
5395 apply_autostash(rebase_path_autostash());
5396 sequencer_remove_state(opts
);
5399 } else if (res
== -3) {
5400 apply_autostash(rebase_path_autostash());
5401 sequencer_remove_state(opts
);
5402 todo_list_release(&new_todo
);
5404 return error(_("nothing to do"));
5405 } else if (res
== -4) {
5406 checkout_onto(r
, opts
, onto_name
, &onto
->object
.oid
, orig_head
);
5407 todo_list_release(&new_todo
);
5412 /* Expand the commit IDs */
5413 todo_list_to_strbuf(r
, &new_todo
, &buf2
, -1, 0);
5414 strbuf_swap(&new_todo
.buf
, &buf2
);
5415 strbuf_release(&buf2
);
5416 new_todo
.total_nr
-= new_todo
.nr
;
5417 if (todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
) < 0)
5418 BUG("invalid todo list after expanding IDs:\n%s",
5421 if (opts
->allow_ff
&& skip_unnecessary_picks(r
, &new_todo
, &oid
)) {
5422 todo_list_release(&new_todo
);
5423 return error(_("could not skip unnecessary pick commands"));
5426 if (todo_list_write_to_file(r
, &new_todo
, todo_file
, NULL
, NULL
, -1,
5427 flags
& ~(TODO_LIST_SHORTEN_IDS
))) {
5428 todo_list_release(&new_todo
);
5429 return error_errno(_("could not write '%s'"), todo_file
);
5434 if (checkout_onto(r
, opts
, onto_name
, &oid
, orig_head
))
5437 if (require_clean_work_tree(r
, "rebase", "", 1, 1))
5440 todo_list_write_total_nr(&new_todo
);
5441 res
= pick_commits(r
, &new_todo
, opts
);
5444 todo_list_release(&new_todo
);
5449 struct subject2item_entry
{
5450 struct hashmap_entry entry
;
5452 char subject
[FLEX_ARRAY
];
5455 static int subject2item_cmp(const void *fndata
,
5456 const struct hashmap_entry
*eptr
,
5457 const struct hashmap_entry
*entry_or_key
,
5460 const struct subject2item_entry
*a
, *b
;
5462 a
= container_of(eptr
, const struct subject2item_entry
, entry
);
5463 b
= container_of(entry_or_key
, const struct subject2item_entry
, entry
);
5465 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
5468 define_commit_slab(commit_todo_item
, struct todo_item
*);
5471 * Rearrange the todo list that has both "pick commit-id msg" and "pick
5472 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
5473 * after the former, and change "pick" to "fixup"/"squash".
5475 * Note that if the config has specified a custom instruction format, each log
5476 * message will have to be retrieved from the commit (as the oneline in the
5477 * script cannot be trusted) in order to normalize the autosquash arrangement.
5479 int todo_list_rearrange_squash(struct todo_list
*todo_list
)
5481 struct hashmap subject2item
;
5482 int rearranged
= 0, *next
, *tail
, i
, nr
= 0, alloc
= 0;
5484 struct commit_todo_item commit_todo
;
5485 struct todo_item
*items
= NULL
;
5487 init_commit_todo_item(&commit_todo
);
5489 * The hashmap maps onelines to the respective todo list index.
5491 * If any items need to be rearranged, the next[i] value will indicate
5492 * which item was moved directly after the i'th.
5494 * In that case, last[i] will indicate the index of the latest item to
5495 * be moved to appear after the i'th.
5497 hashmap_init(&subject2item
, subject2item_cmp
, NULL
, todo_list
->nr
);
5498 ALLOC_ARRAY(next
, todo_list
->nr
);
5499 ALLOC_ARRAY(tail
, todo_list
->nr
);
5500 ALLOC_ARRAY(subjects
, todo_list
->nr
);
5501 for (i
= 0; i
< todo_list
->nr
; i
++) {
5502 struct strbuf buf
= STRBUF_INIT
;
5503 struct todo_item
*item
= todo_list
->items
+ i
;
5504 const char *commit_buffer
, *subject
, *p
;
5507 struct subject2item_entry
*entry
;
5509 next
[i
] = tail
[i
] = -1;
5510 if (!item
->commit
|| item
->command
== TODO_DROP
) {
5515 if (is_fixup(item
->command
)) {
5516 clear_commit_todo_item(&commit_todo
);
5517 return error(_("the script was already rearranged."));
5520 *commit_todo_item_at(&commit_todo
, item
->commit
) = item
;
5522 parse_commit(item
->commit
);
5523 commit_buffer
= logmsg_reencode(item
->commit
, NULL
, "UTF-8");
5524 find_commit_subject(commit_buffer
, &subject
);
5525 format_subject(&buf
, subject
, " ");
5526 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
5527 unuse_commit_buffer(item
->commit
, commit_buffer
);
5528 if ((skip_prefix(subject
, "fixup! ", &p
) ||
5529 skip_prefix(subject
, "squash! ", &p
))) {
5530 struct commit
*commit2
;
5535 if (!skip_prefix(p
, "fixup! ", &p
) &&
5536 !skip_prefix(p
, "squash! ", &p
))
5540 entry
= hashmap_get_entry_from_hash(&subject2item
,
5542 struct subject2item_entry
,
5545 /* found by title */
5547 else if (!strchr(p
, ' ') &&
5549 lookup_commit_reference_by_name(p
)) &&
5550 *commit_todo_item_at(&commit_todo
, commit2
))
5551 /* found by commit name */
5552 i2
= *commit_todo_item_at(&commit_todo
, commit2
)
5555 /* copy can be a prefix of the commit subject */
5556 for (i2
= 0; i2
< i
; i2
++)
5558 starts_with(subjects
[i2
], p
))
5566 todo_list
->items
[i
].command
=
5567 starts_with(subject
, "fixup!") ?
5568 TODO_FIXUP
: TODO_SQUASH
;
5573 next
[i
] = next
[tail
[i2
]];
5577 } else if (!hashmap_get_from_hash(&subject2item
,
5578 strhash(subject
), subject
)) {
5579 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
5581 hashmap_entry_init(&entry
->entry
,
5582 strhash(entry
->subject
));
5583 hashmap_put(&subject2item
, &entry
->entry
);
5588 for (i
= 0; i
< todo_list
->nr
; i
++) {
5589 enum todo_command command
= todo_list
->items
[i
].command
;
5593 * Initially, all commands are 'pick's. If it is a
5594 * fixup or a squash now, we have rearranged it.
5596 if (is_fixup(command
))
5600 ALLOC_GROW(items
, nr
+ 1, alloc
);
5601 items
[nr
++] = todo_list
->items
[cur
];
5606 FREE_AND_NULL(todo_list
->items
);
5607 todo_list
->items
= items
;
5609 todo_list
->alloc
= alloc
;
5614 for (i
= 0; i
< todo_list
->nr
; i
++)
5617 hashmap_clear_and_free(&subject2item
, struct subject2item_entry
, entry
);
5619 clear_commit_todo_item(&commit_todo
);
5624 int sequencer_determine_whence(struct repository
*r
, enum commit_whence
*whence
)
5626 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
5627 struct object_id cherry_pick_head
, rebase_head
;
5629 if (file_exists(git_path_seq_dir()))
5630 *whence
= FROM_CHERRY_PICK_MULTI
;
5631 if (file_exists(rebase_path()) &&
5632 !get_oid("REBASE_HEAD", &rebase_head
) &&
5633 !get_oid("CHERRY_PICK_HEAD", &cherry_pick_head
) &&
5634 oideq(&rebase_head
, &cherry_pick_head
))
5635 *whence
= FROM_REBASE_PICK
;
5637 *whence
= FROM_CHERRY_PICK_SINGLE
;