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 replay_opts
*opts
, const char *commit
,
3424 struct child_process cmd
= CHILD_PROCESS_INIT
;
3428 argv_array_push(&cmd
.args
, "checkout");
3429 argv_array_push(&cmd
.args
, commit
);
3430 argv_array_pushf(&cmd
.env_array
, GIT_REFLOG_ACTION
"=%s", action
);
3433 return run_command(&cmd
);
3435 return run_command_silent_on_success(&cmd
);
3438 int prepare_branch_to_be_rebased(struct replay_opts
*opts
, const char *commit
)
3442 if (commit
&& *commit
) {
3443 action
= reflog_message(opts
, "start", "checkout %s", commit
);
3444 if (run_git_checkout(opts
, commit
, action
))
3445 return error(_("could not checkout %s"), commit
);
3451 static int checkout_onto(struct replay_opts
*opts
,
3452 const char *onto_name
, const char *onto
,
3453 const char *orig_head
)
3455 struct object_id oid
;
3456 const char *action
= reflog_message(opts
, "start", "checkout %s", onto_name
);
3458 if (get_oid(orig_head
, &oid
))
3459 return error(_("%s: not a valid OID"), orig_head
);
3461 if (run_git_checkout(opts
, onto
, action
)) {
3462 apply_autostash(opts
);
3463 sequencer_remove_state(opts
);
3464 return error(_("could not detach HEAD"));
3467 return update_ref(NULL
, "ORIG_HEAD", &oid
, NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3470 static int stopped_at_head(struct repository
*r
)
3472 struct object_id head
;
3473 struct commit
*commit
;
3474 struct commit_message message
;
3476 if (get_oid("HEAD", &head
) ||
3477 !(commit
= lookup_commit(r
, &head
)) ||
3478 parse_commit(commit
) || get_message(commit
, &message
))
3479 fprintf(stderr
, _("Stopped at HEAD\n"));
3481 fprintf(stderr
, _("Stopped at %s\n"), message
.label
);
3482 free_message(commit
, &message
);
3488 static const char rescheduled_advice
[] =
3489 N_("Could not execute the todo command\n"
3493 "It has been rescheduled; To edit the command before continuing, please\n"
3494 "edit the todo list first:\n"
3496 " git rebase --edit-todo\n"
3497 " git rebase --continue\n");
3499 static int pick_commits(struct repository
*r
,
3500 struct todo_list
*todo_list
,
3501 struct replay_opts
*opts
)
3503 int res
= 0, reschedule
= 0;
3505 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
3507 assert(!(opts
->signoff
|| opts
->no_commit
||
3508 opts
->record_origin
|| opts
->edit
));
3509 if (read_and_refresh_cache(r
, opts
))
3512 while (todo_list
->current
< todo_list
->nr
) {
3513 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
3514 const char *arg
= todo_item_get_arg(todo_list
, item
);
3516 if (save_todo(todo_list
, opts
))
3518 if (is_rebase_i(opts
)) {
3519 if (item
->command
!= TODO_COMMENT
) {
3520 FILE *f
= fopen(rebase_path_msgnum(), "w");
3522 todo_list
->done_nr
++;
3525 fprintf(f
, "%d\n", todo_list
->done_nr
);
3529 fprintf(stderr
, "Rebasing (%d/%d)%s",
3531 todo_list
->total_nr
,
3532 opts
->verbose
? "\n" : "\r");
3534 unlink(rebase_path_message());
3535 unlink(rebase_path_author_script());
3536 unlink(rebase_path_stopped_sha());
3537 unlink(rebase_path_amend());
3538 unlink(git_path_merge_head(the_repository
));
3539 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
3541 if (item
->command
== TODO_BREAK
)
3542 return stopped_at_head(r
);
3544 if (item
->command
<= TODO_SQUASH
) {
3545 if (is_rebase_i(opts
))
3546 setenv("GIT_REFLOG_ACTION", reflog_message(opts
,
3547 command_to_string(item
->command
), NULL
),
3549 res
= do_pick_commit(r
, item
->command
, item
->commit
,
3550 opts
, is_final_fixup(todo_list
));
3551 if (is_rebase_i(opts
) && res
< 0) {
3553 advise(_(rescheduled_advice
),
3554 get_item_line_length(todo_list
,
3555 todo_list
->current
),
3556 get_item_line(todo_list
,
3557 todo_list
->current
));
3558 todo_list
->current
--;
3559 if (save_todo(todo_list
, opts
))
3562 if (item
->command
== TODO_EDIT
) {
3563 struct commit
*commit
= item
->commit
;
3566 _("Stopped at %s... %.*s\n"),
3567 short_commit_name(commit
),
3568 item
->arg_len
, arg
);
3569 return error_with_patch(r
, commit
,
3570 arg
, item
->arg_len
, opts
, res
, !res
);
3572 if (is_rebase_i(opts
) && !res
)
3573 record_in_rewritten(&item
->commit
->object
.oid
,
3574 peek_command(todo_list
, 1));
3575 if (res
&& is_fixup(item
->command
)) {
3578 return error_failed_squash(r
, item
->commit
, opts
,
3579 item
->arg_len
, arg
);
3580 } else if (res
&& is_rebase_i(opts
) && item
->commit
) {
3582 struct object_id oid
;
3585 * If we are rewording and have either
3586 * fast-forwarded already, or are about to
3587 * create a new root commit, we want to amend,
3588 * otherwise we do not.
3590 if (item
->command
== TODO_REWORD
&&
3591 !get_oid("HEAD", &oid
) &&
3592 (oideq(&item
->commit
->object
.oid
, &oid
) ||
3593 (opts
->have_squash_onto
&&
3594 oideq(&opts
->squash_onto
, &oid
))))
3597 return res
| error_with_patch(r
, item
->commit
,
3598 arg
, item
->arg_len
, opts
,
3601 } else if (item
->command
== TODO_EXEC
) {
3602 char *end_of_arg
= (char *)(arg
+ item
->arg_len
);
3603 int saved
= *end_of_arg
;
3607 res
= do_exec(r
, arg
);
3608 *end_of_arg
= saved
;
3610 /* Reread the todo file if it has changed. */
3612 if (opts
->reschedule_failed_exec
)
3614 } else if (stat(get_todo_path(opts
), &st
))
3615 res
= error_errno(_("could not stat '%s'"),
3616 get_todo_path(opts
));
3617 else if (match_stat_data(&todo_list
->stat
, &st
)) {
3618 todo_list_release(todo_list
);
3619 if (read_populate_todo(r
, todo_list
, opts
))
3620 res
= -1; /* message was printed */
3621 /* `current` will be incremented below */
3622 todo_list
->current
= -1;
3624 } else if (item
->command
== TODO_LABEL
) {
3625 if ((res
= do_label(r
, arg
, item
->arg_len
)))
3627 } else if (item
->command
== TODO_RESET
) {
3628 if ((res
= do_reset(r
, arg
, item
->arg_len
, opts
)))
3630 } else if (item
->command
== TODO_MERGE
) {
3631 if ((res
= do_merge(r
, item
->commit
,
3633 item
->flags
, opts
)) < 0)
3635 else if (item
->commit
)
3636 record_in_rewritten(&item
->commit
->object
.oid
,
3637 peek_command(todo_list
, 1));
3639 /* failed with merge conflicts */
3640 return error_with_patch(r
, item
->commit
,
3643 } else if (!is_noop(item
->command
))
3644 return error(_("unknown command %d"), item
->command
);
3647 advise(_(rescheduled_advice
),
3648 get_item_line_length(todo_list
,
3649 todo_list
->current
),
3650 get_item_line(todo_list
, todo_list
->current
));
3651 todo_list
->current
--;
3652 if (save_todo(todo_list
, opts
))
3655 return error_with_patch(r
,
3661 todo_list
->current
++;
3666 if (is_rebase_i(opts
)) {
3667 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
3670 /* Stopped in the middle, as planned? */
3671 if (todo_list
->current
< todo_list
->nr
)
3674 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
3675 starts_with(head_ref
.buf
, "refs/")) {
3677 struct object_id head
, orig
;
3680 if (get_oid("HEAD", &head
)) {
3681 res
= error(_("cannot read HEAD"));
3683 strbuf_release(&head_ref
);
3684 strbuf_release(&buf
);
3687 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
3688 get_oid_hex(buf
.buf
, &orig
)) {
3689 res
= error(_("could not read orig-head"));
3690 goto cleanup_head_ref
;
3693 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
3694 res
= error(_("could not read 'onto'"));
3695 goto cleanup_head_ref
;
3697 msg
= reflog_message(opts
, "finish", "%s onto %s",
3698 head_ref
.buf
, buf
.buf
);
3699 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
3700 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
3701 res
= error(_("could not update %s"),
3703 goto cleanup_head_ref
;
3705 msg
= reflog_message(opts
, "finish", "returning to %s",
3707 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
3708 res
= error(_("could not update HEAD to %s"),
3710 goto cleanup_head_ref
;
3715 if (opts
->verbose
) {
3716 struct rev_info log_tree_opt
;
3717 struct object_id orig
, head
;
3719 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3720 repo_init_revisions(r
, &log_tree_opt
, NULL
);
3721 log_tree_opt
.diff
= 1;
3722 log_tree_opt
.diffopt
.output_format
=
3723 DIFF_FORMAT_DIFFSTAT
;
3724 log_tree_opt
.disable_stdin
= 1;
3726 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
3727 !get_oid(buf
.buf
, &orig
) &&
3728 !get_oid("HEAD", &head
)) {
3729 diff_tree_oid(&orig
, &head
, "",
3730 &log_tree_opt
.diffopt
);
3731 log_tree_diff_flush(&log_tree_opt
);
3734 flush_rewritten_pending();
3735 if (!stat(rebase_path_rewritten_list(), &st
) &&
3737 struct child_process child
= CHILD_PROCESS_INIT
;
3738 const char *post_rewrite_hook
=
3739 find_hook("post-rewrite");
3741 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
3743 argv_array_push(&child
.args
, "notes");
3744 argv_array_push(&child
.args
, "copy");
3745 argv_array_push(&child
.args
, "--for-rewrite=rebase");
3746 /* we don't care if this copying failed */
3747 run_command(&child
);
3749 if (post_rewrite_hook
) {
3750 struct child_process hook
= CHILD_PROCESS_INIT
;
3752 hook
.in
= open(rebase_path_rewritten_list(),
3754 hook
.stdout_to_stderr
= 1;
3755 hook
.trace2_hook_name
= "post-rewrite";
3756 argv_array_push(&hook
.args
, post_rewrite_hook
);
3757 argv_array_push(&hook
.args
, "rebase");
3758 /* we don't care if this hook failed */
3762 apply_autostash(opts
);
3766 "Successfully rebased and updated %s.\n",
3769 strbuf_release(&buf
);
3770 strbuf_release(&head_ref
);
3774 * Sequence of picks finished successfully; cleanup by
3775 * removing the .git/sequencer directory
3777 return sequencer_remove_state(opts
);
3780 static int continue_single_pick(struct repository
*r
)
3782 const char *argv
[] = { "commit", NULL
};
3784 if (!file_exists(git_path_cherry_pick_head(r
)) &&
3785 !file_exists(git_path_revert_head(r
)))
3786 return error(_("no cherry-pick or revert in progress"));
3787 return run_command_v_opt(argv
, RUN_GIT_CMD
);
3790 static int commit_staged_changes(struct repository
*r
,
3791 struct replay_opts
*opts
,
3792 struct todo_list
*todo_list
)
3794 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
3795 unsigned int final_fixup
= 0, is_clean
;
3797 if (has_unstaged_changes(r
, 1))
3798 return error(_("cannot rebase: You have unstaged changes."));
3800 is_clean
= !has_uncommitted_changes(r
, 0);
3802 if (file_exists(rebase_path_amend())) {
3803 struct strbuf rev
= STRBUF_INIT
;
3804 struct object_id head
, to_amend
;
3806 if (get_oid("HEAD", &head
))
3807 return error(_("cannot amend non-existing commit"));
3808 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
3809 return error(_("invalid file: '%s'"), rebase_path_amend());
3810 if (get_oid_hex(rev
.buf
, &to_amend
))
3811 return error(_("invalid contents: '%s'"),
3812 rebase_path_amend());
3813 if (!is_clean
&& !oideq(&head
, &to_amend
))
3814 return error(_("\nYou have uncommitted changes in your "
3815 "working tree. Please, commit them\n"
3816 "first and then run 'git rebase "
3817 "--continue' again."));
3819 * When skipping a failed fixup/squash, we need to edit the
3820 * commit message, the current fixup list and count, and if it
3821 * was the last fixup/squash in the chain, we need to clean up
3822 * the commit message and if there was a squash, let the user
3825 if (!is_clean
|| !opts
->current_fixup_count
)
3826 ; /* this is not the final fixup */
3827 else if (!oideq(&head
, &to_amend
) ||
3828 !file_exists(rebase_path_stopped_sha())) {
3829 /* was a final fixup or squash done manually? */
3830 if (!is_fixup(peek_command(todo_list
, 0))) {
3831 unlink(rebase_path_fixup_msg());
3832 unlink(rebase_path_squash_msg());
3833 unlink(rebase_path_current_fixups());
3834 strbuf_reset(&opts
->current_fixups
);
3835 opts
->current_fixup_count
= 0;
3838 /* we are in a fixup/squash chain */
3839 const char *p
= opts
->current_fixups
.buf
;
3840 int len
= opts
->current_fixups
.len
;
3842 opts
->current_fixup_count
--;
3844 BUG("Incorrect current_fixups:\n%s", p
);
3845 while (len
&& p
[len
- 1] != '\n')
3847 strbuf_setlen(&opts
->current_fixups
, len
);
3848 if (write_message(p
, len
, rebase_path_current_fixups(),
3850 return error(_("could not write file: '%s'"),
3851 rebase_path_current_fixups());
3854 * If a fixup/squash in a fixup/squash chain failed, the
3855 * commit message is already correct, no need to commit
3858 * Only if it is the final command in the fixup/squash
3859 * chain, and only if the chain is longer than a single
3860 * fixup/squash command (which was just skipped), do we
3861 * actually need to re-commit with a cleaned up commit
3864 if (opts
->current_fixup_count
> 0 &&
3865 !is_fixup(peek_command(todo_list
, 0))) {
3868 * If there was not a single "squash" in the
3869 * chain, we only need to clean up the commit
3870 * message, no need to bother the user with
3871 * opening the commit message in the editor.
3873 if (!starts_with(p
, "squash ") &&
3874 !strstr(p
, "\nsquash "))
3875 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
3876 } else if (is_fixup(peek_command(todo_list
, 0))) {
3878 * We need to update the squash message to skip
3879 * the latest commit message.
3881 struct commit
*commit
;
3882 const char *path
= rebase_path_squash_msg();
3884 if (parse_head(r
, &commit
) ||
3885 !(p
= get_commit_buffer(commit
, NULL
)) ||
3886 write_message(p
, strlen(p
), path
, 0)) {
3887 unuse_commit_buffer(commit
, p
);
3888 return error(_("could not write file: "
3891 unuse_commit_buffer(commit
, p
);
3895 strbuf_release(&rev
);
3900 const char *cherry_pick_head
= git_path_cherry_pick_head(r
);
3902 if (file_exists(cherry_pick_head
) && unlink(cherry_pick_head
))
3903 return error(_("could not remove CHERRY_PICK_HEAD"));
3908 if (run_git_commit(r
, final_fixup
? NULL
: rebase_path_message(),
3910 return error(_("could not commit staged changes."));
3911 unlink(rebase_path_amend());
3912 unlink(git_path_merge_head(the_repository
));
3914 unlink(rebase_path_fixup_msg());
3915 unlink(rebase_path_squash_msg());
3917 if (opts
->current_fixup_count
> 0) {
3919 * Whether final fixup or not, we just cleaned up the commit
3922 unlink(rebase_path_current_fixups());
3923 strbuf_reset(&opts
->current_fixups
);
3924 opts
->current_fixup_count
= 0;
3929 int sequencer_continue(struct repository
*r
, struct replay_opts
*opts
)
3931 struct todo_list todo_list
= TODO_LIST_INIT
;
3934 if (read_and_refresh_cache(r
, opts
))
3937 if (read_populate_opts(opts
))
3939 if (is_rebase_i(opts
)) {
3940 if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
3941 goto release_todo_list
;
3942 if (commit_staged_changes(r
, opts
, &todo_list
))
3944 } else if (!file_exists(get_todo_path(opts
)))
3945 return continue_single_pick(r
);
3946 else if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
3947 goto release_todo_list
;
3949 if (!is_rebase_i(opts
)) {
3950 /* Verify that the conflict has been resolved */
3951 if (file_exists(git_path_cherry_pick_head(r
)) ||
3952 file_exists(git_path_revert_head(r
))) {
3953 res
= continue_single_pick(r
);
3955 goto release_todo_list
;
3957 if (index_differs_from(r
, "HEAD", NULL
, 0)) {
3958 res
= error_dirty_index(r
, opts
);
3959 goto release_todo_list
;
3961 todo_list
.current
++;
3962 } else if (file_exists(rebase_path_stopped_sha())) {
3963 struct strbuf buf
= STRBUF_INIT
;
3964 struct object_id oid
;
3966 if (read_oneliner(&buf
, rebase_path_stopped_sha(), 1) &&
3967 !get_oid_committish(buf
.buf
, &oid
))
3968 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
3969 strbuf_release(&buf
);
3972 res
= pick_commits(r
, &todo_list
, opts
);
3974 todo_list_release(&todo_list
);
3978 static int single_pick(struct repository
*r
,
3979 struct commit
*cmit
,
3980 struct replay_opts
*opts
)
3982 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
3983 return do_pick_commit(r
, opts
->action
== REPLAY_PICK
?
3984 TODO_PICK
: TODO_REVERT
, cmit
, opts
, 0);
3987 int sequencer_pick_revisions(struct repository
*r
,
3988 struct replay_opts
*opts
)
3990 struct todo_list todo_list
= TODO_LIST_INIT
;
3991 struct object_id oid
;
3995 if (read_and_refresh_cache(r
, opts
))
3998 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
3999 struct object_id oid
;
4000 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
4002 /* This happens when using --stdin. */
4006 if (!get_oid(name
, &oid
)) {
4007 if (!lookup_commit_reference_gently(r
, &oid
, 1)) {
4008 enum object_type type
= oid_object_info(r
,
4011 return error(_("%s: can't cherry-pick a %s"),
4012 name
, type_name(type
));
4015 return error(_("%s: bad revision"), name
);
4019 * If we were called as "git cherry-pick <commit>", just
4020 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4021 * REVERT_HEAD, and don't touch the sequencer state.
4022 * This means it is possible to cherry-pick in the middle
4023 * of a cherry-pick sequence.
4025 if (opts
->revs
->cmdline
.nr
== 1 &&
4026 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
4027 opts
->revs
->no_walk
&&
4028 !opts
->revs
->cmdline
.rev
->flags
) {
4029 struct commit
*cmit
;
4030 if (prepare_revision_walk(opts
->revs
))
4031 return error(_("revision walk setup failed"));
4032 cmit
= get_revision(opts
->revs
);
4034 return error(_("empty commit set passed"));
4035 if (get_revision(opts
->revs
))
4036 BUG("unexpected extra commit from walk");
4037 return single_pick(r
, cmit
, opts
);
4041 * Start a new cherry-pick/ revert sequence; but
4042 * first, make sure that an existing one isn't in
4046 if (walk_revs_populate_todo(&todo_list
, opts
) ||
4047 create_seq_dir() < 0)
4049 if (get_oid("HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
4050 return error(_("can't revert as initial commit"));
4051 if (save_head(oid_to_hex(&oid
)))
4053 if (save_opts(opts
))
4055 update_abort_safety_file();
4056 res
= pick_commits(r
, &todo_list
, opts
);
4057 todo_list_release(&todo_list
);
4061 void append_signoff(struct strbuf
*msgbuf
, size_t ignore_footer
, unsigned flag
)
4063 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
4064 struct strbuf sob
= STRBUF_INIT
;
4067 strbuf_addstr(&sob
, sign_off_header
);
4068 strbuf_addstr(&sob
, fmt_name(WANT_COMMITTER_IDENT
));
4069 strbuf_addch(&sob
, '\n');
4072 strbuf_complete_line(msgbuf
);
4075 * If the whole message buffer is equal to the sob, pretend that we
4076 * found a conforming footer with a matching sob
4078 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
4079 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
4082 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
4085 const char *append_newlines
= NULL
;
4086 size_t len
= msgbuf
->len
- ignore_footer
;
4090 * The buffer is completely empty. Leave foom for
4091 * the title and body to be filled in by the user.
4093 append_newlines
= "\n\n";
4094 } else if (len
== 1) {
4096 * Buffer contains a single newline. Add another
4097 * so that we leave room for the title and body.
4099 append_newlines
= "\n";
4100 } else if (msgbuf
->buf
[len
- 2] != '\n') {
4102 * Buffer ends with a single newline. Add another
4103 * so that there is an empty line between the message
4106 append_newlines
= "\n";
4107 } /* else, the buffer already ends with two newlines. */
4109 if (append_newlines
)
4110 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
4111 append_newlines
, strlen(append_newlines
));
4114 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
4115 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
4118 strbuf_release(&sob
);
4121 struct labels_entry
{
4122 struct hashmap_entry entry
;
4123 char label
[FLEX_ARRAY
];
4126 static int labels_cmp(const void *fndata
, const struct labels_entry
*a
,
4127 const struct labels_entry
*b
, const void *key
)
4129 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
4132 struct string_entry
{
4133 struct oidmap_entry entry
;
4134 char string
[FLEX_ARRAY
];
4137 struct label_state
{
4138 struct oidmap commit2label
;
4139 struct hashmap labels
;
4143 static const char *label_oid(struct object_id
*oid
, const char *label
,
4144 struct label_state
*state
)
4146 struct labels_entry
*labels_entry
;
4147 struct string_entry
*string_entry
;
4148 struct object_id dummy
;
4152 string_entry
= oidmap_get(&state
->commit2label
, oid
);
4154 return string_entry
->string
;
4157 * For "uninteresting" commits, i.e. commits that are not to be
4158 * rebased, and which can therefore not be labeled, we use a unique
4159 * abbreviation of the commit name. This is slightly more complicated
4160 * than calling find_unique_abbrev() because we also need to make
4161 * sure that the abbreviation does not conflict with any other
4164 * We disallow "interesting" commits to be labeled by a string that
4165 * is a valid full-length hash, to ensure that we always can find an
4166 * abbreviation for any uninteresting commit's names that does not
4167 * clash with any other label.
4172 strbuf_reset(&state
->buf
);
4173 strbuf_grow(&state
->buf
, GIT_SHA1_HEXSZ
);
4174 label
= p
= state
->buf
.buf
;
4176 find_unique_abbrev_r(p
, oid
, default_abbrev
);
4179 * We may need to extend the abbreviated hash so that there is
4180 * no conflicting label.
4182 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
4183 size_t i
= strlen(p
) + 1;
4185 oid_to_hex_r(p
, oid
);
4186 for (; i
< GIT_SHA1_HEXSZ
; i
++) {
4189 if (!hashmap_get_from_hash(&state
->labels
,
4195 } else if (((len
= strlen(label
)) == the_hash_algo
->hexsz
&&
4196 !get_oid_hex(label
, &dummy
)) ||
4197 (len
== 1 && *label
== '#') ||
4198 hashmap_get_from_hash(&state
->labels
,
4199 strihash(label
), label
)) {
4201 * If the label already exists, or if the label is a valid full
4202 * OID, or the label is a '#' (which we use as a separator
4203 * between merge heads and oneline), we append a dash and a
4204 * number to make it unique.
4206 struct strbuf
*buf
= &state
->buf
;
4209 strbuf_add(buf
, label
, len
);
4211 for (i
= 2; ; i
++) {
4212 strbuf_setlen(buf
, len
);
4213 strbuf_addf(buf
, "-%d", i
);
4214 if (!hashmap_get_from_hash(&state
->labels
,
4223 FLEX_ALLOC_STR(labels_entry
, label
, label
);
4224 hashmap_entry_init(labels_entry
, strihash(label
));
4225 hashmap_add(&state
->labels
, labels_entry
);
4227 FLEX_ALLOC_STR(string_entry
, string
, label
);
4228 oidcpy(&string_entry
->entry
.oid
, oid
);
4229 oidmap_put(&state
->commit2label
, string_entry
);
4231 return string_entry
->string
;
4234 static int make_script_with_merges(struct pretty_print_context
*pp
,
4235 struct rev_info
*revs
, struct strbuf
*out
,
4238 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
4239 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
4240 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
4241 struct strbuf label
= STRBUF_INIT
;
4242 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
4243 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
4244 struct commit
*commit
;
4245 struct oidmap commit2todo
= OIDMAP_INIT
;
4246 struct string_entry
*entry
;
4247 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
4248 shown
= OIDSET_INIT
;
4249 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
4251 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
4252 const char *cmd_pick
= abbr
? "p" : "pick",
4253 *cmd_label
= abbr
? "l" : "label",
4254 *cmd_reset
= abbr
? "t" : "reset",
4255 *cmd_merge
= abbr
? "m" : "merge";
4257 oidmap_init(&commit2todo
, 0);
4258 oidmap_init(&state
.commit2label
, 0);
4259 hashmap_init(&state
.labels
, (hashmap_cmp_fn
) labels_cmp
, NULL
, 0);
4260 strbuf_init(&state
.buf
, 32);
4262 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
4263 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
4264 FLEX_ALLOC_STR(entry
, string
, "onto");
4265 oidcpy(&entry
->entry
.oid
, oid
);
4266 oidmap_put(&state
.commit2label
, entry
);
4271 * - get onelines for all commits
4272 * - gather all branch tips (i.e. 2nd or later parents of merges)
4273 * - label all branch tips
4275 while ((commit
= get_revision(revs
))) {
4276 struct commit_list
*to_merge
;
4277 const char *p1
, *p2
;
4278 struct object_id
*oid
;
4281 tail
= &commit_list_insert(commit
, tail
)->next
;
4282 oidset_insert(&interesting
, &commit
->object
.oid
);
4284 is_empty
= is_original_commit_empty(commit
);
4285 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
))
4288 strbuf_reset(&oneline
);
4289 pretty_print_commit(pp
, commit
, &oneline
);
4291 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
4293 /* non-merge commit: easy case */
4295 if (!keep_empty
&& is_empty
)
4296 strbuf_addf(&buf
, "%c ", comment_line_char
);
4297 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
4298 oid_to_hex(&commit
->object
.oid
),
4301 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
4302 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
4303 oidmap_put(&commit2todo
, entry
);
4308 /* Create a label */
4309 strbuf_reset(&label
);
4310 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
4311 (p1
= strchr(p1
, '\'')) &&
4312 (p2
= strchr(++p1
, '\'')))
4313 strbuf_add(&label
, p1
, p2
- p1
);
4314 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
4316 (p1
= strstr(p1
, " from ")))
4317 strbuf_addstr(&label
, p1
+ strlen(" from "));
4319 strbuf_addbuf(&label
, &oneline
);
4321 for (p1
= label
.buf
; *p1
; p1
++)
4326 strbuf_addf(&buf
, "%s -C %s",
4327 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
4329 /* label the tips of merged branches */
4330 for (; to_merge
; to_merge
= to_merge
->next
) {
4331 oid
= &to_merge
->item
->object
.oid
;
4332 strbuf_addch(&buf
, ' ');
4334 if (!oidset_contains(&interesting
, oid
)) {
4335 strbuf_addstr(&buf
, label_oid(oid
, NULL
,
4340 tips_tail
= &commit_list_insert(to_merge
->item
,
4343 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
4345 strbuf_addf(&buf
, " # %s", oneline
.buf
);
4347 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
4348 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
4349 oidmap_put(&commit2todo
, entry
);
4354 * - label branch points
4355 * - add HEAD to the branch tips
4357 for (iter
= commits
; iter
; iter
= iter
->next
) {
4358 struct commit_list
*parent
= iter
->item
->parents
;
4359 for (; parent
; parent
= parent
->next
) {
4360 struct object_id
*oid
= &parent
->item
->object
.oid
;
4361 if (!oidset_contains(&interesting
, oid
))
4363 if (oidset_insert(&child_seen
, oid
))
4364 label_oid(oid
, "branch-point", &state
);
4367 /* Add HEAD as implict "tip of branch" */
4369 tips_tail
= &commit_list_insert(iter
->item
,
4374 * Third phase: output the todo list. This is a bit tricky, as we
4375 * want to avoid jumping back and forth between revisions. To
4376 * accomplish that goal, we walk backwards from the branch tips,
4377 * gathering commits not yet shown, reversing the list on the fly,
4378 * then outputting that list (labeling revisions as needed).
4380 strbuf_addf(out
, "%s onto\n", cmd_label
);
4381 for (iter
= tips
; iter
; iter
= iter
->next
) {
4382 struct commit_list
*list
= NULL
, *iter2
;
4384 commit
= iter
->item
;
4385 if (oidset_contains(&shown
, &commit
->object
.oid
))
4387 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
4390 strbuf_addf(out
, "\n%c Branch %s\n", comment_line_char
, entry
->string
);
4392 strbuf_addch(out
, '\n');
4394 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
4395 !oidset_contains(&shown
, &commit
->object
.oid
)) {
4396 commit_list_insert(commit
, &list
);
4397 if (!commit
->parents
) {
4401 commit
= commit
->parents
->item
;
4405 strbuf_addf(out
, "%s %s\n", cmd_reset
,
4406 rebase_cousins
? "onto" : "[new root]");
4408 const char *to
= NULL
;
4410 entry
= oidmap_get(&state
.commit2label
,
4411 &commit
->object
.oid
);
4414 else if (!rebase_cousins
)
4415 to
= label_oid(&commit
->object
.oid
, NULL
,
4418 if (!to
|| !strcmp(to
, "onto"))
4419 strbuf_addf(out
, "%s onto\n", cmd_reset
);
4421 strbuf_reset(&oneline
);
4422 pretty_print_commit(pp
, commit
, &oneline
);
4423 strbuf_addf(out
, "%s %s # %s\n",
4424 cmd_reset
, to
, oneline
.buf
);
4428 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
4429 struct object_id
*oid
= &iter2
->item
->object
.oid
;
4430 entry
= oidmap_get(&commit2todo
, oid
);
4431 /* only show if not already upstream */
4433 strbuf_addf(out
, "%s\n", entry
->string
);
4434 entry
= oidmap_get(&state
.commit2label
, oid
);
4436 strbuf_addf(out
, "%s %s\n",
4437 cmd_label
, entry
->string
);
4438 oidset_insert(&shown
, oid
);
4441 free_commit_list(list
);
4444 free_commit_list(commits
);
4445 free_commit_list(tips
);
4447 strbuf_release(&label
);
4448 strbuf_release(&oneline
);
4449 strbuf_release(&buf
);
4451 oidmap_free(&commit2todo
, 1);
4452 oidmap_free(&state
.commit2label
, 1);
4453 hashmap_free(&state
.labels
, 1);
4454 strbuf_release(&state
.buf
);
4459 int sequencer_make_script(struct repository
*r
, struct strbuf
*out
, int argc
,
4460 const char **argv
, unsigned flags
)
4462 char *format
= NULL
;
4463 struct pretty_print_context pp
= {0};
4464 struct rev_info revs
;
4465 struct commit
*commit
;
4466 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
4467 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
4468 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
4470 repo_init_revisions(r
, &revs
, NULL
);
4471 revs
.verbose_header
= 1;
4473 revs
.max_parents
= 1;
4474 revs
.cherry_mark
= 1;
4477 revs
.right_only
= 1;
4478 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
4479 revs
.topo_order
= 1;
4481 revs
.pretty_given
= 1;
4482 git_config_get_string("rebase.instructionFormat", &format
);
4483 if (!format
|| !*format
) {
4485 format
= xstrdup("%s");
4487 get_commit_format(format
, &revs
);
4489 pp
.fmt
= revs
.commit_format
;
4490 pp
.output_encoding
= get_log_output_encoding();
4492 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1)
4493 return error(_("make_script: unhandled options"));
4495 if (prepare_revision_walk(&revs
) < 0)
4496 return error(_("make_script: error preparing revisions"));
4499 return make_script_with_merges(&pp
, &revs
, out
, flags
);
4501 while ((commit
= get_revision(&revs
))) {
4502 int is_empty
= is_original_commit_empty(commit
);
4504 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
))
4506 if (!keep_empty
&& is_empty
)
4507 strbuf_addf(out
, "%c ", comment_line_char
);
4508 strbuf_addf(out
, "%s %s ", insn
,
4509 oid_to_hex(&commit
->object
.oid
));
4510 pretty_print_commit(&pp
, commit
, out
);
4511 strbuf_addch(out
, '\n');
4517 * Add commands after pick and (series of) squash/fixup commands
4520 void todo_list_add_exec_commands(struct todo_list
*todo_list
,
4521 struct string_list
*commands
)
4523 struct strbuf
*buf
= &todo_list
->buf
;
4524 size_t base_offset
= buf
->len
;
4525 int i
, insert
, nr
= 0, alloc
= 0;
4526 struct todo_item
*items
= NULL
, *base_items
= NULL
;
4528 base_items
= xcalloc(commands
->nr
, sizeof(struct todo_item
));
4529 for (i
= 0; i
< commands
->nr
; i
++) {
4530 size_t command_len
= strlen(commands
->items
[i
].string
);
4532 strbuf_addstr(buf
, commands
->items
[i
].string
);
4533 strbuf_addch(buf
, '\n');
4535 base_items
[i
].command
= TODO_EXEC
;
4536 base_items
[i
].offset_in_buf
= base_offset
;
4537 base_items
[i
].arg_offset
= base_offset
+ strlen("exec ");
4538 base_items
[i
].arg_len
= command_len
- strlen("exec ");
4540 base_offset
+= command_len
+ 1;
4544 * Insert <commands> after every pick. Here, fixup/squash chains
4545 * are considered part of the pick, so we insert the commands *after*
4546 * those chains if there are any.
4548 * As we insert the exec commands immediatly after rearranging
4549 * any fixups and before the user edits the list, a fixup chain
4550 * can never contain comments (any comments are empty picks that
4551 * have been commented out because the user did not specify
4552 * --keep-empty). So, it is safe to insert an exec command
4553 * without looking at the command following a comment.
4556 for (i
= 0; i
< todo_list
->nr
; i
++) {
4557 enum todo_command command
= todo_list
->items
[i
].command
;
4558 if (insert
&& !is_fixup(command
)) {
4559 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
4560 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
4566 ALLOC_GROW(items
, nr
+ 1, alloc
);
4567 items
[nr
++] = todo_list
->items
[i
];
4569 if (command
== TODO_PICK
|| command
== TODO_MERGE
)
4573 /* insert or append final <commands> */
4574 if (insert
|| nr
== todo_list
->nr
) {
4575 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
4576 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
4581 FREE_AND_NULL(todo_list
->items
);
4582 todo_list
->items
= items
;
4584 todo_list
->alloc
= alloc
;
4587 static void todo_list_to_strbuf(struct repository
*r
, struct todo_list
*todo_list
,
4588 struct strbuf
*buf
, int num
, unsigned flags
)
4590 struct todo_item
*item
;
4591 int i
, max
= todo_list
->nr
;
4593 if (num
> 0 && num
< max
)
4596 for (item
= todo_list
->items
, i
= 0; i
< max
; i
++, item
++) {
4597 /* if the item is not a command write it and continue */
4598 if (item
->command
>= TODO_COMMENT
) {
4599 strbuf_addf(buf
, "%.*s\n", item
->arg_len
,
4600 todo_item_get_arg(todo_list
, item
));
4604 /* add command to the buffer */
4605 if (flags
& TODO_LIST_ABBREVIATE_CMDS
)
4606 strbuf_addch(buf
, command_to_char(item
->command
));
4608 strbuf_addstr(buf
, command_to_string(item
->command
));
4612 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
4613 short_commit_name(item
->commit
) :
4614 oid_to_hex(&item
->commit
->object
.oid
);
4616 if (item
->command
== TODO_MERGE
) {
4617 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
4618 strbuf_addstr(buf
, " -c");
4620 strbuf_addstr(buf
, " -C");
4623 strbuf_addf(buf
, " %s", oid
);
4626 /* add all the rest */
4628 strbuf_addch(buf
, '\n');
4630 strbuf_addf(buf
, " %.*s\n", item
->arg_len
,
4631 todo_item_get_arg(todo_list
, item
));
4635 int todo_list_write_to_file(struct repository
*r
, struct todo_list
*todo_list
,
4636 const char *file
, const char *shortrevisions
,
4637 const char *shortonto
, int num
, unsigned flags
)
4640 struct strbuf buf
= STRBUF_INIT
;
4642 todo_list_to_strbuf(r
, todo_list
, &buf
, num
, flags
);
4643 if (flags
& TODO_LIST_APPEND_TODO_HELP
)
4644 append_todo_help(flags
& TODO_LIST_KEEP_EMPTY
, count_commands(todo_list
),
4645 shortrevisions
, shortonto
, &buf
);
4647 res
= write_message(buf
.buf
, buf
.len
, file
, 0);
4648 strbuf_release(&buf
);
4653 static const char edit_todo_list_advice
[] =
4654 N_("You can fix this with 'git rebase --edit-todo' "
4655 "and then run 'git rebase --continue'.\n"
4656 "Or you can abort the rebase with 'git rebase"
4659 int check_todo_list_from_file(struct repository
*r
)
4661 struct todo_list old_todo
= TODO_LIST_INIT
, new_todo
= TODO_LIST_INIT
;
4664 if (strbuf_read_file_or_whine(&new_todo
.buf
, rebase_path_todo()) < 0) {
4669 if (strbuf_read_file_or_whine(&old_todo
.buf
, rebase_path_todo_backup()) < 0) {
4674 res
= todo_list_parse_insn_buffer(r
, old_todo
.buf
.buf
, &old_todo
);
4676 res
= todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
);
4678 res
= todo_list_check(&old_todo
, &new_todo
);
4680 fprintf(stderr
, _(edit_todo_list_advice
));
4682 todo_list_release(&old_todo
);
4683 todo_list_release(&new_todo
);
4688 /* skip picking commits whose parents are unchanged */
4689 static int skip_unnecessary_picks(struct repository
*r
,
4690 struct todo_list
*todo_list
,
4691 struct object_id
*base_oid
)
4693 struct object_id
*parent_oid
;
4696 for (i
= 0; i
< todo_list
->nr
; i
++) {
4697 struct todo_item
*item
= todo_list
->items
+ i
;
4699 if (item
->command
>= TODO_NOOP
)
4701 if (item
->command
!= TODO_PICK
)
4703 if (parse_commit(item
->commit
)) {
4704 return error(_("could not parse commit '%s'"),
4705 oid_to_hex(&item
->commit
->object
.oid
));
4707 if (!item
->commit
->parents
)
4708 break; /* root commit */
4709 if (item
->commit
->parents
->next
)
4710 break; /* merge commit */
4711 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
4712 if (!oideq(parent_oid
, base_oid
))
4714 oidcpy(base_oid
, &item
->commit
->object
.oid
);
4717 const char *done_path
= rebase_path_done();
4719 if (todo_list_write_to_file(r
, todo_list
, done_path
, NULL
, NULL
, i
, 0)) {
4720 error_errno(_("could not write to '%s'"), done_path
);
4724 MOVE_ARRAY(todo_list
->items
, todo_list
->items
+ i
, todo_list
->nr
- i
);
4726 todo_list
->current
= 0;
4728 if (is_fixup(peek_command(todo_list
, 0)))
4729 record_in_rewritten(base_oid
, peek_command(todo_list
, 0));
4735 int complete_action(struct repository
*r
, struct replay_opts
*opts
, unsigned flags
,
4736 const char *shortrevisions
, const char *onto_name
,
4737 const char *onto
, const char *orig_head
, struct string_list
*commands
,
4738 unsigned autosquash
, struct todo_list
*todo_list
)
4740 const char *shortonto
, *todo_file
= rebase_path_todo();
4741 struct todo_list new_todo
= TODO_LIST_INIT
;
4742 struct strbuf
*buf
= &todo_list
->buf
;
4743 struct object_id oid
;
4746 get_oid(onto
, &oid
);
4747 shortonto
= find_unique_abbrev(&oid
, DEFAULT_ABBREV
);
4749 if (buf
->len
== 0) {
4750 struct todo_item
*item
= append_new_todo(todo_list
);
4751 item
->command
= TODO_NOOP
;
4752 item
->commit
= NULL
;
4753 item
->arg_len
= item
->arg_offset
= item
->flags
= item
->offset_in_buf
= 0;
4756 if (autosquash
&& todo_list_rearrange_squash(todo_list
))
4760 todo_list_add_exec_commands(todo_list
, commands
);
4762 if (count_commands(todo_list
) == 0) {
4763 apply_autostash(opts
);
4764 sequencer_remove_state(opts
);
4766 return error(_("nothing to do"));
4769 res
= edit_todo_list(r
, todo_list
, &new_todo
, shortrevisions
,
4773 else if (res
== -2) {
4774 apply_autostash(opts
);
4775 sequencer_remove_state(opts
);
4778 } else if (res
== -3) {
4779 apply_autostash(opts
);
4780 sequencer_remove_state(opts
);
4781 todo_list_release(&new_todo
);
4783 return error(_("nothing to do"));
4786 if (todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
) ||
4787 todo_list_check(todo_list
, &new_todo
)) {
4788 fprintf(stderr
, _(edit_todo_list_advice
));
4789 checkout_onto(opts
, onto_name
, onto
, orig_head
);
4790 todo_list_release(&new_todo
);
4795 if (opts
->allow_ff
&& skip_unnecessary_picks(r
, &new_todo
, &oid
)) {
4796 todo_list_release(&new_todo
);
4797 return error(_("could not skip unnecessary pick commands"));
4800 if (todo_list_write_to_file(r
, &new_todo
, todo_file
, NULL
, NULL
, -1,
4801 flags
& ~(TODO_LIST_SHORTEN_IDS
))) {
4802 todo_list_release(&new_todo
);
4803 return error_errno(_("could not write '%s'"), todo_file
);
4806 todo_list_release(&new_todo
);
4808 if (checkout_onto(opts
, onto_name
, oid_to_hex(&oid
), orig_head
))
4811 if (require_clean_work_tree(r
, "rebase", "", 1, 1))
4814 return sequencer_continue(r
, opts
);
4817 struct subject2item_entry
{
4818 struct hashmap_entry entry
;
4820 char subject
[FLEX_ARRAY
];
4823 static int subject2item_cmp(const void *fndata
,
4824 const struct subject2item_entry
*a
,
4825 const struct subject2item_entry
*b
, const void *key
)
4827 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
4830 define_commit_slab(commit_todo_item
, struct todo_item
*);
4833 * Rearrange the todo list that has both "pick commit-id msg" and "pick
4834 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
4835 * after the former, and change "pick" to "fixup"/"squash".
4837 * Note that if the config has specified a custom instruction format, each log
4838 * message will have to be retrieved from the commit (as the oneline in the
4839 * script cannot be trusted) in order to normalize the autosquash arrangement.
4841 int todo_list_rearrange_squash(struct todo_list
*todo_list
)
4843 struct hashmap subject2item
;
4844 int rearranged
= 0, *next
, *tail
, i
, nr
= 0, alloc
= 0;
4846 struct commit_todo_item commit_todo
;
4847 struct todo_item
*items
= NULL
;
4849 init_commit_todo_item(&commit_todo
);
4851 * The hashmap maps onelines to the respective todo list index.
4853 * If any items need to be rearranged, the next[i] value will indicate
4854 * which item was moved directly after the i'th.
4856 * In that case, last[i] will indicate the index of the latest item to
4857 * be moved to appear after the i'th.
4859 hashmap_init(&subject2item
, (hashmap_cmp_fn
) subject2item_cmp
,
4860 NULL
, todo_list
->nr
);
4861 ALLOC_ARRAY(next
, todo_list
->nr
);
4862 ALLOC_ARRAY(tail
, todo_list
->nr
);
4863 ALLOC_ARRAY(subjects
, todo_list
->nr
);
4864 for (i
= 0; i
< todo_list
->nr
; i
++) {
4865 struct strbuf buf
= STRBUF_INIT
;
4866 struct todo_item
*item
= todo_list
->items
+ i
;
4867 const char *commit_buffer
, *subject
, *p
;
4870 struct subject2item_entry
*entry
;
4872 next
[i
] = tail
[i
] = -1;
4873 if (!item
->commit
|| item
->command
== TODO_DROP
) {
4878 if (is_fixup(item
->command
)) {
4879 clear_commit_todo_item(&commit_todo
);
4880 return error(_("the script was already rearranged."));
4883 *commit_todo_item_at(&commit_todo
, item
->commit
) = item
;
4885 parse_commit(item
->commit
);
4886 commit_buffer
= get_commit_buffer(item
->commit
, NULL
);
4887 find_commit_subject(commit_buffer
, &subject
);
4888 format_subject(&buf
, subject
, " ");
4889 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
4890 unuse_commit_buffer(item
->commit
, commit_buffer
);
4891 if ((skip_prefix(subject
, "fixup! ", &p
) ||
4892 skip_prefix(subject
, "squash! ", &p
))) {
4893 struct commit
*commit2
;
4898 if (!skip_prefix(p
, "fixup! ", &p
) &&
4899 !skip_prefix(p
, "squash! ", &p
))
4903 if ((entry
= hashmap_get_from_hash(&subject2item
,
4905 /* found by title */
4907 else if (!strchr(p
, ' ') &&
4909 lookup_commit_reference_by_name(p
)) &&
4910 *commit_todo_item_at(&commit_todo
, commit2
))
4911 /* found by commit name */
4912 i2
= *commit_todo_item_at(&commit_todo
, commit2
)
4915 /* copy can be a prefix of the commit subject */
4916 for (i2
= 0; i2
< i
; i2
++)
4918 starts_with(subjects
[i2
], p
))
4926 todo_list
->items
[i
].command
=
4927 starts_with(subject
, "fixup!") ?
4928 TODO_FIXUP
: TODO_SQUASH
;
4934 } else if (!hashmap_get_from_hash(&subject2item
,
4935 strhash(subject
), subject
)) {
4936 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
4938 hashmap_entry_init(entry
, strhash(entry
->subject
));
4939 hashmap_put(&subject2item
, entry
);
4944 for (i
= 0; i
< todo_list
->nr
; i
++) {
4945 enum todo_command command
= todo_list
->items
[i
].command
;
4949 * Initially, all commands are 'pick's. If it is a
4950 * fixup or a squash now, we have rearranged it.
4952 if (is_fixup(command
))
4956 ALLOC_GROW(items
, nr
+ 1, alloc
);
4957 items
[nr
++] = todo_list
->items
[cur
];
4962 FREE_AND_NULL(todo_list
->items
);
4963 todo_list
->items
= items
;
4965 todo_list
->alloc
= alloc
;
4970 for (i
= 0; i
< todo_list
->nr
; i
++)
4973 hashmap_free(&subject2item
, 1);
4975 clear_commit_todo_item(&commit_todo
);