5 #include "object-store.h"
10 #include "run-command.h"
13 #include "cache-tree.h"
17 #include "merge-recursive.h"
19 #include "argv-array.h"
23 #include "wt-status.h"
25 #include "notes-utils.h"
27 #include "unpack-trees.h"
31 #include "commit-slab.h"
33 #include "commit-reach.h"
34 #include "rebase-interactive.h"
36 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
38 static const char sign_off_header
[] = "Signed-off-by: ";
39 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
41 GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
43 GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
45 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
46 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
47 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
48 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
50 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
52 * The file containing rebase commands, comments, and empty lines.
53 * This file is created by "git rebase -i" then edited by the user. As
54 * the lines are processed, they are removed from the front of this
55 * file and written to the tail of 'done'.
57 GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
58 GIT_PATH_FUNC(rebase_path_todo_backup
, "rebase-merge/git-rebase-todo.backup")
61 * The rebase command lines that have already been processed. A line
62 * is moved here when it is first handled, before any associated user
65 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
67 * The file to keep track of how many commands were already processed (e.g.
70 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum")
72 * The file to keep track of how many commands are to be processed in total
73 * (e.g. for the prompt).
75 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end")
77 * The commit message that is planned to be used for any changes that
78 * need to be committed following a user interaction.
80 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
82 * The file into which is accumulated the suggested commit message for
83 * squash/fixup commands. When the first of a series of squash/fixups
84 * is seen, the file is created and the commit message from the
85 * previous commit and from the first squash/fixup commit are written
86 * to it. The commit message for each subsequent squash/fixup commit
87 * is appended to the file as it is processed.
89 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
91 * If the current series of squash/fixups has not yet included a squash
92 * command, then this file exists and holds the commit message of the
93 * original "pick" commit. (If the series ends without a "squash"
94 * command, then this can be used as the commit message of the combined
95 * commit without opening the editor.)
97 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
99 * This file contains the list fixup/squash commands that have been
100 * accumulated into message-fixup or message-squash so far.
102 static GIT_PATH_FUNC(rebase_path_current_fixups
, "rebase-merge/current-fixups")
104 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
105 * GIT_AUTHOR_DATE that will be used for the commit that is currently
108 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
110 * When an "edit" rebase command is being processed, the SHA1 of the
111 * commit to be edited is recorded in this file. When "git rebase
112 * --continue" is executed, if there are any staged changes then they
113 * will be amended to the HEAD commit, but only provided the HEAD
114 * commit is still the commit to be edited. When any other rebase
115 * command is processed, this file is deleted.
117 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
119 * When we stop at a given patch via the "edit" command, this file contains
120 * the abbreviated commit name of the corresponding patch.
122 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
124 * For the post-rewrite hook, we make a list of rewritten commits and
125 * their new sha1s. The rewritten-pending list keeps the sha1s of
126 * commits that have been processed, but not committed yet,
127 * e.g. because they are waiting for a 'squash' command.
129 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
130 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
131 "rebase-merge/rewritten-pending")
134 * The path of the file containig the OID of the "squash onto" commit, i.e.
135 * the dummy commit used for `reset [new root]`.
137 static GIT_PATH_FUNC(rebase_path_squash_onto
, "rebase-merge/squash-onto")
140 * The path of the file listing refs that need to be deleted after the rebase
141 * finishes. This is used by the `label` command to record the need for cleanup.
143 static GIT_PATH_FUNC(rebase_path_refs_to_delete
, "rebase-merge/refs-to-delete")
146 * The following files are written by git-rebase just after parsing the
149 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
150 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
151 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
152 static GIT_PATH_FUNC(rebase_path_quiet
, "rebase-merge/quiet")
153 static GIT_PATH_FUNC(rebase_path_signoff
, "rebase-merge/signoff")
154 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
155 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
156 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
157 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
158 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
159 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
160 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec
, "rebase-merge/reschedule-failed-exec")
162 static int git_sequencer_config(const char *k
, const char *v
, void *cb
)
164 struct replay_opts
*opts
= cb
;
167 if (!strcmp(k
, "commit.cleanup")) {
170 status
= git_config_string(&s
, k
, v
);
174 if (!strcmp(s
, "verbatim"))
175 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
176 else if (!strcmp(s
, "whitespace"))
177 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
178 else if (!strcmp(s
, "strip"))
179 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_ALL
;
180 else if (!strcmp(s
, "scissors"))
181 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
183 warning(_("invalid commit message cleanup mode '%s'"),
190 if (!strcmp(k
, "commit.gpgsign")) {
191 opts
->gpg_sign
= git_config_bool(k
, v
) ? xstrdup("") : NULL
;
195 status
= git_gpg_config(k
, v
, NULL
);
199 return git_diff_basic_config(k
, v
, NULL
);
202 void sequencer_init_config(struct replay_opts
*opts
)
204 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
205 git_config(git_sequencer_config
, opts
);
208 static inline int is_rebase_i(const struct replay_opts
*opts
)
210 return opts
->action
== REPLAY_INTERACTIVE_REBASE
;
213 static const char *get_dir(const struct replay_opts
*opts
)
215 if (is_rebase_i(opts
))
216 return rebase_path();
217 return git_path_seq_dir();
220 static const char *get_todo_path(const struct replay_opts
*opts
)
222 if (is_rebase_i(opts
))
223 return rebase_path_todo();
224 return git_path_todo_file();
228 * Returns 0 for non-conforming footer
229 * Returns 1 for conforming footer
230 * Returns 2 when sob exists within conforming footer
231 * Returns 3 when sob exists within conforming footer as last entry
233 static int has_conforming_footer(struct strbuf
*sb
, struct strbuf
*sob
,
234 size_t ignore_footer
)
236 struct process_trailer_options opts
= PROCESS_TRAILER_OPTIONS_INIT
;
237 struct trailer_info info
;
239 int found_sob
= 0, found_sob_last
= 0;
243 trailer_info_get(&info
, sb
->buf
, &opts
);
245 if (info
.trailer_start
== info
.trailer_end
)
248 for (i
= 0; i
< info
.trailer_nr
; i
++)
249 if (sob
&& !strncmp(info
.trailers
[i
], sob
->buf
, sob
->len
)) {
251 if (i
== info
.trailer_nr
- 1)
255 trailer_info_release(&info
);
264 static const char *gpg_sign_opt_quoted(struct replay_opts
*opts
)
266 static struct strbuf buf
= STRBUF_INIT
;
270 sq_quotef(&buf
, "-S%s", opts
->gpg_sign
);
274 int sequencer_remove_state(struct replay_opts
*opts
)
276 struct strbuf buf
= STRBUF_INIT
;
279 if (is_rebase_i(opts
) &&
280 strbuf_read_file(&buf
, rebase_path_refs_to_delete(), 0) > 0) {
283 char *eol
= strchr(p
, '\n');
286 if (delete_ref("(rebase -i) cleanup", p
, NULL
, 0) < 0)
287 warning(_("could not delete '%s'"), p
);
294 free(opts
->gpg_sign
);
295 free(opts
->strategy
);
296 for (i
= 0; i
< opts
->xopts_nr
; i
++)
297 free(opts
->xopts
[i
]);
299 strbuf_release(&opts
->current_fixups
);
302 strbuf_addstr(&buf
, get_dir(opts
));
303 remove_dir_recursively(&buf
, 0);
304 strbuf_release(&buf
);
309 static const char *action_name(const struct replay_opts
*opts
)
311 switch (opts
->action
) {
315 return N_("cherry-pick");
316 case REPLAY_INTERACTIVE_REBASE
:
317 return N_("rebase -i");
319 die(_("unknown action: %d"), opts
->action
);
322 struct commit_message
{
329 static const char *short_commit_name(struct commit
*commit
)
331 return find_unique_abbrev(&commit
->object
.oid
, DEFAULT_ABBREV
);
334 static int get_message(struct commit
*commit
, struct commit_message
*out
)
336 const char *abbrev
, *subject
;
339 out
->message
= logmsg_reencode(commit
, NULL
, get_commit_output_encoding());
340 abbrev
= short_commit_name(commit
);
342 subject_len
= find_commit_subject(out
->message
, &subject
);
344 out
->subject
= xmemdupz(subject
, subject_len
);
345 out
->label
= xstrfmt("%s... %s", abbrev
, out
->subject
);
346 out
->parent_label
= xstrfmt("parent of %s", out
->label
);
351 static void free_message(struct commit
*commit
, struct commit_message
*msg
)
353 free(msg
->parent_label
);
356 unuse_commit_buffer(commit
, msg
->message
);
359 static void print_advice(struct repository
*r
, int show_hint
,
360 struct replay_opts
*opts
)
362 char *msg
= getenv("GIT_CHERRY_PICK_HELP");
365 fprintf(stderr
, "%s\n", msg
);
367 * A conflict has occurred but the porcelain
368 * (typically rebase --interactive) wants to take care
369 * of the commit itself so remove CHERRY_PICK_HEAD
371 unlink(git_path_cherry_pick_head(r
));
377 advise(_("after resolving the conflicts, mark the corrected paths\n"
378 "with 'git add <paths>' or 'git rm <paths>'"));
380 advise(_("after resolving the conflicts, mark the corrected paths\n"
381 "with 'git add <paths>' or 'git rm <paths>'\n"
382 "and commit the result with 'git commit'"));
386 static int write_message(const void *buf
, size_t len
, const char *filename
,
389 struct lock_file msg_file
= LOCK_INIT
;
391 int msg_fd
= hold_lock_file_for_update(&msg_file
, filename
, 0);
393 return error_errno(_("could not lock '%s'"), filename
);
394 if (write_in_full(msg_fd
, buf
, len
) < 0) {
395 error_errno(_("could not write to '%s'"), filename
);
396 rollback_lock_file(&msg_file
);
399 if (append_eol
&& write(msg_fd
, "\n", 1) < 0) {
400 error_errno(_("could not write eol to '%s'"), filename
);
401 rollback_lock_file(&msg_file
);
404 if (commit_lock_file(&msg_file
) < 0)
405 return error(_("failed to finalize '%s'"), filename
);
411 * Reads a file that was presumably written by a shell script, i.e. with an
412 * end-of-line marker that needs to be stripped.
414 * Note that only the last end-of-line marker is stripped, consistent with the
415 * behavior of "$(cat path)" in a shell script.
417 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
419 static int read_oneliner(struct strbuf
*buf
,
420 const char *path
, int skip_if_empty
)
422 int orig_len
= buf
->len
;
424 if (!file_exists(path
))
427 if (strbuf_read_file(buf
, path
, 0) < 0) {
428 warning_errno(_("could not read '%s'"), path
);
432 if (buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\n') {
433 if (--buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\r')
435 buf
->buf
[buf
->len
] = '\0';
438 if (skip_if_empty
&& buf
->len
== orig_len
)
444 static struct tree
*empty_tree(struct repository
*r
)
446 return lookup_tree(r
, the_hash_algo
->empty_tree
);
449 static int error_dirty_index(struct repository
*repo
, struct replay_opts
*opts
)
451 if (repo_read_index_unmerged(repo
))
452 return error_resolve_conflict(_(action_name(opts
)));
454 error(_("your local changes would be overwritten by %s."),
455 _(action_name(opts
)));
457 if (advice_commit_before_merge
)
458 advise(_("commit your changes or stash them to proceed."));
462 static void update_abort_safety_file(void)
464 struct object_id head
;
466 /* Do nothing on a single-pick */
467 if (!file_exists(git_path_seq_dir()))
470 if (!get_oid("HEAD", &head
))
471 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head
));
473 write_file(git_path_abort_safety_file(), "%s", "");
476 static int fast_forward_to(struct repository
*r
,
477 const struct object_id
*to
,
478 const struct object_id
*from
,
480 struct replay_opts
*opts
)
482 struct ref_transaction
*transaction
;
483 struct strbuf sb
= STRBUF_INIT
;
484 struct strbuf err
= STRBUF_INIT
;
487 if (checkout_fast_forward(r
, from
, to
, 1))
488 return -1; /* the callee should have complained already */
490 strbuf_addf(&sb
, _("%s: fast-forward"), _(action_name(opts
)));
492 transaction
= ref_transaction_begin(&err
);
494 ref_transaction_update(transaction
, "HEAD",
495 to
, unborn
&& !is_rebase_i(opts
) ?
498 ref_transaction_commit(transaction
, &err
)) {
499 ref_transaction_free(transaction
);
500 error("%s", err
.buf
);
502 strbuf_release(&err
);
507 strbuf_release(&err
);
508 ref_transaction_free(transaction
);
509 update_abort_safety_file();
513 void append_conflicts_hint(struct index_state
*istate
,
514 struct strbuf
*msgbuf
)
518 strbuf_addch(msgbuf
, '\n');
519 strbuf_commented_addf(msgbuf
, "Conflicts:\n");
520 for (i
= 0; i
< istate
->cache_nr
;) {
521 const struct cache_entry
*ce
= istate
->cache
[i
++];
523 strbuf_commented_addf(msgbuf
, "\t%s\n", ce
->name
);
524 while (i
< istate
->cache_nr
&&
525 !strcmp(ce
->name
, istate
->cache
[i
]->name
))
531 static int do_recursive_merge(struct repository
*r
,
532 struct commit
*base
, struct commit
*next
,
533 const char *base_label
, const char *next_label
,
534 struct object_id
*head
, struct strbuf
*msgbuf
,
535 struct replay_opts
*opts
)
537 struct merge_options o
;
538 struct tree
*result
, *next_tree
, *base_tree
, *head_tree
;
541 struct lock_file index_lock
= LOCK_INIT
;
543 if (repo_hold_locked_index(r
, &index_lock
, LOCK_REPORT_ON_ERROR
) < 0)
548 init_merge_options(&o
, r
);
549 o
.ancestor
= base
? base_label
: "(empty tree)";
551 o
.branch2
= next
? next_label
: "(empty tree)";
552 if (is_rebase_i(opts
))
554 o
.show_rename_progress
= 1;
556 head_tree
= parse_tree_indirect(head
);
557 next_tree
= next
? get_commit_tree(next
) : empty_tree(r
);
558 base_tree
= base
? get_commit_tree(base
) : empty_tree(r
);
560 for (xopt
= opts
->xopts
; xopt
!= opts
->xopts
+ opts
->xopts_nr
; xopt
++)
561 parse_merge_opt(&o
, *xopt
);
563 clean
= merge_trees(&o
,
565 next_tree
, base_tree
, &result
);
566 if (is_rebase_i(opts
) && clean
<= 0)
567 fputs(o
.obuf
.buf
, stdout
);
568 strbuf_release(&o
.obuf
);
569 diff_warn_rename_limit("merge.renamelimit", o
.needed_rename_limit
, 0);
571 rollback_lock_file(&index_lock
);
575 if (write_locked_index(r
->index
, &index_lock
,
576 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
578 * TRANSLATORS: %s will be "revert", "cherry-pick" or
581 return error(_("%s: Unable to write new index file"),
582 _(action_name(opts
)));
585 append_conflicts_hint(r
->index
, msgbuf
);
590 static struct object_id
*get_cache_tree_oid(struct index_state
*istate
)
592 if (!istate
->cache_tree
)
593 istate
->cache_tree
= cache_tree();
595 if (!cache_tree_fully_valid(istate
->cache_tree
))
596 if (cache_tree_update(istate
, 0)) {
597 error(_("unable to update cache tree"));
601 return &istate
->cache_tree
->oid
;
604 static int is_index_unchanged(struct repository
*r
)
606 struct object_id head_oid
, *cache_tree_oid
;
607 struct commit
*head_commit
;
608 struct index_state
*istate
= r
->index
;
610 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
611 return error(_("could not resolve HEAD commit"));
613 head_commit
= lookup_commit(r
, &head_oid
);
616 * If head_commit is NULL, check_commit, called from
617 * lookup_commit, would have indicated that head_commit is not
618 * a commit object already. parse_commit() will return failure
619 * without further complaints in such a case. Otherwise, if
620 * the commit is invalid, parse_commit() will complain. So
621 * there is nothing for us to say here. Just return failure.
623 if (parse_commit(head_commit
))
626 if (!(cache_tree_oid
= get_cache_tree_oid(istate
)))
629 return oideq(cache_tree_oid
, get_commit_tree_oid(head_commit
));
632 static int write_author_script(const char *message
)
634 struct strbuf buf
= STRBUF_INIT
;
639 if (!*message
|| starts_with(message
, "\n")) {
641 /* Missing 'author' line? */
642 unlink(rebase_path_author_script());
644 } else if (skip_prefix(message
, "author ", &message
))
646 else if ((eol
= strchr(message
, '\n')))
651 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
652 while (*message
&& *message
!= '\n' && *message
!= '\r')
653 if (skip_prefix(message
, " <", &message
))
655 else if (*message
!= '\'')
656 strbuf_addch(&buf
, *(message
++));
658 strbuf_addf(&buf
, "'\\%c'", *(message
++));
659 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
660 while (*message
&& *message
!= '\n' && *message
!= '\r')
661 if (skip_prefix(message
, "> ", &message
))
663 else if (*message
!= '\'')
664 strbuf_addch(&buf
, *(message
++));
666 strbuf_addf(&buf
, "'\\%c'", *(message
++));
667 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
668 while (*message
&& *message
!= '\n' && *message
!= '\r')
669 if (*message
!= '\'')
670 strbuf_addch(&buf
, *(message
++));
672 strbuf_addf(&buf
, "'\\%c'", *(message
++));
673 strbuf_addch(&buf
, '\'');
674 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
675 strbuf_release(&buf
);
680 * Take a series of KEY='VALUE' lines where VALUE part is
681 * sq-quoted, and append <KEY, VALUE> at the end of the string list
683 static int parse_key_value_squoted(char *buf
, struct string_list
*list
)
686 struct string_list_item
*item
;
688 char *cp
= strchr(buf
, '=');
690 np
= strchrnul(buf
, '\n');
691 return error(_("no key present in '%.*s'"),
692 (int) (np
- buf
), buf
);
694 np
= strchrnul(cp
, '\n');
696 item
= string_list_append(list
, buf
);
698 buf
= np
+ (*np
== '\n');
702 return error(_("unable to dequote value of '%s'"),
704 item
->util
= xstrdup(cp
);
710 * Reads and parses the state directory's "author-script" file, and sets name,
711 * email and date accordingly.
712 * Returns 0 on success, -1 if the file could not be parsed.
714 * The author script is of the format:
716 * GIT_AUTHOR_NAME='$author_name'
717 * GIT_AUTHOR_EMAIL='$author_email'
718 * GIT_AUTHOR_DATE='$author_date'
720 * where $author_name, $author_email and $author_date are quoted. We are strict
721 * with our parsing, as the file was meant to be eval'd in the old
722 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
723 * from what this function expects, it is better to bail out than to do
724 * something that the user does not expect.
726 int read_author_script(const char *path
, char **name
, char **email
, char **date
,
729 struct strbuf buf
= STRBUF_INIT
;
730 struct string_list kv
= STRING_LIST_INIT_DUP
;
731 int retval
= -1; /* assume failure */
732 int i
, name_i
= -2, email_i
= -2, date_i
= -2, err
= 0;
734 if (strbuf_read_file(&buf
, path
, 256) <= 0) {
735 strbuf_release(&buf
);
736 if (errno
== ENOENT
&& allow_missing
)
739 return error_errno(_("could not open '%s' for reading"),
743 if (parse_key_value_squoted(buf
.buf
, &kv
))
746 for (i
= 0; i
< kv
.nr
; i
++) {
747 if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_NAME")) {
749 name_i
= error(_("'GIT_AUTHOR_NAME' already given"));
752 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_EMAIL")) {
754 email_i
= error(_("'GIT_AUTHOR_EMAIL' already given"));
757 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_DATE")) {
759 date_i
= error(_("'GIT_AUTHOR_DATE' already given"));
763 err
= error(_("unknown variable '%s'"),
768 error(_("missing 'GIT_AUTHOR_NAME'"));
770 error(_("missing 'GIT_AUTHOR_EMAIL'"));
772 error(_("missing 'GIT_AUTHOR_DATE'"));
773 if (date_i
< 0 || email_i
< 0 || date_i
< 0 || err
)
775 *name
= kv
.items
[name_i
].util
;
776 *email
= kv
.items
[email_i
].util
;
777 *date
= kv
.items
[date_i
].util
;
780 string_list_clear(&kv
, !!retval
);
781 strbuf_release(&buf
);
786 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
787 * file with shell quoting into struct argv_array. Returns -1 on
788 * error, 0 otherwise.
790 static int read_env_script(struct argv_array
*env
)
792 char *name
, *email
, *date
;
794 if (read_author_script(rebase_path_author_script(),
795 &name
, &email
, &date
, 0))
798 argv_array_pushf(env
, "GIT_AUTHOR_NAME=%s", name
);
799 argv_array_pushf(env
, "GIT_AUTHOR_EMAIL=%s", email
);
800 argv_array_pushf(env
, "GIT_AUTHOR_DATE=%s", date
);
808 static char *get_author(const char *message
)
813 a
= find_commit_header(message
, "author", &len
);
815 return xmemdupz(a
, len
);
820 /* Read author-script and return an ident line (author <email> timestamp) */
821 static const char *read_author_ident(struct strbuf
*buf
)
823 struct strbuf out
= STRBUF_INIT
;
824 char *name
, *email
, *date
;
826 if (read_author_script(rebase_path_author_script(),
827 &name
, &email
, &date
, 0))
830 /* validate date since fmt_ident() will die() on bad value */
831 if (parse_date(date
, &out
)){
832 warning(_("invalid date format '%s' in '%s'"),
833 date
, rebase_path_author_script());
834 strbuf_release(&out
);
839 strbuf_addstr(&out
, fmt_ident(name
, email
, WANT_AUTHOR_IDENT
, date
, 0));
840 strbuf_swap(buf
, &out
);
841 strbuf_release(&out
);
848 static const char staged_changes_advice
[] =
849 N_("you have staged changes in your working tree\n"
850 "If these changes are meant to be squashed into the previous commit, run:\n"
852 " git commit --amend %s\n"
854 "If they are meant to go into a new commit, run:\n"
858 "In both cases, once you're done, continue with:\n"
860 " git rebase --continue\n");
862 #define ALLOW_EMPTY (1<<0)
863 #define EDIT_MSG (1<<1)
864 #define AMEND_MSG (1<<2)
865 #define CLEANUP_MSG (1<<3)
866 #define VERIFY_MSG (1<<4)
867 #define CREATE_ROOT_COMMIT (1<<5)
869 static int run_command_silent_on_success(struct child_process
*cmd
)
871 struct strbuf buf
= STRBUF_INIT
;
874 cmd
->stdout_to_stderr
= 1;
875 rc
= pipe_command(cmd
,
881 fputs(buf
.buf
, stderr
);
882 strbuf_release(&buf
);
887 * If we are cherry-pick, and if the merge did not result in
888 * hand-editing, we will hit this commit and inherit the original
889 * author date and name.
891 * If we are revert, or if our cherry-pick results in a hand merge,
892 * we had better say that the current user is responsible for that.
894 * An exception is when run_git_commit() is called during an
895 * interactive rebase: in that case, we will want to retain the
898 static int run_git_commit(struct repository
*r
,
900 struct replay_opts
*opts
,
903 struct child_process cmd
= CHILD_PROCESS_INIT
;
906 if ((flags
& CREATE_ROOT_COMMIT
) && !(flags
& AMEND_MSG
)) {
907 struct strbuf msg
= STRBUF_INIT
, script
= STRBUF_INIT
;
908 const char *author
= NULL
;
909 struct object_id root_commit
, *cache_tree_oid
;
912 if (is_rebase_i(opts
)) {
913 author
= read_author_ident(&script
);
915 strbuf_release(&script
);
921 BUG("root commit without message");
923 if (!(cache_tree_oid
= get_cache_tree_oid(r
->index
)))
927 res
= strbuf_read_file(&msg
, defmsg
, 0);
930 res
= error_errno(_("could not read '%s'"), defmsg
);
932 res
= commit_tree(msg
.buf
, msg
.len
, cache_tree_oid
,
933 NULL
, &root_commit
, author
,
936 strbuf_release(&msg
);
937 strbuf_release(&script
);
939 update_ref(NULL
, "CHERRY_PICK_HEAD", &root_commit
, NULL
,
940 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
);
941 res
= update_ref(NULL
, "HEAD", &root_commit
, NULL
, 0,
942 UPDATE_REFS_MSG_ON_ERR
);
944 return res
< 0 ? error(_("writing root commit")) : 0;
949 if (is_rebase_i(opts
) && read_env_script(&cmd
.env_array
)) {
950 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
952 return error(_(staged_changes_advice
),
956 argv_array_push(&cmd
.args
, "commit");
958 if (!(flags
& VERIFY_MSG
))
959 argv_array_push(&cmd
.args
, "-n");
960 if ((flags
& AMEND_MSG
))
961 argv_array_push(&cmd
.args
, "--amend");
963 argv_array_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
965 argv_array_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
966 else if (!(flags
& EDIT_MSG
))
967 argv_array_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
968 if ((flags
& CLEANUP_MSG
))
969 argv_array_push(&cmd
.args
, "--cleanup=strip");
970 if ((flags
& EDIT_MSG
))
971 argv_array_push(&cmd
.args
, "-e");
972 else if (!(flags
& CLEANUP_MSG
) &&
973 !opts
->signoff
&& !opts
->record_origin
&&
974 git_config_get_value("commit.cleanup", &value
))
975 argv_array_push(&cmd
.args
, "--cleanup=verbatim");
977 if ((flags
& ALLOW_EMPTY
))
978 argv_array_push(&cmd
.args
, "--allow-empty");
980 if (!(flags
& EDIT_MSG
))
981 argv_array_push(&cmd
.args
, "--allow-empty-message");
983 if (is_rebase_i(opts
) && !(flags
& EDIT_MSG
))
984 return run_command_silent_on_success(&cmd
);
986 return run_command(&cmd
);
989 static int rest_is_empty(const struct strbuf
*sb
, int start
)
994 /* Check if the rest is just whitespace and Signed-off-by's. */
995 for (i
= start
; i
< sb
->len
; i
++) {
996 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1002 if (strlen(sign_off_header
) <= eol
- i
&&
1003 starts_with(sb
->buf
+ i
, sign_off_header
)) {
1008 if (!isspace(sb
->buf
[i
++]))
1016 * Find out if the message in the strbuf contains only whitespace and
1017 * Signed-off-by lines.
1019 int message_is_empty(const struct strbuf
*sb
,
1020 enum commit_msg_cleanup_mode cleanup_mode
)
1022 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1024 return rest_is_empty(sb
, 0);
1028 * See if the user edited the message in the editor or left what
1029 * was in the template intact
1031 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
1032 enum commit_msg_cleanup_mode cleanup_mode
)
1034 struct strbuf tmpl
= STRBUF_INIT
;
1037 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1040 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
1043 strbuf_stripspace(&tmpl
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1044 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
1046 strbuf_release(&tmpl
);
1047 return rest_is_empty(sb
, start
- sb
->buf
);
1050 int update_head_with_reflog(const struct commit
*old_head
,
1051 const struct object_id
*new_head
,
1052 const char *action
, const struct strbuf
*msg
,
1055 struct ref_transaction
*transaction
;
1056 struct strbuf sb
= STRBUF_INIT
;
1061 strbuf_addstr(&sb
, action
);
1062 strbuf_addstr(&sb
, ": ");
1065 nl
= strchr(msg
->buf
, '\n');
1067 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
1069 strbuf_addbuf(&sb
, msg
);
1070 strbuf_addch(&sb
, '\n');
1073 transaction
= ref_transaction_begin(err
);
1075 ref_transaction_update(transaction
, "HEAD", new_head
,
1076 old_head
? &old_head
->object
.oid
: &null_oid
,
1078 ref_transaction_commit(transaction
, err
)) {
1081 ref_transaction_free(transaction
);
1082 strbuf_release(&sb
);
1087 static int run_rewrite_hook(const struct object_id
*oldoid
,
1088 const struct object_id
*newoid
)
1090 struct child_process proc
= CHILD_PROCESS_INIT
;
1091 const char *argv
[3];
1093 struct strbuf sb
= STRBUF_INIT
;
1095 argv
[0] = find_hook("post-rewrite");
1104 proc
.stdout_to_stderr
= 1;
1105 proc
.trace2_hook_name
= "post-rewrite";
1107 code
= start_command(&proc
);
1110 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
1111 sigchain_push(SIGPIPE
, SIG_IGN
);
1112 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
1114 strbuf_release(&sb
);
1115 sigchain_pop(SIGPIPE
);
1116 return finish_command(&proc
);
1119 void commit_post_rewrite(struct repository
*r
,
1120 const struct commit
*old_head
,
1121 const struct object_id
*new_head
)
1123 struct notes_rewrite_cfg
*cfg
;
1125 cfg
= init_copy_notes_for_rewrite("amend");
1127 /* we are amending, so old_head is not NULL */
1128 copy_note_for_rewrite(cfg
, &old_head
->object
.oid
, new_head
);
1129 finish_copy_notes_for_rewrite(r
, cfg
, "Notes added by 'git commit --amend'");
1131 run_rewrite_hook(&old_head
->object
.oid
, new_head
);
1134 static int run_prepare_commit_msg_hook(struct repository
*r
,
1138 struct argv_array hook_env
= ARGV_ARRAY_INIT
;
1142 name
= git_path_commit_editmsg();
1143 if (write_message(msg
->buf
, msg
->len
, name
, 0))
1146 argv_array_pushf(&hook_env
, "GIT_INDEX_FILE=%s", r
->index_file
);
1147 argv_array_push(&hook_env
, "GIT_EDITOR=:");
1149 ret
= run_hook_le(hook_env
.argv
, "prepare-commit-msg", name
,
1150 "commit", commit
, NULL
);
1152 ret
= run_hook_le(hook_env
.argv
, "prepare-commit-msg", name
,
1155 ret
= error(_("'prepare-commit-msg' hook failed"));
1156 argv_array_clear(&hook_env
);
1161 static const char implicit_ident_advice_noconfig
[] =
1162 N_("Your name and email address were configured automatically based\n"
1163 "on your username and hostname. Please check that they are accurate.\n"
1164 "You can suppress this message by setting them explicitly. Run the\n"
1165 "following command and follow the instructions in your editor to edit\n"
1166 "your configuration file:\n"
1168 " git config --global --edit\n"
1170 "After doing this, you may fix the identity used for this commit with:\n"
1172 " git commit --amend --reset-author\n");
1174 static const char implicit_ident_advice_config
[] =
1175 N_("Your name and email address were configured automatically based\n"
1176 "on your username and hostname. Please check that they are accurate.\n"
1177 "You can suppress this message by setting them explicitly:\n"
1179 " git config --global user.name \"Your Name\"\n"
1180 " git config --global user.email you@example.com\n"
1182 "After doing this, you may fix the identity used for this commit with:\n"
1184 " git commit --amend --reset-author\n");
1186 static const char *implicit_ident_advice(void)
1188 char *user_config
= expand_user_path("~/.gitconfig", 0);
1189 char *xdg_config
= xdg_config_home("config");
1190 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1196 return _(implicit_ident_advice_config
);
1198 return _(implicit_ident_advice_noconfig
);
1202 void print_commit_summary(struct repository
*r
,
1204 const struct object_id
*oid
,
1207 struct rev_info rev
;
1208 struct commit
*commit
;
1209 struct strbuf format
= STRBUF_INIT
;
1211 struct pretty_print_context pctx
= {0};
1212 struct strbuf author_ident
= STRBUF_INIT
;
1213 struct strbuf committer_ident
= STRBUF_INIT
;
1215 commit
= lookup_commit(r
, oid
);
1217 die(_("couldn't look up newly created commit"));
1218 if (parse_commit(commit
))
1219 die(_("could not parse newly created commit"));
1221 strbuf_addstr(&format
, "format:%h] %s");
1223 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1224 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1225 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1226 strbuf_addstr(&format
, "\n Author: ");
1227 strbuf_addbuf_percentquote(&format
, &author_ident
);
1229 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
1230 struct strbuf date
= STRBUF_INIT
;
1232 format_commit_message(commit
, "%ad", &date
, &pctx
);
1233 strbuf_addstr(&format
, "\n Date: ");
1234 strbuf_addbuf_percentquote(&format
, &date
);
1235 strbuf_release(&date
);
1237 if (!committer_ident_sufficiently_given()) {
1238 strbuf_addstr(&format
, "\n Committer: ");
1239 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1240 if (advice_implicit_identity
) {
1241 strbuf_addch(&format
, '\n');
1242 strbuf_addstr(&format
, implicit_ident_advice());
1245 strbuf_release(&author_ident
);
1246 strbuf_release(&committer_ident
);
1248 repo_init_revisions(r
, &rev
, prefix
);
1249 setup_revisions(0, NULL
, &rev
, NULL
);
1252 rev
.diffopt
.output_format
=
1253 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1255 rev
.verbose_header
= 1;
1256 rev
.show_root_diff
= 1;
1257 get_commit_format(format
.buf
, &rev
);
1258 rev
.always_show_header
= 0;
1259 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1260 rev
.diffopt
.break_opt
= 0;
1261 diff_setup_done(&rev
.diffopt
);
1263 head
= resolve_ref_unsafe("HEAD", 0, NULL
, NULL
);
1265 die_errno(_("unable to resolve HEAD after creating commit"));
1266 if (!strcmp(head
, "HEAD"))
1267 head
= _("detached HEAD");
1269 skip_prefix(head
, "refs/heads/", &head
);
1270 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1271 _(" (root-commit)") : "");
1273 if (!log_tree_commit(&rev
, commit
)) {
1274 rev
.always_show_header
= 1;
1275 rev
.use_terminator
= 1;
1276 log_tree_commit(&rev
, commit
);
1279 strbuf_release(&format
);
1282 static int parse_head(struct repository
*r
, struct commit
**head
)
1284 struct commit
*current_head
;
1285 struct object_id oid
;
1287 if (get_oid("HEAD", &oid
)) {
1288 current_head
= NULL
;
1290 current_head
= lookup_commit_reference(r
, &oid
);
1292 return error(_("could not parse HEAD"));
1293 if (!oideq(&oid
, ¤t_head
->object
.oid
)) {
1294 warning(_("HEAD %s is not a commit!"),
1297 if (parse_commit(current_head
))
1298 return error(_("could not parse HEAD commit"));
1300 *head
= current_head
;
1306 * Try to commit without forking 'git commit'. In some cases we need
1307 * to run 'git commit' to display an error message
1310 * -1 - error unable to commit
1312 * 1 - run 'git commit'
1314 static int try_to_commit(struct repository
*r
,
1315 struct strbuf
*msg
, const char *author
,
1316 struct replay_opts
*opts
, unsigned int flags
,
1317 struct object_id
*oid
)
1319 struct object_id tree
;
1320 struct commit
*current_head
;
1321 struct commit_list
*parents
= NULL
;
1322 struct commit_extra_header
*extra
= NULL
;
1323 struct strbuf err
= STRBUF_INIT
;
1324 struct strbuf commit_msg
= STRBUF_INIT
;
1325 char *amend_author
= NULL
;
1326 const char *hook_commit
= NULL
;
1327 enum commit_msg_cleanup_mode cleanup
;
1330 if (parse_head(r
, ¤t_head
))
1333 if (flags
& AMEND_MSG
) {
1334 const char *exclude_gpgsig
[] = { "gpgsig", NULL
};
1335 const char *out_enc
= get_commit_output_encoding();
1336 const char *message
= logmsg_reencode(current_head
, NULL
,
1340 const char *orig_message
= NULL
;
1342 find_commit_subject(message
, &orig_message
);
1344 strbuf_addstr(msg
, orig_message
);
1345 hook_commit
= "HEAD";
1347 author
= amend_author
= get_author(message
);
1348 unuse_commit_buffer(current_head
, message
);
1350 res
= error(_("unable to parse commit author"));
1353 parents
= copy_commit_list(current_head
->parents
);
1354 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1355 } else if (current_head
) {
1356 commit_list_insert(current_head
, &parents
);
1359 if (write_index_as_tree(&tree
, r
->index
, r
->index_file
, 0, NULL
)) {
1360 res
= error(_("git write-tree failed to write a tree"));
1364 if (!(flags
& ALLOW_EMPTY
) && oideq(current_head
?
1365 get_commit_tree_oid(current_head
) :
1366 the_hash_algo
->empty_tree
, &tree
)) {
1367 res
= 1; /* run 'git commit' to display error message */
1371 if (find_hook("prepare-commit-msg")) {
1372 res
= run_prepare_commit_msg_hook(r
, msg
, hook_commit
);
1375 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1377 res
= error_errno(_("unable to read commit message "
1379 git_path_commit_editmsg());
1385 cleanup
= (flags
& CLEANUP_MSG
) ? COMMIT_MSG_CLEANUP_ALL
:
1386 opts
->default_msg_cleanup
;
1388 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1389 strbuf_stripspace(msg
, cleanup
== COMMIT_MSG_CLEANUP_ALL
);
1390 if ((flags
& EDIT_MSG
) && message_is_empty(msg
, cleanup
)) {
1391 res
= 1; /* run 'git commit' to display error message */
1397 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
,
1398 oid
, author
, opts
->gpg_sign
, extra
)) {
1399 res
= error(_("failed to write commit object"));
1403 if (update_head_with_reflog(current_head
, oid
,
1404 getenv("GIT_REFLOG_ACTION"), msg
, &err
)) {
1405 res
= error("%s", err
.buf
);
1409 if (flags
& AMEND_MSG
)
1410 commit_post_rewrite(r
, current_head
, oid
);
1413 free_commit_extra_headers(extra
);
1414 strbuf_release(&err
);
1415 strbuf_release(&commit_msg
);
1421 static int do_commit(struct repository
*r
,
1422 const char *msg_file
, const char *author
,
1423 struct replay_opts
*opts
, unsigned int flags
)
1427 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
) &&
1428 !(flags
& CREATE_ROOT_COMMIT
)) {
1429 struct object_id oid
;
1430 struct strbuf sb
= STRBUF_INIT
;
1432 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1433 return error_errno(_("unable to read commit message "
1437 res
= try_to_commit(r
, msg_file
? &sb
: NULL
,
1438 author
, opts
, flags
, &oid
);
1439 strbuf_release(&sb
);
1441 unlink(git_path_cherry_pick_head(r
));
1442 unlink(git_path_merge_msg(r
));
1443 if (!is_rebase_i(opts
))
1444 print_commit_summary(r
, NULL
, &oid
,
1445 SUMMARY_SHOW_AUTHOR_DATE
);
1450 return run_git_commit(r
, msg_file
, opts
, flags
);
1455 static int is_original_commit_empty(struct commit
*commit
)
1457 const struct object_id
*ptree_oid
;
1459 if (parse_commit(commit
))
1460 return error(_("could not parse commit %s"),
1461 oid_to_hex(&commit
->object
.oid
));
1462 if (commit
->parents
) {
1463 struct commit
*parent
= commit
->parents
->item
;
1464 if (parse_commit(parent
))
1465 return error(_("could not parse parent commit %s"),
1466 oid_to_hex(&parent
->object
.oid
));
1467 ptree_oid
= get_commit_tree_oid(parent
);
1469 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1472 return oideq(ptree_oid
, get_commit_tree_oid(commit
));
1476 * Do we run "git commit" with "--allow-empty"?
1478 static int allow_empty(struct repository
*r
,
1479 struct replay_opts
*opts
,
1480 struct commit
*commit
)
1482 int index_unchanged
, empty_commit
;
1487 * (1) we do not allow empty at all and error out.
1489 * (2) we allow ones that were initially empty, but
1490 * forbid the ones that become empty;
1492 * (3) we allow both.
1494 if (!opts
->allow_empty
)
1495 return 0; /* let "git commit" barf as necessary */
1497 index_unchanged
= is_index_unchanged(r
);
1498 if (index_unchanged
< 0)
1499 return index_unchanged
;
1500 if (!index_unchanged
)
1501 return 0; /* we do not have to say --allow-empty */
1503 if (opts
->keep_redundant_commits
)
1506 empty_commit
= is_original_commit_empty(commit
);
1507 if (empty_commit
< 0)
1508 return empty_commit
;
1518 } todo_command_info
[] = {
1535 static const char *command_to_string(const enum todo_command command
)
1537 if (command
< TODO_COMMENT
)
1538 return todo_command_info
[command
].str
;
1539 die(_("unknown command: %d"), command
);
1542 static char command_to_char(const enum todo_command command
)
1544 if (command
< TODO_COMMENT
&& todo_command_info
[command
].c
)
1545 return todo_command_info
[command
].c
;
1546 return comment_line_char
;
1549 static int is_noop(const enum todo_command command
)
1551 return TODO_NOOP
<= command
;
1554 static int is_fixup(enum todo_command command
)
1556 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1559 /* Does this command create a (non-merge) commit? */
1560 static int is_pick_or_similar(enum todo_command command
)
1575 static int update_squash_messages(struct repository
*r
,
1576 enum todo_command command
,
1577 struct commit
*commit
,
1578 struct replay_opts
*opts
)
1580 struct strbuf buf
= STRBUF_INIT
;
1582 const char *message
, *body
;
1584 if (opts
->current_fixup_count
> 0) {
1585 struct strbuf header
= STRBUF_INIT
;
1588 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
1589 return error(_("could not read '%s'"),
1590 rebase_path_squash_msg());
1592 eol
= buf
.buf
[0] != comment_line_char
?
1593 buf
.buf
: strchrnul(buf
.buf
, '\n');
1595 strbuf_addf(&header
, "%c ", comment_line_char
);
1596 strbuf_addf(&header
, _("This is a combination of %d commits."),
1597 opts
->current_fixup_count
+ 2);
1598 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
1599 strbuf_release(&header
);
1601 struct object_id head
;
1602 struct commit
*head_commit
;
1603 const char *head_message
, *body
;
1605 if (get_oid("HEAD", &head
))
1606 return error(_("need a HEAD to fixup"));
1607 if (!(head_commit
= lookup_commit_reference(r
, &head
)))
1608 return error(_("could not read HEAD"));
1609 if (!(head_message
= get_commit_buffer(head_commit
, NULL
)))
1610 return error(_("could not read HEAD's commit message"));
1612 find_commit_subject(head_message
, &body
);
1613 if (write_message(body
, strlen(body
),
1614 rebase_path_fixup_msg(), 0)) {
1615 unuse_commit_buffer(head_commit
, head_message
);
1616 return error(_("cannot write '%s'"),
1617 rebase_path_fixup_msg());
1620 strbuf_addf(&buf
, "%c ", comment_line_char
);
1621 strbuf_addf(&buf
, _("This is a combination of %d commits."), 2);
1622 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1623 strbuf_addstr(&buf
, _("This is the 1st commit message:"));
1624 strbuf_addstr(&buf
, "\n\n");
1625 strbuf_addstr(&buf
, body
);
1627 unuse_commit_buffer(head_commit
, head_message
);
1630 if (!(message
= get_commit_buffer(commit
, NULL
)))
1631 return error(_("could not read commit message of %s"),
1632 oid_to_hex(&commit
->object
.oid
));
1633 find_commit_subject(message
, &body
);
1635 if (command
== TODO_SQUASH
) {
1636 unlink(rebase_path_fixup_msg());
1637 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1638 strbuf_addf(&buf
, _("This is the commit message #%d:"),
1639 ++opts
->current_fixup_count
+ 1);
1640 strbuf_addstr(&buf
, "\n\n");
1641 strbuf_addstr(&buf
, body
);
1642 } else if (command
== TODO_FIXUP
) {
1643 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1644 strbuf_addf(&buf
, _("The commit message #%d will be skipped:"),
1645 ++opts
->current_fixup_count
+ 1);
1646 strbuf_addstr(&buf
, "\n\n");
1647 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
1649 return error(_("unknown command: %d"), command
);
1650 unuse_commit_buffer(commit
, message
);
1652 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(), 0);
1653 strbuf_release(&buf
);
1656 strbuf_addf(&opts
->current_fixups
, "%s%s %s",
1657 opts
->current_fixups
.len
? "\n" : "",
1658 command_to_string(command
),
1659 oid_to_hex(&commit
->object
.oid
));
1660 res
= write_message(opts
->current_fixups
.buf
,
1661 opts
->current_fixups
.len
,
1662 rebase_path_current_fixups(), 0);
1668 static void flush_rewritten_pending(void)
1670 struct strbuf buf
= STRBUF_INIT
;
1671 struct object_id newoid
;
1674 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
1675 !get_oid("HEAD", &newoid
) &&
1676 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1677 char *bol
= buf
.buf
, *eol
;
1680 eol
= strchrnul(bol
, '\n');
1681 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
1682 bol
, oid_to_hex(&newoid
));
1688 unlink(rebase_path_rewritten_pending());
1690 strbuf_release(&buf
);
1693 static void record_in_rewritten(struct object_id
*oid
,
1694 enum todo_command next_command
)
1696 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
1701 fprintf(out
, "%s\n", oid_to_hex(oid
));
1704 if (!is_fixup(next_command
))
1705 flush_rewritten_pending();
1708 static int do_pick_commit(struct repository
*r
,
1709 enum todo_command command
,
1710 struct commit
*commit
,
1711 struct replay_opts
*opts
,
1714 unsigned int flags
= opts
->edit
? EDIT_MSG
: 0;
1715 const char *msg_file
= opts
->edit
? NULL
: git_path_merge_msg(r
);
1716 struct object_id head
;
1717 struct commit
*base
, *next
, *parent
;
1718 const char *base_label
, *next_label
;
1719 char *author
= NULL
;
1720 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
1721 struct strbuf msgbuf
= STRBUF_INIT
;
1722 int res
, unborn
= 0, allow
;
1724 if (opts
->no_commit
) {
1726 * We do not intend to commit immediately. We just want to
1727 * merge the differences in, so let's compute the tree
1728 * that represents the "current" state for merge-recursive
1731 if (write_index_as_tree(&head
, r
->index
, r
->index_file
, 0, NULL
))
1732 return error(_("your index file is unmerged."));
1734 unborn
= get_oid("HEAD", &head
);
1735 /* Do we want to generate a root commit? */
1736 if (is_pick_or_similar(command
) && opts
->have_squash_onto
&&
1737 oideq(&head
, &opts
->squash_onto
)) {
1738 if (is_fixup(command
))
1739 return error(_("cannot fixup root commit"));
1740 flags
|= CREATE_ROOT_COMMIT
;
1743 oidcpy(&head
, the_hash_algo
->empty_tree
);
1744 if (index_differs_from(r
, unborn
? empty_tree_oid_hex() : "HEAD",
1746 return error_dirty_index(r
, opts
);
1748 discard_index(r
->index
);
1750 if (!commit
->parents
)
1752 else if (commit
->parents
->next
) {
1753 /* Reverting or cherry-picking a merge commit */
1755 struct commit_list
*p
;
1757 if (!opts
->mainline
)
1758 return error(_("commit %s is a merge but no -m option was given."),
1759 oid_to_hex(&commit
->object
.oid
));
1761 for (cnt
= 1, p
= commit
->parents
;
1762 cnt
!= opts
->mainline
&& p
;
1765 if (cnt
!= opts
->mainline
|| !p
)
1766 return error(_("commit %s does not have parent %d"),
1767 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
1769 } else if (1 < opts
->mainline
)
1771 * Non-first parent explicitly specified as mainline for
1774 return error(_("commit %s does not have parent %d"),
1775 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
1777 parent
= commit
->parents
->item
;
1779 if (get_message(commit
, &msg
) != 0)
1780 return error(_("cannot get commit message for %s"),
1781 oid_to_hex(&commit
->object
.oid
));
1783 if (opts
->allow_ff
&& !is_fixup(command
) &&
1784 ((parent
&& oideq(&parent
->object
.oid
, &head
)) ||
1785 (!parent
&& unborn
))) {
1786 if (is_rebase_i(opts
))
1787 write_author_script(msg
.message
);
1788 res
= fast_forward_to(r
, &commit
->object
.oid
, &head
, unborn
,
1790 if (res
|| command
!= TODO_REWORD
)
1792 flags
|= EDIT_MSG
| AMEND_MSG
| VERIFY_MSG
;
1794 goto fast_forward_edit
;
1796 if (parent
&& parse_commit(parent
) < 0)
1797 /* TRANSLATORS: The first %s will be a "todo" command like
1798 "revert" or "pick", the second %s a SHA1. */
1799 return error(_("%s: cannot parse parent commit %s"),
1800 command_to_string(command
),
1801 oid_to_hex(&parent
->object
.oid
));
1804 * "commit" is an existing commit. We would want to apply
1805 * the difference it introduces since its first parent "prev"
1806 * on top of the current HEAD if we are cherry-pick. Or the
1807 * reverse of it if we are revert.
1810 if (command
== TODO_REVERT
) {
1812 base_label
= msg
.label
;
1814 next_label
= msg
.parent_label
;
1815 strbuf_addstr(&msgbuf
, "Revert \"");
1816 strbuf_addstr(&msgbuf
, msg
.subject
);
1817 strbuf_addstr(&msgbuf
, "\"\n\nThis reverts commit ");
1818 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
1820 if (commit
->parents
&& commit
->parents
->next
) {
1821 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
1822 strbuf_addstr(&msgbuf
, oid_to_hex(&parent
->object
.oid
));
1824 strbuf_addstr(&msgbuf
, ".\n");
1829 base_label
= msg
.parent_label
;
1831 next_label
= msg
.label
;
1833 /* Append the commit log message to msgbuf. */
1834 if (find_commit_subject(msg
.message
, &p
))
1835 strbuf_addstr(&msgbuf
, p
);
1837 if (opts
->record_origin
) {
1838 strbuf_complete_line(&msgbuf
);
1839 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
1840 strbuf_addch(&msgbuf
, '\n');
1841 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
1842 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
1843 strbuf_addstr(&msgbuf
, ")\n");
1845 if (!is_fixup(command
))
1846 author
= get_author(msg
.message
);
1849 if (command
== TODO_REWORD
)
1850 flags
|= EDIT_MSG
| VERIFY_MSG
;
1851 else if (is_fixup(command
)) {
1852 if (update_squash_messages(r
, command
, commit
, opts
))
1856 msg_file
= rebase_path_squash_msg();
1857 else if (file_exists(rebase_path_fixup_msg())) {
1858 flags
|= CLEANUP_MSG
;
1859 msg_file
= rebase_path_fixup_msg();
1861 const char *dest
= git_path_squash_msg(r
);
1863 if (copy_file(dest
, rebase_path_squash_msg(), 0666))
1864 return error(_("could not rename '%s' to '%s'"),
1865 rebase_path_squash_msg(), dest
);
1866 unlink(git_path_merge_msg(r
));
1872 if (opts
->signoff
&& !is_fixup(command
))
1873 append_signoff(&msgbuf
, 0, 0);
1875 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
1877 else if (!opts
->strategy
|| !strcmp(opts
->strategy
, "recursive") || command
== TODO_REVERT
) {
1878 res
= do_recursive_merge(r
, base
, next
, base_label
, next_label
,
1879 &head
, &msgbuf
, opts
);
1883 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
1884 git_path_merge_msg(r
), 0);
1886 struct commit_list
*common
= NULL
;
1887 struct commit_list
*remotes
= NULL
;
1889 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
1890 git_path_merge_msg(r
), 0);
1892 commit_list_insert(base
, &common
);
1893 commit_list_insert(next
, &remotes
);
1894 res
|= try_merge_command(r
, opts
->strategy
,
1895 opts
->xopts_nr
, (const char **)opts
->xopts
,
1896 common
, oid_to_hex(&head
), remotes
);
1897 free_commit_list(common
);
1898 free_commit_list(remotes
);
1900 strbuf_release(&msgbuf
);
1903 * If the merge was clean or if it failed due to conflict, we write
1904 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1905 * However, if the merge did not even start, then we don't want to
1908 if (command
== TODO_PICK
&& !opts
->no_commit
&& (res
== 0 || res
== 1) &&
1909 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
1910 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1912 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
1913 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
1914 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1918 error(command
== TODO_REVERT
1919 ? _("could not revert %s... %s")
1920 : _("could not apply %s... %s"),
1921 short_commit_name(commit
), msg
.subject
);
1922 print_advice(r
, res
== 1, opts
);
1923 repo_rerere(r
, opts
->allow_rerere_auto
);
1927 allow
= allow_empty(r
, opts
, commit
);
1932 flags
|= ALLOW_EMPTY
;
1933 if (!opts
->no_commit
) {
1935 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
1936 res
= do_commit(r
, msg_file
, author
, opts
, flags
);
1938 res
= error(_("unable to parse commit author"));
1941 if (!res
&& final_fixup
) {
1942 unlink(rebase_path_fixup_msg());
1943 unlink(rebase_path_squash_msg());
1944 unlink(rebase_path_current_fixups());
1945 strbuf_reset(&opts
->current_fixups
);
1946 opts
->current_fixup_count
= 0;
1950 free_message(commit
, &msg
);
1952 update_abort_safety_file();
1957 static int prepare_revs(struct replay_opts
*opts
)
1960 * picking (but not reverting) ranges (but not individual revisions)
1961 * should be done in reverse
1963 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
1964 opts
->revs
->reverse
^= 1;
1966 if (prepare_revision_walk(opts
->revs
))
1967 return error(_("revision walk setup failed"));
1972 static int read_and_refresh_cache(struct repository
*r
,
1973 struct replay_opts
*opts
)
1975 struct lock_file index_lock
= LOCK_INIT
;
1976 int index_fd
= repo_hold_locked_index(r
, &index_lock
, 0);
1977 if (repo_read_index(r
) < 0) {
1978 rollback_lock_file(&index_lock
);
1979 return error(_("git %s: failed to read the index"),
1980 _(action_name(opts
)));
1982 refresh_index(r
->index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
1983 if (index_fd
>= 0) {
1984 if (write_locked_index(r
->index
, &index_lock
,
1985 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
1986 return error(_("git %s: failed to refresh the index"),
1987 _(action_name(opts
)));
1993 enum todo_item_flags
{
1994 TODO_EDIT_MERGE_MSG
= 1
1997 void todo_list_release(struct todo_list
*todo_list
)
1999 strbuf_release(&todo_list
->buf
);
2000 FREE_AND_NULL(todo_list
->items
);
2001 todo_list
->nr
= todo_list
->alloc
= 0;
2004 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
2006 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
2007 return todo_list
->items
+ todo_list
->nr
++;
2010 const char *todo_item_get_arg(struct todo_list
*todo_list
,
2011 struct todo_item
*item
)
2013 return todo_list
->buf
.buf
+ item
->arg_offset
;
2016 static int parse_insn_line(struct repository
*r
, struct todo_item
*item
,
2017 const char *buf
, const char *bol
, char *eol
)
2019 struct object_id commit_oid
;
2020 char *end_of_object_name
;
2021 int i
, saved
, status
, padding
;
2026 bol
+= strspn(bol
, " \t");
2028 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
2029 item
->command
= TODO_COMMENT
;
2030 item
->commit
= NULL
;
2031 item
->arg_offset
= bol
- buf
;
2032 item
->arg_len
= eol
- bol
;
2036 for (i
= 0; i
< TODO_COMMENT
; i
++)
2037 if (skip_prefix(bol
, todo_command_info
[i
].str
, &bol
)) {
2040 } else if ((bol
+ 1 == eol
|| bol
[1] == ' ') &&
2041 *bol
== todo_command_info
[i
].c
) {
2046 if (i
>= TODO_COMMENT
)
2049 /* Eat up extra spaces/ tabs before object name */
2050 padding
= strspn(bol
, " \t");
2053 if (item
->command
== TODO_NOOP
|| item
->command
== TODO_BREAK
) {
2055 return error(_("%s does not accept arguments: '%s'"),
2056 command_to_string(item
->command
), bol
);
2057 item
->commit
= NULL
;
2058 item
->arg_offset
= bol
- buf
;
2059 item
->arg_len
= eol
- bol
;
2064 return error(_("missing arguments for %s"),
2065 command_to_string(item
->command
));
2067 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
2068 item
->command
== TODO_RESET
) {
2069 item
->commit
= NULL
;
2070 item
->arg_offset
= bol
- buf
;
2071 item
->arg_len
= (int)(eol
- bol
);
2075 if (item
->command
== TODO_MERGE
) {
2076 if (skip_prefix(bol
, "-C", &bol
))
2077 bol
+= strspn(bol
, " \t");
2078 else if (skip_prefix(bol
, "-c", &bol
)) {
2079 bol
+= strspn(bol
, " \t");
2080 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2082 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2083 item
->commit
= NULL
;
2084 item
->arg_offset
= bol
- buf
;
2085 item
->arg_len
= (int)(eol
- bol
);
2090 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
2091 saved
= *end_of_object_name
;
2092 *end_of_object_name
= '\0';
2093 status
= get_oid(bol
, &commit_oid
);
2094 *end_of_object_name
= saved
;
2096 bol
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2097 item
->arg_offset
= bol
- buf
;
2098 item
->arg_len
= (int)(eol
- bol
);
2103 item
->commit
= lookup_commit_reference(r
, &commit_oid
);
2104 return !item
->commit
;
2107 int todo_list_parse_insn_buffer(struct repository
*r
, char *buf
,
2108 struct todo_list
*todo_list
)
2110 struct todo_item
*item
;
2111 char *p
= buf
, *next_p
;
2112 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2114 todo_list
->current
= todo_list
->nr
= 0;
2116 for (i
= 1; *p
; i
++, p
= next_p
) {
2117 char *eol
= strchrnul(p
, '\n');
2119 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2121 if (p
!= eol
&& eol
[-1] == '\r')
2122 eol
--; /* strip Carriage Return */
2124 item
= append_new_todo(todo_list
);
2125 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2126 if (parse_insn_line(r
, item
, buf
, p
, eol
)) {
2127 res
= error(_("invalid line %d: %.*s"),
2128 i
, (int)(eol
- p
), p
);
2129 item
->command
= TODO_COMMENT
+ 1;
2130 item
->arg_offset
= p
- buf
;
2131 item
->arg_len
= (int)(eol
- p
);
2132 item
->commit
= NULL
;
2137 else if (is_fixup(item
->command
))
2138 return error(_("cannot '%s' without a previous commit"),
2139 command_to_string(item
->command
));
2140 else if (!is_noop(item
->command
))
2147 static int count_commands(struct todo_list
*todo_list
)
2151 for (i
= 0; i
< todo_list
->nr
; i
++)
2152 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2158 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2160 return index
< todo_list
->nr
?
2161 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2164 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2166 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2169 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2171 return get_item_line_offset(todo_list
, index
+ 1)
2172 - get_item_line_offset(todo_list
, index
);
2175 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2180 fd
= open(path
, O_RDONLY
);
2182 return error_errno(_("could not open '%s'"), path
);
2183 len
= strbuf_read(sb
, fd
, 0);
2186 return error(_("could not read '%s'."), path
);
2190 static int read_populate_todo(struct repository
*r
,
2191 struct todo_list
*todo_list
,
2192 struct replay_opts
*opts
)
2195 const char *todo_file
= get_todo_path(opts
);
2198 strbuf_reset(&todo_list
->buf
);
2199 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2202 res
= stat(todo_file
, &st
);
2204 return error(_("could not stat '%s'"), todo_file
);
2205 fill_stat_data(&todo_list
->stat
, &st
);
2207 res
= todo_list_parse_insn_buffer(r
, todo_list
->buf
.buf
, todo_list
);
2209 if (is_rebase_i(opts
))
2210 return error(_("please fix this using "
2211 "'git rebase --edit-todo'."));
2212 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2215 if (!todo_list
->nr
&&
2216 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2217 return error(_("no commits parsed."));
2219 if (!is_rebase_i(opts
)) {
2220 enum todo_command valid
=
2221 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2224 for (i
= 0; i
< todo_list
->nr
; i
++)
2225 if (valid
== todo_list
->items
[i
].command
)
2227 else if (valid
== TODO_PICK
)
2228 return error(_("cannot cherry-pick during a revert."));
2230 return error(_("cannot revert during a cherry-pick."));
2233 if (is_rebase_i(opts
)) {
2234 struct todo_list done
= TODO_LIST_INIT
;
2235 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2237 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2238 !todo_list_parse_insn_buffer(r
, done
.buf
.buf
, &done
))
2239 todo_list
->done_nr
= count_commands(&done
);
2241 todo_list
->done_nr
= 0;
2243 todo_list
->total_nr
= todo_list
->done_nr
2244 + count_commands(todo_list
);
2245 todo_list_release(&done
);
2248 fprintf(f
, "%d\n", todo_list
->total_nr
);
2256 static int git_config_string_dup(char **dest
,
2257 const char *var
, const char *value
)
2260 return config_error_nonbool(var
);
2262 *dest
= xstrdup(value
);
2266 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
2268 struct replay_opts
*opts
= data
;
2273 else if (!strcmp(key
, "options.no-commit"))
2274 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
2275 else if (!strcmp(key
, "options.edit"))
2276 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
2277 else if (!strcmp(key
, "options.signoff"))
2278 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
2279 else if (!strcmp(key
, "options.record-origin"))
2280 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
2281 else if (!strcmp(key
, "options.allow-ff"))
2282 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
2283 else if (!strcmp(key
, "options.mainline"))
2284 opts
->mainline
= git_config_int(key
, value
);
2285 else if (!strcmp(key
, "options.strategy"))
2286 git_config_string_dup(&opts
->strategy
, key
, value
);
2287 else if (!strcmp(key
, "options.gpg-sign"))
2288 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
2289 else if (!strcmp(key
, "options.strategy-option")) {
2290 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
2291 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(value
);
2292 } else if (!strcmp(key
, "options.allow-rerere-auto"))
2293 opts
->allow_rerere_auto
=
2294 git_config_bool_or_int(key
, value
, &error_flag
) ?
2295 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
2297 return error(_("invalid key: %s"), key
);
2300 return error(_("invalid value for %s: %s"), key
, value
);
2305 void parse_strategy_opts(struct replay_opts
*opts
, char *raw_opts
)
2308 char *strategy_opts_string
= raw_opts
;
2310 if (*strategy_opts_string
== ' ')
2311 strategy_opts_string
++;
2313 opts
->xopts_nr
= split_cmdline(strategy_opts_string
,
2314 (const char ***)&opts
->xopts
);
2315 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
2316 const char *arg
= opts
->xopts
[i
];
2318 skip_prefix(arg
, "--", &arg
);
2319 opts
->xopts
[i
] = xstrdup(arg
);
2323 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2326 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2328 opts
->strategy
= strbuf_detach(buf
, NULL
);
2329 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2332 parse_strategy_opts(opts
, buf
->buf
);
2335 static int read_populate_opts(struct replay_opts
*opts
)
2337 if (is_rebase_i(opts
)) {
2338 struct strbuf buf
= STRBUF_INIT
;
2340 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(), 1)) {
2341 if (!starts_with(buf
.buf
, "-S"))
2344 free(opts
->gpg_sign
);
2345 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2350 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(), 1)) {
2351 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2352 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2353 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2354 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2358 if (file_exists(rebase_path_verbose()))
2361 if (file_exists(rebase_path_quiet()))
2364 if (file_exists(rebase_path_signoff())) {
2369 if (file_exists(rebase_path_reschedule_failed_exec()))
2370 opts
->reschedule_failed_exec
= 1;
2372 read_strategy_opts(opts
, &buf
);
2373 strbuf_release(&buf
);
2375 if (read_oneliner(&opts
->current_fixups
,
2376 rebase_path_current_fixups(), 1)) {
2377 const char *p
= opts
->current_fixups
.buf
;
2378 opts
->current_fixup_count
= 1;
2379 while ((p
= strchr(p
, '\n'))) {
2380 opts
->current_fixup_count
++;
2385 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
2386 if (get_oid_hex(buf
.buf
, &opts
->squash_onto
) < 0)
2387 return error(_("unusable squash-onto"));
2388 opts
->have_squash_onto
= 1;
2394 if (!file_exists(git_path_opts_file()))
2397 * The function git_parse_source(), called from git_config_from_file(),
2398 * may die() in case of a syntactically incorrect file. We do not care
2399 * about this case, though, because we wrote that file ourselves, so we
2400 * are pretty certain that it is syntactically correct.
2402 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
2403 return error(_("malformed options sheet: '%s'"),
2404 git_path_opts_file());
2408 static void write_strategy_opts(struct replay_opts
*opts
)
2411 struct strbuf buf
= STRBUF_INIT
;
2413 for (i
= 0; i
< opts
->xopts_nr
; ++i
)
2414 strbuf_addf(&buf
, " --%s", opts
->xopts
[i
]);
2416 write_file(rebase_path_strategy_opts(), "%s\n", buf
.buf
);
2417 strbuf_release(&buf
);
2420 int write_basic_state(struct replay_opts
*opts
, const char *head_name
,
2421 const char *onto
, const char *orig_head
)
2423 const char *quiet
= getenv("GIT_QUIET");
2426 write_file(rebase_path_head_name(), "%s\n", head_name
);
2428 write_file(rebase_path_onto(), "%s\n", onto
);
2430 write_file(rebase_path_orig_head(), "%s\n", orig_head
);
2433 write_file(rebase_path_quiet(), "%s\n", quiet
);
2435 write_file(rebase_path_verbose(), "%s", "");
2437 write_file(rebase_path_strategy(), "%s\n", opts
->strategy
);
2438 if (opts
->xopts_nr
> 0)
2439 write_strategy_opts(opts
);
2441 if (opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
)
2442 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2443 else if (opts
->allow_rerere_auto
== RERERE_NOAUTOUPDATE
)
2444 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2447 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts
->gpg_sign
);
2449 write_file(rebase_path_signoff(), "--signoff\n");
2450 if (opts
->reschedule_failed_exec
)
2451 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
2456 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
2457 struct replay_opts
*opts
)
2459 enum todo_command command
= opts
->action
== REPLAY_PICK
?
2460 TODO_PICK
: TODO_REVERT
;
2461 const char *command_string
= todo_command_info
[command
].str
;
2462 struct commit
*commit
;
2464 if (prepare_revs(opts
))
2467 while ((commit
= get_revision(opts
->revs
))) {
2468 struct todo_item
*item
= append_new_todo(todo_list
);
2469 const char *commit_buffer
= get_commit_buffer(commit
, NULL
);
2470 const char *subject
;
2473 item
->command
= command
;
2474 item
->commit
= commit
;
2475 item
->arg_offset
= 0;
2477 item
->offset_in_buf
= todo_list
->buf
.len
;
2478 subject_len
= find_commit_subject(commit_buffer
, &subject
);
2479 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
2480 short_commit_name(commit
), subject_len
, subject
);
2481 unuse_commit_buffer(commit
, commit_buffer
);
2485 return error(_("empty commit set passed"));
2490 static int create_seq_dir(void)
2492 if (file_exists(git_path_seq_dir())) {
2493 error(_("a cherry-pick or revert is already in progress"));
2494 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
2496 } else if (mkdir(git_path_seq_dir(), 0777) < 0)
2497 return error_errno(_("could not create sequencer directory '%s'"),
2498 git_path_seq_dir());
2502 static int save_head(const char *head
)
2504 struct lock_file head_lock
= LOCK_INIT
;
2505 struct strbuf buf
= STRBUF_INIT
;
2509 fd
= hold_lock_file_for_update(&head_lock
, git_path_head_file(), 0);
2511 return error_errno(_("could not lock HEAD"));
2512 strbuf_addf(&buf
, "%s\n", head
);
2513 written
= write_in_full(fd
, buf
.buf
, buf
.len
);
2514 strbuf_release(&buf
);
2516 error_errno(_("could not write to '%s'"), git_path_head_file());
2517 rollback_lock_file(&head_lock
);
2520 if (commit_lock_file(&head_lock
) < 0)
2521 return error(_("failed to finalize '%s'"), git_path_head_file());
2525 static int rollback_is_safe(void)
2527 struct strbuf sb
= STRBUF_INIT
;
2528 struct object_id expected_head
, actual_head
;
2530 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
2532 if (get_oid_hex(sb
.buf
, &expected_head
)) {
2533 strbuf_release(&sb
);
2534 die(_("could not parse %s"), git_path_abort_safety_file());
2536 strbuf_release(&sb
);
2538 else if (errno
== ENOENT
)
2539 oidclr(&expected_head
);
2541 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2543 if (get_oid("HEAD", &actual_head
))
2544 oidclr(&actual_head
);
2546 return oideq(&actual_head
, &expected_head
);
2549 static int reset_for_rollback(const struct object_id
*oid
)
2551 const char *argv
[4]; /* reset --merge <arg> + NULL */
2554 argv
[1] = "--merge";
2555 argv
[2] = oid_to_hex(oid
);
2557 return run_command_v_opt(argv
, RUN_GIT_CMD
);
2560 static int rollback_single_pick(struct repository
*r
)
2562 struct object_id head_oid
;
2564 if (!file_exists(git_path_cherry_pick_head(r
)) &&
2565 !file_exists(git_path_revert_head(r
)))
2566 return error(_("no cherry-pick or revert in progress"));
2567 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
2568 return error(_("cannot resolve HEAD"));
2569 if (is_null_oid(&head_oid
))
2570 return error(_("cannot abort from a branch yet to be born"));
2571 return reset_for_rollback(&head_oid
);
2574 int sequencer_rollback(struct repository
*r
, struct replay_opts
*opts
)
2577 struct object_id oid
;
2578 struct strbuf buf
= STRBUF_INIT
;
2581 f
= fopen(git_path_head_file(), "r");
2582 if (!f
&& errno
== ENOENT
) {
2584 * There is no multiple-cherry-pick in progress.
2585 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2586 * a single-cherry-pick in progress, abort that.
2588 return rollback_single_pick(r
);
2591 return error_errno(_("cannot open '%s'"), git_path_head_file());
2592 if (strbuf_getline_lf(&buf
, f
)) {
2593 error(_("cannot read '%s': %s"), git_path_head_file(),
2594 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
2599 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
2600 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2601 git_path_head_file());
2604 if (is_null_oid(&oid
)) {
2605 error(_("cannot abort from a branch yet to be born"));
2609 if (!rollback_is_safe()) {
2610 /* Do not error, just do not rollback */
2611 warning(_("You seem to have moved HEAD. "
2612 "Not rewinding, check your HEAD!"));
2614 if (reset_for_rollback(&oid
))
2616 strbuf_release(&buf
);
2617 return sequencer_remove_state(opts
);
2619 strbuf_release(&buf
);
2623 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
2625 struct lock_file todo_lock
= LOCK_INIT
;
2626 const char *todo_path
= get_todo_path(opts
);
2627 int next
= todo_list
->current
, offset
, fd
;
2630 * rebase -i writes "git-rebase-todo" without the currently executing
2631 * command, appending it to "done" instead.
2633 if (is_rebase_i(opts
))
2636 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
2638 return error_errno(_("could not lock '%s'"), todo_path
);
2639 offset
= get_item_line_offset(todo_list
, next
);
2640 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
2641 todo_list
->buf
.len
- offset
) < 0)
2642 return error_errno(_("could not write to '%s'"), todo_path
);
2643 if (commit_lock_file(&todo_lock
) < 0)
2644 return error(_("failed to finalize '%s'"), todo_path
);
2646 if (is_rebase_i(opts
) && next
> 0) {
2647 const char *done
= rebase_path_done();
2648 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
2653 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
2654 get_item_line_length(todo_list
, next
- 1))
2656 ret
= error_errno(_("could not write to '%s'"), done
);
2658 ret
= error_errno(_("failed to finalize '%s'"), done
);
2664 static int save_opts(struct replay_opts
*opts
)
2666 const char *opts_file
= git_path_opts_file();
2669 if (opts
->no_commit
)
2670 res
|= git_config_set_in_file_gently(opts_file
, "options.no-commit", "true");
2672 res
|= git_config_set_in_file_gently(opts_file
, "options.edit", "true");
2674 res
|= git_config_set_in_file_gently(opts_file
, "options.signoff", "true");
2675 if (opts
->record_origin
)
2676 res
|= git_config_set_in_file_gently(opts_file
, "options.record-origin", "true");
2678 res
|= git_config_set_in_file_gently(opts_file
, "options.allow-ff", "true");
2679 if (opts
->mainline
) {
2680 struct strbuf buf
= STRBUF_INIT
;
2681 strbuf_addf(&buf
, "%d", opts
->mainline
);
2682 res
|= git_config_set_in_file_gently(opts_file
, "options.mainline", buf
.buf
);
2683 strbuf_release(&buf
);
2686 res
|= git_config_set_in_file_gently(opts_file
, "options.strategy", opts
->strategy
);
2688 res
|= git_config_set_in_file_gently(opts_file
, "options.gpg-sign", opts
->gpg_sign
);
2691 for (i
= 0; i
< opts
->xopts_nr
; i
++)
2692 res
|= git_config_set_multivar_in_file_gently(opts_file
,
2693 "options.strategy-option",
2694 opts
->xopts
[i
], "^$", 0);
2696 if (opts
->allow_rerere_auto
)
2697 res
|= git_config_set_in_file_gently(opts_file
, "options.allow-rerere-auto",
2698 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
2703 static int make_patch(struct repository
*r
,
2704 struct commit
*commit
,
2705 struct replay_opts
*opts
)
2707 struct strbuf buf
= STRBUF_INIT
;
2708 struct rev_info log_tree_opt
;
2709 const char *subject
, *p
;
2712 p
= short_commit_name(commit
);
2713 if (write_message(p
, strlen(p
), rebase_path_stopped_sha(), 1) < 0)
2715 if (update_ref("rebase", "REBASE_HEAD", &commit
->object
.oid
,
2716 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2717 res
|= error(_("could not update %s"), "REBASE_HEAD");
2719 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
2720 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
2721 repo_init_revisions(r
, &log_tree_opt
, NULL
);
2722 log_tree_opt
.abbrev
= 0;
2723 log_tree_opt
.diff
= 1;
2724 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
2725 log_tree_opt
.disable_stdin
= 1;
2726 log_tree_opt
.no_commit_id
= 1;
2727 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
2728 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
2729 if (!log_tree_opt
.diffopt
.file
)
2730 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
2732 res
|= log_tree_commit(&log_tree_opt
, commit
);
2733 fclose(log_tree_opt
.diffopt
.file
);
2737 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
2738 if (!file_exists(buf
.buf
)) {
2739 const char *commit_buffer
= get_commit_buffer(commit
, NULL
);
2740 find_commit_subject(commit_buffer
, &subject
);
2741 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
2742 unuse_commit_buffer(commit
, commit_buffer
);
2744 strbuf_release(&buf
);
2749 static int intend_to_amend(void)
2751 struct object_id head
;
2754 if (get_oid("HEAD", &head
))
2755 return error(_("cannot read HEAD"));
2757 p
= oid_to_hex(&head
);
2758 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
2761 static int error_with_patch(struct repository
*r
,
2762 struct commit
*commit
,
2763 const char *subject
, int subject_len
,
2764 struct replay_opts
*opts
,
2765 int exit_code
, int to_amend
)
2768 if (make_patch(r
, commit
, opts
))
2770 } else if (copy_file(rebase_path_message(),
2771 git_path_merge_msg(r
), 0666))
2772 return error(_("unable to copy '%s' to '%s'"),
2773 git_path_merge_msg(r
), rebase_path_message());
2776 if (intend_to_amend())
2780 _("You can amend the commit now, with\n"
2782 " git commit --amend %s\n"
2784 "Once you are satisfied with your changes, run\n"
2786 " git rebase --continue\n"),
2787 gpg_sign_opt_quoted(opts
));
2788 } else if (exit_code
) {
2790 fprintf_ln(stderr
, _("Could not apply %s... %.*s"),
2791 short_commit_name(commit
), subject_len
, subject
);
2794 * We don't have the hash of the parent so
2795 * just print the line from the todo file.
2797 fprintf_ln(stderr
, _("Could not merge %.*s"),
2798 subject_len
, subject
);
2804 static int error_failed_squash(struct repository
*r
,
2805 struct commit
*commit
,
2806 struct replay_opts
*opts
,
2808 const char *subject
)
2810 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
2811 return error(_("could not copy '%s' to '%s'"),
2812 rebase_path_squash_msg(), rebase_path_message());
2813 unlink(git_path_merge_msg(r
));
2814 if (copy_file(git_path_merge_msg(r
), rebase_path_message(), 0666))
2815 return error(_("could not copy '%s' to '%s'"),
2816 rebase_path_message(),
2817 git_path_merge_msg(r
));
2818 return error_with_patch(r
, commit
, subject
, subject_len
, opts
, 1, 0);
2821 static int do_exec(struct repository
*r
, const char *command_line
)
2823 struct argv_array child_env
= ARGV_ARRAY_INIT
;
2824 const char *child_argv
[] = { NULL
, NULL
};
2827 fprintf(stderr
, "Executing: %s\n", command_line
);
2828 child_argv
[0] = command_line
;
2829 argv_array_pushf(&child_env
, "GIT_DIR=%s", absolute_path(get_git_dir()));
2830 argv_array_pushf(&child_env
, "GIT_WORK_TREE=%s",
2831 absolute_path(get_git_work_tree()));
2832 status
= run_command_v_opt_cd_env(child_argv
, RUN_USING_SHELL
, NULL
,
2835 /* force re-reading of the cache */
2836 if (discard_index(r
->index
) < 0 || repo_read_index(r
) < 0)
2837 return error(_("could not read index"));
2839 dirty
= require_clean_work_tree(r
, "rebase", NULL
, 1, 1);
2842 warning(_("execution failed: %s\n%s"
2843 "You can fix the problem, and then run\n"
2845 " git rebase --continue\n"
2848 dirty
? N_("and made changes to the index and/or the "
2849 "working tree\n") : "");
2851 /* command not found */
2854 warning(_("execution succeeded: %s\nbut "
2855 "left changes to the index and/or the working tree\n"
2856 "Commit or stash your changes, and then run\n"
2858 " git rebase --continue\n"
2859 "\n"), command_line
);
2863 argv_array_clear(&child_env
);
2868 static int safe_append(const char *filename
, const char *fmt
, ...)
2871 struct lock_file lock
= LOCK_INIT
;
2872 int fd
= hold_lock_file_for_update(&lock
, filename
,
2873 LOCK_REPORT_ON_ERROR
);
2874 struct strbuf buf
= STRBUF_INIT
;
2879 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
2880 error_errno(_("could not read '%s'"), filename
);
2881 rollback_lock_file(&lock
);
2884 strbuf_complete(&buf
, '\n');
2886 strbuf_vaddf(&buf
, fmt
, ap
);
2889 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
2890 error_errno(_("could not write to '%s'"), filename
);
2891 strbuf_release(&buf
);
2892 rollback_lock_file(&lock
);
2895 if (commit_lock_file(&lock
) < 0) {
2896 strbuf_release(&buf
);
2897 rollback_lock_file(&lock
);
2898 return error(_("failed to finalize '%s'"), filename
);
2901 strbuf_release(&buf
);
2905 static int do_label(struct repository
*r
, const char *name
, int len
)
2907 struct ref_store
*refs
= get_main_ref_store(r
);
2908 struct ref_transaction
*transaction
;
2909 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
2910 struct strbuf msg
= STRBUF_INIT
;
2912 struct object_id head_oid
;
2914 if (len
== 1 && *name
== '#')
2915 return error(_("illegal label name: '%.*s'"), len
, name
);
2917 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
2918 strbuf_addf(&msg
, "rebase -i (label) '%.*s'", len
, name
);
2920 transaction
= ref_store_transaction_begin(refs
, &err
);
2922 error("%s", err
.buf
);
2924 } else if (get_oid("HEAD", &head_oid
)) {
2925 error(_("could not read HEAD"));
2927 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
2928 NULL
, 0, msg
.buf
, &err
) < 0 ||
2929 ref_transaction_commit(transaction
, &err
)) {
2930 error("%s", err
.buf
);
2933 ref_transaction_free(transaction
);
2934 strbuf_release(&err
);
2935 strbuf_release(&msg
);
2938 ret
= safe_append(rebase_path_refs_to_delete(),
2939 "%s\n", ref_name
.buf
);
2940 strbuf_release(&ref_name
);
2945 static const char *reflog_message(struct replay_opts
*opts
,
2946 const char *sub_action
, const char *fmt
, ...);
2948 static int do_reset(struct repository
*r
,
2949 const char *name
, int len
,
2950 struct replay_opts
*opts
)
2952 struct strbuf ref_name
= STRBUF_INIT
;
2953 struct object_id oid
;
2954 struct lock_file lock
= LOCK_INIT
;
2955 struct tree_desc desc
;
2957 struct unpack_trees_options unpack_tree_opts
;
2960 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0)
2963 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
2964 if (!opts
->have_squash_onto
) {
2966 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
2967 NULL
, &opts
->squash_onto
,
2969 return error(_("writing fake root commit"));
2970 opts
->have_squash_onto
= 1;
2971 hex
= oid_to_hex(&opts
->squash_onto
);
2972 if (write_message(hex
, strlen(hex
),
2973 rebase_path_squash_onto(), 0))
2974 return error(_("writing squash-onto"));
2976 oidcpy(&oid
, &opts
->squash_onto
);
2980 /* Determine the length of the label */
2981 for (i
= 0; i
< len
; i
++)
2982 if (isspace(name
[i
]))
2986 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
2987 if (get_oid(ref_name
.buf
, &oid
) &&
2988 get_oid(ref_name
.buf
+ strlen("refs/rewritten/"), &oid
)) {
2989 error(_("could not read '%s'"), ref_name
.buf
);
2990 rollback_lock_file(&lock
);
2991 strbuf_release(&ref_name
);
2996 memset(&unpack_tree_opts
, 0, sizeof(unpack_tree_opts
));
2997 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
2998 unpack_tree_opts
.head_idx
= 1;
2999 unpack_tree_opts
.src_index
= r
->index
;
3000 unpack_tree_opts
.dst_index
= r
->index
;
3001 unpack_tree_opts
.fn
= oneway_merge
;
3002 unpack_tree_opts
.merge
= 1;
3003 unpack_tree_opts
.update
= 1;
3005 if (repo_read_index_unmerged(r
)) {
3006 rollback_lock_file(&lock
);
3007 strbuf_release(&ref_name
);
3008 return error_resolve_conflict(_(action_name(opts
)));
3011 if (!fill_tree_descriptor(&desc
, &oid
)) {
3012 error(_("failed to find tree of %s"), oid_to_hex(&oid
));
3013 rollback_lock_file(&lock
);
3014 free((void *)desc
.buffer
);
3015 strbuf_release(&ref_name
);
3019 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
3020 rollback_lock_file(&lock
);
3021 free((void *)desc
.buffer
);
3022 strbuf_release(&ref_name
);
3026 tree
= parse_tree_indirect(&oid
);
3027 prime_cache_tree(r
, r
->index
, tree
);
3029 if (write_locked_index(r
->index
, &lock
, COMMIT_LOCK
) < 0)
3030 ret
= error(_("could not write index"));
3031 free((void *)desc
.buffer
);
3034 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
3035 len
, name
), "HEAD", &oid
,
3036 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3038 strbuf_release(&ref_name
);
3042 static struct commit
*lookup_label(const char *label
, int len
,
3045 struct commit
*commit
;
3048 strbuf_addf(buf
, "refs/rewritten/%.*s", len
, label
);
3049 commit
= lookup_commit_reference_by_name(buf
->buf
);
3051 /* fall back to non-rewritten ref or commit */
3052 strbuf_splice(buf
, 0, strlen("refs/rewritten/"), "", 0);
3053 commit
= lookup_commit_reference_by_name(buf
->buf
);
3057 error(_("could not resolve '%s'"), buf
->buf
);
3062 static int do_merge(struct repository
*r
,
3063 struct commit
*commit
,
3064 const char *arg
, int arg_len
,
3065 int flags
, struct replay_opts
*opts
)
3067 int run_commit_flags
= (flags
& TODO_EDIT_MERGE_MSG
) ?
3068 EDIT_MSG
| VERIFY_MSG
: 0;
3069 struct strbuf ref_name
= STRBUF_INIT
;
3070 struct commit
*head_commit
, *merge_commit
, *i
;
3071 struct commit_list
*bases
, *j
, *reversed
= NULL
;
3072 struct commit_list
*to_merge
= NULL
, **tail
= &to_merge
;
3073 struct merge_options o
;
3074 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
, k
;
3075 static struct lock_file lock
;
3078 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0) {
3083 head_commit
= lookup_commit_reference_by_name("HEAD");
3085 ret
= error(_("cannot merge without a current revision"));
3090 * For octopus merges, the arg starts with the list of revisions to be
3091 * merged. The list is optionally followed by '#' and the oneline.
3093 merge_arg_len
= oneline_offset
= arg_len
;
3094 for (p
= arg
; p
- arg
< arg_len
; p
+= strspn(p
, " \t\n")) {
3097 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
3098 p
+= 1 + strspn(p
+ 1, " \t\n");
3099 oneline_offset
= p
- arg
;
3102 k
= strcspn(p
, " \t\n");
3105 merge_commit
= lookup_label(p
, k
, &ref_name
);
3106 if (!merge_commit
) {
3107 ret
= error(_("unable to parse '%.*s'"), k
, p
);
3110 tail
= &commit_list_insert(merge_commit
, tail
)->next
;
3112 merge_arg_len
= p
- arg
;
3116 ret
= error(_("nothing to merge: '%.*s'"), arg_len
, arg
);
3120 if (opts
->have_squash_onto
&&
3121 oideq(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
3123 * When the user tells us to "merge" something into a
3124 * "[new root]", let's simply fast-forward to the merge head.
3126 rollback_lock_file(&lock
);
3128 ret
= error(_("octopus merge cannot be executed on "
3129 "top of a [new root]"));
3131 ret
= fast_forward_to(r
, &to_merge
->item
->object
.oid
,
3132 &head_commit
->object
.oid
, 0,
3138 const char *message
= get_commit_buffer(commit
, NULL
);
3143 ret
= error(_("could not get commit message of '%s'"),
3144 oid_to_hex(&commit
->object
.oid
));
3147 write_author_script(message
);
3148 find_commit_subject(message
, &body
);
3150 ret
= write_message(body
, len
, git_path_merge_msg(r
), 0);
3151 unuse_commit_buffer(commit
, message
);
3153 error_errno(_("could not write '%s'"),
3154 git_path_merge_msg(r
));
3158 struct strbuf buf
= STRBUF_INIT
;
3161 strbuf_addf(&buf
, "author %s", git_author_info(0));
3162 write_author_script(buf
.buf
);
3165 if (oneline_offset
< arg_len
) {
3166 p
= arg
+ oneline_offset
;
3167 len
= arg_len
- oneline_offset
;
3169 strbuf_addf(&buf
, "Merge %s '%.*s'",
3170 to_merge
->next
? "branches" : "branch",
3171 merge_arg_len
, arg
);
3176 ret
= write_message(p
, len
, git_path_merge_msg(r
), 0);
3177 strbuf_release(&buf
);
3179 error_errno(_("could not write '%s'"),
3180 git_path_merge_msg(r
));
3186 * If HEAD is not identical to the first parent of the original merge
3187 * commit, we cannot fast-forward.
3189 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
3190 oideq(&commit
->parents
->item
->object
.oid
,
3191 &head_commit
->object
.oid
);
3194 * If any merge head is different from the original one, we cannot
3197 if (can_fast_forward
) {
3198 struct commit_list
*p
= commit
->parents
->next
;
3200 for (j
= to_merge
; j
&& p
; j
= j
->next
, p
= p
->next
)
3201 if (!oideq(&j
->item
->object
.oid
,
3202 &p
->item
->object
.oid
)) {
3203 can_fast_forward
= 0;
3207 * If the number of merge heads differs from the original merge
3208 * commit, we cannot fast-forward.
3211 can_fast_forward
= 0;
3214 if (can_fast_forward
) {
3215 rollback_lock_file(&lock
);
3216 ret
= fast_forward_to(r
, &commit
->object
.oid
,
3217 &head_commit
->object
.oid
, 0, opts
);
3221 if (to_merge
->next
) {
3223 struct child_process cmd
= CHILD_PROCESS_INIT
;
3225 if (read_env_script(&cmd
.env_array
)) {
3226 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
3228 ret
= error(_(staged_changes_advice
), gpg_opt
, gpg_opt
);
3233 argv_array_push(&cmd
.args
, "merge");
3234 argv_array_push(&cmd
.args
, "-s");
3235 argv_array_push(&cmd
.args
, "octopus");
3236 argv_array_push(&cmd
.args
, "--no-edit");
3237 argv_array_push(&cmd
.args
, "--no-ff");
3238 argv_array_push(&cmd
.args
, "--no-log");
3239 argv_array_push(&cmd
.args
, "--no-stat");
3240 argv_array_push(&cmd
.args
, "-F");
3241 argv_array_push(&cmd
.args
, git_path_merge_msg(r
));
3243 argv_array_push(&cmd
.args
, opts
->gpg_sign
);
3245 /* Add the tips to be merged */
3246 for (j
= to_merge
; j
; j
= j
->next
)
3247 argv_array_push(&cmd
.args
,
3248 oid_to_hex(&j
->item
->object
.oid
));
3250 strbuf_release(&ref_name
);
3251 unlink(git_path_cherry_pick_head(r
));
3252 rollback_lock_file(&lock
);
3254 rollback_lock_file(&lock
);
3255 ret
= run_command(&cmd
);
3257 /* force re-reading of the cache */
3258 if (!ret
&& (discard_index(r
->index
) < 0 ||
3259 repo_read_index(r
) < 0))
3260 ret
= error(_("could not read index"));
3264 merge_commit
= to_merge
->item
;
3265 bases
= get_merge_bases(head_commit
, merge_commit
);
3266 if (bases
&& oideq(&merge_commit
->object
.oid
,
3267 &bases
->item
->object
.oid
)) {
3269 /* skip merging an ancestor of HEAD */
3273 write_message(oid_to_hex(&merge_commit
->object
.oid
), GIT_SHA1_HEXSZ
,
3274 git_path_merge_head(r
), 0);
3275 write_message("no-ff", 5, git_path_merge_mode(r
), 0);
3277 for (j
= bases
; j
; j
= j
->next
)
3278 commit_list_insert(j
->item
, &reversed
);
3279 free_commit_list(bases
);
3282 init_merge_options(&o
, r
);
3284 o
.branch2
= ref_name
.buf
;
3285 o
.buffer_output
= 2;
3287 ret
= merge_recursive(&o
, head_commit
, merge_commit
, reversed
, &i
);
3289 fputs(o
.obuf
.buf
, stdout
);
3290 strbuf_release(&o
.obuf
);
3292 error(_("could not even attempt to merge '%.*s'"),
3293 merge_arg_len
, arg
);
3297 * The return value of merge_recursive() is 1 on clean, and 0 on
3300 * Let's reverse that, so that do_merge() returns 0 upon success and
3301 * 1 upon failed merge (keeping the return value -1 for the cases where
3302 * we will want to reschedule the `merge` command).
3306 if (r
->index
->cache_changed
&&
3307 write_locked_index(r
->index
, &lock
, COMMIT_LOCK
)) {
3308 ret
= error(_("merge: Unable to write new index file"));
3312 rollback_lock_file(&lock
);
3314 repo_rerere(r
, opts
->allow_rerere_auto
);
3317 * In case of problems, we now want to return a positive
3318 * value (a negative one would indicate that the `merge`
3319 * command needs to be rescheduled).
3321 ret
= !!run_git_commit(r
, git_path_merge_msg(r
), opts
,
3325 strbuf_release(&ref_name
);
3326 rollback_lock_file(&lock
);
3327 free_commit_list(to_merge
);
3331 static int is_final_fixup(struct todo_list
*todo_list
)
3333 int i
= todo_list
->current
;
3335 if (!is_fixup(todo_list
->items
[i
].command
))
3338 while (++i
< todo_list
->nr
)
3339 if (is_fixup(todo_list
->items
[i
].command
))
3341 else if (!is_noop(todo_list
->items
[i
].command
))
3346 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
3350 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
3351 if (!is_noop(todo_list
->items
[i
].command
))
3352 return todo_list
->items
[i
].command
;
3357 static int apply_autostash(struct replay_opts
*opts
)
3359 struct strbuf stash_sha1
= STRBUF_INIT
;
3360 struct child_process child
= CHILD_PROCESS_INIT
;
3363 if (!read_oneliner(&stash_sha1
, rebase_path_autostash(), 1)) {
3364 strbuf_release(&stash_sha1
);
3367 strbuf_trim(&stash_sha1
);
3370 child
.no_stdout
= 1;
3371 child
.no_stderr
= 1;
3372 argv_array_push(&child
.args
, "stash");
3373 argv_array_push(&child
.args
, "apply");
3374 argv_array_push(&child
.args
, stash_sha1
.buf
);
3375 if (!run_command(&child
))
3376 fprintf(stderr
, _("Applied autostash.\n"));
3378 struct child_process store
= CHILD_PROCESS_INIT
;
3381 argv_array_push(&store
.args
, "stash");
3382 argv_array_push(&store
.args
, "store");
3383 argv_array_push(&store
.args
, "-m");
3384 argv_array_push(&store
.args
, "autostash");
3385 argv_array_push(&store
.args
, "-q");
3386 argv_array_push(&store
.args
, stash_sha1
.buf
);
3387 if (run_command(&store
))
3388 ret
= error(_("cannot store %s"), stash_sha1
.buf
);
3391 _("Applying autostash resulted in conflicts.\n"
3392 "Your changes are safe in the stash.\n"
3393 "You can run \"git stash pop\" or"
3394 " \"git stash drop\" at any time.\n"));
3397 strbuf_release(&stash_sha1
);
3401 static const char *reflog_message(struct replay_opts
*opts
,
3402 const char *sub_action
, const char *fmt
, ...)
3405 static struct strbuf buf
= STRBUF_INIT
;
3409 strbuf_addstr(&buf
, action_name(opts
));
3411 strbuf_addf(&buf
, " (%s)", sub_action
);
3413 strbuf_addstr(&buf
, ": ");
3414 strbuf_vaddf(&buf
, fmt
, ap
);
3421 static int run_git_checkout(struct repository
*r
, struct replay_opts
*opts
,
3422 const char *commit
, const char *action
)
3424 struct child_process cmd
= CHILD_PROCESS_INIT
;
3429 argv_array_push(&cmd
.args
, "checkout");
3430 argv_array_push(&cmd
.args
, commit
);
3431 argv_array_pushf(&cmd
.env_array
, GIT_REFLOG_ACTION
"=%s", action
);
3434 ret
= run_command(&cmd
);
3436 ret
= run_command_silent_on_success(&cmd
);
3439 discard_index(r
->index
);
3444 int prepare_branch_to_be_rebased(struct repository
*r
, struct replay_opts
*opts
,
3449 if (commit
&& *commit
) {
3450 action
= reflog_message(opts
, "start", "checkout %s", commit
);
3451 if (run_git_checkout(r
, opts
, commit
, action
))
3452 return error(_("could not checkout %s"), commit
);
3458 static int checkout_onto(struct repository
*r
, struct replay_opts
*opts
,
3459 const char *onto_name
, const char *onto
,
3460 const char *orig_head
)
3462 struct object_id oid
;
3463 const char *action
= reflog_message(opts
, "start", "checkout %s", onto_name
);
3465 if (get_oid(orig_head
, &oid
))
3466 return error(_("%s: not a valid OID"), orig_head
);
3468 if (run_git_checkout(r
, opts
, onto
, action
)) {
3469 apply_autostash(opts
);
3470 sequencer_remove_state(opts
);
3471 return error(_("could not detach HEAD"));
3474 return update_ref(NULL
, "ORIG_HEAD", &oid
, NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3477 static int stopped_at_head(struct repository
*r
)
3479 struct object_id head
;
3480 struct commit
*commit
;
3481 struct commit_message message
;
3483 if (get_oid("HEAD", &head
) ||
3484 !(commit
= lookup_commit(r
, &head
)) ||
3485 parse_commit(commit
) || get_message(commit
, &message
))
3486 fprintf(stderr
, _("Stopped at HEAD\n"));
3488 fprintf(stderr
, _("Stopped at %s\n"), message
.label
);
3489 free_message(commit
, &message
);
3495 static const char rescheduled_advice
[] =
3496 N_("Could not execute the todo command\n"
3500 "It has been rescheduled; To edit the command before continuing, please\n"
3501 "edit the todo list first:\n"
3503 " git rebase --edit-todo\n"
3504 " git rebase --continue\n");
3506 static int pick_commits(struct repository
*r
,
3507 struct todo_list
*todo_list
,
3508 struct replay_opts
*opts
)
3510 int res
= 0, reschedule
= 0;
3512 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
3514 assert(!(opts
->signoff
|| opts
->no_commit
||
3515 opts
->record_origin
|| opts
->edit
));
3516 if (read_and_refresh_cache(r
, opts
))
3519 while (todo_list
->current
< todo_list
->nr
) {
3520 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
3521 const char *arg
= todo_item_get_arg(todo_list
, item
);
3523 if (save_todo(todo_list
, opts
))
3525 if (is_rebase_i(opts
)) {
3526 if (item
->command
!= TODO_COMMENT
) {
3527 FILE *f
= fopen(rebase_path_msgnum(), "w");
3529 todo_list
->done_nr
++;
3532 fprintf(f
, "%d\n", todo_list
->done_nr
);
3536 fprintf(stderr
, "Rebasing (%d/%d)%s",
3538 todo_list
->total_nr
,
3539 opts
->verbose
? "\n" : "\r");
3541 unlink(rebase_path_message());
3542 unlink(rebase_path_author_script());
3543 unlink(rebase_path_stopped_sha());
3544 unlink(rebase_path_amend());
3545 unlink(git_path_merge_head(the_repository
));
3546 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
3548 if (item
->command
== TODO_BREAK
)
3549 return stopped_at_head(r
);
3551 if (item
->command
<= TODO_SQUASH
) {
3552 if (is_rebase_i(opts
))
3553 setenv("GIT_REFLOG_ACTION", reflog_message(opts
,
3554 command_to_string(item
->command
), NULL
),
3556 res
= do_pick_commit(r
, item
->command
, item
->commit
,
3557 opts
, is_final_fixup(todo_list
));
3558 if (is_rebase_i(opts
) && res
< 0) {
3560 advise(_(rescheduled_advice
),
3561 get_item_line_length(todo_list
,
3562 todo_list
->current
),
3563 get_item_line(todo_list
,
3564 todo_list
->current
));
3565 todo_list
->current
--;
3566 if (save_todo(todo_list
, opts
))
3569 if (item
->command
== TODO_EDIT
) {
3570 struct commit
*commit
= item
->commit
;
3573 _("Stopped at %s... %.*s\n"),
3574 short_commit_name(commit
),
3575 item
->arg_len
, arg
);
3576 return error_with_patch(r
, commit
,
3577 arg
, item
->arg_len
, opts
, res
, !res
);
3579 if (is_rebase_i(opts
) && !res
)
3580 record_in_rewritten(&item
->commit
->object
.oid
,
3581 peek_command(todo_list
, 1));
3582 if (res
&& is_fixup(item
->command
)) {
3585 return error_failed_squash(r
, item
->commit
, opts
,
3586 item
->arg_len
, arg
);
3587 } else if (res
&& is_rebase_i(opts
) && item
->commit
) {
3589 struct object_id oid
;
3592 * If we are rewording and have either
3593 * fast-forwarded already, or are about to
3594 * create a new root commit, we want to amend,
3595 * otherwise we do not.
3597 if (item
->command
== TODO_REWORD
&&
3598 !get_oid("HEAD", &oid
) &&
3599 (oideq(&item
->commit
->object
.oid
, &oid
) ||
3600 (opts
->have_squash_onto
&&
3601 oideq(&opts
->squash_onto
, &oid
))))
3604 return res
| error_with_patch(r
, item
->commit
,
3605 arg
, item
->arg_len
, opts
,
3608 } else if (item
->command
== TODO_EXEC
) {
3609 char *end_of_arg
= (char *)(arg
+ item
->arg_len
);
3610 int saved
= *end_of_arg
;
3614 res
= do_exec(r
, arg
);
3615 *end_of_arg
= saved
;
3617 /* Reread the todo file if it has changed. */
3619 if (opts
->reschedule_failed_exec
)
3621 } else if (stat(get_todo_path(opts
), &st
))
3622 res
= error_errno(_("could not stat '%s'"),
3623 get_todo_path(opts
));
3624 else if (match_stat_data(&todo_list
->stat
, &st
)) {
3625 todo_list_release(todo_list
);
3626 if (read_populate_todo(r
, todo_list
, opts
))
3627 res
= -1; /* message was printed */
3628 /* `current` will be incremented below */
3629 todo_list
->current
= -1;
3631 } else if (item
->command
== TODO_LABEL
) {
3632 if ((res
= do_label(r
, arg
, item
->arg_len
)))
3634 } else if (item
->command
== TODO_RESET
) {
3635 if ((res
= do_reset(r
, arg
, item
->arg_len
, opts
)))
3637 } else if (item
->command
== TODO_MERGE
) {
3638 if ((res
= do_merge(r
, item
->commit
,
3640 item
->flags
, opts
)) < 0)
3642 else if (item
->commit
)
3643 record_in_rewritten(&item
->commit
->object
.oid
,
3644 peek_command(todo_list
, 1));
3646 /* failed with merge conflicts */
3647 return error_with_patch(r
, item
->commit
,
3650 } else if (!is_noop(item
->command
))
3651 return error(_("unknown command %d"), item
->command
);
3654 advise(_(rescheduled_advice
),
3655 get_item_line_length(todo_list
,
3656 todo_list
->current
),
3657 get_item_line(todo_list
, todo_list
->current
));
3658 todo_list
->current
--;
3659 if (save_todo(todo_list
, opts
))
3662 return error_with_patch(r
,
3668 todo_list
->current
++;
3673 if (is_rebase_i(opts
)) {
3674 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
3677 /* Stopped in the middle, as planned? */
3678 if (todo_list
->current
< todo_list
->nr
)
3681 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
3682 starts_with(head_ref
.buf
, "refs/")) {
3684 struct object_id head
, orig
;
3687 if (get_oid("HEAD", &head
)) {
3688 res
= error(_("cannot read HEAD"));
3690 strbuf_release(&head_ref
);
3691 strbuf_release(&buf
);
3694 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
3695 get_oid_hex(buf
.buf
, &orig
)) {
3696 res
= error(_("could not read orig-head"));
3697 goto cleanup_head_ref
;
3700 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
3701 res
= error(_("could not read 'onto'"));
3702 goto cleanup_head_ref
;
3704 msg
= reflog_message(opts
, "finish", "%s onto %s",
3705 head_ref
.buf
, buf
.buf
);
3706 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
3707 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
3708 res
= error(_("could not update %s"),
3710 goto cleanup_head_ref
;
3712 msg
= reflog_message(opts
, "finish", "returning to %s",
3714 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
3715 res
= error(_("could not update HEAD to %s"),
3717 goto cleanup_head_ref
;
3722 if (opts
->verbose
) {
3723 struct rev_info log_tree_opt
;
3724 struct object_id orig
, head
;
3726 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3727 repo_init_revisions(r
, &log_tree_opt
, NULL
);
3728 log_tree_opt
.diff
= 1;
3729 log_tree_opt
.diffopt
.output_format
=
3730 DIFF_FORMAT_DIFFSTAT
;
3731 log_tree_opt
.disable_stdin
= 1;
3733 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
3734 !get_oid(buf
.buf
, &orig
) &&
3735 !get_oid("HEAD", &head
)) {
3736 diff_tree_oid(&orig
, &head
, "",
3737 &log_tree_opt
.diffopt
);
3738 log_tree_diff_flush(&log_tree_opt
);
3741 flush_rewritten_pending();
3742 if (!stat(rebase_path_rewritten_list(), &st
) &&
3744 struct child_process child
= CHILD_PROCESS_INIT
;
3745 const char *post_rewrite_hook
=
3746 find_hook("post-rewrite");
3748 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
3750 argv_array_push(&child
.args
, "notes");
3751 argv_array_push(&child
.args
, "copy");
3752 argv_array_push(&child
.args
, "--for-rewrite=rebase");
3753 /* we don't care if this copying failed */
3754 run_command(&child
);
3756 if (post_rewrite_hook
) {
3757 struct child_process hook
= CHILD_PROCESS_INIT
;
3759 hook
.in
= open(rebase_path_rewritten_list(),
3761 hook
.stdout_to_stderr
= 1;
3762 hook
.trace2_hook_name
= "post-rewrite";
3763 argv_array_push(&hook
.args
, post_rewrite_hook
);
3764 argv_array_push(&hook
.args
, "rebase");
3765 /* we don't care if this hook failed */
3769 apply_autostash(opts
);
3773 "Successfully rebased and updated %s.\n",
3776 strbuf_release(&buf
);
3777 strbuf_release(&head_ref
);
3781 * Sequence of picks finished successfully; cleanup by
3782 * removing the .git/sequencer directory
3784 return sequencer_remove_state(opts
);
3787 static int continue_single_pick(struct repository
*r
)
3789 const char *argv
[] = { "commit", NULL
};
3791 if (!file_exists(git_path_cherry_pick_head(r
)) &&
3792 !file_exists(git_path_revert_head(r
)))
3793 return error(_("no cherry-pick or revert in progress"));
3794 return run_command_v_opt(argv
, RUN_GIT_CMD
);
3797 static int commit_staged_changes(struct repository
*r
,
3798 struct replay_opts
*opts
,
3799 struct todo_list
*todo_list
)
3801 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
3802 unsigned int final_fixup
= 0, is_clean
;
3804 if (has_unstaged_changes(r
, 1))
3805 return error(_("cannot rebase: You have unstaged changes."));
3807 is_clean
= !has_uncommitted_changes(r
, 0);
3809 if (file_exists(rebase_path_amend())) {
3810 struct strbuf rev
= STRBUF_INIT
;
3811 struct object_id head
, to_amend
;
3813 if (get_oid("HEAD", &head
))
3814 return error(_("cannot amend non-existing commit"));
3815 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
3816 return error(_("invalid file: '%s'"), rebase_path_amend());
3817 if (get_oid_hex(rev
.buf
, &to_amend
))
3818 return error(_("invalid contents: '%s'"),
3819 rebase_path_amend());
3820 if (!is_clean
&& !oideq(&head
, &to_amend
))
3821 return error(_("\nYou have uncommitted changes in your "
3822 "working tree. Please, commit them\n"
3823 "first and then run 'git rebase "
3824 "--continue' again."));
3826 * When skipping a failed fixup/squash, we need to edit the
3827 * commit message, the current fixup list and count, and if it
3828 * was the last fixup/squash in the chain, we need to clean up
3829 * the commit message and if there was a squash, let the user
3832 if (!is_clean
|| !opts
->current_fixup_count
)
3833 ; /* this is not the final fixup */
3834 else if (!oideq(&head
, &to_amend
) ||
3835 !file_exists(rebase_path_stopped_sha())) {
3836 /* was a final fixup or squash done manually? */
3837 if (!is_fixup(peek_command(todo_list
, 0))) {
3838 unlink(rebase_path_fixup_msg());
3839 unlink(rebase_path_squash_msg());
3840 unlink(rebase_path_current_fixups());
3841 strbuf_reset(&opts
->current_fixups
);
3842 opts
->current_fixup_count
= 0;
3845 /* we are in a fixup/squash chain */
3846 const char *p
= opts
->current_fixups
.buf
;
3847 int len
= opts
->current_fixups
.len
;
3849 opts
->current_fixup_count
--;
3851 BUG("Incorrect current_fixups:\n%s", p
);
3852 while (len
&& p
[len
- 1] != '\n')
3854 strbuf_setlen(&opts
->current_fixups
, len
);
3855 if (write_message(p
, len
, rebase_path_current_fixups(),
3857 return error(_("could not write file: '%s'"),
3858 rebase_path_current_fixups());
3861 * If a fixup/squash in a fixup/squash chain failed, the
3862 * commit message is already correct, no need to commit
3865 * Only if it is the final command in the fixup/squash
3866 * chain, and only if the chain is longer than a single
3867 * fixup/squash command (which was just skipped), do we
3868 * actually need to re-commit with a cleaned up commit
3871 if (opts
->current_fixup_count
> 0 &&
3872 !is_fixup(peek_command(todo_list
, 0))) {
3875 * If there was not a single "squash" in the
3876 * chain, we only need to clean up the commit
3877 * message, no need to bother the user with
3878 * opening the commit message in the editor.
3880 if (!starts_with(p
, "squash ") &&
3881 !strstr(p
, "\nsquash "))
3882 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
3883 } else if (is_fixup(peek_command(todo_list
, 0))) {
3885 * We need to update the squash message to skip
3886 * the latest commit message.
3888 struct commit
*commit
;
3889 const char *path
= rebase_path_squash_msg();
3891 if (parse_head(r
, &commit
) ||
3892 !(p
= get_commit_buffer(commit
, NULL
)) ||
3893 write_message(p
, strlen(p
), path
, 0)) {
3894 unuse_commit_buffer(commit
, p
);
3895 return error(_("could not write file: "
3898 unuse_commit_buffer(commit
, p
);
3902 strbuf_release(&rev
);
3907 const char *cherry_pick_head
= git_path_cherry_pick_head(r
);
3909 if (file_exists(cherry_pick_head
) && unlink(cherry_pick_head
))
3910 return error(_("could not remove CHERRY_PICK_HEAD"));
3915 if (run_git_commit(r
, final_fixup
? NULL
: rebase_path_message(),
3917 return error(_("could not commit staged changes."));
3918 unlink(rebase_path_amend());
3919 unlink(git_path_merge_head(the_repository
));
3921 unlink(rebase_path_fixup_msg());
3922 unlink(rebase_path_squash_msg());
3924 if (opts
->current_fixup_count
> 0) {
3926 * Whether final fixup or not, we just cleaned up the commit
3929 unlink(rebase_path_current_fixups());
3930 strbuf_reset(&opts
->current_fixups
);
3931 opts
->current_fixup_count
= 0;
3936 int sequencer_continue(struct repository
*r
, struct replay_opts
*opts
)
3938 struct todo_list todo_list
= TODO_LIST_INIT
;
3941 if (read_and_refresh_cache(r
, opts
))
3944 if (read_populate_opts(opts
))
3946 if (is_rebase_i(opts
)) {
3947 if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
3948 goto release_todo_list
;
3949 if (commit_staged_changes(r
, opts
, &todo_list
))
3951 } else if (!file_exists(get_todo_path(opts
)))
3952 return continue_single_pick(r
);
3953 else if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
3954 goto release_todo_list
;
3956 if (!is_rebase_i(opts
)) {
3957 /* Verify that the conflict has been resolved */
3958 if (file_exists(git_path_cherry_pick_head(r
)) ||
3959 file_exists(git_path_revert_head(r
))) {
3960 res
= continue_single_pick(r
);
3962 goto release_todo_list
;
3964 if (index_differs_from(r
, "HEAD", NULL
, 0)) {
3965 res
= error_dirty_index(r
, opts
);
3966 goto release_todo_list
;
3968 todo_list
.current
++;
3969 } else if (file_exists(rebase_path_stopped_sha())) {
3970 struct strbuf buf
= STRBUF_INIT
;
3971 struct object_id oid
;
3973 if (read_oneliner(&buf
, rebase_path_stopped_sha(), 1) &&
3974 !get_oid_committish(buf
.buf
, &oid
))
3975 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
3976 strbuf_release(&buf
);
3979 res
= pick_commits(r
, &todo_list
, opts
);
3981 todo_list_release(&todo_list
);
3985 static int single_pick(struct repository
*r
,
3986 struct commit
*cmit
,
3987 struct replay_opts
*opts
)
3989 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
3990 return do_pick_commit(r
, opts
->action
== REPLAY_PICK
?
3991 TODO_PICK
: TODO_REVERT
, cmit
, opts
, 0);
3994 int sequencer_pick_revisions(struct repository
*r
,
3995 struct replay_opts
*opts
)
3997 struct todo_list todo_list
= TODO_LIST_INIT
;
3998 struct object_id oid
;
4002 if (read_and_refresh_cache(r
, opts
))
4005 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
4006 struct object_id oid
;
4007 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
4009 /* This happens when using --stdin. */
4013 if (!get_oid(name
, &oid
)) {
4014 if (!lookup_commit_reference_gently(r
, &oid
, 1)) {
4015 enum object_type type
= oid_object_info(r
,
4018 return error(_("%s: can't cherry-pick a %s"),
4019 name
, type_name(type
));
4022 return error(_("%s: bad revision"), name
);
4026 * If we were called as "git cherry-pick <commit>", just
4027 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4028 * REVERT_HEAD, and don't touch the sequencer state.
4029 * This means it is possible to cherry-pick in the middle
4030 * of a cherry-pick sequence.
4032 if (opts
->revs
->cmdline
.nr
== 1 &&
4033 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
4034 opts
->revs
->no_walk
&&
4035 !opts
->revs
->cmdline
.rev
->flags
) {
4036 struct commit
*cmit
;
4037 if (prepare_revision_walk(opts
->revs
))
4038 return error(_("revision walk setup failed"));
4039 cmit
= get_revision(opts
->revs
);
4041 return error(_("empty commit set passed"));
4042 if (get_revision(opts
->revs
))
4043 BUG("unexpected extra commit from walk");
4044 return single_pick(r
, cmit
, opts
);
4048 * Start a new cherry-pick/ revert sequence; but
4049 * first, make sure that an existing one isn't in
4053 if (walk_revs_populate_todo(&todo_list
, opts
) ||
4054 create_seq_dir() < 0)
4056 if (get_oid("HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
4057 return error(_("can't revert as initial commit"));
4058 if (save_head(oid_to_hex(&oid
)))
4060 if (save_opts(opts
))
4062 update_abort_safety_file();
4063 res
= pick_commits(r
, &todo_list
, opts
);
4064 todo_list_release(&todo_list
);
4068 void append_signoff(struct strbuf
*msgbuf
, size_t ignore_footer
, unsigned flag
)
4070 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
4071 struct strbuf sob
= STRBUF_INIT
;
4074 strbuf_addstr(&sob
, sign_off_header
);
4075 strbuf_addstr(&sob
, fmt_name(WANT_COMMITTER_IDENT
));
4076 strbuf_addch(&sob
, '\n');
4079 strbuf_complete_line(msgbuf
);
4082 * If the whole message buffer is equal to the sob, pretend that we
4083 * found a conforming footer with a matching sob
4085 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
4086 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
4089 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
4092 const char *append_newlines
= NULL
;
4093 size_t len
= msgbuf
->len
- ignore_footer
;
4097 * The buffer is completely empty. Leave foom for
4098 * the title and body to be filled in by the user.
4100 append_newlines
= "\n\n";
4101 } else if (len
== 1) {
4103 * Buffer contains a single newline. Add another
4104 * so that we leave room for the title and body.
4106 append_newlines
= "\n";
4107 } else if (msgbuf
->buf
[len
- 2] != '\n') {
4109 * Buffer ends with a single newline. Add another
4110 * so that there is an empty line between the message
4113 append_newlines
= "\n";
4114 } /* else, the buffer already ends with two newlines. */
4116 if (append_newlines
)
4117 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
4118 append_newlines
, strlen(append_newlines
));
4121 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
4122 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
4125 strbuf_release(&sob
);
4128 struct labels_entry
{
4129 struct hashmap_entry entry
;
4130 char label
[FLEX_ARRAY
];
4133 static int labels_cmp(const void *fndata
, const struct labels_entry
*a
,
4134 const struct labels_entry
*b
, const void *key
)
4136 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
4139 struct string_entry
{
4140 struct oidmap_entry entry
;
4141 char string
[FLEX_ARRAY
];
4144 struct label_state
{
4145 struct oidmap commit2label
;
4146 struct hashmap labels
;
4150 static const char *label_oid(struct object_id
*oid
, const char *label
,
4151 struct label_state
*state
)
4153 struct labels_entry
*labels_entry
;
4154 struct string_entry
*string_entry
;
4155 struct object_id dummy
;
4159 string_entry
= oidmap_get(&state
->commit2label
, oid
);
4161 return string_entry
->string
;
4164 * For "uninteresting" commits, i.e. commits that are not to be
4165 * rebased, and which can therefore not be labeled, we use a unique
4166 * abbreviation of the commit name. This is slightly more complicated
4167 * than calling find_unique_abbrev() because we also need to make
4168 * sure that the abbreviation does not conflict with any other
4171 * We disallow "interesting" commits to be labeled by a string that
4172 * is a valid full-length hash, to ensure that we always can find an
4173 * abbreviation for any uninteresting commit's names that does not
4174 * clash with any other label.
4179 strbuf_reset(&state
->buf
);
4180 strbuf_grow(&state
->buf
, GIT_SHA1_HEXSZ
);
4181 label
= p
= state
->buf
.buf
;
4183 find_unique_abbrev_r(p
, oid
, default_abbrev
);
4186 * We may need to extend the abbreviated hash so that there is
4187 * no conflicting label.
4189 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
4190 size_t i
= strlen(p
) + 1;
4192 oid_to_hex_r(p
, oid
);
4193 for (; i
< GIT_SHA1_HEXSZ
; i
++) {
4196 if (!hashmap_get_from_hash(&state
->labels
,
4202 } else if (((len
= strlen(label
)) == the_hash_algo
->hexsz
&&
4203 !get_oid_hex(label
, &dummy
)) ||
4204 (len
== 1 && *label
== '#') ||
4205 hashmap_get_from_hash(&state
->labels
,
4206 strihash(label
), label
)) {
4208 * If the label already exists, or if the label is a valid full
4209 * OID, or the label is a '#' (which we use as a separator
4210 * between merge heads and oneline), we append a dash and a
4211 * number to make it unique.
4213 struct strbuf
*buf
= &state
->buf
;
4216 strbuf_add(buf
, label
, len
);
4218 for (i
= 2; ; i
++) {
4219 strbuf_setlen(buf
, len
);
4220 strbuf_addf(buf
, "-%d", i
);
4221 if (!hashmap_get_from_hash(&state
->labels
,
4230 FLEX_ALLOC_STR(labels_entry
, label
, label
);
4231 hashmap_entry_init(labels_entry
, strihash(label
));
4232 hashmap_add(&state
->labels
, labels_entry
);
4234 FLEX_ALLOC_STR(string_entry
, string
, label
);
4235 oidcpy(&string_entry
->entry
.oid
, oid
);
4236 oidmap_put(&state
->commit2label
, string_entry
);
4238 return string_entry
->string
;
4241 static int make_script_with_merges(struct pretty_print_context
*pp
,
4242 struct rev_info
*revs
, struct strbuf
*out
,
4245 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
4246 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
4247 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
4248 struct strbuf label
= STRBUF_INIT
;
4249 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
4250 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
4251 struct commit
*commit
;
4252 struct oidmap commit2todo
= OIDMAP_INIT
;
4253 struct string_entry
*entry
;
4254 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
4255 shown
= OIDSET_INIT
;
4256 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
4258 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
4259 const char *cmd_pick
= abbr
? "p" : "pick",
4260 *cmd_label
= abbr
? "l" : "label",
4261 *cmd_reset
= abbr
? "t" : "reset",
4262 *cmd_merge
= abbr
? "m" : "merge";
4264 oidmap_init(&commit2todo
, 0);
4265 oidmap_init(&state
.commit2label
, 0);
4266 hashmap_init(&state
.labels
, (hashmap_cmp_fn
) labels_cmp
, NULL
, 0);
4267 strbuf_init(&state
.buf
, 32);
4269 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
4270 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
4271 FLEX_ALLOC_STR(entry
, string
, "onto");
4272 oidcpy(&entry
->entry
.oid
, oid
);
4273 oidmap_put(&state
.commit2label
, entry
);
4278 * - get onelines for all commits
4279 * - gather all branch tips (i.e. 2nd or later parents of merges)
4280 * - label all branch tips
4282 while ((commit
= get_revision(revs
))) {
4283 struct commit_list
*to_merge
;
4284 const char *p1
, *p2
;
4285 struct object_id
*oid
;
4288 tail
= &commit_list_insert(commit
, tail
)->next
;
4289 oidset_insert(&interesting
, &commit
->object
.oid
);
4291 is_empty
= is_original_commit_empty(commit
);
4292 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
))
4295 strbuf_reset(&oneline
);
4296 pretty_print_commit(pp
, commit
, &oneline
);
4298 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
4300 /* non-merge commit: easy case */
4302 if (!keep_empty
&& is_empty
)
4303 strbuf_addf(&buf
, "%c ", comment_line_char
);
4304 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
4305 oid_to_hex(&commit
->object
.oid
),
4308 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
4309 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
4310 oidmap_put(&commit2todo
, entry
);
4315 /* Create a label */
4316 strbuf_reset(&label
);
4317 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
4318 (p1
= strchr(p1
, '\'')) &&
4319 (p2
= strchr(++p1
, '\'')))
4320 strbuf_add(&label
, p1
, p2
- p1
);
4321 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
4323 (p1
= strstr(p1
, " from ")))
4324 strbuf_addstr(&label
, p1
+ strlen(" from "));
4326 strbuf_addbuf(&label
, &oneline
);
4328 for (p1
= label
.buf
; *p1
; p1
++)
4333 strbuf_addf(&buf
, "%s -C %s",
4334 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
4336 /* label the tips of merged branches */
4337 for (; to_merge
; to_merge
= to_merge
->next
) {
4338 oid
= &to_merge
->item
->object
.oid
;
4339 strbuf_addch(&buf
, ' ');
4341 if (!oidset_contains(&interesting
, oid
)) {
4342 strbuf_addstr(&buf
, label_oid(oid
, NULL
,
4347 tips_tail
= &commit_list_insert(to_merge
->item
,
4350 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
4352 strbuf_addf(&buf
, " # %s", oneline
.buf
);
4354 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
4355 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
4356 oidmap_put(&commit2todo
, entry
);
4361 * - label branch points
4362 * - add HEAD to the branch tips
4364 for (iter
= commits
; iter
; iter
= iter
->next
) {
4365 struct commit_list
*parent
= iter
->item
->parents
;
4366 for (; parent
; parent
= parent
->next
) {
4367 struct object_id
*oid
= &parent
->item
->object
.oid
;
4368 if (!oidset_contains(&interesting
, oid
))
4370 if (oidset_insert(&child_seen
, oid
))
4371 label_oid(oid
, "branch-point", &state
);
4374 /* Add HEAD as implict "tip of branch" */
4376 tips_tail
= &commit_list_insert(iter
->item
,
4381 * Third phase: output the todo list. This is a bit tricky, as we
4382 * want to avoid jumping back and forth between revisions. To
4383 * accomplish that goal, we walk backwards from the branch tips,
4384 * gathering commits not yet shown, reversing the list on the fly,
4385 * then outputting that list (labeling revisions as needed).
4387 strbuf_addf(out
, "%s onto\n", cmd_label
);
4388 for (iter
= tips
; iter
; iter
= iter
->next
) {
4389 struct commit_list
*list
= NULL
, *iter2
;
4391 commit
= iter
->item
;
4392 if (oidset_contains(&shown
, &commit
->object
.oid
))
4394 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
4397 strbuf_addf(out
, "\n%c Branch %s\n", comment_line_char
, entry
->string
);
4399 strbuf_addch(out
, '\n');
4401 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
4402 !oidset_contains(&shown
, &commit
->object
.oid
)) {
4403 commit_list_insert(commit
, &list
);
4404 if (!commit
->parents
) {
4408 commit
= commit
->parents
->item
;
4412 strbuf_addf(out
, "%s %s\n", cmd_reset
,
4413 rebase_cousins
? "onto" : "[new root]");
4415 const char *to
= NULL
;
4417 entry
= oidmap_get(&state
.commit2label
,
4418 &commit
->object
.oid
);
4421 else if (!rebase_cousins
)
4422 to
= label_oid(&commit
->object
.oid
, NULL
,
4425 if (!to
|| !strcmp(to
, "onto"))
4426 strbuf_addf(out
, "%s onto\n", cmd_reset
);
4428 strbuf_reset(&oneline
);
4429 pretty_print_commit(pp
, commit
, &oneline
);
4430 strbuf_addf(out
, "%s %s # %s\n",
4431 cmd_reset
, to
, oneline
.buf
);
4435 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
4436 struct object_id
*oid
= &iter2
->item
->object
.oid
;
4437 entry
= oidmap_get(&commit2todo
, oid
);
4438 /* only show if not already upstream */
4440 strbuf_addf(out
, "%s\n", entry
->string
);
4441 entry
= oidmap_get(&state
.commit2label
, oid
);
4443 strbuf_addf(out
, "%s %s\n",
4444 cmd_label
, entry
->string
);
4445 oidset_insert(&shown
, oid
);
4448 free_commit_list(list
);
4451 free_commit_list(commits
);
4452 free_commit_list(tips
);
4454 strbuf_release(&label
);
4455 strbuf_release(&oneline
);
4456 strbuf_release(&buf
);
4458 oidmap_free(&commit2todo
, 1);
4459 oidmap_free(&state
.commit2label
, 1);
4460 hashmap_free(&state
.labels
, 1);
4461 strbuf_release(&state
.buf
);
4466 int sequencer_make_script(struct repository
*r
, struct strbuf
*out
, int argc
,
4467 const char **argv
, unsigned flags
)
4469 char *format
= NULL
;
4470 struct pretty_print_context pp
= {0};
4471 struct rev_info revs
;
4472 struct commit
*commit
;
4473 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
4474 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
4475 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
4477 repo_init_revisions(r
, &revs
, NULL
);
4478 revs
.verbose_header
= 1;
4480 revs
.max_parents
= 1;
4481 revs
.cherry_mark
= 1;
4484 revs
.right_only
= 1;
4485 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
4486 revs
.topo_order
= 1;
4488 revs
.pretty_given
= 1;
4489 git_config_get_string("rebase.instructionFormat", &format
);
4490 if (!format
|| !*format
) {
4492 format
= xstrdup("%s");
4494 get_commit_format(format
, &revs
);
4496 pp
.fmt
= revs
.commit_format
;
4497 pp
.output_encoding
= get_log_output_encoding();
4499 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1)
4500 return error(_("make_script: unhandled options"));
4502 if (prepare_revision_walk(&revs
) < 0)
4503 return error(_("make_script: error preparing revisions"));
4506 return make_script_with_merges(&pp
, &revs
, out
, flags
);
4508 while ((commit
= get_revision(&revs
))) {
4509 int is_empty
= is_original_commit_empty(commit
);
4511 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
))
4513 if (!keep_empty
&& is_empty
)
4514 strbuf_addf(out
, "%c ", comment_line_char
);
4515 strbuf_addf(out
, "%s %s ", insn
,
4516 oid_to_hex(&commit
->object
.oid
));
4517 pretty_print_commit(&pp
, commit
, out
);
4518 strbuf_addch(out
, '\n');
4524 * Add commands after pick and (series of) squash/fixup commands
4527 void todo_list_add_exec_commands(struct todo_list
*todo_list
,
4528 struct string_list
*commands
)
4530 struct strbuf
*buf
= &todo_list
->buf
;
4531 size_t base_offset
= buf
->len
;
4532 int i
, insert
, nr
= 0, alloc
= 0;
4533 struct todo_item
*items
= NULL
, *base_items
= NULL
;
4535 base_items
= xcalloc(commands
->nr
, sizeof(struct todo_item
));
4536 for (i
= 0; i
< commands
->nr
; i
++) {
4537 size_t command_len
= strlen(commands
->items
[i
].string
);
4539 strbuf_addstr(buf
, commands
->items
[i
].string
);
4540 strbuf_addch(buf
, '\n');
4542 base_items
[i
].command
= TODO_EXEC
;
4543 base_items
[i
].offset_in_buf
= base_offset
;
4544 base_items
[i
].arg_offset
= base_offset
+ strlen("exec ");
4545 base_items
[i
].arg_len
= command_len
- strlen("exec ");
4547 base_offset
+= command_len
+ 1;
4551 * Insert <commands> after every pick. Here, fixup/squash chains
4552 * are considered part of the pick, so we insert the commands *after*
4553 * those chains if there are any.
4555 * As we insert the exec commands immediatly after rearranging
4556 * any fixups and before the user edits the list, a fixup chain
4557 * can never contain comments (any comments are empty picks that
4558 * have been commented out because the user did not specify
4559 * --keep-empty). So, it is safe to insert an exec command
4560 * without looking at the command following a comment.
4563 for (i
= 0; i
< todo_list
->nr
; i
++) {
4564 enum todo_command command
= todo_list
->items
[i
].command
;
4565 if (insert
&& !is_fixup(command
)) {
4566 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
4567 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
4573 ALLOC_GROW(items
, nr
+ 1, alloc
);
4574 items
[nr
++] = todo_list
->items
[i
];
4576 if (command
== TODO_PICK
|| command
== TODO_MERGE
)
4580 /* insert or append final <commands> */
4581 if (insert
|| nr
== todo_list
->nr
) {
4582 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
4583 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
4588 FREE_AND_NULL(todo_list
->items
);
4589 todo_list
->items
= items
;
4591 todo_list
->alloc
= alloc
;
4594 static void todo_list_to_strbuf(struct repository
*r
, struct todo_list
*todo_list
,
4595 struct strbuf
*buf
, int num
, unsigned flags
)
4597 struct todo_item
*item
;
4598 int i
, max
= todo_list
->nr
;
4600 if (num
> 0 && num
< max
)
4603 for (item
= todo_list
->items
, i
= 0; i
< max
; i
++, item
++) {
4604 /* if the item is not a command write it and continue */
4605 if (item
->command
>= TODO_COMMENT
) {
4606 strbuf_addf(buf
, "%.*s\n", item
->arg_len
,
4607 todo_item_get_arg(todo_list
, item
));
4611 /* add command to the buffer */
4612 if (flags
& TODO_LIST_ABBREVIATE_CMDS
)
4613 strbuf_addch(buf
, command_to_char(item
->command
));
4615 strbuf_addstr(buf
, command_to_string(item
->command
));
4619 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
4620 short_commit_name(item
->commit
) :
4621 oid_to_hex(&item
->commit
->object
.oid
);
4623 if (item
->command
== TODO_MERGE
) {
4624 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
4625 strbuf_addstr(buf
, " -c");
4627 strbuf_addstr(buf
, " -C");
4630 strbuf_addf(buf
, " %s", oid
);
4633 /* add all the rest */
4635 strbuf_addch(buf
, '\n');
4637 strbuf_addf(buf
, " %.*s\n", item
->arg_len
,
4638 todo_item_get_arg(todo_list
, item
));
4642 int todo_list_write_to_file(struct repository
*r
, struct todo_list
*todo_list
,
4643 const char *file
, const char *shortrevisions
,
4644 const char *shortonto
, int num
, unsigned flags
)
4647 struct strbuf buf
= STRBUF_INIT
;
4649 todo_list_to_strbuf(r
, todo_list
, &buf
, num
, flags
);
4650 if (flags
& TODO_LIST_APPEND_TODO_HELP
)
4651 append_todo_help(flags
& TODO_LIST_KEEP_EMPTY
, count_commands(todo_list
),
4652 shortrevisions
, shortonto
, &buf
);
4654 res
= write_message(buf
.buf
, buf
.len
, file
, 0);
4655 strbuf_release(&buf
);
4660 static const char edit_todo_list_advice
[] =
4661 N_("You can fix this with 'git rebase --edit-todo' "
4662 "and then run 'git rebase --continue'.\n"
4663 "Or you can abort the rebase with 'git rebase"
4666 int check_todo_list_from_file(struct repository
*r
)
4668 struct todo_list old_todo
= TODO_LIST_INIT
, new_todo
= TODO_LIST_INIT
;
4671 if (strbuf_read_file_or_whine(&new_todo
.buf
, rebase_path_todo()) < 0) {
4676 if (strbuf_read_file_or_whine(&old_todo
.buf
, rebase_path_todo_backup()) < 0) {
4681 res
= todo_list_parse_insn_buffer(r
, old_todo
.buf
.buf
, &old_todo
);
4683 res
= todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
);
4685 res
= todo_list_check(&old_todo
, &new_todo
);
4687 fprintf(stderr
, _(edit_todo_list_advice
));
4689 todo_list_release(&old_todo
);
4690 todo_list_release(&new_todo
);
4695 /* skip picking commits whose parents are unchanged */
4696 static int skip_unnecessary_picks(struct repository
*r
,
4697 struct todo_list
*todo_list
,
4698 struct object_id
*base_oid
)
4700 struct object_id
*parent_oid
;
4703 for (i
= 0; i
< todo_list
->nr
; i
++) {
4704 struct todo_item
*item
= todo_list
->items
+ i
;
4706 if (item
->command
>= TODO_NOOP
)
4708 if (item
->command
!= TODO_PICK
)
4710 if (parse_commit(item
->commit
)) {
4711 return error(_("could not parse commit '%s'"),
4712 oid_to_hex(&item
->commit
->object
.oid
));
4714 if (!item
->commit
->parents
)
4715 break; /* root commit */
4716 if (item
->commit
->parents
->next
)
4717 break; /* merge commit */
4718 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
4719 if (!oideq(parent_oid
, base_oid
))
4721 oidcpy(base_oid
, &item
->commit
->object
.oid
);
4724 const char *done_path
= rebase_path_done();
4726 if (todo_list_write_to_file(r
, todo_list
, done_path
, NULL
, NULL
, i
, 0)) {
4727 error_errno(_("could not write to '%s'"), done_path
);
4731 MOVE_ARRAY(todo_list
->items
, todo_list
->items
+ i
, todo_list
->nr
- i
);
4733 todo_list
->current
= 0;
4735 if (is_fixup(peek_command(todo_list
, 0)))
4736 record_in_rewritten(base_oid
, peek_command(todo_list
, 0));
4742 int complete_action(struct repository
*r
, struct replay_opts
*opts
, unsigned flags
,
4743 const char *shortrevisions
, const char *onto_name
,
4744 const char *onto
, const char *orig_head
, struct string_list
*commands
,
4745 unsigned autosquash
, struct todo_list
*todo_list
)
4747 const char *shortonto
, *todo_file
= rebase_path_todo();
4748 struct todo_list new_todo
= TODO_LIST_INIT
;
4749 struct strbuf
*buf
= &todo_list
->buf
;
4750 struct object_id oid
;
4753 get_oid(onto
, &oid
);
4754 shortonto
= find_unique_abbrev(&oid
, DEFAULT_ABBREV
);
4756 if (buf
->len
== 0) {
4757 struct todo_item
*item
= append_new_todo(todo_list
);
4758 item
->command
= TODO_NOOP
;
4759 item
->commit
= NULL
;
4760 item
->arg_len
= item
->arg_offset
= item
->flags
= item
->offset_in_buf
= 0;
4763 if (autosquash
&& todo_list_rearrange_squash(todo_list
))
4767 todo_list_add_exec_commands(todo_list
, commands
);
4769 if (count_commands(todo_list
) == 0) {
4770 apply_autostash(opts
);
4771 sequencer_remove_state(opts
);
4773 return error(_("nothing to do"));
4776 res
= edit_todo_list(r
, todo_list
, &new_todo
, shortrevisions
,
4780 else if (res
== -2) {
4781 apply_autostash(opts
);
4782 sequencer_remove_state(opts
);
4785 } else if (res
== -3) {
4786 apply_autostash(opts
);
4787 sequencer_remove_state(opts
);
4788 todo_list_release(&new_todo
);
4790 return error(_("nothing to do"));
4793 if (todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
) ||
4794 todo_list_check(todo_list
, &new_todo
)) {
4795 fprintf(stderr
, _(edit_todo_list_advice
));
4796 checkout_onto(r
, opts
, onto_name
, onto
, orig_head
);
4797 todo_list_release(&new_todo
);
4802 if (opts
->allow_ff
&& skip_unnecessary_picks(r
, &new_todo
, &oid
)) {
4803 todo_list_release(&new_todo
);
4804 return error(_("could not skip unnecessary pick commands"));
4807 if (todo_list_write_to_file(r
, &new_todo
, todo_file
, NULL
, NULL
, -1,
4808 flags
& ~(TODO_LIST_SHORTEN_IDS
))) {
4809 todo_list_release(&new_todo
);
4810 return error_errno(_("could not write '%s'"), todo_file
);
4813 todo_list_release(&new_todo
);
4815 if (checkout_onto(r
, opts
, onto_name
, oid_to_hex(&oid
), orig_head
))
4818 if (require_clean_work_tree(r
, "rebase", "", 1, 1))
4821 return sequencer_continue(r
, opts
);
4824 struct subject2item_entry
{
4825 struct hashmap_entry entry
;
4827 char subject
[FLEX_ARRAY
];
4830 static int subject2item_cmp(const void *fndata
,
4831 const struct subject2item_entry
*a
,
4832 const struct subject2item_entry
*b
, const void *key
)
4834 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
4837 define_commit_slab(commit_todo_item
, struct todo_item
*);
4840 * Rearrange the todo list that has both "pick commit-id msg" and "pick
4841 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
4842 * after the former, and change "pick" to "fixup"/"squash".
4844 * Note that if the config has specified a custom instruction format, each log
4845 * message will have to be retrieved from the commit (as the oneline in the
4846 * script cannot be trusted) in order to normalize the autosquash arrangement.
4848 int todo_list_rearrange_squash(struct todo_list
*todo_list
)
4850 struct hashmap subject2item
;
4851 int rearranged
= 0, *next
, *tail
, i
, nr
= 0, alloc
= 0;
4853 struct commit_todo_item commit_todo
;
4854 struct todo_item
*items
= NULL
;
4856 init_commit_todo_item(&commit_todo
);
4858 * The hashmap maps onelines to the respective todo list index.
4860 * If any items need to be rearranged, the next[i] value will indicate
4861 * which item was moved directly after the i'th.
4863 * In that case, last[i] will indicate the index of the latest item to
4864 * be moved to appear after the i'th.
4866 hashmap_init(&subject2item
, (hashmap_cmp_fn
) subject2item_cmp
,
4867 NULL
, todo_list
->nr
);
4868 ALLOC_ARRAY(next
, todo_list
->nr
);
4869 ALLOC_ARRAY(tail
, todo_list
->nr
);
4870 ALLOC_ARRAY(subjects
, todo_list
->nr
);
4871 for (i
= 0; i
< todo_list
->nr
; i
++) {
4872 struct strbuf buf
= STRBUF_INIT
;
4873 struct todo_item
*item
= todo_list
->items
+ i
;
4874 const char *commit_buffer
, *subject
, *p
;
4877 struct subject2item_entry
*entry
;
4879 next
[i
] = tail
[i
] = -1;
4880 if (!item
->commit
|| item
->command
== TODO_DROP
) {
4885 if (is_fixup(item
->command
)) {
4886 clear_commit_todo_item(&commit_todo
);
4887 return error(_("the script was already rearranged."));
4890 *commit_todo_item_at(&commit_todo
, item
->commit
) = item
;
4892 parse_commit(item
->commit
);
4893 commit_buffer
= get_commit_buffer(item
->commit
, NULL
);
4894 find_commit_subject(commit_buffer
, &subject
);
4895 format_subject(&buf
, subject
, " ");
4896 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
4897 unuse_commit_buffer(item
->commit
, commit_buffer
);
4898 if ((skip_prefix(subject
, "fixup! ", &p
) ||
4899 skip_prefix(subject
, "squash! ", &p
))) {
4900 struct commit
*commit2
;
4905 if (!skip_prefix(p
, "fixup! ", &p
) &&
4906 !skip_prefix(p
, "squash! ", &p
))
4910 if ((entry
= hashmap_get_from_hash(&subject2item
,
4912 /* found by title */
4914 else if (!strchr(p
, ' ') &&
4916 lookup_commit_reference_by_name(p
)) &&
4917 *commit_todo_item_at(&commit_todo
, commit2
))
4918 /* found by commit name */
4919 i2
= *commit_todo_item_at(&commit_todo
, commit2
)
4922 /* copy can be a prefix of the commit subject */
4923 for (i2
= 0; i2
< i
; i2
++)
4925 starts_with(subjects
[i2
], p
))
4933 todo_list
->items
[i
].command
=
4934 starts_with(subject
, "fixup!") ?
4935 TODO_FIXUP
: TODO_SQUASH
;
4941 } else if (!hashmap_get_from_hash(&subject2item
,
4942 strhash(subject
), subject
)) {
4943 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
4945 hashmap_entry_init(entry
, strhash(entry
->subject
));
4946 hashmap_put(&subject2item
, entry
);
4951 for (i
= 0; i
< todo_list
->nr
; i
++) {
4952 enum todo_command command
= todo_list
->items
[i
].command
;
4956 * Initially, all commands are 'pick's. If it is a
4957 * fixup or a squash now, we have rearranged it.
4959 if (is_fixup(command
))
4963 ALLOC_GROW(items
, nr
+ 1, alloc
);
4964 items
[nr
++] = todo_list
->items
[cur
];
4969 FREE_AND_NULL(todo_list
->items
);
4970 todo_list
->items
= items
;
4972 todo_list
->alloc
= alloc
;
4977 for (i
= 0; i
< todo_list
->nr
; i
++)
4980 hashmap_free(&subject2item
, 1);
4982 clear_commit_todo_item(&commit_todo
);