5 #include "object-store.h"
10 #include "run-command.h"
13 #include "cache-tree.h"
17 #include "merge-ort.h"
18 #include "merge-ort-wrappers.h"
24 #include "wt-status.h"
26 #include "notes-utils.h"
28 #include "unpack-trees.h"
32 #include "commit-slab.h"
34 #include "commit-reach.h"
35 #include "rebase-interactive.h"
38 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
40 static const char sign_off_header[] = "Signed-off-by: ";
41 static const char cherry_picked_prefix[] = "(cherry picked from commit ";
43 GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
45 static GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
47 static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
48 static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
49 static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
50 static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
52 static GIT_PATH_FUNC(rebase_path, "rebase-merge")
54 * The file containing rebase commands, comments, and empty lines.
55 * This file is created by "git rebase -i" then edited by the user. As
56 * the lines are processed, they are removed from the front of this
57 * file and written to the tail of 'done'.
59 GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
60 GIT_PATH_FUNC(rebase_path_todo_backup, "rebase-merge/git-rebase-todo.backup")
62 GIT_PATH_FUNC(rebase_path_dropped, "rebase-merge/dropped")
65 * The rebase command lines that have already been processed. A line
66 * is moved here when it is first handled, before any associated user
69 static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
71 * The file to keep track of how many commands were already processed (e.g.
74 static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum")
76 * The file to keep track of how many commands are to be processed in total
77 * (e.g. for the prompt).
79 static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end")
81 * The commit message that is planned to be used for any changes that
82 * need to be committed following a user interaction.
84 static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
86 * The file into which is accumulated the suggested commit message for
87 * squash/fixup commands. When the first of a series of squash/fixups
88 * is seen, the file is created and the commit message from the
89 * previous commit and from the first squash/fixup commit are written
90 * to it. The commit message for each subsequent squash/fixup commit
91 * is appended to the file as it is processed.
93 static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
95 * If the current series of squash/fixups has not yet included a squash
96 * command, then this file exists and holds the commit message of the
97 * original "pick" commit. (If the series ends without a "squash"
98 * command, then this can be used as the commit message of the combined
99 * commit without opening the editor.)
101 static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
103 * This file contains the list fixup/squash commands that have been
104 * accumulated into message-fixup or message-squash so far.
106 static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")
108 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
109 * GIT_AUTHOR_DATE that will be used for the commit that is currently
112 static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
114 * When an "edit" rebase command is being processed, the SHA1 of the
115 * commit to be edited is recorded in this file. When "git rebase
116 * --continue" is executed, if there are any staged changes then they
117 * will be amended to the HEAD commit, but only provided the HEAD
118 * commit is still the commit to be edited. When any other rebase
119 * command is processed, this file is deleted.
121 static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
123 * When we stop at a given patch via the "edit" command, this file contains
124 * the commit object name of the corresponding patch.
126 static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
128 * For the post-rewrite hook, we make a list of rewritten commits and
129 * their new sha1s. The rewritten-pending list keeps the sha1s of
130 * commits that have been processed, but not committed yet,
131 * e.g. because they are waiting for a 'squash' command.
133 static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
134 static GIT_PATH_FUNC(rebase_path_rewritten_pending,
135 "rebase-merge/rewritten-pending")
138 * The path of the file containing the OID of the "squash onto" commit, i.e.
139 * the dummy commit used for `reset [new root]`.
141 static GIT_PATH_FUNC(rebase_path_squash_onto, "rebase-merge/squash-onto")
144 * The path of the file listing refs that need to be deleted after the rebase
145 * finishes. This is used by the `label` command to record the need for cleanup.
147 static GIT_PATH_FUNC(rebase_path_refs_to_delete, "rebase-merge/refs-to-delete")
150 * The following files are written by git-rebase just after parsing the
153 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
154 static GIT_PATH_FUNC(rebase_path_cdate_is_adate, "rebase-merge/cdate_is_adate")
155 static GIT_PATH_FUNC(rebase_path_ignore_date, "rebase-merge/ignore_date")
156 static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
157 static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
158 static GIT_PATH_FUNC(rebase_path_quiet, "rebase-merge/quiet")
159 static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")
160 static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
161 static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
162 static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
163 static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
164 static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
165 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
166 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec, "rebase-merge/reschedule-failed-exec")
167 static GIT_PATH_FUNC(rebase_path_drop_redundant_commits, "rebase-merge/drop_redundant_commits")
168 static GIT_PATH_FUNC(rebase_path_keep_redundant_commits, "rebase-merge/keep_redundant_commits")
170 static int git_sequencer_config(const char *k, const char *v, void *cb)
172 struct replay_opts *opts = cb;
175 if (!strcmp(k, "commit.cleanup")) {
178 status = git_config_string(&s, k, v);
182 if (!strcmp(s, "verbatim")) {
183 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
184 opts->explicit_cleanup = 1;
185 } else if (!strcmp(s, "whitespace")) {
186 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
187 opts->explicit_cleanup = 1;
188 } else if (!strcmp(s, "strip")) {
189 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
190 opts->explicit_cleanup = 1;
191 } else if (!strcmp(s, "scissors")) {
192 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SCISSORS;
193 opts->explicit_cleanup = 1;
195 warning(_("invalid commit message cleanup mode '%s'"),
203 if (!strcmp(k, "commit.gpgsign")) {
204 opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
208 if (!opts->default_strategy && !strcmp(k, "pull.twohead")) {
209 int ret = git_config_string((const char**)&opts->default_strategy, k, v);
212 * pull.twohead is allowed to be multi-valued; we only
213 * care about the first value.
215 char *tmp = strchr(opts->default_strategy, ' ');
222 status = git_gpg_config(k, v, NULL);
226 return git_diff_basic_config(k, v, NULL);
229 void sequencer_init_config(struct replay_opts *opts)
231 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
232 git_config(git_sequencer_config, opts);
235 static inline int is_rebase_i(const struct replay_opts *opts)
237 return opts->action == REPLAY_INTERACTIVE_REBASE;
240 static const char *get_dir(const struct replay_opts *opts)
242 if (is_rebase_i(opts))
243 return rebase_path();
244 return git_path_seq_dir();
247 static const char *get_todo_path(const struct replay_opts *opts)
249 if (is_rebase_i(opts))
250 return rebase_path_todo();
251 return git_path_todo_file();
255 * Returns 0 for non-conforming footer
256 * Returns 1 for conforming footer
257 * Returns 2 when sob exists within conforming footer
258 * Returns 3 when sob exists within conforming footer as last entry
260 static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
261 size_t ignore_footer)
263 struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
264 struct trailer_info info;
266 int found_sob = 0, found_sob_last = 0;
272 saved_char = sb->buf[sb->len - ignore_footer];
273 sb->buf[sb->len - ignore_footer] = '\0';
276 trailer_info_get(&info, sb->buf, &opts);
279 sb->buf[sb->len - ignore_footer] = saved_char;
281 if (info.trailer_start == info.trailer_end)
284 for (i = 0; i < info.trailer_nr; i++)
285 if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
287 if (i == info.trailer_nr - 1)
291 trailer_info_release(&info);
300 static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
302 static struct strbuf buf = STRBUF_INIT;
306 sq_quotef(&buf, "-S%s", opts->gpg_sign);
310 int sequencer_remove_state(struct replay_opts *opts)
312 struct strbuf buf = STRBUF_INIT;
315 if (is_rebase_i(opts) &&
316 strbuf_read_file(&buf, rebase_path_refs_to_delete(), 0) > 0) {
319 char *eol = strchr(p, '\n');
322 if (delete_ref("(rebase) cleanup", p, NULL, 0) < 0) {
323 warning(_("could not delete '%s'"), p);
332 free(opts->gpg_sign);
333 free(opts->default_strategy);
334 free(opts->strategy);
335 for (i = 0; i < opts->xopts_nr; i++)
336 free(opts->xopts[i]);
338 strbuf_release(&opts->current_fixups);
341 strbuf_addstr(&buf, get_dir(opts));
342 if (remove_dir_recursively(&buf, 0))
343 ret = error(_("could not remove '%s'"), buf.buf);
344 strbuf_release(&buf);
349 static const char *action_name(const struct replay_opts *opts)
351 switch (opts->action) {
355 return N_("cherry-pick");
356 case REPLAY_INTERACTIVE_REBASE:
359 die(_("unknown action: %d"), opts->action);
362 struct commit_message {
369 static const char *short_commit_name(struct commit *commit)
371 return find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV);
374 static int get_message(struct commit *commit, struct commit_message *out)
376 const char *abbrev, *subject;
379 out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
380 abbrev = short_commit_name(commit);
382 subject_len = find_commit_subject(out->message, &subject);
384 out->subject = xmemdupz(subject, subject_len);
385 out->label = xstrfmt("%s (%s)", abbrev, out->subject);
386 out->parent_label = xstrfmt("parent of %s", out->label);
391 static void free_message(struct commit *commit, struct commit_message *msg)
393 free(msg->parent_label);
396 unuse_commit_buffer(commit, msg->message);
399 static void print_advice(struct repository *r, int show_hint,
400 struct replay_opts *opts)
402 char *msg = getenv("GIT_CHERRY_PICK_HELP");
405 fprintf(stderr, "%s\n", msg);
407 * A conflict has occurred but the porcelain
408 * (typically rebase --interactive) wants to take care
409 * of the commit itself so remove CHERRY_PICK_HEAD
411 refs_delete_ref(get_main_ref_store(r), "", "CHERRY_PICK_HEAD",
418 advise(_("after resolving the conflicts, mark the corrected paths\n"
419 "with 'git add <paths>' or 'git rm <paths>'"));
421 advise(_("after resolving the conflicts, mark the corrected paths\n"
422 "with 'git add <paths>' or 'git rm <paths>'\n"
423 "and commit the result with 'git commit'"));
427 static int write_message(const void *buf, size_t len, const char *filename,
430 struct lock_file msg_file = LOCK_INIT;
432 int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
434 return error_errno(_("could not lock '%s'"), filename);
435 if (write_in_full(msg_fd, buf, len) < 0) {
436 error_errno(_("could not write to '%s'"), filename);
437 rollback_lock_file(&msg_file);
440 if (append_eol && write(msg_fd, "\n", 1) < 0) {
441 error_errno(_("could not write eol to '%s'"), filename);
442 rollback_lock_file(&msg_file);
445 if (commit_lock_file(&msg_file) < 0)
446 return error(_("failed to finalize '%s'"), filename);
451 int read_oneliner(struct strbuf *buf,
452 const char *path, unsigned flags)
454 int orig_len = buf->len;
456 if (strbuf_read_file(buf, path, 0) < 0) {
457 if ((flags & READ_ONELINER_WARN_MISSING) ||
458 (errno != ENOENT && errno != ENOTDIR))
459 warning_errno(_("could not read '%s'"), path);
463 if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
464 if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
466 buf->buf[buf->len] = '\0';
469 if ((flags & READ_ONELINER_SKIP_IF_EMPTY) && buf->len == orig_len)
475 static struct tree *empty_tree(struct repository *r)
477 return lookup_tree(r, the_hash_algo->empty_tree);
480 static int error_dirty_index(struct repository *repo, struct replay_opts *opts)
482 if (repo_read_index_unmerged(repo))
483 return error_resolve_conflict(_(action_name(opts)));
485 error(_("your local changes would be overwritten by %s."),
486 _(action_name(opts)));
488 if (advice_commit_before_merge)
489 advise(_("commit your changes or stash them to proceed."));
493 static void update_abort_safety_file(void)
495 struct object_id head;
497 /* Do nothing on a single-pick */
498 if (!file_exists(git_path_seq_dir()))
501 if (!get_oid("HEAD", &head))
502 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
504 write_file(git_path_abort_safety_file(), "%s", "");
507 static int fast_forward_to(struct repository *r,
508 const struct object_id *to,
509 const struct object_id *from,
511 struct replay_opts *opts)
513 struct ref_transaction *transaction;
514 struct strbuf sb = STRBUF_INIT;
515 struct strbuf err = STRBUF_INIT;
518 if (checkout_fast_forward(r, from, to, 1))
519 return -1; /* the callee should have complained already */
521 strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
523 transaction = ref_transaction_begin(&err);
525 ref_transaction_update(transaction, "HEAD",
526 to, unborn && !is_rebase_i(opts) ?
529 ref_transaction_commit(transaction, &err)) {
530 ref_transaction_free(transaction);
531 error("%s", err.buf);
533 strbuf_release(&err);
538 strbuf_release(&err);
539 ref_transaction_free(transaction);
540 update_abort_safety_file();
544 enum commit_msg_cleanup_mode get_cleanup_mode(const char *cleanup_arg,
547 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
548 return use_editor ? COMMIT_MSG_CLEANUP_ALL :
549 COMMIT_MSG_CLEANUP_SPACE;
550 else if (!strcmp(cleanup_arg, "verbatim"))
551 return COMMIT_MSG_CLEANUP_NONE;
552 else if (!strcmp(cleanup_arg, "whitespace"))
553 return COMMIT_MSG_CLEANUP_SPACE;
554 else if (!strcmp(cleanup_arg, "strip"))
555 return COMMIT_MSG_CLEANUP_ALL;
556 else if (!strcmp(cleanup_arg, "scissors"))
557 return use_editor ? COMMIT_MSG_CLEANUP_SCISSORS :
558 COMMIT_MSG_CLEANUP_SPACE;
560 die(_("Invalid cleanup mode %s"), cleanup_arg);
564 * NB using int rather than enum cleanup_mode to stop clang's
565 * -Wtautological-constant-out-of-range-compare complaining that the comparison
568 static const char *describe_cleanup_mode(int cleanup_mode)
570 static const char *modes[] = { "whitespace",
575 if (cleanup_mode < ARRAY_SIZE(modes))
576 return modes[cleanup_mode];
578 BUG("invalid cleanup_mode provided (%d)", cleanup_mode);
581 void append_conflicts_hint(struct index_state *istate,
582 struct strbuf *msgbuf, enum commit_msg_cleanup_mode cleanup_mode)
586 if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS) {
587 strbuf_addch(msgbuf, '\n');
588 wt_status_append_cut_line(msgbuf);
589 strbuf_addch(msgbuf, comment_line_char);
592 strbuf_addch(msgbuf, '\n');
593 strbuf_commented_addf(msgbuf, "Conflicts:\n");
594 for (i = 0; i < istate->cache_nr;) {
595 const struct cache_entry *ce = istate->cache[i++];
597 strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
598 while (i < istate->cache_nr &&
599 !strcmp(ce->name, istate->cache[i]->name))
605 static int do_recursive_merge(struct repository *r,
606 struct commit *base, struct commit *next,
607 const char *base_label, const char *next_label,
608 struct object_id *head, struct strbuf *msgbuf,
609 struct replay_opts *opts)
611 struct merge_options o;
612 struct merge_result result;
613 struct tree *next_tree, *base_tree, *head_tree;
614 int clean, show_output;
616 struct lock_file index_lock = LOCK_INIT;
618 if (repo_hold_locked_index(r, &index_lock, LOCK_REPORT_ON_ERROR) < 0)
623 init_merge_options(&o, r);
624 o.ancestor = base ? base_label : "(empty tree)";
626 o.branch2 = next ? next_label : "(empty tree)";
627 if (is_rebase_i(opts))
629 o.show_rename_progress = 1;
631 head_tree = parse_tree_indirect(head);
632 next_tree = next ? get_commit_tree(next) : empty_tree(r);
633 base_tree = base ? get_commit_tree(base) : empty_tree(r);
635 for (i = 0; i < opts->xopts_nr; i++)
636 parse_merge_opt(&o, opts->xopts[i]);
638 if (opts->strategy && !strcmp(opts->strategy, "ort")) {
639 memset(&result, 0, sizeof(result));
640 merge_incore_nonrecursive(&o, base_tree, head_tree, next_tree,
642 show_output = !is_rebase_i(opts) || !result.clean;
644 * TODO: merge_switch_to_result will update index/working tree;
645 * we only really want to do that if !result.clean || this is
646 * the final patch to be picked. But determining this is the
647 * final patch would take some work, and "head_tree" would need
648 * to be replace with the tree the index matched before we
649 * started doing any picks.
651 merge_switch_to_result(&o, head_tree, &result, 1, show_output);
652 clean = result.clean;
654 clean = merge_trees(&o, head_tree, next_tree, base_tree);
655 if (is_rebase_i(opts) && clean <= 0)
656 fputs(o.obuf.buf, stdout);
657 strbuf_release(&o.obuf);
660 rollback_lock_file(&index_lock);
664 if (write_locked_index(r->index, &index_lock,
665 COMMIT_LOCK | SKIP_IF_UNCHANGED))
667 * TRANSLATORS: %s will be "revert", "cherry-pick" or
670 return error(_("%s: Unable to write new index file"),
671 _(action_name(opts)));
674 append_conflicts_hint(r->index, msgbuf,
675 opts->default_msg_cleanup);
680 static struct object_id *get_cache_tree_oid(struct index_state *istate)
682 if (!istate->cache_tree)
683 istate->cache_tree = cache_tree();
685 if (!cache_tree_fully_valid(istate->cache_tree))
686 if (cache_tree_update(istate, 0)) {
687 error(_("unable to update cache tree"));
691 return &istate->cache_tree->oid;
694 static int is_index_unchanged(struct repository *r)
696 struct object_id head_oid, *cache_tree_oid;
697 struct commit *head_commit;
698 struct index_state *istate = r->index;
700 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
701 return error(_("could not resolve HEAD commit"));
703 head_commit = lookup_commit(r, &head_oid);
706 * If head_commit is NULL, check_commit, called from
707 * lookup_commit, would have indicated that head_commit is not
708 * a commit object already. parse_commit() will return failure
709 * without further complaints in such a case. Otherwise, if
710 * the commit is invalid, parse_commit() will complain. So
711 * there is nothing for us to say here. Just return failure.
713 if (parse_commit(head_commit))
716 if (!(cache_tree_oid = get_cache_tree_oid(istate)))
719 return oideq(cache_tree_oid, get_commit_tree_oid(head_commit));
722 static int write_author_script(const char *message)
724 struct strbuf buf = STRBUF_INIT;
729 if (!*message || starts_with(message, "\n")) {
731 /* Missing 'author' line? */
732 unlink(rebase_path_author_script());
734 } else if (skip_prefix(message, "author ", &message))
736 else if ((eol = strchr(message, '\n')))
741 strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
742 while (*message && *message != '\n' && *message != '\r')
743 if (skip_prefix(message, " <", &message))
745 else if (*message != '\'')
746 strbuf_addch(&buf, *(message++));
748 strbuf_addf(&buf, "'\\%c'", *(message++));
749 strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
750 while (*message && *message != '\n' && *message != '\r')
751 if (skip_prefix(message, "> ", &message))
753 else if (*message != '\'')
754 strbuf_addch(&buf, *(message++));
756 strbuf_addf(&buf, "'\\%c'", *(message++));
757 strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
758 while (*message && *message != '\n' && *message != '\r')
759 if (*message != '\'')
760 strbuf_addch(&buf, *(message++));
762 strbuf_addf(&buf, "'\\%c'", *(message++));
763 strbuf_addch(&buf, '\'');
764 res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
765 strbuf_release(&buf);
770 * Take a series of KEY='VALUE' lines where VALUE part is
771 * sq-quoted, and append <KEY, VALUE> at the end of the string list
773 static int parse_key_value_squoted(char *buf, struct string_list *list)
776 struct string_list_item *item;
778 char *cp = strchr(buf, '=');
780 np = strchrnul(buf, '\n');
781 return error(_("no key present in '%.*s'"),
782 (int) (np - buf), buf);
784 np = strchrnul(cp, '\n');
786 item = string_list_append(list, buf);
788 buf = np + (*np == '\n');
792 return error(_("unable to dequote value of '%s'"),
794 item->util = xstrdup(cp);
800 * Reads and parses the state directory's "author-script" file, and sets name,
801 * email and date accordingly.
802 * Returns 0 on success, -1 if the file could not be parsed.
804 * The author script is of the format:
806 * GIT_AUTHOR_NAME='$author_name'
807 * GIT_AUTHOR_EMAIL='$author_email'
808 * GIT_AUTHOR_DATE='$author_date'
810 * where $author_name, $author_email and $author_date are quoted. We are strict
811 * with our parsing, as the file was meant to be eval'd in the now-removed
812 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
813 * from what this function expects, it is better to bail out than to do
814 * something that the user does not expect.
816 int read_author_script(const char *path, char **name, char **email, char **date,
819 struct strbuf buf = STRBUF_INIT;
820 struct string_list kv = STRING_LIST_INIT_DUP;
821 int retval = -1; /* assume failure */
822 int i, name_i = -2, email_i = -2, date_i = -2, err = 0;
824 if (strbuf_read_file(&buf, path, 256) <= 0) {
825 strbuf_release(&buf);
826 if (errno == ENOENT && allow_missing)
829 return error_errno(_("could not open '%s' for reading"),
833 if (parse_key_value_squoted(buf.buf, &kv))
836 for (i = 0; i < kv.nr; i++) {
837 if (!strcmp(kv.items[i].string, "GIT_AUTHOR_NAME")) {
839 name_i = error(_("'GIT_AUTHOR_NAME' already given"));
842 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_EMAIL")) {
844 email_i = error(_("'GIT_AUTHOR_EMAIL' already given"));
847 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_DATE")) {
849 date_i = error(_("'GIT_AUTHOR_DATE' already given"));
853 err = error(_("unknown variable '%s'"),
858 error(_("missing 'GIT_AUTHOR_NAME'"));
860 error(_("missing 'GIT_AUTHOR_EMAIL'"));
862 error(_("missing 'GIT_AUTHOR_DATE'"));
863 if (date_i < 0 || email_i < 0 || date_i < 0 || err)
865 *name = kv.items[name_i].util;
866 *email = kv.items[email_i].util;
867 *date = kv.items[date_i].util;
870 string_list_clear(&kv, !!retval);
871 strbuf_release(&buf);
876 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
877 * file with shell quoting into struct strvec. Returns -1 on
878 * error, 0 otherwise.
880 static int read_env_script(struct strvec *env)
882 char *name, *email, *date;
884 if (read_author_script(rebase_path_author_script(),
885 &name, &email, &date, 0))
888 strvec_pushf(env, "GIT_AUTHOR_NAME=%s", name);
889 strvec_pushf(env, "GIT_AUTHOR_EMAIL=%s", email);
890 strvec_pushf(env, "GIT_AUTHOR_DATE=%s", date);
898 static char *get_author(const char *message)
903 a = find_commit_header(message, "author", &len);
905 return xmemdupz(a, len);
910 static const char *author_date_from_env_array(const struct strvec *env)
915 for (i = 0; i < env->nr; i++)
916 if (skip_prefix(env->v[i],
917 "GIT_AUTHOR_DATE=", &date))
920 * If GIT_AUTHOR_DATE is missing we should have already errored out when
923 BUG("GIT_AUTHOR_DATE missing from author script");
926 static const char staged_changes_advice[] =
927 N_("you have staged changes in your working tree\n"
928 "If these changes are meant to be squashed into the previous commit, run:\n"
930 " git commit --amend %s\n"
932 "If they are meant to go into a new commit, run:\n"
936 "In both cases, once you're done, continue with:\n"
938 " git rebase --continue\n");
940 #define ALLOW_EMPTY (1<<0)
941 #define EDIT_MSG (1<<1)
942 #define AMEND_MSG (1<<2)
943 #define CLEANUP_MSG (1<<3)
944 #define VERIFY_MSG (1<<4)
945 #define CREATE_ROOT_COMMIT (1<<5)
947 static int run_command_silent_on_success(struct child_process *cmd)
949 struct strbuf buf = STRBUF_INIT;
952 cmd->stdout_to_stderr = 1;
953 rc = pipe_command(cmd,
959 fputs(buf.buf, stderr);
960 strbuf_release(&buf);
965 * If we are cherry-pick, and if the merge did not result in
966 * hand-editing, we will hit this commit and inherit the original
967 * author date and name.
969 * If we are revert, or if our cherry-pick results in a hand merge,
970 * we had better say that the current user is responsible for that.
972 * An exception is when run_git_commit() is called during an
973 * interactive rebase: in that case, we will want to retain the
976 static int run_git_commit(const char *defmsg,
977 struct replay_opts *opts,
980 struct child_process cmd = CHILD_PROCESS_INIT;
984 if (is_rebase_i(opts) && read_env_script(&cmd.env_array)) {
985 const char *gpg_opt = gpg_sign_opt_quoted(opts);
987 return error(_(staged_changes_advice),
991 if (opts->committer_date_is_author_date)
992 strvec_pushf(&cmd.env_array, "GIT_COMMITTER_DATE=%s",
995 author_date_from_env_array(&cmd.env_array));
996 if (opts->ignore_date)
997 strvec_push(&cmd.env_array, "GIT_AUTHOR_DATE=");
999 strvec_push(&cmd.args, "commit");
1001 if (!(flags & VERIFY_MSG))
1002 strvec_push(&cmd.args, "-n");
1003 if ((flags & AMEND_MSG))
1004 strvec_push(&cmd.args, "--amend");
1006 strvec_pushf(&cmd.args, "-S%s", opts->gpg_sign);
1008 strvec_push(&cmd.args, "--no-gpg-sign");
1010 strvec_pushl(&cmd.args, "-F", defmsg, NULL);
1011 else if (!(flags & EDIT_MSG))
1012 strvec_pushl(&cmd.args, "-C", "HEAD", NULL);
1013 if ((flags & CLEANUP_MSG))
1014 strvec_push(&cmd.args, "--cleanup=strip");
1015 if ((flags & EDIT_MSG))
1016 strvec_push(&cmd.args, "-e");
1017 else if (!(flags & CLEANUP_MSG) &&
1018 !opts->signoff && !opts->record_origin &&
1019 !opts->explicit_cleanup)
1020 strvec_push(&cmd.args, "--cleanup=verbatim");
1022 if ((flags & ALLOW_EMPTY))
1023 strvec_push(&cmd.args, "--allow-empty");
1025 if (!(flags & EDIT_MSG))
1026 strvec_push(&cmd.args, "--allow-empty-message");
1028 if (is_rebase_i(opts) && !(flags & EDIT_MSG))
1029 return run_command_silent_on_success(&cmd);
1031 return run_command(&cmd);
1034 static int rest_is_empty(const struct strbuf *sb, int start)
1039 /* Check if the rest is just whitespace and Signed-off-by's. */
1040 for (i = start; i < sb->len; i++) {
1041 nl = memchr(sb->buf + i, '\n', sb->len - i);
1047 if (strlen(sign_off_header) <= eol - i &&
1048 starts_with(sb->buf + i, sign_off_header)) {
1053 if (!isspace(sb->buf[i++]))
1060 void cleanup_message(struct strbuf *msgbuf,
1061 enum commit_msg_cleanup_mode cleanup_mode, int verbose)
1063 if (verbose || /* Truncate the message just before the diff, if any. */
1064 cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS)
1065 strbuf_setlen(msgbuf, wt_status_locate_end(msgbuf->buf, msgbuf->len));
1066 if (cleanup_mode != COMMIT_MSG_CLEANUP_NONE)
1067 strbuf_stripspace(msgbuf, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1071 * Find out if the message in the strbuf contains only whitespace and
1072 * Signed-off-by lines.
1074 int message_is_empty(const struct strbuf *sb,
1075 enum commit_msg_cleanup_mode cleanup_mode)
1077 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1079 return rest_is_empty(sb, 0);
1083 * See if the user edited the message in the editor or left what
1084 * was in the template intact
1086 int template_untouched(const struct strbuf *sb, const char *template_file,
1087 enum commit_msg_cleanup_mode cleanup_mode)
1089 struct strbuf tmpl = STRBUF_INIT;
1092 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1095 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1098 strbuf_stripspace(&tmpl, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1099 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1101 strbuf_release(&tmpl);
1102 return rest_is_empty(sb, start - sb->buf);
1105 int update_head_with_reflog(const struct commit *old_head,
1106 const struct object_id *new_head,
1107 const char *action, const struct strbuf *msg,
1110 struct ref_transaction *transaction;
1111 struct strbuf sb = STRBUF_INIT;
1116 strbuf_addstr(&sb, action);
1117 strbuf_addstr(&sb, ": ");
1120 nl = strchr(msg->buf, '\n');
1122 strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
1124 strbuf_addbuf(&sb, msg);
1125 strbuf_addch(&sb, '\n');
1128 transaction = ref_transaction_begin(err);
1130 ref_transaction_update(transaction, "HEAD", new_head,
1131 old_head ? &old_head->object.oid : &null_oid,
1133 ref_transaction_commit(transaction, err)) {
1136 ref_transaction_free(transaction);
1137 strbuf_release(&sb);
1142 static int run_rewrite_hook(const struct object_id *oldoid,
1143 const struct object_id *newoid)
1145 struct child_process proc = CHILD_PROCESS_INIT;
1146 const char *argv[3];
1148 struct strbuf sb = STRBUF_INIT;
1150 argv[0] = find_hook("post-rewrite");
1159 proc.stdout_to_stderr = 1;
1160 proc.trace2_hook_name = "post-rewrite";
1162 code = start_command(&proc);
1165 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1166 sigchain_push(SIGPIPE, SIG_IGN);
1167 write_in_full(proc.in, sb.buf, sb.len);
1169 strbuf_release(&sb);
1170 sigchain_pop(SIGPIPE);
1171 return finish_command(&proc);
1174 void commit_post_rewrite(struct repository *r,
1175 const struct commit *old_head,
1176 const struct object_id *new_head)
1178 struct notes_rewrite_cfg *cfg;
1180 cfg = init_copy_notes_for_rewrite("amend");
1182 /* we are amending, so old_head is not NULL */
1183 copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
1184 finish_copy_notes_for_rewrite(r, cfg, "Notes added by 'git commit --amend'");
1186 run_rewrite_hook(&old_head->object.oid, new_head);
1189 static int run_prepare_commit_msg_hook(struct repository *r,
1194 const char *name, *arg1 = NULL, *arg2 = NULL;
1196 name = git_path_commit_editmsg();
1197 if (write_message(msg->buf, msg->len, name, 0))
1206 if (run_commit_hook(0, r->index_file, "prepare-commit-msg", name,
1208 ret = error(_("'prepare-commit-msg' hook failed"));
1213 static const char implicit_ident_advice_noconfig[] =
1214 N_("Your name and email address were configured automatically based\n"
1215 "on your username and hostname. Please check that they are accurate.\n"
1216 "You can suppress this message by setting them explicitly. Run the\n"
1217 "following command and follow the instructions in your editor to edit\n"
1218 "your configuration file:\n"
1220 " git config --global --edit\n"
1222 "After doing this, you may fix the identity used for this commit with:\n"
1224 " git commit --amend --reset-author\n");
1226 static const char implicit_ident_advice_config[] =
1227 N_("Your name and email address were configured automatically based\n"
1228 "on your username and hostname. Please check that they are accurate.\n"
1229 "You can suppress this message by setting them explicitly:\n"
1231 " git config --global user.name \"Your Name\"\n"
1232 " git config --global user.email you@example.com\n"
1234 "After doing this, you may fix the identity used for this commit with:\n"
1236 " git commit --amend --reset-author\n");
1238 static const char *implicit_ident_advice(void)
1240 char *user_config = expand_user_path("~/.gitconfig", 0);
1241 char *xdg_config = xdg_config_home("config");
1242 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1248 return _(implicit_ident_advice_config);
1250 return _(implicit_ident_advice_noconfig);
1254 void print_commit_summary(struct repository *r,
1256 const struct object_id *oid,
1259 struct rev_info rev;
1260 struct commit *commit;
1261 struct strbuf format = STRBUF_INIT;
1263 struct pretty_print_context pctx = {0};
1264 struct strbuf author_ident = STRBUF_INIT;
1265 struct strbuf committer_ident = STRBUF_INIT;
1267 commit = lookup_commit(r, oid);
1269 die(_("couldn't look up newly created commit"));
1270 if (parse_commit(commit))
1271 die(_("could not parse newly created commit"));
1273 strbuf_addstr(&format, "format:%h] %s");
1275 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1276 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1277 if (strbuf_cmp(&author_ident, &committer_ident)) {
1278 strbuf_addstr(&format, "\n Author: ");
1279 strbuf_addbuf_percentquote(&format, &author_ident);
1281 if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
1282 struct strbuf date = STRBUF_INIT;
1284 format_commit_message(commit, "%ad", &date, &pctx);
1285 strbuf_addstr(&format, "\n Date: ");
1286 strbuf_addbuf_percentquote(&format, &date);
1287 strbuf_release(&date);
1289 if (!committer_ident_sufficiently_given()) {
1290 strbuf_addstr(&format, "\n Committer: ");
1291 strbuf_addbuf_percentquote(&format, &committer_ident);
1292 if (advice_implicit_identity) {
1293 strbuf_addch(&format, '\n');
1294 strbuf_addstr(&format, implicit_ident_advice());
1297 strbuf_release(&author_ident);
1298 strbuf_release(&committer_ident);
1300 repo_init_revisions(r, &rev, prefix);
1301 setup_revisions(0, NULL, &rev, NULL);
1304 rev.diffopt.output_format =
1305 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1307 rev.verbose_header = 1;
1308 rev.show_root_diff = 1;
1309 get_commit_format(format.buf, &rev);
1310 rev.always_show_header = 0;
1311 rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1312 rev.diffopt.break_opt = 0;
1313 diff_setup_done(&rev.diffopt);
1315 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1317 die_errno(_("unable to resolve HEAD after creating commit"));
1318 if (!strcmp(head, "HEAD"))
1319 head = _("detached HEAD");
1321 skip_prefix(head, "refs/heads/", &head);
1322 printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1323 _(" (root-commit)") : "");
1325 if (!log_tree_commit(&rev, commit)) {
1326 rev.always_show_header = 1;
1327 rev.use_terminator = 1;
1328 log_tree_commit(&rev, commit);
1331 strbuf_release(&format);
1334 static int parse_head(struct repository *r, struct commit **head)
1336 struct commit *current_head;
1337 struct object_id oid;
1339 if (get_oid("HEAD", &oid)) {
1340 current_head = NULL;
1342 current_head = lookup_commit_reference(r, &oid);
1344 return error(_("could not parse HEAD"));
1345 if (!oideq(&oid, ¤t_head->object.oid)) {
1346 warning(_("HEAD %s is not a commit!"),
1349 if (parse_commit(current_head))
1350 return error(_("could not parse HEAD commit"));
1352 *head = current_head;
1358 * Try to commit without forking 'git commit'. In some cases we need
1359 * to run 'git commit' to display an error message
1362 * -1 - error unable to commit
1364 * 1 - run 'git commit'
1366 static int try_to_commit(struct repository *r,
1367 struct strbuf *msg, const char *author,
1368 struct replay_opts *opts, unsigned int flags,
1369 struct object_id *oid)
1371 struct object_id tree;
1372 struct commit *current_head = NULL;
1373 struct commit_list *parents = NULL;
1374 struct commit_extra_header *extra = NULL;
1375 struct strbuf err = STRBUF_INIT;
1376 struct strbuf commit_msg = STRBUF_INIT;
1377 char *amend_author = NULL;
1378 const char *committer = NULL;
1379 const char *hook_commit = NULL;
1380 enum commit_msg_cleanup_mode cleanup;
1383 if (parse_head(r, ¤t_head))
1386 if (flags & AMEND_MSG) {
1387 const char *exclude_gpgsig[] = { "gpgsig", "gpgsig-sha256", NULL };
1388 const char *out_enc = get_commit_output_encoding();
1389 const char *message = logmsg_reencode(current_head, NULL,
1393 const char *orig_message = NULL;
1395 find_commit_subject(message, &orig_message);
1397 strbuf_addstr(msg, orig_message);
1398 hook_commit = "HEAD";
1400 author = amend_author = get_author(message);
1401 unuse_commit_buffer(current_head, message);
1403 res = error(_("unable to parse commit author"));
1406 parents = copy_commit_list(current_head->parents);
1407 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1408 } else if (current_head &&
1409 (!(flags & CREATE_ROOT_COMMIT) || (flags & AMEND_MSG))) {
1410 commit_list_insert(current_head, &parents);
1413 if (write_index_as_tree(&tree, r->index, r->index_file, 0, NULL)) {
1414 res = error(_("git write-tree failed to write a tree"));
1418 if (!(flags & ALLOW_EMPTY)) {
1419 struct commit *first_parent = current_head;
1421 if (flags & AMEND_MSG) {
1422 if (current_head->parents) {
1423 first_parent = current_head->parents->item;
1424 if (repo_parse_commit(r, first_parent)) {
1425 res = error(_("could not parse HEAD commit"));
1429 first_parent = NULL;
1432 if (oideq(first_parent
1433 ? get_commit_tree_oid(first_parent)
1434 : the_hash_algo->empty_tree,
1436 res = 1; /* run 'git commit' to display error message */
1441 if (find_hook("prepare-commit-msg")) {
1442 res = run_prepare_commit_msg_hook(r, msg, hook_commit);
1445 if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1447 res = error_errno(_("unable to read commit message "
1449 git_path_commit_editmsg());
1455 if (flags & CLEANUP_MSG)
1456 cleanup = COMMIT_MSG_CLEANUP_ALL;
1457 else if ((opts->signoff || opts->record_origin) &&
1458 !opts->explicit_cleanup)
1459 cleanup = COMMIT_MSG_CLEANUP_SPACE;
1461 cleanup = opts->default_msg_cleanup;
1463 if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1464 strbuf_stripspace(msg, cleanup == COMMIT_MSG_CLEANUP_ALL);
1465 if ((flags & EDIT_MSG) && message_is_empty(msg, cleanup)) {
1466 res = 1; /* run 'git commit' to display error message */
1470 if (opts->committer_date_is_author_date) {
1471 struct ident_split id;
1472 struct strbuf date = STRBUF_INIT;
1474 if (!opts->ignore_date) {
1475 if (split_ident_line(&id, author, (int)strlen(author)) < 0) {
1476 res = error(_("invalid author identity '%s'"),
1480 if (!id.date_begin) {
1482 "corrupt author: missing date information"));
1485 strbuf_addf(&date, "@%.*s %.*s",
1486 (int)(id.date_end - id.date_begin),
1488 (int)(id.tz_end - id.tz_begin),
1493 committer = fmt_ident(getenv("GIT_COMMITTER_NAME"),
1494 getenv("GIT_COMMITTER_EMAIL"),
1495 WANT_COMMITTER_IDENT,
1496 opts->ignore_date ? NULL : date.buf,
1498 strbuf_release(&date);
1503 if (opts->ignore_date) {
1504 struct ident_split id;
1507 if (split_ident_line(&id, author, strlen(author)) < 0) {
1508 error(_("invalid author identity '%s'"), author);
1511 name = xmemdupz(id.name_begin, id.name_end - id.name_begin);
1512 email = xmemdupz(id.mail_begin, id.mail_end - id.mail_begin);
1513 author = fmt_ident(name, email, WANT_AUTHOR_IDENT, NULL,
1519 if (commit_tree_extended(msg->buf, msg->len, &tree, parents, oid,
1520 author, committer, opts->gpg_sign, extra)) {
1521 res = error(_("failed to write commit object"));
1525 if (update_head_with_reflog(current_head, oid,
1526 getenv("GIT_REFLOG_ACTION"), msg, &err)) {
1527 res = error("%s", err.buf);
1531 run_commit_hook(0, r->index_file, "post-commit", NULL);
1532 if (flags & AMEND_MSG)
1533 commit_post_rewrite(r, current_head, oid);
1536 free_commit_extra_headers(extra);
1537 strbuf_release(&err);
1538 strbuf_release(&commit_msg);
1544 static int write_rebase_head(struct object_id *oid)
1546 if (update_ref("rebase", "REBASE_HEAD", oid,
1547 NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1548 return error(_("could not update %s"), "REBASE_HEAD");
1553 static int do_commit(struct repository *r,
1554 const char *msg_file, const char *author,
1555 struct replay_opts *opts, unsigned int flags,
1556 struct object_id *oid)
1560 if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG)) {
1561 struct object_id oid;
1562 struct strbuf sb = STRBUF_INIT;
1564 if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1565 return error_errno(_("unable to read commit message "
1569 res = try_to_commit(r, msg_file ? &sb : NULL,
1570 author, opts, flags, &oid);
1571 strbuf_release(&sb);
1573 refs_delete_ref(get_main_ref_store(r), "",
1574 "CHERRY_PICK_HEAD", NULL, 0);
1575 unlink(git_path_merge_msg(r));
1576 if (!is_rebase_i(opts))
1577 print_commit_summary(r, NULL, &oid,
1578 SUMMARY_SHOW_AUTHOR_DATE);
1583 if (is_rebase_i(opts) && oid)
1584 if (write_rebase_head(oid))
1586 return run_git_commit(msg_file, opts, flags);
1592 static int is_original_commit_empty(struct commit *commit)
1594 const struct object_id *ptree_oid;
1596 if (parse_commit(commit))
1597 return error(_("could not parse commit %s"),
1598 oid_to_hex(&commit->object.oid));
1599 if (commit->parents) {
1600 struct commit *parent = commit->parents->item;
1601 if (parse_commit(parent))
1602 return error(_("could not parse parent commit %s"),
1603 oid_to_hex(&parent->object.oid));
1604 ptree_oid = get_commit_tree_oid(parent);
1606 ptree_oid = the_hash_algo->empty_tree; /* commit is root */
1609 return oideq(ptree_oid, get_commit_tree_oid(commit));
1613 * Should empty commits be allowed? Return status:
1614 * <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1615 * 0: Halt on empty commit
1616 * 1: Allow empty commit
1617 * 2: Drop empty commit
1619 static int allow_empty(struct repository *r,
1620 struct replay_opts *opts,
1621 struct commit *commit)
1623 int index_unchanged, originally_empty;
1628 * (1) we do not allow empty at all and error out.
1630 * (2) we allow ones that were initially empty, and
1631 * just drop the ones that become empty
1633 * (3) we allow ones that were initially empty, but
1634 * halt for the ones that become empty;
1636 * (4) we allow both.
1638 if (!opts->allow_empty)
1639 return 0; /* let "git commit" barf as necessary */
1641 index_unchanged = is_index_unchanged(r);
1642 if (index_unchanged < 0)
1643 return index_unchanged;
1644 if (!index_unchanged)
1645 return 0; /* we do not have to say --allow-empty */
1647 if (opts->keep_redundant_commits)
1650 originally_empty = is_original_commit_empty(commit);
1651 if (originally_empty < 0)
1652 return originally_empty;
1653 if (originally_empty)
1655 else if (opts->drop_redundant_commits)
1664 } todo_command_info[] = {
1681 static const char *command_to_string(const enum todo_command command)
1683 if (command < TODO_COMMENT)
1684 return todo_command_info[command].str;
1685 die(_("unknown command: %d"), command);
1688 static char command_to_char(const enum todo_command command)
1690 if (command < TODO_COMMENT)
1691 return todo_command_info[command].c;
1692 return comment_line_char;
1695 static int is_noop(const enum todo_command command)
1697 return TODO_NOOP <= command;
1700 static int is_fixup(enum todo_command command)
1702 return command == TODO_FIXUP || command == TODO_SQUASH;
1705 /* Does this command create a (non-merge) commit? */
1706 static int is_pick_or_similar(enum todo_command command)
1721 static int update_squash_messages(struct repository *r,
1722 enum todo_command command,
1723 struct commit *commit,
1724 struct replay_opts *opts)
1726 struct strbuf buf = STRBUF_INIT;
1728 const char *message, *body;
1729 const char *encoding = get_commit_output_encoding();
1731 if (opts->current_fixup_count > 0) {
1732 struct strbuf header = STRBUF_INIT;
1735 if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
1736 return error(_("could not read '%s'"),
1737 rebase_path_squash_msg());
1739 eol = buf.buf[0] != comment_line_char ?
1740 buf.buf : strchrnul(buf.buf, '\n');
1742 strbuf_addf(&header, "%c ", comment_line_char);
1743 strbuf_addf(&header, _("This is a combination of %d commits."),
1744 opts->current_fixup_count + 2);
1745 strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
1746 strbuf_release(&header);
1748 struct object_id head;
1749 struct commit *head_commit;
1750 const char *head_message, *body;
1752 if (get_oid("HEAD", &head))
1753 return error(_("need a HEAD to fixup"));
1754 if (!(head_commit = lookup_commit_reference(r, &head)))
1755 return error(_("could not read HEAD"));
1756 if (!(head_message = logmsg_reencode(head_commit, NULL, encoding)))
1757 return error(_("could not read HEAD's commit message"));
1759 find_commit_subject(head_message, &body);
1760 if (write_message(body, strlen(body),
1761 rebase_path_fixup_msg(), 0)) {
1762 unuse_commit_buffer(head_commit, head_message);
1763 return error(_("cannot write '%s'"),
1764 rebase_path_fixup_msg());
1767 strbuf_addf(&buf, "%c ", comment_line_char);
1768 strbuf_addf(&buf, _("This is a combination of %d commits."), 2);
1769 strbuf_addf(&buf, "\n%c ", comment_line_char);
1770 strbuf_addstr(&buf, _("This is the 1st commit message:"));
1771 strbuf_addstr(&buf, "\n\n");
1772 strbuf_addstr(&buf, body);
1774 unuse_commit_buffer(head_commit, head_message);
1777 if (!(message = logmsg_reencode(commit, NULL, encoding)))
1778 return error(_("could not read commit message of %s"),
1779 oid_to_hex(&commit->object.oid));
1780 find_commit_subject(message, &body);
1782 if (command == TODO_SQUASH) {
1783 unlink(rebase_path_fixup_msg());
1784 strbuf_addf(&buf, "\n%c ", comment_line_char);
1785 strbuf_addf(&buf, _("This is the commit message #%d:"),
1786 ++opts->current_fixup_count + 1);
1787 strbuf_addstr(&buf, "\n\n");
1788 strbuf_addstr(&buf, body);
1789 } else if (command == TODO_FIXUP) {
1790 strbuf_addf(&buf, "\n%c ", comment_line_char);
1791 strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
1792 ++opts->current_fixup_count + 1);
1793 strbuf_addstr(&buf, "\n\n");
1794 strbuf_add_commented_lines(&buf, body, strlen(body));
1796 return error(_("unknown command: %d"), command);
1797 unuse_commit_buffer(commit, message);
1799 res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
1800 strbuf_release(&buf);
1803 strbuf_addf(&opts->current_fixups, "%s%s %s",
1804 opts->current_fixups.len ? "\n" : "",
1805 command_to_string(command),
1806 oid_to_hex(&commit->object.oid));
1807 res = write_message(opts->current_fixups.buf,
1808 opts->current_fixups.len,
1809 rebase_path_current_fixups(), 0);
1815 static void flush_rewritten_pending(void)
1817 struct strbuf buf = STRBUF_INIT;
1818 struct object_id newoid;
1821 if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
1822 !get_oid("HEAD", &newoid) &&
1823 (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1824 char *bol = buf.buf, *eol;
1827 eol = strchrnul(bol, '\n');
1828 fprintf(out, "%.*s %s\n", (int)(eol - bol),
1829 bol, oid_to_hex(&newoid));
1835 unlink(rebase_path_rewritten_pending());
1837 strbuf_release(&buf);
1840 static void record_in_rewritten(struct object_id *oid,
1841 enum todo_command next_command)
1843 FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
1848 fprintf(out, "%s\n", oid_to_hex(oid));
1851 if (!is_fixup(next_command))
1852 flush_rewritten_pending();
1855 static int do_pick_commit(struct repository *r,
1856 enum todo_command command,
1857 struct commit *commit,
1858 struct replay_opts *opts,
1859 int final_fixup, int *check_todo)
1861 unsigned int flags = opts->edit ? EDIT_MSG : 0;
1862 const char *msg_file = opts->edit ? NULL : git_path_merge_msg(r);
1863 struct object_id head;
1864 struct commit *base, *next, *parent;
1865 const char *base_label, *next_label;
1866 char *author = NULL;
1867 struct commit_message msg = { NULL, NULL, NULL, NULL };
1868 struct strbuf msgbuf = STRBUF_INIT;
1869 int res, unborn = 0, reword = 0, allow, drop_commit;
1871 if (opts->no_commit) {
1873 * We do not intend to commit immediately. We just want to
1874 * merge the differences in, so let's compute the tree
1875 * that represents the "current" state for merge-recursive
1878 if (write_index_as_tree(&head, r->index, r->index_file, 0, NULL))
1879 return error(_("your index file is unmerged."));
1881 unborn = get_oid("HEAD", &head);
1882 /* Do we want to generate a root commit? */
1883 if (is_pick_or_similar(command) && opts->have_squash_onto &&
1884 oideq(&head, &opts->squash_onto)) {
1885 if (is_fixup(command))
1886 return error(_("cannot fixup root commit"));
1887 flags |= CREATE_ROOT_COMMIT;
1890 oidcpy(&head, the_hash_algo->empty_tree);
1891 if (index_differs_from(r, unborn ? empty_tree_oid_hex() : "HEAD",
1893 return error_dirty_index(r, opts);
1895 discard_index(r->index);
1897 if (!commit->parents)
1899 else if (commit->parents->next) {
1900 /* Reverting or cherry-picking a merge commit */
1902 struct commit_list *p;
1904 if (!opts->mainline)
1905 return error(_("commit %s is a merge but no -m option was given."),
1906 oid_to_hex(&commit->object.oid));
1908 for (cnt = 1, p = commit->parents;
1909 cnt != opts->mainline && p;
1912 if (cnt != opts->mainline || !p)
1913 return error(_("commit %s does not have parent %d"),
1914 oid_to_hex(&commit->object.oid), opts->mainline);
1916 } else if (1 < opts->mainline)
1918 * Non-first parent explicitly specified as mainline for
1921 return error(_("commit %s does not have parent %d"),
1922 oid_to_hex(&commit->object.oid), opts->mainline);
1924 parent = commit->parents->item;
1926 if (get_message(commit, &msg) != 0)
1927 return error(_("cannot get commit message for %s"),
1928 oid_to_hex(&commit->object.oid));
1930 if (opts->allow_ff && !is_fixup(command) &&
1931 ((parent && oideq(&parent->object.oid, &head)) ||
1932 (!parent && unborn))) {
1933 if (is_rebase_i(opts))
1934 write_author_script(msg.message);
1935 res = fast_forward_to(r, &commit->object.oid, &head, unborn,
1937 if (res || command != TODO_REWORD)
1941 goto fast_forward_edit;
1943 if (parent && parse_commit(parent) < 0)
1944 /* TRANSLATORS: The first %s will be a "todo" command like
1945 "revert" or "pick", the second %s a SHA1. */
1946 return error(_("%s: cannot parse parent commit %s"),
1947 command_to_string(command),
1948 oid_to_hex(&parent->object.oid));
1951 * "commit" is an existing commit. We would want to apply
1952 * the difference it introduces since its first parent "prev"
1953 * on top of the current HEAD if we are cherry-pick. Or the
1954 * reverse of it if we are revert.
1957 if (command == TODO_REVERT) {
1959 base_label = msg.label;
1961 next_label = msg.parent_label;
1962 strbuf_addstr(&msgbuf, "Revert \"");
1963 strbuf_addstr(&msgbuf, msg.subject);
1964 strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
1965 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1967 if (commit->parents && commit->parents->next) {
1968 strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
1969 strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
1971 strbuf_addstr(&msgbuf, ".\n");
1976 base_label = msg.parent_label;
1978 next_label = msg.label;
1980 /* Append the commit log message to msgbuf. */
1981 if (find_commit_subject(msg.message, &p))
1982 strbuf_addstr(&msgbuf, p);
1984 if (opts->record_origin) {
1985 strbuf_complete_line(&msgbuf);
1986 if (!has_conforming_footer(&msgbuf, NULL, 0))
1987 strbuf_addch(&msgbuf, '\n');
1988 strbuf_addstr(&msgbuf, cherry_picked_prefix);
1989 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1990 strbuf_addstr(&msgbuf, ")\n");
1992 if (!is_fixup(command))
1993 author = get_author(msg.message);
1996 if (command == TODO_REWORD)
1998 else if (is_fixup(command)) {
1999 if (update_squash_messages(r, command, commit, opts))
2003 msg_file = rebase_path_squash_msg();
2004 else if (file_exists(rebase_path_fixup_msg())) {
2005 flags |= CLEANUP_MSG;
2006 msg_file = rebase_path_fixup_msg();
2008 const char *dest = git_path_squash_msg(r);
2010 if (copy_file(dest, rebase_path_squash_msg(), 0666))
2011 return error(_("could not rename '%s' to '%s'"),
2012 rebase_path_squash_msg(), dest);
2013 unlink(git_path_merge_msg(r));
2019 if (opts->signoff && !is_fixup(command))
2020 append_signoff(&msgbuf, 0, 0);
2022 if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
2024 else if (!opts->strategy ||
2025 !strcmp(opts->strategy, "recursive") ||
2026 !strcmp(opts->strategy, "ort") ||
2027 command == TODO_REVERT) {
2028 res = do_recursive_merge(r, base, next, base_label, next_label,
2029 &head, &msgbuf, opts);
2033 res |= write_message(msgbuf.buf, msgbuf.len,
2034 git_path_merge_msg(r), 0);
2036 struct commit_list *common = NULL;
2037 struct commit_list *remotes = NULL;
2039 res = write_message(msgbuf.buf, msgbuf.len,
2040 git_path_merge_msg(r), 0);
2042 commit_list_insert(base, &common);
2043 commit_list_insert(next, &remotes);
2044 res |= try_merge_command(r, opts->strategy,
2045 opts->xopts_nr, (const char **)opts->xopts,
2046 common, oid_to_hex(&head), remotes);
2047 free_commit_list(common);
2048 free_commit_list(remotes);
2050 strbuf_release(&msgbuf);
2053 * If the merge was clean or if it failed due to conflict, we write
2054 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
2055 * However, if the merge did not even start, then we don't want to
2058 if ((command == TODO_PICK || command == TODO_REWORD ||
2059 command == TODO_EDIT) && !opts->no_commit &&
2060 (res == 0 || res == 1) &&
2061 update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
2062 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2064 if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
2065 update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
2066 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2070 error(command == TODO_REVERT
2071 ? _("could not revert %s... %s")
2072 : _("could not apply %s... %s"),
2073 short_commit_name(commit), msg.subject);
2074 print_advice(r, res == 1, opts);
2075 repo_rerere(r, opts->allow_rerere_auto);
2080 allow = allow_empty(r, opts, commit);
2084 } else if (allow == 1) {
2085 flags |= ALLOW_EMPTY;
2086 } else if (allow == 2) {
2088 refs_delete_ref(get_main_ref_store(r), "", "CHERRY_PICK_HEAD",
2090 unlink(git_path_merge_msg(r));
2092 _("dropping %s %s -- patch contents already upstream\n"),
2093 oid_to_hex(&commit->object.oid), msg.subject);
2094 } /* else allow == 0 and there's nothing special to do */
2095 if (!opts->no_commit && !drop_commit) {
2096 if (author || command == TODO_REVERT || (flags & AMEND_MSG))
2097 res = do_commit(r, msg_file, author, opts, flags,
2098 commit? &commit->object.oid : NULL);
2100 res = error(_("unable to parse commit author"));
2101 *check_todo = !!(flags & EDIT_MSG);
2102 if (!res && reword) {
2104 res = run_git_commit(NULL, opts, EDIT_MSG |
2105 VERIFY_MSG | AMEND_MSG |
2106 (flags & ALLOW_EMPTY));
2112 if (!res && final_fixup) {
2113 unlink(rebase_path_fixup_msg());
2114 unlink(rebase_path_squash_msg());
2115 unlink(rebase_path_current_fixups());
2116 strbuf_reset(&opts->current_fixups);
2117 opts->current_fixup_count = 0;
2121 free_message(commit, &msg);
2123 update_abort_safety_file();
2128 static int prepare_revs(struct replay_opts *opts)
2131 * picking (but not reverting) ranges (but not individual revisions)
2132 * should be done in reverse
2134 if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
2135 opts->revs->reverse ^= 1;
2137 if (prepare_revision_walk(opts->revs))
2138 return error(_("revision walk setup failed"));
2143 static int read_and_refresh_cache(struct repository *r,
2144 struct replay_opts *opts)
2146 struct lock_file index_lock = LOCK_INIT;
2147 int index_fd = repo_hold_locked_index(r, &index_lock, 0);
2148 if (repo_read_index(r) < 0) {
2149 rollback_lock_file(&index_lock);
2150 return error(_("git %s: failed to read the index"),
2151 _(action_name(opts)));
2153 refresh_index(r->index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
2154 if (index_fd >= 0) {
2155 if (write_locked_index(r->index, &index_lock,
2156 COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
2157 return error(_("git %s: failed to refresh the index"),
2158 _(action_name(opts)));
2164 enum todo_item_flags {
2165 TODO_EDIT_MERGE_MSG = 1
2168 void todo_list_release(struct todo_list *todo_list)
2170 strbuf_release(&todo_list->buf);
2171 FREE_AND_NULL(todo_list->items);
2172 todo_list->nr = todo_list->alloc = 0;
2175 static struct todo_item *append_new_todo(struct todo_list *todo_list)
2177 ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
2178 todo_list->total_nr++;
2179 return todo_list->items + todo_list->nr++;
2182 const char *todo_item_get_arg(struct todo_list *todo_list,
2183 struct todo_item *item)
2185 return todo_list->buf.buf + item->arg_offset;
2188 static int is_command(enum todo_command command, const char **bol)
2190 const char *str = todo_command_info[command].str;
2191 const char nick = todo_command_info[command].c;
2192 const char *p = *bol + 1;
2194 return skip_prefix(*bol, str, bol) ||
2195 ((nick && **bol == nick) &&
2196 (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r' || !*p) &&
2200 static int parse_insn_line(struct repository *r, struct todo_item *item,
2201 const char *buf, const char *bol, char *eol)
2203 struct object_id commit_oid;
2204 char *end_of_object_name;
2205 int i, saved, status, padding;
2210 bol += strspn(bol, " \t");
2212 if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
2213 item->command = TODO_COMMENT;
2214 item->commit = NULL;
2215 item->arg_offset = bol - buf;
2216 item->arg_len = eol - bol;
2220 for (i = 0; i < TODO_COMMENT; i++)
2221 if (is_command(i, &bol)) {
2225 if (i >= TODO_COMMENT)
2228 /* Eat up extra spaces/ tabs before object name */
2229 padding = strspn(bol, " \t");
2232 if (item->command == TODO_NOOP || item->command == TODO_BREAK) {
2234 return error(_("%s does not accept arguments: '%s'"),
2235 command_to_string(item->command), bol);
2236 item->commit = NULL;
2237 item->arg_offset = bol - buf;
2238 item->arg_len = eol - bol;
2243 return error(_("missing arguments for %s"),
2244 command_to_string(item->command));
2246 if (item->command == TODO_EXEC || item->command == TODO_LABEL ||
2247 item->command == TODO_RESET) {
2248 item->commit = NULL;
2249 item->arg_offset = bol - buf;
2250 item->arg_len = (int)(eol - bol);
2254 if (item->command == TODO_MERGE) {
2255 if (skip_prefix(bol, "-C", &bol))
2256 bol += strspn(bol, " \t");
2257 else if (skip_prefix(bol, "-c", &bol)) {
2258 bol += strspn(bol, " \t");
2259 item->flags |= TODO_EDIT_MERGE_MSG;
2261 item->flags |= TODO_EDIT_MERGE_MSG;
2262 item->commit = NULL;
2263 item->arg_offset = bol - buf;
2264 item->arg_len = (int)(eol - bol);
2269 end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
2270 saved = *end_of_object_name;
2271 *end_of_object_name = '\0';
2272 status = get_oid(bol, &commit_oid);
2274 error(_("could not parse '%s'"), bol); /* return later */
2275 *end_of_object_name = saved;
2277 bol = end_of_object_name + strspn(end_of_object_name, " \t");
2278 item->arg_offset = bol - buf;
2279 item->arg_len = (int)(eol - bol);
2284 item->commit = lookup_commit_reference(r, &commit_oid);
2285 return item->commit ? 0 : -1;
2288 int sequencer_get_last_command(struct repository *r, enum replay_action *action)
2290 const char *todo_file, *bol;
2291 struct strbuf buf = STRBUF_INIT;
2294 todo_file = git_path_todo_file();
2295 if (strbuf_read_file(&buf, todo_file, 0) < 0) {
2296 if (errno == ENOENT || errno == ENOTDIR)
2299 return error_errno("unable to open '%s'", todo_file);
2301 bol = buf.buf + strspn(buf.buf, " \t\r\n");
2302 if (is_command(TODO_PICK, &bol) && (*bol == ' ' || *bol == '\t'))
2303 *action = REPLAY_PICK;
2304 else if (is_command(TODO_REVERT, &bol) &&
2305 (*bol == ' ' || *bol == '\t'))
2306 *action = REPLAY_REVERT;
2310 strbuf_release(&buf);
2315 int todo_list_parse_insn_buffer(struct repository *r, char *buf,
2316 struct todo_list *todo_list)
2318 struct todo_item *item;
2319 char *p = buf, *next_p;
2320 int i, res = 0, fixup_okay = file_exists(rebase_path_done());
2322 todo_list->current = todo_list->nr = 0;
2324 for (i = 1; *p; i++, p = next_p) {
2325 char *eol = strchrnul(p, '\n');
2327 next_p = *eol ? eol + 1 /* skip LF */ : eol;
2329 if (p != eol && eol[-1] == '\r')
2330 eol--; /* strip Carriage Return */
2332 item = append_new_todo(todo_list);
2333 item->offset_in_buf = p - todo_list->buf.buf;
2334 if (parse_insn_line(r, item, buf, p, eol)) {
2335 res = error(_("invalid line %d: %.*s"),
2336 i, (int)(eol - p), p);
2337 item->command = TODO_COMMENT + 1;
2338 item->arg_offset = p - buf;
2339 item->arg_len = (int)(eol - p);
2340 item->commit = NULL;
2345 else if (is_fixup(item->command))
2346 return error(_("cannot '%s' without a previous commit"),
2347 command_to_string(item->command));
2348 else if (!is_noop(item->command))
2355 static int count_commands(struct todo_list *todo_list)
2359 for (i = 0; i < todo_list->nr; i++)
2360 if (todo_list->items[i].command != TODO_COMMENT)
2366 static int get_item_line_offset(struct todo_list *todo_list, int index)
2368 return index < todo_list->nr ?
2369 todo_list->items[index].offset_in_buf : todo_list->buf.len;
2372 static const char *get_item_line(struct todo_list *todo_list, int index)
2374 return todo_list->buf.buf + get_item_line_offset(todo_list, index);
2377 static int get_item_line_length(struct todo_list *todo_list, int index)
2379 return get_item_line_offset(todo_list, index + 1)
2380 - get_item_line_offset(todo_list, index);
2383 static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
2388 fd = open(path, O_RDONLY);
2390 return error_errno(_("could not open '%s'"), path);
2391 len = strbuf_read(sb, fd, 0);
2394 return error(_("could not read '%s'."), path);
2398 static int have_finished_the_last_pick(void)
2400 struct strbuf buf = STRBUF_INIT;
2402 const char *todo_path = git_path_todo_file();
2405 if (strbuf_read_file(&buf, todo_path, 0) < 0) {
2406 if (errno == ENOENT) {
2409 error_errno("unable to open '%s'", todo_path);
2413 /* If there is only one line then we are done */
2414 eol = strchr(buf.buf, '\n');
2415 if (!eol || !eol[1])
2418 strbuf_release(&buf);
2423 void sequencer_post_commit_cleanup(struct repository *r, int verbose)
2425 struct replay_opts opts = REPLAY_OPTS_INIT;
2426 int need_cleanup = 0;
2428 if (refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD")) {
2429 if (!refs_delete_ref(get_main_ref_store(r), "",
2430 "CHERRY_PICK_HEAD", NULL, 0) &&
2432 warning(_("cancelling a cherry picking in progress"));
2433 opts.action = REPLAY_PICK;
2437 if (refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD")) {
2438 if (!refs_delete_ref(get_main_ref_store(r), "", "REVERT_HEAD",
2441 warning(_("cancelling a revert in progress"));
2442 opts.action = REPLAY_REVERT;
2449 if (!have_finished_the_last_pick())
2452 sequencer_remove_state(&opts);
2455 static void todo_list_write_total_nr(struct todo_list *todo_list)
2457 FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
2460 fprintf(f, "%d\n", todo_list->total_nr);
2465 static int read_populate_todo(struct repository *r,
2466 struct todo_list *todo_list,
2467 struct replay_opts *opts)
2470 const char *todo_file = get_todo_path(opts);
2473 strbuf_reset(&todo_list->buf);
2474 if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
2477 res = stat(todo_file, &st);
2479 return error(_("could not stat '%s'"), todo_file);
2480 fill_stat_data(&todo_list->stat, &st);
2482 res = todo_list_parse_insn_buffer(r, todo_list->buf.buf, todo_list);
2484 if (is_rebase_i(opts))
2485 return error(_("please fix this using "
2486 "'git rebase --edit-todo'."));
2487 return error(_("unusable instruction sheet: '%s'"), todo_file);
2490 if (!todo_list->nr &&
2491 (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
2492 return error(_("no commits parsed."));
2494 if (!is_rebase_i(opts)) {
2495 enum todo_command valid =
2496 opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
2499 for (i = 0; i < todo_list->nr; i++)
2500 if (valid == todo_list->items[i].command)
2502 else if (valid == TODO_PICK)
2503 return error(_("cannot cherry-pick during a revert."));
2505 return error(_("cannot revert during a cherry-pick."));
2508 if (is_rebase_i(opts)) {
2509 struct todo_list done = TODO_LIST_INIT;
2511 if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
2512 !todo_list_parse_insn_buffer(r, done.buf.buf, &done))
2513 todo_list->done_nr = count_commands(&done);
2515 todo_list->done_nr = 0;
2517 todo_list->total_nr = todo_list->done_nr
2518 + count_commands(todo_list);
2519 todo_list_release(&done);
2521 todo_list_write_total_nr(todo_list);
2527 static int git_config_string_dup(char **dest,
2528 const char *var, const char *value)
2531 return config_error_nonbool(var);
2533 *dest = xstrdup(value);
2537 static int populate_opts_cb(const char *key, const char *value, void *data)
2539 struct replay_opts *opts = data;
2544 else if (!strcmp(key, "options.no-commit"))
2545 opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
2546 else if (!strcmp(key, "options.edit"))
2547 opts->edit = git_config_bool_or_int(key, value, &error_flag);
2548 else if (!strcmp(key, "options.allow-empty"))
2550 git_config_bool_or_int(key, value, &error_flag);
2551 else if (!strcmp(key, "options.allow-empty-message"))
2552 opts->allow_empty_message =
2553 git_config_bool_or_int(key, value, &error_flag);
2554 else if (!strcmp(key, "options.keep-redundant-commits"))
2555 opts->keep_redundant_commits =
2556 git_config_bool_or_int(key, value, &error_flag);
2557 else if (!strcmp(key, "options.signoff"))
2558 opts->signoff = git_config_bool_or_int(key, value, &error_flag);
2559 else if (!strcmp(key, "options.record-origin"))
2560 opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
2561 else if (!strcmp(key, "options.allow-ff"))
2562 opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
2563 else if (!strcmp(key, "options.mainline"))
2564 opts->mainline = git_config_int(key, value);
2565 else if (!strcmp(key, "options.strategy"))
2566 git_config_string_dup(&opts->strategy, key, value);
2567 else if (!strcmp(key, "options.gpg-sign"))
2568 git_config_string_dup(&opts->gpg_sign, key, value);
2569 else if (!strcmp(key, "options.strategy-option")) {
2570 ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
2571 opts->xopts[opts->xopts_nr++] = xstrdup(value);
2572 } else if (!strcmp(key, "options.allow-rerere-auto"))
2573 opts->allow_rerere_auto =
2574 git_config_bool_or_int(key, value, &error_flag) ?
2575 RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
2576 else if (!strcmp(key, "options.default-msg-cleanup")) {
2577 opts->explicit_cleanup = 1;
2578 opts->default_msg_cleanup = get_cleanup_mode(value, 1);
2580 return error(_("invalid key: %s"), key);
2583 return error(_("invalid value for %s: %s"), key, value);
2588 void parse_strategy_opts(struct replay_opts *opts, char *raw_opts)
2591 char *strategy_opts_string = raw_opts;
2593 if (*strategy_opts_string == ' ')
2594 strategy_opts_string++;
2596 opts->xopts_nr = split_cmdline(strategy_opts_string,
2597 (const char ***)&opts->xopts);
2598 for (i = 0; i < opts->xopts_nr; i++) {
2599 const char *arg = opts->xopts[i];
2601 skip_prefix(arg, "--", &arg);
2602 opts->xopts[i] = xstrdup(arg);
2606 static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
2609 if (!read_oneliner(buf, rebase_path_strategy(), 0))
2611 opts->strategy = strbuf_detach(buf, NULL);
2612 if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2615 parse_strategy_opts(opts, buf->buf);
2618 static int read_populate_opts(struct replay_opts *opts)
2620 if (is_rebase_i(opts)) {
2621 struct strbuf buf = STRBUF_INIT;
2624 if (read_oneliner(&buf, rebase_path_gpg_sign_opt(),
2625 READ_ONELINER_SKIP_IF_EMPTY)) {
2626 if (!starts_with(buf.buf, "-S"))
2629 free(opts->gpg_sign);
2630 opts->gpg_sign = xstrdup(buf.buf + 2);
2635 if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(),
2636 READ_ONELINER_SKIP_IF_EMPTY)) {
2637 if (!strcmp(buf.buf, "--rerere-autoupdate"))
2638 opts->allow_rerere_auto = RERERE_AUTOUPDATE;
2639 else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
2640 opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
2644 if (file_exists(rebase_path_verbose()))
2647 if (file_exists(rebase_path_quiet()))
2650 if (file_exists(rebase_path_signoff())) {
2655 if (file_exists(rebase_path_cdate_is_adate())) {
2657 opts->committer_date_is_author_date = 1;
2660 if (file_exists(rebase_path_ignore_date())) {
2662 opts->ignore_date = 1;
2665 if (file_exists(rebase_path_reschedule_failed_exec()))
2666 opts->reschedule_failed_exec = 1;
2668 if (file_exists(rebase_path_drop_redundant_commits()))
2669 opts->drop_redundant_commits = 1;
2671 if (file_exists(rebase_path_keep_redundant_commits()))
2672 opts->keep_redundant_commits = 1;
2674 read_strategy_opts(opts, &buf);
2677 if (read_oneliner(&opts->current_fixups,
2678 rebase_path_current_fixups(),
2679 READ_ONELINER_SKIP_IF_EMPTY)) {
2680 const char *p = opts->current_fixups.buf;
2681 opts->current_fixup_count = 1;
2682 while ((p = strchr(p, '\n'))) {
2683 opts->current_fixup_count++;
2688 if (read_oneliner(&buf, rebase_path_squash_onto(), 0)) {
2689 if (get_oid_committish(buf.buf, &opts->squash_onto) < 0) {
2690 ret = error(_("unusable squash-onto"));
2693 opts->have_squash_onto = 1;
2697 strbuf_release(&buf);
2701 if (!file_exists(git_path_opts_file()))
2704 * The function git_parse_source(), called from git_config_from_file(),
2705 * may die() in case of a syntactically incorrect file. We do not care
2706 * about this case, though, because we wrote that file ourselves, so we
2707 * are pretty certain that it is syntactically correct.
2709 if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
2710 return error(_("malformed options sheet: '%s'"),
2711 git_path_opts_file());
2715 static void write_strategy_opts(struct replay_opts *opts)
2718 struct strbuf buf = STRBUF_INIT;
2720 for (i = 0; i < opts->xopts_nr; ++i)
2721 strbuf_addf(&buf, " --%s", opts->xopts[i]);
2723 write_file(rebase_path_strategy_opts(), "%s\n", buf.buf);
2724 strbuf_release(&buf);
2727 int write_basic_state(struct replay_opts *opts, const char *head_name,
2728 struct commit *onto, const struct object_id *orig_head)
2731 write_file(rebase_path_head_name(), "%s\n", head_name);
2733 write_file(rebase_path_onto(), "%s\n",
2734 oid_to_hex(&onto->object.oid));
2736 write_file(rebase_path_orig_head(), "%s\n",
2737 oid_to_hex(orig_head));
2740 write_file(rebase_path_quiet(), "%s", "");
2742 write_file(rebase_path_verbose(), "%s", "");
2744 write_file(rebase_path_strategy(), "%s\n", opts->strategy);
2745 if (opts->xopts_nr > 0)
2746 write_strategy_opts(opts);
2748 if (opts->allow_rerere_auto == RERERE_AUTOUPDATE)
2749 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2750 else if (opts->allow_rerere_auto == RERERE_NOAUTOUPDATE)
2751 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2754 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts->gpg_sign);
2756 write_file(rebase_path_signoff(), "--signoff\n");
2757 if (opts->drop_redundant_commits)
2758 write_file(rebase_path_drop_redundant_commits(), "%s", "");
2759 if (opts->keep_redundant_commits)
2760 write_file(rebase_path_keep_redundant_commits(), "%s", "");
2761 if (opts->committer_date_is_author_date)
2762 write_file(rebase_path_cdate_is_adate(), "%s", "");
2763 if (opts->ignore_date)
2764 write_file(rebase_path_ignore_date(), "%s", "");
2765 if (opts->reschedule_failed_exec)
2766 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
2771 static int walk_revs_populate_todo(struct todo_list *todo_list,
2772 struct replay_opts *opts)
2774 enum todo_command command = opts->action == REPLAY_PICK ?
2775 TODO_PICK : TODO_REVERT;
2776 const char *command_string = todo_command_info[command].str;
2777 const char *encoding;
2778 struct commit *commit;
2780 if (prepare_revs(opts))
2783 encoding = get_log_output_encoding();
2785 while ((commit = get_revision(opts->revs))) {
2786 struct todo_item *item = append_new_todo(todo_list);
2787 const char *commit_buffer = logmsg_reencode(commit, NULL, encoding);
2788 const char *subject;
2791 item->command = command;
2792 item->commit = commit;
2793 item->arg_offset = 0;
2795 item->offset_in_buf = todo_list->buf.len;
2796 subject_len = find_commit_subject(commit_buffer, &subject);
2797 strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
2798 short_commit_name(commit), subject_len, subject);
2799 unuse_commit_buffer(commit, commit_buffer);
2803 return error(_("empty commit set passed"));
2808 static int create_seq_dir(struct repository *r)
2810 enum replay_action action;
2811 const char *in_progress_error = NULL;
2812 const char *in_progress_advice = NULL;
2813 unsigned int advise_skip =
2814 refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD") ||
2815 refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD");
2817 if (!sequencer_get_last_command(r, &action)) {
2820 in_progress_error = _("revert is already in progress");
2821 in_progress_advice =
2822 _("try \"git revert (--continue | %s--abort | --quit)\"");
2825 in_progress_error = _("cherry-pick is already in progress");
2826 in_progress_advice =
2827 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
2830 BUG("unexpected action in create_seq_dir");
2833 if (in_progress_error) {
2834 error("%s", in_progress_error);
2835 if (advice_sequencer_in_use)
2836 advise(in_progress_advice,
2837 advise_skip ? "--skip | " : "");
2840 if (mkdir(git_path_seq_dir(), 0777) < 0)
2841 return error_errno(_("could not create sequencer directory '%s'"),
2842 git_path_seq_dir());
2847 static int save_head(const char *head)
2849 struct lock_file head_lock = LOCK_INIT;
2850 struct strbuf buf = STRBUF_INIT;
2854 fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
2856 return error_errno(_("could not lock HEAD"));
2857 strbuf_addf(&buf, "%s\n", head);
2858 written = write_in_full(fd, buf.buf, buf.len);
2859 strbuf_release(&buf);
2861 error_errno(_("could not write to '%s'"), git_path_head_file());
2862 rollback_lock_file(&head_lock);
2865 if (commit_lock_file(&head_lock) < 0)
2866 return error(_("failed to finalize '%s'"), git_path_head_file());
2870 static int rollback_is_safe(void)
2872 struct strbuf sb = STRBUF_INIT;
2873 struct object_id expected_head, actual_head;
2875 if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2877 if (get_oid_hex(sb.buf, &expected_head)) {
2878 strbuf_release(&sb);
2879 die(_("could not parse %s"), git_path_abort_safety_file());
2881 strbuf_release(&sb);
2883 else if (errno == ENOENT)
2884 oidclr(&expected_head);
2886 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2888 if (get_oid("HEAD", &actual_head))
2889 oidclr(&actual_head);
2891 return oideq(&actual_head, &expected_head);
2894 static int reset_merge(const struct object_id *oid)
2897 struct strvec argv = STRVEC_INIT;
2899 strvec_pushl(&argv, "reset", "--merge", NULL);
2901 if (!is_null_oid(oid))
2902 strvec_push(&argv, oid_to_hex(oid));
2904 ret = run_command_v_opt(argv.v, RUN_GIT_CMD);
2905 strvec_clear(&argv);
2910 static int rollback_single_pick(struct repository *r)
2912 struct object_id head_oid;
2914 if (!refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD") &&
2915 !refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD"))
2916 return error(_("no cherry-pick or revert in progress"));
2917 if (read_ref_full("HEAD", 0, &head_oid, NULL))
2918 return error(_("cannot resolve HEAD"));
2919 if (is_null_oid(&head_oid))
2920 return error(_("cannot abort from a branch yet to be born"));
2921 return reset_merge(&head_oid);
2924 static int skip_single_pick(void)
2926 struct object_id head;
2928 if (read_ref_full("HEAD", 0, &head, NULL))
2929 return error(_("cannot resolve HEAD"));
2930 return reset_merge(&head);
2933 int sequencer_rollback(struct repository *r, struct replay_opts *opts)
2936 struct object_id oid;
2937 struct strbuf buf = STRBUF_INIT;
2940 f = fopen(git_path_head_file(), "r");
2941 if (!f && errno == ENOENT) {
2943 * There is no multiple-cherry-pick in progress.
2944 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2945 * a single-cherry-pick in progress, abort that.
2947 return rollback_single_pick(r);
2950 return error_errno(_("cannot open '%s'"), git_path_head_file());
2951 if (strbuf_getline_lf(&buf, f)) {
2952 error(_("cannot read '%s': %s"), git_path_head_file(),
2953 ferror(f) ? strerror(errno) : _("unexpected end of file"));
2958 if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
2959 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2960 git_path_head_file());
2963 if (is_null_oid(&oid)) {
2964 error(_("cannot abort from a branch yet to be born"));
2968 if (!rollback_is_safe()) {
2969 /* Do not error, just do not rollback */
2970 warning(_("You seem to have moved HEAD. "
2971 "Not rewinding, check your HEAD!"));
2973 if (reset_merge(&oid))
2975 strbuf_release(&buf);
2976 return sequencer_remove_state(opts);
2978 strbuf_release(&buf);
2982 int sequencer_skip(struct repository *r, struct replay_opts *opts)
2984 enum replay_action action = -1;
2985 sequencer_get_last_command(r, &action);
2988 * Check whether the subcommand requested to skip the commit is actually
2989 * in progress and that it's safe to skip the commit.
2991 * opts->action tells us which subcommand requested to skip the commit.
2992 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
2993 * action is in progress and we can skip the commit.
2995 * Otherwise we check that the last instruction was related to the
2996 * particular subcommand we're trying to execute and barf if that's not
2999 * Finally we check that the rollback is "safe", i.e., has the HEAD
3000 * moved? In this case, it doesn't make sense to "reset the merge" and
3001 * "skip the commit" as the user already handled this by committing. But
3002 * we'd not want to barf here, instead give advice on how to proceed. We
3003 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
3004 * it gets removed when the user commits, so if it still exists we're
3005 * sure the user can't have committed before.
3007 switch (opts->action) {
3009 if (!refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD")) {
3010 if (action != REPLAY_REVERT)
3011 return error(_("no revert in progress"));
3012 if (!rollback_is_safe())
3017 if (!refs_ref_exists(get_main_ref_store(r),
3018 "CHERRY_PICK_HEAD")) {
3019 if (action != REPLAY_PICK)
3020 return error(_("no cherry-pick in progress"));
3021 if (!rollback_is_safe())
3026 BUG("unexpected action in sequencer_skip");
3029 if (skip_single_pick())
3030 return error(_("failed to skip the commit"));
3031 if (!is_directory(git_path_seq_dir()))
3034 return sequencer_continue(r, opts);
3037 error(_("there is nothing to skip"));
3039 if (advice_resolve_conflict) {
3040 advise(_("have you committed already?\n"
3041 "try \"git %s --continue\""),
3042 action == REPLAY_REVERT ? "revert" : "cherry-pick");
3047 static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
3049 struct lock_file todo_lock = LOCK_INIT;
3050 const char *todo_path = get_todo_path(opts);
3051 int next = todo_list->current, offset, fd;
3054 * rebase -i writes "git-rebase-todo" without the currently executing
3055 * command, appending it to "done" instead.
3057 if (is_rebase_i(opts))
3060 fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
3062 return error_errno(_("could not lock '%s'"), todo_path);
3063 offset = get_item_line_offset(todo_list, next);
3064 if (write_in_full(fd, todo_list->buf.buf + offset,
3065 todo_list->buf.len - offset) < 0)
3066 return error_errno(_("could not write to '%s'"), todo_path);
3067 if (commit_lock_file(&todo_lock) < 0)
3068 return error(_("failed to finalize '%s'"), todo_path);
3070 if (is_rebase_i(opts) && next > 0) {
3071 const char *done = rebase_path_done();
3072 int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
3077 if (write_in_full(fd, get_item_line(todo_list, next - 1),
3078 get_item_line_length(todo_list, next - 1))
3080 ret = error_errno(_("could not write to '%s'"), done);
3082 ret = error_errno(_("failed to finalize '%s'"), done);
3088 static int save_opts(struct replay_opts *opts)
3090 const char *opts_file = git_path_opts_file();
3093 if (opts->no_commit)
3094 res |= git_config_set_in_file_gently(opts_file,
3095 "options.no-commit", "true");
3097 res |= git_config_set_in_file_gently(opts_file,
3098 "options.edit", "true");
3099 if (opts->allow_empty)
3100 res |= git_config_set_in_file_gently(opts_file,
3101 "options.allow-empty", "true");
3102 if (opts->allow_empty_message)
3103 res |= git_config_set_in_file_gently(opts_file,
3104 "options.allow-empty-message", "true");
3105 if (opts->keep_redundant_commits)
3106 res |= git_config_set_in_file_gently(opts_file,
3107 "options.keep-redundant-commits", "true");
3109 res |= git_config_set_in_file_gently(opts_file,
3110 "options.signoff", "true");
3111 if (opts->record_origin)
3112 res |= git_config_set_in_file_gently(opts_file,
3113 "options.record-origin", "true");
3115 res |= git_config_set_in_file_gently(opts_file,
3116 "options.allow-ff", "true");
3117 if (opts->mainline) {
3118 struct strbuf buf = STRBUF_INIT;
3119 strbuf_addf(&buf, "%d", opts->mainline);
3120 res |= git_config_set_in_file_gently(opts_file,
3121 "options.mainline", buf.buf);
3122 strbuf_release(&buf);
3125 res |= git_config_set_in_file_gently(opts_file,
3126 "options.strategy", opts->strategy);
3128 res |= git_config_set_in_file_gently(opts_file,
3129 "options.gpg-sign", opts->gpg_sign);
3132 for (i = 0; i < opts->xopts_nr; i++)
3133 res |= git_config_set_multivar_in_file_gently(opts_file,
3134 "options.strategy-option",
3135 opts->xopts[i], "^$", 0);
3137 if (opts->allow_rerere_auto)
3138 res |= git_config_set_in_file_gently(opts_file,
3139 "options.allow-rerere-auto",
3140 opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
3143 if (opts->explicit_cleanup)
3144 res |= git_config_set_in_file_gently(opts_file,
3145 "options.default-msg-cleanup",
3146 describe_cleanup_mode(opts->default_msg_cleanup));
3150 static int make_patch(struct repository *r,
3151 struct commit *commit,
3152 struct replay_opts *opts)
3154 struct strbuf buf = STRBUF_INIT;
3155 struct rev_info log_tree_opt;
3156 const char *subject;
3157 char hex[GIT_MAX_HEXSZ + 1];
3160 oid_to_hex_r(hex, &commit->object.oid);
3161 if (write_message(hex, strlen(hex), rebase_path_stopped_sha(), 1) < 0)
3163 res |= write_rebase_head(&commit->object.oid);
3165 strbuf_addf(&buf, "%s/patch", get_dir(opts));
3166 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
3167 repo_init_revisions(r, &log_tree_opt, NULL);
3168 log_tree_opt.abbrev = 0;
3169 log_tree_opt.diff = 1;
3170 log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
3171 log_tree_opt.disable_stdin = 1;
3172 log_tree_opt.no_commit_id = 1;
3173 log_tree_opt.diffopt.file = fopen(buf.buf, "w");
3174 log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
3175 if (!log_tree_opt.diffopt.file)
3176 res |= error_errno(_("could not open '%s'"), buf.buf);
3178 res |= log_tree_commit(&log_tree_opt, commit);
3179 fclose(log_tree_opt.diffopt.file);
3183 strbuf_addf(&buf, "%s/message", get_dir(opts));
3184 if (!file_exists(buf.buf)) {
3185 const char *encoding = get_commit_output_encoding();
3186 const char *commit_buffer = logmsg_reencode(commit, NULL, encoding);
3187 find_commit_subject(commit_buffer, &subject);
3188 res |= write_message(subject, strlen(subject), buf.buf, 1);
3189 unuse_commit_buffer(commit, commit_buffer);
3191 strbuf_release(&buf);
3196 static int intend_to_amend(void)
3198 struct object_id head;
3201 if (get_oid("HEAD", &head))
3202 return error(_("cannot read HEAD"));
3204 p = oid_to_hex(&head);
3205 return write_message(p, strlen(p), rebase_path_amend(), 1);
3208 static int error_with_patch(struct repository *r,
3209 struct commit *commit,
3210 const char *subject, int subject_len,
3211 struct replay_opts *opts,
3212 int exit_code, int to_amend)
3215 if (make_patch(r, commit, opts))
3217 } else if (copy_file(rebase_path_message(),
3218 git_path_merge_msg(r), 0666))
3219 return error(_("unable to copy '%s' to '%s'"),
3220 git_path_merge_msg(r), rebase_path_message());
3223 if (intend_to_amend())
3227 _("You can amend the commit now, with\n"
3229 " git commit --amend %s\n"
3231 "Once you are satisfied with your changes, run\n"
3233 " git rebase --continue\n"),
3234 gpg_sign_opt_quoted(opts));
3235 } else if (exit_code) {
3237 fprintf_ln(stderr, _("Could not apply %s... %.*s"),
3238 short_commit_name(commit), subject_len, subject);
3241 * We don't have the hash of the parent so
3242 * just print the line from the todo file.
3244 fprintf_ln(stderr, _("Could not merge %.*s"),
3245 subject_len, subject);
3251 static int error_failed_squash(struct repository *r,
3252 struct commit *commit,
3253 struct replay_opts *opts,
3255 const char *subject)
3257 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3258 return error(_("could not copy '%s' to '%s'"),
3259 rebase_path_squash_msg(), rebase_path_message());
3260 unlink(git_path_merge_msg(r));
3261 if (copy_file(git_path_merge_msg(r), rebase_path_message(), 0666))
3262 return error(_("could not copy '%s' to '%s'"),
3263 rebase_path_message(),
3264 git_path_merge_msg(r));
3265 return error_with_patch(r, commit, subject, subject_len, opts, 1, 0);
3268 static int do_exec(struct repository *r, const char *command_line)
3270 struct strvec child_env = STRVEC_INIT;
3271 const char *child_argv[] = { NULL, NULL };
3274 fprintf(stderr, _("Executing: %s\n"), command_line);
3275 child_argv[0] = command_line;
3276 strvec_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
3277 strvec_pushf(&child_env, "GIT_WORK_TREE=%s",
3278 absolute_path(get_git_work_tree()));
3279 status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
3282 /* force re-reading of the cache */
3283 if (discard_index(r->index) < 0 || repo_read_index(r) < 0)
3284 return error(_("could not read index"));
3286 dirty = require_clean_work_tree(r, "rebase", NULL, 1, 1);
3289 warning(_("execution failed: %s\n%s"
3290 "You can fix the problem, and then run\n"
3292 " git rebase --continue\n"
3295 dirty ? N_("and made changes to the index and/or the "
3296 "working tree\n") : "");
3298 /* command not found */
3301 warning(_("execution succeeded: %s\nbut "
3302 "left changes to the index and/or the working tree\n"
3303 "Commit or stash your changes, and then run\n"
3305 " git rebase --continue\n"
3306 "\n"), command_line);
3310 strvec_clear(&child_env);
3315 static int safe_append(const char *filename, const char *fmt, ...)
3318 struct lock_file lock = LOCK_INIT;
3319 int fd = hold_lock_file_for_update(&lock, filename,
3320 LOCK_REPORT_ON_ERROR);
3321 struct strbuf buf = STRBUF_INIT;
3326 if (strbuf_read_file(&buf, filename, 0) < 0 && errno != ENOENT) {
3327 error_errno(_("could not read '%s'"), filename);
3328 rollback_lock_file(&lock);
3331 strbuf_complete(&buf, '\n');
3333 strbuf_vaddf(&buf, fmt, ap);
3336 if (write_in_full(fd, buf.buf, buf.len) < 0) {
3337 error_errno(_("could not write to '%s'"), filename);
3338 strbuf_release(&buf);
3339 rollback_lock_file(&lock);
3342 if (commit_lock_file(&lock) < 0) {
3343 strbuf_release(&buf);
3344 rollback_lock_file(&lock);
3345 return error(_("failed to finalize '%s'"), filename);
3348 strbuf_release(&buf);
3352 static int do_label(struct repository *r, const char *name, int len)
3354 struct ref_store *refs = get_main_ref_store(r);
3355 struct ref_transaction *transaction;
3356 struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
3357 struct strbuf msg = STRBUF_INIT;
3359 struct object_id head_oid;
3361 if (len == 1 && *name == '#')
3362 return error(_("illegal label name: '%.*s'"), len, name);
3364 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3365 strbuf_addf(&msg, "rebase (label) '%.*s'", len, name);
3367 transaction = ref_store_transaction_begin(refs, &err);
3369 error("%s", err.buf);
3371 } else if (get_oid("HEAD", &head_oid)) {
3372 error(_("could not read HEAD"));
3374 } else if (ref_transaction_update(transaction, ref_name.buf, &head_oid,
3375 NULL, 0, msg.buf, &err) < 0 ||
3376 ref_transaction_commit(transaction, &err)) {
3377 error("%s", err.buf);
3380 ref_transaction_free(transaction);
3381 strbuf_release(&err);
3382 strbuf_release(&msg);
3385 ret = safe_append(rebase_path_refs_to_delete(),
3386 "%s\n", ref_name.buf);
3387 strbuf_release(&ref_name);
3392 static const char *reflog_message(struct replay_opts *opts,
3393 const char *sub_action, const char *fmt, ...);
3395 static int do_reset(struct repository *r,
3396 const char *name, int len,
3397 struct replay_opts *opts)
3399 struct strbuf ref_name = STRBUF_INIT;
3400 struct object_id oid;
3401 struct lock_file lock = LOCK_INIT;
3402 struct tree_desc desc;
3404 struct unpack_trees_options unpack_tree_opts;
3407 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0)
3410 if (len == 10 && !strncmp("[new root]", name, len)) {
3411 if (!opts->have_squash_onto) {
3413 if (commit_tree("", 0, the_hash_algo->empty_tree,
3414 NULL, &opts->squash_onto,
3416 return error(_("writing fake root commit"));
3417 opts->have_squash_onto = 1;
3418 hex = oid_to_hex(&opts->squash_onto);
3419 if (write_message(hex, strlen(hex),
3420 rebase_path_squash_onto(), 0))
3421 return error(_("writing squash-onto"));
3423 oidcpy(&oid, &opts->squash_onto);
3427 /* Determine the length of the label */
3428 for (i = 0; i < len; i++)
3429 if (isspace(name[i]))
3433 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3434 if (get_oid(ref_name.buf, &oid) &&
3435 get_oid(ref_name.buf + strlen("refs/rewritten/"), &oid)) {
3436 error(_("could not read '%s'"), ref_name.buf);
3437 rollback_lock_file(&lock);
3438 strbuf_release(&ref_name);
3443 memset(&unpack_tree_opts, 0, sizeof(unpack_tree_opts));
3444 setup_unpack_trees_porcelain(&unpack_tree_opts, "reset");
3445 unpack_tree_opts.head_idx = 1;
3446 unpack_tree_opts.src_index = r->index;
3447 unpack_tree_opts.dst_index = r->index;
3448 unpack_tree_opts.fn = oneway_merge;
3449 unpack_tree_opts.merge = 1;
3450 unpack_tree_opts.update = 1;
3451 init_checkout_metadata(&unpack_tree_opts.meta, name, &oid, NULL);
3453 if (repo_read_index_unmerged(r)) {
3454 rollback_lock_file(&lock);
3455 strbuf_release(&ref_name);
3456 return error_resolve_conflict(_(action_name(opts)));
3459 if (!fill_tree_descriptor(r, &desc, &oid)) {
3460 error(_("failed to find tree of %s"), oid_to_hex(&oid));
3461 rollback_lock_file(&lock);
3462 free((void *)desc.buffer);
3463 strbuf_release(&ref_name);
3467 if (unpack_trees(1, &desc, &unpack_tree_opts)) {
3468 rollback_lock_file(&lock);
3469 free((void *)desc.buffer);
3470 strbuf_release(&ref_name);
3474 tree = parse_tree_indirect(&oid);
3475 prime_cache_tree(r, r->index, tree);
3477 if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
3478 ret = error(_("could not write index"));
3479 free((void *)desc.buffer);
3482 ret = update_ref(reflog_message(opts, "reset", "'%.*s'",
3483 len, name), "HEAD", &oid,
3484 NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3486 strbuf_release(&ref_name);
3490 static struct commit *lookup_label(const char *label, int len,
3493 struct commit *commit;
3496 strbuf_addf(buf, "refs/rewritten/%.*s", len, label);
3497 commit = lookup_commit_reference_by_name(buf->buf);
3499 /* fall back to non-rewritten ref or commit */
3500 strbuf_splice(buf, 0, strlen("refs/rewritten/"), "", 0);
3501 commit = lookup_commit_reference_by_name(buf->buf);
3505 error(_("could not resolve '%s'"), buf->buf);
3510 static int do_merge(struct repository *r,
3511 struct commit *commit,
3512 const char *arg, int arg_len,
3513 int flags, struct replay_opts *opts)
3515 int run_commit_flags = (flags & TODO_EDIT_MERGE_MSG) ?
3516 EDIT_MSG | VERIFY_MSG : 0;
3517 struct strbuf ref_name = STRBUF_INIT;
3518 struct commit *head_commit, *merge_commit, *i;
3519 struct commit_list *bases, *j, *reversed = NULL;
3520 struct commit_list *to_merge = NULL, **tail = &to_merge;
3521 const char *strategy = !opts->xopts_nr &&
3523 !strcmp(opts->strategy, "recursive") ||
3524 !strcmp(opts->strategy, "ort")) ?
3525 NULL : opts->strategy;
3526 struct merge_options o;
3527 int merge_arg_len, oneline_offset, can_fast_forward, ret, k;
3528 static struct lock_file lock;
3531 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0) {
3536 head_commit = lookup_commit_reference_by_name("HEAD");
3538 ret = error(_("cannot merge without a current revision"));
3543 * For octopus merges, the arg starts with the list of revisions to be
3544 * merged. The list is optionally followed by '#' and the oneline.
3546 merge_arg_len = oneline_offset = arg_len;
3547 for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {
3550 if (*p == '#' && (!p[1] || isspace(p[1]))) {
3551 p += 1 + strspn(p + 1, " \t\n");
3552 oneline_offset = p - arg;
3555 k = strcspn(p, " \t\n");
3558 merge_commit = lookup_label(p, k, &ref_name);
3559 if (!merge_commit) {
3560 ret = error(_("unable to parse '%.*s'"), k, p);
3563 tail = &commit_list_insert(merge_commit, tail)->next;
3565 merge_arg_len = p - arg;
3569 ret = error(_("nothing to merge: '%.*s'"), arg_len, arg);
3573 if (opts->have_squash_onto &&
3574 oideq(&head_commit->object.oid, &opts->squash_onto)) {
3576 * When the user tells us to "merge" something into a
3577 * "[new root]", let's simply fast-forward to the merge head.
3579 rollback_lock_file(&lock);
3581 ret = error(_("octopus merge cannot be executed on "
3582 "top of a [new root]"));
3584 ret = fast_forward_to(r, &to_merge->item->object.oid,
3585 &head_commit->object.oid, 0,
3591 const char *encoding = get_commit_output_encoding();
3592 const char *message = logmsg_reencode(commit, NULL, encoding);
3597 ret = error(_("could not get commit message of '%s'"),
3598 oid_to_hex(&commit->object.oid));
3601 write_author_script(message);
3602 find_commit_subject(message, &body);
3604 ret = write_message(body, len, git_path_merge_msg(r), 0);
3605 unuse_commit_buffer(commit, message);
3607 error_errno(_("could not write '%s'"),
3608 git_path_merge_msg(r));
3612 struct strbuf buf = STRBUF_INIT;
3615 strbuf_addf(&buf, "author %s", git_author_info(0));
3616 write_author_script(buf.buf);
3619 if (oneline_offset < arg_len) {
3620 p = arg + oneline_offset;
3621 len = arg_len - oneline_offset;
3623 strbuf_addf(&buf, "Merge %s '%.*s'",
3624 to_merge->next ? "branches" : "branch",
3625 merge_arg_len, arg);
3630 ret = write_message(p, len, git_path_merge_msg(r), 0);
3631 strbuf_release(&buf);
3633 error_errno(_("could not write '%s'"),
3634 git_path_merge_msg(r));
3640 * If HEAD is not identical to the first parent of the original merge
3641 * commit, we cannot fast-forward.
3643 can_fast_forward = opts->allow_ff && commit && commit->parents &&
3644 oideq(&commit->parents->item->object.oid,
3645 &head_commit->object.oid);
3648 * If any merge head is different from the original one, we cannot
3651 if (can_fast_forward) {
3652 struct commit_list *p = commit->parents->next;
3654 for (j = to_merge; j && p; j = j->next, p = p->next)
3655 if (!oideq(&j->item->object.oid,
3656 &p->item->object.oid)) {
3657 can_fast_forward = 0;
3661 * If the number of merge heads differs from the original merge
3662 * commit, we cannot fast-forward.
3665 can_fast_forward = 0;
3668 if (can_fast_forward) {
3669 rollback_lock_file(&lock);
3670 ret = fast_forward_to(r, &commit->object.oid,
3671 &head_commit->object.oid, 0, opts);
3672 if (flags & TODO_EDIT_MERGE_MSG) {
3673 run_commit_flags |= AMEND_MSG;
3674 goto fast_forward_edit;
3679 if (strategy || to_merge->next) {
3681 struct child_process cmd = CHILD_PROCESS_INIT;
3683 if (read_env_script(&cmd.env_array)) {
3684 const char *gpg_opt = gpg_sign_opt_quoted(opts);
3686 ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
3690 if (opts->committer_date_is_author_date)
3691 strvec_pushf(&cmd.env_array, "GIT_COMMITTER_DATE=%s",
3694 author_date_from_env_array(&cmd.env_array));
3695 if (opts->ignore_date)
3696 strvec_push(&cmd.env_array, "GIT_AUTHOR_DATE=");
3699 strvec_push(&cmd.args, "merge");
3700 strvec_push(&cmd.args, "-s");
3702 strvec_push(&cmd.args, "octopus");
3704 strvec_push(&cmd.args, strategy);
3705 for (k = 0; k < opts->xopts_nr; k++)
3706 strvec_pushf(&cmd.args,
3707 "-X%s", opts->xopts[k]);
3709 strvec_push(&cmd.args, "--no-edit");
3710 strvec_push(&cmd.args, "--no-ff");
3711 strvec_push(&cmd.args, "--no-log");
3712 strvec_push(&cmd.args, "--no-stat");
3713 strvec_push(&cmd.args, "-F");
3714 strvec_push(&cmd.args, git_path_merge_msg(r));
3716 strvec_pushf(&cmd.args, "-S%s", opts->gpg_sign);
3718 strvec_push(&cmd.args, "--no-gpg-sign");
3720 /* Add the tips to be merged */
3721 for (j = to_merge; j; j = j->next)
3722 strvec_push(&cmd.args,
3723 oid_to_hex(&j->item->object.oid));
3725 strbuf_release(&ref_name);
3726 refs_delete_ref(get_main_ref_store(r), "", "CHERRY_PICK_HEAD",
3728 rollback_lock_file(&lock);
3730 ret = run_command(&cmd);
3732 /* force re-reading of the cache */
3733 if (!ret && (discard_index(r->index) < 0 ||
3734 repo_read_index(r) < 0))
3735 ret = error(_("could not read index"));
3739 merge_commit = to_merge->item;
3740 bases = get_merge_bases(head_commit, merge_commit);
3741 if (bases && oideq(&merge_commit->object.oid,
3742 &bases->item->object.oid)) {
3744 /* skip merging an ancestor of HEAD */
3748 write_message(oid_to_hex(&merge_commit->object.oid), the_hash_algo->hexsz,
3749 git_path_merge_head(r), 0);
3750 write_message("no-ff", 5, git_path_merge_mode(r), 0);
3752 for (j = bases; j; j = j->next)
3753 commit_list_insert(j->item, &reversed);
3754 free_commit_list(bases);
3757 init_merge_options(&o, r);
3759 o.branch2 = ref_name.buf;
3760 o.buffer_output = 2;
3762 if (opts->strategy && !strcmp(opts->strategy, "ort")) {
3764 * TODO: Should use merge_incore_recursive() and
3765 * merge_switch_to_result(), skipping the call to
3766 * merge_switch_to_result() when we don't actually need to
3767 * update the index and working copy immediately.
3769 ret = merge_ort_recursive(&o,
3770 head_commit, merge_commit, reversed,
3773 ret = merge_recursive(&o, head_commit, merge_commit, reversed,
3777 fputs(o.obuf.buf, stdout);
3778 strbuf_release(&o.obuf);
3780 error(_("could not even attempt to merge '%.*s'"),
3781 merge_arg_len, arg);
3785 * The return value of merge_recursive() is 1 on clean, and 0 on
3788 * Let's reverse that, so that do_merge() returns 0 upon success and
3789 * 1 upon failed merge (keeping the return value -1 for the cases where
3790 * we will want to reschedule the `merge` command).
3794 if (r->index->cache_changed &&
3795 write_locked_index(r->index, &lock, COMMIT_LOCK)) {
3796 ret = error(_("merge: Unable to write new index file"));
3800 rollback_lock_file(&lock);
3802 repo_rerere(r, opts->allow_rerere_auto);
3805 * In case of problems, we now want to return a positive
3806 * value (a negative one would indicate that the `merge`
3807 * command needs to be rescheduled).
3810 ret = !!run_git_commit(git_path_merge_msg(r), opts,
3814 strbuf_release(&ref_name);
3815 rollback_lock_file(&lock);
3816 free_commit_list(to_merge);
3820 static int is_final_fixup(struct todo_list *todo_list)
3822 int i = todo_list->current;
3824 if (!is_fixup(todo_list->items[i].command))
3827 while (++i < todo_list->nr)
3828 if (is_fixup(todo_list->items[i].command))
3830 else if (!is_noop(todo_list->items[i].command))
3835 static enum todo_command peek_command(struct todo_list *todo_list, int offset)
3839 for (i = todo_list->current + offset; i < todo_list->nr; i++)
3840 if (!is_noop(todo_list->items[i].command))
3841 return todo_list->items[i].command;
3846 void create_autostash(struct repository *r, const char *path,
3847 const char *default_reflog_action)
3849 struct strbuf buf = STRBUF_INIT;
3850 struct lock_file lock_file = LOCK_INIT;
3853 fd = repo_hold_locked_index(r, &lock_file, 0);
3854 refresh_index(r->index, REFRESH_QUIET, NULL, NULL, NULL);
3856 repo_update_index_if_able(r, &lock_file);
3857 rollback_lock_file(&lock_file);
3859 if (has_unstaged_changes(r, 1) ||
3860 has_uncommitted_changes(r, 1)) {
3861 struct child_process stash = CHILD_PROCESS_INIT;
3862 struct object_id oid;
3864 strvec_pushl(&stash.args,
3865 "stash", "create", "autostash", NULL);
3869 if (capture_command(&stash, &buf, GIT_MAX_HEXSZ))
3870 die(_("Cannot autostash"));
3871 strbuf_trim_trailing_newline(&buf);
3872 if (get_oid(buf.buf, &oid))
3873 die(_("Unexpected stash response: '%s'"),
3876 strbuf_add_unique_abbrev(&buf, &oid, DEFAULT_ABBREV);
3878 if (safe_create_leading_directories_const(path))
3879 die(_("Could not create directory for '%s'"),
3881 write_file(path, "%s", oid_to_hex(&oid));
3882 printf(_("Created autostash: %s\n"), buf.buf);
3883 if (reset_head(r, NULL, "reset --hard",
3884 NULL, RESET_HEAD_HARD, NULL, NULL,
3885 default_reflog_action) < 0)
3886 die(_("could not reset --hard"));
3888 if (discard_index(r->index) < 0 ||
3889 repo_read_index(r) < 0)
3890 die(_("could not read index"));
3892 strbuf_release(&buf);
3895 static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply)
3897 struct child_process child = CHILD_PROCESS_INIT;
3900 if (attempt_apply) {
3902 child.no_stdout = 1;
3903 child.no_stderr = 1;
3904 strvec_push(&child.args, "stash");
3905 strvec_push(&child.args, "apply");
3906 strvec_push(&child.args, stash_oid);
3907 ret = run_command(&child);
3910 if (attempt_apply && !ret)
3911 fprintf(stderr, _("Applied autostash.\n"));
3913 struct child_process store = CHILD_PROCESS_INIT;
3916 strvec_push(&store.args, "stash");
3917 strvec_push(&store.args, "store");
3918 strvec_push(&store.args, "-m");
3919 strvec_push(&store.args, "autostash");
3920 strvec_push(&store.args, "-q");
3921 strvec_push(&store.args, stash_oid);
3922 if (run_command(&store))
3923 ret = error(_("cannot store %s"), stash_oid);
3927 "Your changes are safe in the stash.\n"
3928 "You can run \"git stash pop\" or"
3929 " \"git stash drop\" at any time.\n"),
3931 _("Applying autostash resulted in conflicts.") :
3932 _("Autostash exists; creating a new stash entry."));
3938 static int apply_save_autostash(const char *path, int attempt_apply)
3940 struct strbuf stash_oid = STRBUF_INIT;
3943 if (!read_oneliner(&stash_oid, path,
3944 READ_ONELINER_SKIP_IF_EMPTY)) {
3945 strbuf_release(&stash_oid);
3948 strbuf_trim(&stash_oid);
3950 ret = apply_save_autostash_oid(stash_oid.buf, attempt_apply);
3953 strbuf_release(&stash_oid);
3957 int save_autostash(const char *path)
3959 return apply_save_autostash(path, 0);
3962 int apply_autostash(const char *path)
3964 return apply_save_autostash(path, 1);
3967 int apply_autostash_oid(const char *stash_oid)
3969 return apply_save_autostash_oid(stash_oid, 1);
3972 static const char *reflog_message(struct replay_opts *opts,
3973 const char *sub_action, const char *fmt, ...)
3976 static struct strbuf buf = STRBUF_INIT;
3977 char *reflog_action = getenv(GIT_REFLOG_ACTION);
3981 strbuf_addstr(&buf, reflog_action ? reflog_action : action_name(opts));
3983 strbuf_addf(&buf, " (%s)", sub_action);
3985 strbuf_addstr(&buf, ": ");
3986 strbuf_vaddf(&buf, fmt, ap);
3993 static int run_git_checkout(struct repository *r, struct replay_opts *opts,
3994 const char *commit, const char *action)
3996 struct child_process cmd = CHILD_PROCESS_INIT;
4001 strvec_push(&cmd.args, "checkout");
4002 strvec_push(&cmd.args, commit);
4003 strvec_pushf(&cmd.env_array, GIT_REFLOG_ACTION "=%s", action);
4006 ret = run_command(&cmd);
4008 ret = run_command_silent_on_success(&cmd);
4011 discard_index(r->index);
4016 static int checkout_onto(struct repository *r, struct replay_opts *opts,
4017 const char *onto_name, const struct object_id *onto,
4018 const struct object_id *orig_head)
4020 const char *action = reflog_message(opts, "start", "checkout %s", onto_name);
4022 if (run_git_checkout(r, opts, oid_to_hex(onto), action)) {
4023 apply_autostash(rebase_path_autostash());
4024 sequencer_remove_state(opts);
4025 return error(_("could not detach HEAD"));
4028 return update_ref(NULL, "ORIG_HEAD", orig_head, NULL, 0, UPDATE_REFS_MSG_ON_ERR);
4031 static int stopped_at_head(struct repository *r)
4033 struct object_id head;
4034 struct commit *commit;
4035 struct commit_message message;
4037 if (get_oid("HEAD", &head) ||
4038 !(commit = lookup_commit(r, &head)) ||
4039 parse_commit(commit) || get_message(commit, &message))
4040 fprintf(stderr, _("Stopped at HEAD\n"));
4042 fprintf(stderr, _("Stopped at %s\n"), message.label);
4043 free_message(commit, &message);
4049 static const char rescheduled_advice[] =
4050 N_("Could not execute the todo command\n"
4054 "It has been rescheduled; To edit the command before continuing, please\n"
4055 "edit the todo list first:\n"
4057 " git rebase --edit-todo\n"
4058 " git rebase --continue\n");
4060 static int pick_commits(struct repository *r,
4061 struct todo_list *todo_list,
4062 struct replay_opts *opts)
4064 int res = 0, reschedule = 0;
4065 char *prev_reflog_action;
4067 /* Note that 0 for 3rd parameter of setenv means set only if not set */
4068 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
4069 prev_reflog_action = xstrdup(getenv(GIT_REFLOG_ACTION));
4071 assert(!(opts->signoff || opts->no_commit ||
4072 opts->record_origin || opts->edit ||
4073 opts->committer_date_is_author_date ||
4074 opts->ignore_date));
4075 if (read_and_refresh_cache(r, opts))
4078 while (todo_list->current < todo_list->nr) {
4079 struct todo_item *item = todo_list->items + todo_list->current;
4080 const char *arg = todo_item_get_arg(todo_list, item);
4083 if (save_todo(todo_list, opts))
4085 if (is_rebase_i(opts)) {
4086 if (item->command != TODO_COMMENT) {
4087 FILE *f = fopen(rebase_path_msgnum(), "w");
4089 todo_list->done_nr++;
4092 fprintf(f, "%d\n", todo_list->done_nr);
4096 fprintf(stderr, _("Rebasing (%d/%d)%s"),
4098 todo_list->total_nr,
4099 opts->verbose ? "\n" : "\r");
4101 unlink(rebase_path_message());
4102 unlink(rebase_path_author_script());
4103 unlink(rebase_path_stopped_sha());
4104 unlink(rebase_path_amend());
4105 unlink(git_path_merge_head(r));
4106 delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
4108 if (item->command == TODO_BREAK) {
4111 return stopped_at_head(r);
4114 if (item->command <= TODO_SQUASH) {
4115 if (is_rebase_i(opts))
4116 setenv(GIT_REFLOG_ACTION, reflog_message(opts,
4117 command_to_string(item->command), NULL),
4119 res = do_pick_commit(r, item->command, item->commit,
4120 opts, is_final_fixup(todo_list),
4122 if (is_rebase_i(opts))
4123 setenv(GIT_REFLOG_ACTION, prev_reflog_action, 1);
4124 if (is_rebase_i(opts) && res < 0) {
4126 advise(_(rescheduled_advice),
4127 get_item_line_length(todo_list,
4128 todo_list->current),
4129 get_item_line(todo_list,
4130 todo_list->current));
4131 todo_list->current--;
4132 if (save_todo(todo_list, opts))
4135 if (item->command == TODO_EDIT) {
4136 struct commit *commit = item->commit;
4141 _("Stopped at %s... %.*s\n"),
4142 short_commit_name(commit),
4143 item->arg_len, arg);
4145 return error_with_patch(r, commit,
4146 arg, item->arg_len, opts, res, !res);
4148 if (is_rebase_i(opts) && !res)
4149 record_in_rewritten(&item->commit->object.oid,
4150 peek_command(todo_list, 1));
4151 if (res && is_fixup(item->command)) {
4154 return error_failed_squash(r, item->commit, opts,
4155 item->arg_len, arg);
4156 } else if (res && is_rebase_i(opts) && item->commit) {
4158 struct object_id oid;
4161 * If we are rewording and have either
4162 * fast-forwarded already, or are about to
4163 * create a new root commit, we want to amend,
4164 * otherwise we do not.
4166 if (item->command == TODO_REWORD &&
4167 !get_oid("HEAD", &oid) &&
4168 (oideq(&item->commit->object.oid, &oid) ||
4169 (opts->have_squash_onto &&
4170 oideq(&opts->squash_onto, &oid))))
4173 return res | error_with_patch(r, item->commit,
4174 arg, item->arg_len, opts,
4177 } else if (item->command == TODO_EXEC) {
4178 char *end_of_arg = (char *)(arg + item->arg_len);
4179 int saved = *end_of_arg;
4184 res = do_exec(r, arg);
4185 *end_of_arg = saved;
4188 if (opts->reschedule_failed_exec)
4192 } else if (item->command == TODO_LABEL) {
4193 if ((res = do_label(r, arg, item->arg_len)))
4195 } else if (item->command == TODO_RESET) {
4196 if ((res = do_reset(r, arg, item->arg_len, opts)))
4198 } else if (item->command == TODO_MERGE) {
4199 if ((res = do_merge(r, item->commit,
4201 item->flags, opts)) < 0)
4203 else if (item->commit)
4204 record_in_rewritten(&item->commit->object.oid,
4205 peek_command(todo_list, 1));
4207 /* failed with merge conflicts */
4208 return error_with_patch(r, item->commit,
4211 } else if (!is_noop(item->command))
4212 return error(_("unknown command %d"), item->command);
4215 advise(_(rescheduled_advice),
4216 get_item_line_length(todo_list,
4217 todo_list->current),
4218 get_item_line(todo_list, todo_list->current));
4219 todo_list->current--;
4220 if (save_todo(todo_list, opts))
4223 return error_with_patch(r,
4227 } else if (is_rebase_i(opts) && check_todo && !res) {
4230 if (stat(get_todo_path(opts), &st)) {
4231 res = error_errno(_("could not stat '%s'"),
4232 get_todo_path(opts));
4233 } else if (match_stat_data(&todo_list->stat, &st)) {
4234 /* Reread the todo file if it has changed. */
4235 todo_list_release(todo_list);
4236 if (read_populate_todo(r, todo_list, opts))
4237 res = -1; /* message was printed */
4238 /* `current` will be incremented below */
4239 todo_list->current = -1;
4243 todo_list->current++;
4248 if (is_rebase_i(opts)) {
4249 struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
4252 /* Stopped in the middle, as planned? */
4253 if (todo_list->current < todo_list->nr)
4256 if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
4257 starts_with(head_ref.buf, "refs/")) {
4259 struct object_id head, orig;
4262 if (get_oid("HEAD", &head)) {
4263 res = error(_("cannot read HEAD"));
4265 strbuf_release(&head_ref);
4266 strbuf_release(&buf);
4269 if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
4270 get_oid_hex(buf.buf, &orig)) {
4271 res = error(_("could not read orig-head"));
4272 goto cleanup_head_ref;
4275 if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
4276 res = error(_("could not read 'onto'"));
4277 goto cleanup_head_ref;
4279 msg = reflog_message(opts, "finish", "%s onto %s",
4280 head_ref.buf, buf.buf);
4281 if (update_ref(msg, head_ref.buf, &head, &orig,
4282 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
4283 res = error(_("could not update %s"),
4285 goto cleanup_head_ref;
4287 msg = reflog_message(opts, "finish", "returning to %s",
4289 if (create_symref("HEAD", head_ref.buf, msg)) {
4290 res = error(_("could not update HEAD to %s"),
4292 goto cleanup_head_ref;
4297 if (opts->verbose) {
4298 struct rev_info log_tree_opt;
4299 struct object_id orig, head;
4301 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
4302 repo_init_revisions(r, &log_tree_opt, NULL);
4303 log_tree_opt.diff = 1;
4304 log_tree_opt.diffopt.output_format =
4305 DIFF_FORMAT_DIFFSTAT;
4306 log_tree_opt.disable_stdin = 1;
4308 if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
4309 !get_oid(buf.buf, &orig) &&
4310 !get_oid("HEAD", &head)) {
4311 diff_tree_oid(&orig, &head, "",
4312 &log_tree_opt.diffopt);
4313 log_tree_diff_flush(&log_tree_opt);
4316 flush_rewritten_pending();
4317 if (!stat(rebase_path_rewritten_list(), &st) &&
4319 struct child_process child = CHILD_PROCESS_INIT;
4320 const char *post_rewrite_hook =
4321 find_hook("post-rewrite");
4323 child.in = open(rebase_path_rewritten_list(), O_RDONLY);
4325 strvec_push(&child.args, "notes");
4326 strvec_push(&child.args, "copy");
4327 strvec_push(&child.args, "--for-rewrite=rebase");
4328 /* we don't care if this copying failed */
4329 run_command(&child);
4331 if (post_rewrite_hook) {
4332 struct child_process hook = CHILD_PROCESS_INIT;
4334 hook.in = open(rebase_path_rewritten_list(),
4336 hook.stdout_to_stderr = 1;
4337 hook.trace2_hook_name = "post-rewrite";
4338 strvec_push(&hook.args, post_rewrite_hook);
4339 strvec_push(&hook.args, "rebase");
4340 /* we don't care if this hook failed */
4344 apply_autostash(rebase_path_autostash());
4350 _("Successfully rebased and updated %s.\n"),
4354 strbuf_release(&buf);
4355 strbuf_release(&head_ref);
4359 * Sequence of picks finished successfully; cleanup by
4360 * removing the .git/sequencer directory
4362 return sequencer_remove_state(opts);
4365 static int continue_single_pick(struct repository *r)
4367 const char *argv[] = { "commit", NULL };
4369 if (!refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD") &&
4370 !refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD"))
4371 return error(_("no cherry-pick or revert in progress"));
4372 return run_command_v_opt(argv, RUN_GIT_CMD);
4375 static int commit_staged_changes(struct repository *r,
4376 struct replay_opts *opts,
4377 struct todo_list *todo_list)
4379 unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
4380 unsigned int final_fixup = 0, is_clean;
4382 if (has_unstaged_changes(r, 1))
4383 return error(_("cannot rebase: You have unstaged changes."));
4385 is_clean = !has_uncommitted_changes(r, 0);
4387 if (file_exists(rebase_path_amend())) {
4388 struct strbuf rev = STRBUF_INIT;
4389 struct object_id head, to_amend;
4391 if (get_oid("HEAD", &head))
4392 return error(_("cannot amend non-existing commit"));
4393 if (!read_oneliner(&rev, rebase_path_amend(), 0))
4394 return error(_("invalid file: '%s'"), rebase_path_amend());
4395 if (get_oid_hex(rev.buf, &to_amend))
4396 return error(_("invalid contents: '%s'"),
4397 rebase_path_amend());
4398 if (!is_clean && !oideq(&head, &to_amend))
4399 return error(_("\nYou have uncommitted changes in your "
4400 "working tree. Please, commit them\n"
4401 "first and then run 'git rebase "
4402 "--continue' again."));
4404 * When skipping a failed fixup/squash, we need to edit the
4405 * commit message, the current fixup list and count, and if it
4406 * was the last fixup/squash in the chain, we need to clean up
4407 * the commit message and if there was a squash, let the user
4410 if (!is_clean || !opts->current_fixup_count)
4411 ; /* this is not the final fixup */
4412 else if (!oideq(&head, &to_amend) ||
4413 !file_exists(rebase_path_stopped_sha())) {
4414 /* was a final fixup or squash done manually? */
4415 if (!is_fixup(peek_command(todo_list, 0))) {
4416 unlink(rebase_path_fixup_msg());
4417 unlink(rebase_path_squash_msg());
4418 unlink(rebase_path_current_fixups());
4419 strbuf_reset(&opts->current_fixups);
4420 opts->current_fixup_count = 0;
4423 /* we are in a fixup/squash chain */
4424 const char *p = opts->current_fixups.buf;
4425 int len = opts->current_fixups.len;
4427 opts->current_fixup_count--;
4429 BUG("Incorrect current_fixups:\n%s", p);
4430 while (len && p[len - 1] != '\n')
4432 strbuf_setlen(&opts->current_fixups, len);
4433 if (write_message(p, len, rebase_path_current_fixups(),
4435 return error(_("could not write file: '%s'"),
4436 rebase_path_current_fixups());
4439 * If a fixup/squash in a fixup/squash chain failed, the
4440 * commit message is already correct, no need to commit
4443 * Only if it is the final command in the fixup/squash
4444 * chain, and only if the chain is longer than a single
4445 * fixup/squash command (which was just skipped), do we
4446 * actually need to re-commit with a cleaned up commit
4449 if (opts->current_fixup_count > 0 &&
4450 !is_fixup(peek_command(todo_list, 0))) {
4453 * If there was not a single "squash" in the
4454 * chain, we only need to clean up the commit
4455 * message, no need to bother the user with
4456 * opening the commit message in the editor.
4458 if (!starts_with(p, "squash ") &&
4459 !strstr(p, "\nsquash "))
4460 flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;
4461 } else if (is_fixup(peek_command(todo_list, 0))) {
4463 * We need to update the squash message to skip
4464 * the latest commit message.
4466 struct commit *commit;
4467 const char *path = rebase_path_squash_msg();
4468 const char *encoding = get_commit_output_encoding();
4470 if (parse_head(r, &commit) ||
4471 !(p = logmsg_reencode(commit, NULL, encoding)) ||
4472 write_message(p, strlen(p), path, 0)) {
4473 unuse_commit_buffer(commit, p);
4474 return error(_("could not write file: "
4477 unuse_commit_buffer(commit, p);
4481 strbuf_release(&rev);
4486 if (refs_ref_exists(get_main_ref_store(r),
4487 "CHERRY_PICK_HEAD") &&
4488 refs_delete_ref(get_main_ref_store(r), "",
4489 "CHERRY_PICK_HEAD", NULL, 0))
4490 return error(_("could not remove CHERRY_PICK_HEAD"));
4495 if (run_git_commit(final_fixup ? NULL : rebase_path_message(),
4497 return error(_("could not commit staged changes."));
4498 unlink(rebase_path_amend());
4499 unlink(git_path_merge_head(r));
4501 unlink(rebase_path_fixup_msg());
4502 unlink(rebase_path_squash_msg());
4504 if (opts->current_fixup_count > 0) {
4506 * Whether final fixup or not, we just cleaned up the commit
4509 unlink(rebase_path_current_fixups());
4510 strbuf_reset(&opts->current_fixups);
4511 opts->current_fixup_count = 0;
4516 int sequencer_continue(struct repository *r, struct replay_opts *opts)
4518 struct todo_list todo_list = TODO_LIST_INIT;
4521 if (read_and_refresh_cache(r, opts))
4524 if (read_populate_opts(opts))
4526 if (is_rebase_i(opts)) {
4527 if ((res = read_populate_todo(r, &todo_list, opts)))
4528 goto release_todo_list;
4530 if (file_exists(rebase_path_dropped())) {
4531 if ((res = todo_list_check_against_backup(r, &todo_list)))
4532 goto release_todo_list;
4534 unlink(rebase_path_dropped());
4537 if (commit_staged_changes(r, opts, &todo_list)) {
4539 goto release_todo_list;
4541 } else if (!file_exists(get_todo_path(opts)))
4542 return continue_single_pick(r);
4543 else if ((res = read_populate_todo(r, &todo_list, opts)))
4544 goto release_todo_list;
4546 if (!is_rebase_i(opts)) {
4547 /* Verify that the conflict has been resolved */
4548 if (refs_ref_exists(get_main_ref_store(r),
4549 "CHERRY_PICK_HEAD") ||
4550 refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD")) {
4551 res = continue_single_pick(r);
4553 goto release_todo_list;
4555 if (index_differs_from(r, "HEAD", NULL, 0)) {
4556 res = error_dirty_index(r, opts);
4557 goto release_todo_list;
4559 todo_list.current++;
4560 } else if (file_exists(rebase_path_stopped_sha())) {
4561 struct strbuf buf = STRBUF_INIT;
4562 struct object_id oid;
4564 if (read_oneliner(&buf, rebase_path_stopped_sha(),
4565 READ_ONELINER_SKIP_IF_EMPTY) &&
4566 !get_oid_hex(buf.buf, &oid))
4567 record_in_rewritten(&oid, peek_command(&todo_list, 0));
4568 strbuf_release(&buf);
4571 res = pick_commits(r, &todo_list, opts);
4573 todo_list_release(&todo_list);
4577 static int single_pick(struct repository *r,
4578 struct commit *cmit,
4579 struct replay_opts *opts)
4583 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
4584 return do_pick_commit(r, opts->action == REPLAY_PICK ?
4585 TODO_PICK : TODO_REVERT, cmit, opts, 0,
4589 int sequencer_pick_revisions(struct repository *r,
4590 struct replay_opts *opts)
4592 struct todo_list todo_list = TODO_LIST_INIT;
4593 struct object_id oid;
4597 if (read_and_refresh_cache(r, opts))
4600 for (i = 0; i < opts->revs->pending.nr; i++) {
4601 struct object_id oid;
4602 const char *name = opts->revs->pending.objects[i].name;
4604 /* This happens when using --stdin. */
4608 if (!get_oid(name, &oid)) {
4609 if (!lookup_commit_reference_gently(r, &oid, 1)) {
4610 enum object_type type = oid_object_info(r,
4613 return error(_("%s: can't cherry-pick a %s"),
4614 name, type_name(type));
4617 return error(_("%s: bad revision"), name);
4621 * If we were called as "git cherry-pick <commit>", just
4622 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4623 * REVERT_HEAD, and don't touch the sequencer state.
4624 * This means it is possible to cherry-pick in the middle
4625 * of a cherry-pick sequence.
4627 if (opts->revs->cmdline.nr == 1 &&
4628 opts->revs->cmdline.rev->whence == REV_CMD_REV &&
4629 opts->revs->no_walk &&
4630 !opts->revs->cmdline.rev->flags) {
4631 struct commit *cmit;
4632 if (prepare_revision_walk(opts->revs))
4633 return error(_("revision walk setup failed"));
4634 cmit = get_revision(opts->revs);
4636 return error(_("empty commit set passed"));
4637 if (get_revision(opts->revs))
4638 BUG("unexpected extra commit from walk");
4639 return single_pick(r, cmit, opts);
4643 * Start a new cherry-pick/ revert sequence; but
4644 * first, make sure that an existing one isn't in
4648 if (walk_revs_populate_todo(&todo_list, opts) ||
4649 create_seq_dir(r) < 0)
4651 if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
4652 return error(_("can't revert as initial commit"));
4653 if (save_head(oid_to_hex(&oid)))
4655 if (save_opts(opts))
4657 update_abort_safety_file();
4658 res = pick_commits(r, &todo_list, opts);
4659 todo_list_release(&todo_list);
4663 void append_signoff(struct strbuf *msgbuf, size_t ignore_footer, unsigned flag)
4665 unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
4666 struct strbuf sob = STRBUF_INIT;
4669 strbuf_addstr(&sob, sign_off_header);
4670 strbuf_addstr(&sob, fmt_name(WANT_COMMITTER_IDENT));
4671 strbuf_addch(&sob, '\n');
4674 strbuf_complete_line(msgbuf);
4677 * If the whole message buffer is equal to the sob, pretend that we
4678 * found a conforming footer with a matching sob
4680 if (msgbuf->len - ignore_footer == sob.len &&
4681 !strncmp(msgbuf->buf, sob.buf, sob.len))
4684 has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
4687 const char *append_newlines = NULL;
4688 size_t len = msgbuf->len - ignore_footer;
4692 * The buffer is completely empty. Leave foom for
4693 * the title and body to be filled in by the user.
4695 append_newlines = "\n\n";
4696 } else if (len == 1) {
4698 * Buffer contains a single newline. Add another
4699 * so that we leave room for the title and body.
4701 append_newlines = "\n";
4702 } else if (msgbuf->buf[len - 2] != '\n') {
4704 * Buffer ends with a single newline. Add another
4705 * so that there is an empty line between the message
4708 append_newlines = "\n";
4709 } /* else, the buffer already ends with two newlines. */
4711 if (append_newlines)
4712 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4713 append_newlines, strlen(append_newlines));
4716 if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
4717 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4720 strbuf_release(&sob);
4723 struct labels_entry {
4724 struct hashmap_entry entry;
4725 char label[FLEX_ARRAY];
4728 static int labels_cmp(const void *fndata, const struct hashmap_entry *eptr,
4729 const struct hashmap_entry *entry_or_key, const void *key)
4731 const struct labels_entry *a, *b;
4733 a = container_of(eptr, const struct labels_entry, entry);
4734 b = container_of(entry_or_key, const struct labels_entry, entry);
4736 return key ? strcmp(a->label, key) : strcmp(a->label, b->label);
4739 struct string_entry {
4740 struct oidmap_entry entry;
4741 char string[FLEX_ARRAY];
4744 struct label_state {
4745 struct oidmap commit2label;
4746 struct hashmap labels;
4750 static const char *label_oid(struct object_id *oid, const char *label,
4751 struct label_state *state)
4753 struct labels_entry *labels_entry;
4754 struct string_entry *string_entry;
4755 struct object_id dummy;
4758 string_entry = oidmap_get(&state->commit2label, oid);
4760 return string_entry->string;
4763 * For "uninteresting" commits, i.e. commits that are not to be
4764 * rebased, and which can therefore not be labeled, we use a unique
4765 * abbreviation of the commit name. This is slightly more complicated
4766 * than calling find_unique_abbrev() because we also need to make
4767 * sure that the abbreviation does not conflict with any other
4770 * We disallow "interesting" commits to be labeled by a string that
4771 * is a valid full-length hash, to ensure that we always can find an
4772 * abbreviation for any uninteresting commit's names that does not
4773 * clash with any other label.
4775 strbuf_reset(&state->buf);
4779 strbuf_grow(&state->buf, GIT_MAX_HEXSZ);
4780 label = p = state->buf.buf;
4782 find_unique_abbrev_r(p, oid, default_abbrev);
4785 * We may need to extend the abbreviated hash so that there is
4786 * no conflicting label.
4788 if (hashmap_get_from_hash(&state->labels, strihash(p), p)) {
4789 size_t i = strlen(p) + 1;
4791 oid_to_hex_r(p, oid);
4792 for (; i < the_hash_algo->hexsz; i++) {
4795 if (!hashmap_get_from_hash(&state->labels,
4802 struct strbuf *buf = &state->buf;
4805 * Sanitize labels by replacing non-alpha-numeric characters
4806 * (including white-space ones) by dashes, as they might be
4807 * illegal in file names (and hence in ref names).
4809 * Note that we retain non-ASCII UTF-8 characters (identified
4810 * via the most significant bit). They should be all acceptable
4811 * in file names. We do not validate the UTF-8 here, that's not
4812 * the job of this function.
4814 for (; *label; label++)
4815 if ((*label & 0x80) || isalnum(*label))
4816 strbuf_addch(buf, *label);
4817 /* avoid leading dash and double-dashes */
4818 else if (buf->len && buf->buf[buf->len - 1] != '-')
4819 strbuf_addch(buf, '-');
4821 strbuf_addstr(buf, "rev-");
4822 strbuf_add_unique_abbrev(buf, oid, default_abbrev);
4826 if ((buf->len == the_hash_algo->hexsz &&
4827 !get_oid_hex(label, &dummy)) ||
4828 (buf->len == 1 && *label == '#') ||
4829 hashmap_get_from_hash(&state->labels,
4830 strihash(label), label)) {
4832 * If the label already exists, or if the label is a
4833 * valid full OID, or the label is a '#' (which we use
4834 * as a separator between merge heads and oneline), we
4835 * append a dash and a number to make it unique.
4837 size_t len = buf->len;
4839 for (i = 2; ; i++) {
4840 strbuf_setlen(buf, len);
4841 strbuf_addf(buf, "-%d", i);
4842 if (!hashmap_get_from_hash(&state->labels,
4852 FLEX_ALLOC_STR(labels_entry, label, label);
4853 hashmap_entry_init(&labels_entry->entry, strihash(label));
4854 hashmap_add(&state->labels, &labels_entry->entry);
4856 FLEX_ALLOC_STR(string_entry, string, label);
4857 oidcpy(&string_entry->entry.oid, oid);
4858 oidmap_put(&state->commit2label, string_entry);
4860 return string_entry->string;
4863 static int make_script_with_merges(struct pretty_print_context *pp,
4864 struct rev_info *revs, struct strbuf *out,
4867 int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4868 int rebase_cousins = flags & TODO_LIST_REBASE_COUSINS;
4869 int root_with_onto = flags & TODO_LIST_ROOT_WITH_ONTO;
4870 struct strbuf buf = STRBUF_INIT, oneline = STRBUF_INIT;
4871 struct strbuf label = STRBUF_INIT;
4872 struct commit_list *commits = NULL, **tail = &commits, *iter;
4873 struct commit_list *tips = NULL, **tips_tail = &tips;
4874 struct commit *commit;
4875 struct oidmap commit2todo = OIDMAP_INIT;
4876 struct string_entry *entry;
4877 struct oidset interesting = OIDSET_INIT, child_seen = OIDSET_INIT,
4878 shown = OIDSET_INIT;
4879 struct label_state state = { OIDMAP_INIT, { NULL }, STRBUF_INIT };
4881 int abbr = flags & TODO_LIST_ABBREVIATE_CMDS;
4882 const char *cmd_pick = abbr ? "p" : "pick",
4883 *cmd_label = abbr ? "l" : "label",
4884 *cmd_reset = abbr ? "t" : "reset",
4885 *cmd_merge = abbr ? "m" : "merge";
4887 oidmap_init(&commit2todo, 0);
4888 oidmap_init(&state.commit2label, 0);
4889 hashmap_init(&state.labels, labels_cmp, NULL, 0);
4890 strbuf_init(&state.buf, 32);
4892 if (revs->cmdline.nr && (revs->cmdline.rev[0].flags & BOTTOM)) {
4893 struct labels_entry *onto_label_entry;
4894 struct object_id *oid = &revs->cmdline.rev[0].item->oid;
4895 FLEX_ALLOC_STR(entry, string, "onto");
4896 oidcpy(&entry->entry.oid, oid);
4897 oidmap_put(&state.commit2label, entry);
4899 FLEX_ALLOC_STR(onto_label_entry, label, "onto");
4900 hashmap_entry_init(&onto_label_entry->entry, strihash("onto"));
4901 hashmap_add(&state.labels, &onto_label_entry->entry);
4906 * - get onelines for all commits
4907 * - gather all branch tips (i.e. 2nd or later parents of merges)
4908 * - label all branch tips
4910 while ((commit = get_revision(revs))) {
4911 struct commit_list *to_merge;
4912 const char *p1, *p2;
4913 struct object_id *oid;
4916 tail = &commit_list_insert(commit, tail)->next;
4917 oidset_insert(&interesting, &commit->object.oid);
4919 is_empty = is_original_commit_empty(commit);
4920 if (!is_empty && (commit->object.flags & PATCHSAME))
4922 if (is_empty && !keep_empty)
4925 strbuf_reset(&oneline);
4926 pretty_print_commit(pp, commit, &oneline);
4928 to_merge = commit->parents ? commit->parents->next : NULL;
4930 /* non-merge commit: easy case */
4932 strbuf_addf(&buf, "%s %s %s", cmd_pick,
4933 oid_to_hex(&commit->object.oid),
4936 strbuf_addf(&buf, " %c empty",
4939 FLEX_ALLOC_STR(entry, string, buf.buf);
4940 oidcpy(&entry->entry.oid, &commit->object.oid);
4941 oidmap_put(&commit2todo, entry);
4946 /* Create a label */
4947 strbuf_reset(&label);
4948 if (skip_prefix(oneline.buf, "Merge ", &p1) &&
4949 (p1 = strchr(p1, '\'')) &&
4950 (p2 = strchr(++p1, '\'')))
4951 strbuf_add(&label, p1, p2 - p1);
4952 else if (skip_prefix(oneline.buf, "Merge pull request ",
4954 (p1 = strstr(p1, " from ")))
4955 strbuf_addstr(&label, p1 + strlen(" from "));
4957 strbuf_addbuf(&label, &oneline);
4960 strbuf_addf(&buf, "%s -C %s",
4961 cmd_merge, oid_to_hex(&commit->object.oid));
4963 /* label the tips of merged branches */
4964 for (; to_merge; to_merge = to_merge->next) {
4965 oid = &to_merge->item->object.oid;
4966 strbuf_addch(&buf, ' ');
4968 if (!oidset_contains(&interesting, oid)) {
4969 strbuf_addstr(&buf, label_oid(oid, NULL,
4974 tips_tail = &commit_list_insert(to_merge->item,
4977 strbuf_addstr(&buf, label_oid(oid, label.buf, &state));
4979 strbuf_addf(&buf, " # %s", oneline.buf);
4981 FLEX_ALLOC_STR(entry, string, buf.buf);
4982 oidcpy(&entry->entry.oid, &commit->object.oid);
4983 oidmap_put(&commit2todo, entry);
4988 * - label branch points
4989 * - add HEAD to the branch tips
4991 for (iter = commits; iter; iter = iter->next) {
4992 struct commit_list *parent = iter->item->parents;
4993 for (; parent; parent = parent->next) {
4994 struct object_id *oid = &parent->item->object.oid;
4995 if (!oidset_contains(&interesting, oid))
4997 if (oidset_insert(&child_seen, oid))
4998 label_oid(oid, "branch-point", &state);
5001 /* Add HEAD as implicit "tip of branch" */
5003 tips_tail = &commit_list_insert(iter->item,
5008 * Third phase: output the todo list. This is a bit tricky, as we
5009 * want to avoid jumping back and forth between revisions. To
5010 * accomplish that goal, we walk backwards from the branch tips,
5011 * gathering commits not yet shown, reversing the list on the fly,
5012 * then outputting that list (labeling revisions as needed).
5014 strbuf_addf(out, "%s onto\n", cmd_label);
5015 for (iter = tips; iter; iter = iter->next) {
5016 struct commit_list *list = NULL, *iter2;
5018 commit = iter->item;
5019 if (oidset_contains(&shown, &commit->object.oid))
5021 entry = oidmap_get(&state.commit2label, &commit->object.oid);
5024 strbuf_addf(out, "\n%c Branch %s\n", comment_line_char, entry->string);
5026 strbuf_addch(out, '\n');
5028 while (oidset_contains(&interesting, &commit->object.oid) &&
5029 !oidset_contains(&shown, &commit->object.oid)) {
5030 commit_list_insert(commit, &list);
5031 if (!commit->parents) {
5035 commit = commit->parents->item;
5039 strbuf_addf(out, "%s %s\n", cmd_reset,
5040 rebase_cousins || root_with_onto ?
5041 "onto" : "[new root]");
5043 const char *to = NULL;
5045 entry = oidmap_get(&state.commit2label,
5046 &commit->object.oid);
5049 else if (!rebase_cousins)
5050 to = label_oid(&commit->object.oid, NULL,
5053 if (!to || !strcmp(to, "onto"))
5054 strbuf_addf(out, "%s onto\n", cmd_reset);
5056 strbuf_reset(&oneline);
5057 pretty_print_commit(pp, commit, &oneline);
5058 strbuf_addf(out, "%s %s # %s\n",
5059 cmd_reset, to, oneline.buf);
5063 for (iter2 = list; iter2; iter2 = iter2->next) {
5064 struct object_id *oid = &iter2->item->object.oid;
5065 entry = oidmap_get(&commit2todo, oid);
5066 /* only show if not already upstream */
5068 strbuf_addf(out, "%s\n", entry->string);
5069 entry = oidmap_get(&state.commit2label, oid);
5071 strbuf_addf(out, "%s %s\n",
5072 cmd_label, entry->string);
5073 oidset_insert(&shown, oid);
5076 free_commit_list(list);
5079 free_commit_list(commits);
5080 free_commit_list(tips);
5082 strbuf_release(&label);
5083 strbuf_release(&oneline);
5084 strbuf_release(&buf);
5086 oidmap_free(&commit2todo, 1);
5087 oidmap_free(&state.commit2label, 1);
5088 hashmap_clear_and_free(&state.labels, struct labels_entry, entry);
5089 strbuf_release(&state.buf);
5094 int sequencer_make_script(struct repository *r, struct strbuf *out, int argc,
5095 const char **argv, unsigned flags)
5097 char *format = NULL;
5098 struct pretty_print_context pp = {0};
5099 struct rev_info revs;
5100 struct commit *commit;
5101 int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
5102 const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";
5103 int rebase_merges = flags & TODO_LIST_REBASE_MERGES;
5104 int reapply_cherry_picks = flags & TODO_LIST_REAPPLY_CHERRY_PICKS;
5106 repo_init_revisions(r, &revs, NULL);
5107 revs.verbose_header = 1;
5109 revs.max_parents = 1;
5110 revs.cherry_mark = !reapply_cherry_picks;
5113 revs.right_only = 1;
5114 revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
5115 revs.topo_order = 1;
5117 revs.pretty_given = 1;
5118 git_config_get_string("rebase.instructionFormat", &format);
5119 if (!format || !*format) {
5121 format = xstrdup("%s");
5123 get_commit_format(format, &revs);
5125 pp.fmt = revs.commit_format;
5126 pp.output_encoding = get_log_output_encoding();
5128 if (setup_revisions(argc, argv, &revs, NULL) > 1)
5129 return error(_("make_script: unhandled options"));
5131 if (prepare_revision_walk(&revs) < 0)
5132 return error(_("make_script: error preparing revisions"));
5135 return make_script_with_merges(&pp, &revs, out, flags);
5137 while ((commit = get_revision(&revs))) {
5138 int is_empty = is_original_commit_empty(commit);
5140 if (!is_empty && (commit->object.flags & PATCHSAME))
5142 if (is_empty && !keep_empty)
5144 strbuf_addf(out, "%s %s ", insn,
5145 oid_to_hex(&commit->object.oid));
5146 pretty_print_commit(&pp, commit, out);
5148 strbuf_addf(out, " %c empty", comment_line_char);
5149 strbuf_addch(out, '\n');
5155 * Add commands after pick and (series of) squash/fixup commands
5158 void todo_list_add_exec_commands(struct todo_list *todo_list,
5159 struct string_list *commands)
5161 struct strbuf *buf = &todo_list->buf;
5162 size_t base_offset = buf->len;
5163 int i, insert, nr = 0, alloc = 0;
5164 struct todo_item *items = NULL, *base_items = NULL;
5166 base_items = xcalloc(commands->nr, sizeof(struct todo_item));
5167 for (i = 0; i < commands->nr; i++) {
5168 size_t command_len = strlen(commands->items[i].string);
5170 strbuf_addstr(buf, commands->items[i].string);
5171 strbuf_addch(buf, '\n');
5173 base_items[i].command = TODO_EXEC;
5174 base_items[i].offset_in_buf = base_offset;
5175 base_items[i].arg_offset = base_offset + strlen("exec ");
5176 base_items[i].arg_len = command_len - strlen("exec ");
5178 base_offset += command_len + 1;
5182 * Insert <commands> after every pick. Here, fixup/squash chains
5183 * are considered part of the pick, so we insert the commands *after*
5184 * those chains if there are any.
5186 * As we insert the exec commands immediately after rearranging
5187 * any fixups and before the user edits the list, a fixup chain
5188 * can never contain comments (any comments are empty picks that
5189 * have been commented out because the user did not specify
5190 * --keep-empty). So, it is safe to insert an exec command
5191 * without looking at the command following a comment.
5194 for (i = 0; i < todo_list->nr; i++) {
5195 enum todo_command command = todo_list->items[i].command;
5196 if (insert && !is_fixup(command)) {
5197 ALLOC_GROW(items, nr + commands->nr, alloc);
5198 COPY_ARRAY(items + nr, base_items, commands->nr);
5204 ALLOC_GROW(items, nr + 1, alloc);
5205 items[nr++] = todo_list->items[i];
5207 if (command == TODO_PICK || command == TODO_MERGE)
5211 /* insert or append final <commands> */
5212 if (insert || nr == todo_list->nr) {
5213 ALLOC_GROW(items, nr + commands->nr, alloc);
5214 COPY_ARRAY(items + nr, base_items, commands->nr);
5219 FREE_AND_NULL(todo_list->items);
5220 todo_list->items = items;
5222 todo_list->alloc = alloc;
5225 static void todo_list_to_strbuf(struct repository *r, struct todo_list *todo_list,
5226 struct strbuf *buf, int num, unsigned flags)
5228 struct todo_item *item;
5229 int i, max = todo_list->nr;
5231 if (num > 0 && num < max)
5234 for (item = todo_list->items, i = 0; i < max; i++, item++) {
5237 /* if the item is not a command write it and continue */
5238 if (item->command >= TODO_COMMENT) {
5239 strbuf_addf(buf, "%.*s\n", item->arg_len,
5240 todo_item_get_arg(todo_list, item));
5244 /* add command to the buffer */
5245 cmd = command_to_char(item->command);
5246 if ((flags & TODO_LIST_ABBREVIATE_CMDS) && cmd)
5247 strbuf_addch(buf, cmd);
5249 strbuf_addstr(buf, command_to_string(item->command));
5253 const char *oid = flags & TODO_LIST_SHORTEN_IDS ?
5254 short_commit_name(item->commit) :
5255 oid_to_hex(&item->commit->object.oid);
5257 if (item->command == TODO_MERGE) {
5258 if (item->flags & TODO_EDIT_MERGE_MSG)
5259 strbuf_addstr(buf, " -c");
5261 strbuf_addstr(buf, " -C");
5264 strbuf_addf(buf, " %s", oid);
5267 /* add all the rest */
5269 strbuf_addch(buf, '\n');
5271 strbuf_addf(buf, " %.*s\n", item->arg_len,
5272 todo_item_get_arg(todo_list, item));
5276 int todo_list_write_to_file(struct repository *r, struct todo_list *todo_list,
5277 const char *file, const char *shortrevisions,
5278 const char *shortonto, int num, unsigned flags)
5281 struct strbuf buf = STRBUF_INIT;
5283 todo_list_to_strbuf(r, todo_list, &buf, num, flags);
5284 if (flags & TODO_LIST_APPEND_TODO_HELP)
5285 append_todo_help(count_commands(todo_list),
5286 shortrevisions, shortonto, &buf);
5288 res = write_message(buf.buf, buf.len, file, 0);
5289 strbuf_release(&buf);
5294 /* skip picking commits whose parents are unchanged */
5295 static int skip_unnecessary_picks(struct repository *r,
5296 struct todo_list *todo_list,
5297 struct object_id *base_oid)
5299 struct object_id *parent_oid;
5302 for (i = 0; i < todo_list->nr; i++) {
5303 struct todo_item *item = todo_list->items + i;
5305 if (item->command >= TODO_NOOP)
5307 if (item->command != TODO_PICK)
5309 if (parse_commit(item->commit)) {
5310 return error(_("could not parse commit '%s'"),
5311 oid_to_hex(&item->commit->object.oid));
5313 if (!item->commit->parents)
5314 break; /* root commit */
5315 if (item->commit->parents->next)
5316 break; /* merge commit */
5317 parent_oid = &item->commit->parents->item->object.oid;
5318 if (!oideq(parent_oid, base_oid))
5320 oidcpy(base_oid, &item->commit->object.oid);
5323 const char *done_path = rebase_path_done();
5325 if (todo_list_write_to_file(r, todo_list, done_path, NULL, NULL, i, 0)) {
5326 error_errno(_("could not write to '%s'"), done_path);
5330 MOVE_ARRAY(todo_list->items, todo_list->items + i, todo_list->nr - i);
5332 todo_list->current = 0;
5333 todo_list->done_nr += i;
5335 if (is_fixup(peek_command(todo_list, 0)))
5336 record_in_rewritten(base_oid, peek_command(todo_list, 0));
5342 int complete_action(struct repository *r, struct replay_opts *opts, unsigned flags,
5343 const char *shortrevisions, const char *onto_name,
5344 struct commit *onto, const struct object_id *orig_head,
5345 struct string_list *commands, unsigned autosquash,
5346 struct todo_list *todo_list)
5348 char shortonto[GIT_MAX_HEXSZ + 1];
5349 const char *todo_file = rebase_path_todo();
5350 struct todo_list new_todo = TODO_LIST_INIT;
5351 struct strbuf *buf = &todo_list->buf, buf2 = STRBUF_INIT;
5352 struct object_id oid = onto->object.oid;
5355 find_unique_abbrev_r(shortonto, &oid, DEFAULT_ABBREV);
5357 if (buf->len == 0) {
5358 struct todo_item *item = append_new_todo(todo_list);
5359 item->command = TODO_NOOP;
5360 item->commit = NULL;
5361 item->arg_len = item->arg_offset = item->flags = item->offset_in_buf = 0;
5364 if (autosquash && todo_list_rearrange_squash(todo_list))
5368 todo_list_add_exec_commands(todo_list, commands);
5370 if (count_commands(todo_list) == 0) {
5371 apply_autostash(rebase_path_autostash());
5372 sequencer_remove_state(opts);
5374 return error(_("nothing to do"));
5377 res = edit_todo_list(r, todo_list, &new_todo, shortrevisions,
5381 else if (res == -2) {
5382 apply_autostash(rebase_path_autostash());
5383 sequencer_remove_state(opts);
5386 } else if (res == -3) {
5387 apply_autostash(rebase_path_autostash());
5388 sequencer_remove_state(opts);
5389 todo_list_release(&new_todo);
5391 return error(_("nothing to do"));
5392 } else if (res == -4) {
5393 checkout_onto(r, opts, onto_name, &onto->object.oid, orig_head);
5394 todo_list_release(&new_todo);
5399 /* Expand the commit IDs */
5400 todo_list_to_strbuf(r, &new_todo, &buf2, -1, 0);
5401 strbuf_swap(&new_todo.buf, &buf2);
5402 strbuf_release(&buf2);
5403 new_todo.total_nr -= new_todo.nr;
5404 if (todo_list_parse_insn_buffer(r, new_todo.buf.buf, &new_todo) < 0)
5405 BUG("invalid todo list after expanding IDs:\n%s",
5408 if (opts->allow_ff && skip_unnecessary_picks(r, &new_todo, &oid)) {
5409 todo_list_release(&new_todo);
5410 return error(_("could not skip unnecessary pick commands"));
5413 if (todo_list_write_to_file(r, &new_todo, todo_file, NULL, NULL, -1,
5414 flags & ~(TODO_LIST_SHORTEN_IDS))) {
5415 todo_list_release(&new_todo);
5416 return error_errno(_("could not write '%s'"), todo_file);
5421 if (checkout_onto(r, opts, onto_name, &oid, orig_head))
5424 if (require_clean_work_tree(r, "rebase", "", 1, 1))
5427 todo_list_write_total_nr(&new_todo);
5428 res = pick_commits(r, &new_todo, opts);
5431 todo_list_release(&new_todo);
5436 struct subject2item_entry {
5437 struct hashmap_entry entry;
5439 char subject[FLEX_ARRAY];
5442 static int subject2item_cmp(const void *fndata,
5443 const struct hashmap_entry *eptr,
5444 const struct hashmap_entry *entry_or_key,
5447 const struct subject2item_entry *a, *b;
5449 a = container_of(eptr, const struct subject2item_entry, entry);
5450 b = container_of(entry_or_key, const struct subject2item_entry, entry);
5452 return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
5455 define_commit_slab(commit_todo_item, struct todo_item *);
5458 * Rearrange the todo list that has both "pick commit-id msg" and "pick
5459 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
5460 * after the former, and change "pick" to "fixup"/"squash".
5462 * Note that if the config has specified a custom instruction format, each log
5463 * message will have to be retrieved from the commit (as the oneline in the
5464 * script cannot be trusted) in order to normalize the autosquash arrangement.
5466 int todo_list_rearrange_squash(struct todo_list *todo_list)
5468 struct hashmap subject2item;
5469 int rearranged = 0, *next, *tail, i, nr = 0, alloc = 0;
5471 struct commit_todo_item commit_todo;
5472 struct todo_item *items = NULL;
5474 init_commit_todo_item(&commit_todo);
5476 * The hashmap maps onelines to the respective todo list index.
5478 * If any items need to be rearranged, the next[i] value will indicate
5479 * which item was moved directly after the i'th.
5481 * In that case, last[i] will indicate the index of the latest item to
5482 * be moved to appear after the i'th.
5484 hashmap_init(&subject2item, subject2item_cmp, NULL, todo_list->nr);
5485 ALLOC_ARRAY(next, todo_list->nr);
5486 ALLOC_ARRAY(tail, todo_list->nr);
5487 ALLOC_ARRAY(subjects, todo_list->nr);
5488 for (i = 0; i < todo_list->nr; i++) {
5489 struct strbuf buf = STRBUF_INIT;
5490 struct todo_item *item = todo_list->items + i;
5491 const char *commit_buffer, *subject, *p;
5494 struct subject2item_entry *entry;
5496 next[i] = tail[i] = -1;
5497 if (!item->commit || item->command == TODO_DROP) {
5502 if (is_fixup(item->command)) {
5503 clear_commit_todo_item(&commit_todo);
5504 return error(_("the script was already rearranged."));
5507 *commit_todo_item_at(&commit_todo, item->commit) = item;
5509 parse_commit(item->commit);
5510 commit_buffer = logmsg_reencode(item->commit, NULL, "UTF-8");
5511 find_commit_subject(commit_buffer, &subject);
5512 format_subject(&buf, subject, " ");
5513 subject = subjects[i] = strbuf_detach(&buf, &subject_len);
5514 unuse_commit_buffer(item->commit, commit_buffer);
5515 if ((skip_prefix(subject, "fixup! ", &p) ||
5516 skip_prefix(subject, "squash! ", &p))) {
5517 struct commit *commit2;
5522 if (!skip_prefix(p, "fixup! ", &p) &&
5523 !skip_prefix(p, "squash! ", &p))
5527 entry = hashmap_get_entry_from_hash(&subject2item,
5529 struct subject2item_entry,
5532 /* found by title */
5534 else if (!strchr(p, ' ') &&
5536 lookup_commit_reference_by_name(p)) &&
5537 *commit_todo_item_at(&commit_todo, commit2))
5538 /* found by commit name */
5539 i2 = *commit_todo_item_at(&commit_todo, commit2)
5542 /* copy can be a prefix of the commit subject */
5543 for (i2 = 0; i2 < i; i2++)
5545 starts_with(subjects[i2], p))
5553 todo_list->items[i].command =
5554 starts_with(subject, "fixup!") ?
5555 TODO_FIXUP : TODO_SQUASH;
5560 next[i] = next[tail[i2]];
5564 } else if (!hashmap_get_from_hash(&subject2item,
5565 strhash(subject), subject)) {
5566 FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
5568 hashmap_entry_init(&entry->entry,
5569 strhash(entry->subject));
5570 hashmap_put(&subject2item, &entry->entry);
5575 for (i = 0; i < todo_list->nr; i++) {
5576 enum todo_command command = todo_list->items[i].command;
5580 * Initially, all commands are 'pick's. If it is a
5581 * fixup or a squash now, we have rearranged it.
5583 if (is_fixup(command))
5587 ALLOC_GROW(items, nr + 1, alloc);
5588 items[nr++] = todo_list->items[cur];
5593 FREE_AND_NULL(todo_list->items);
5594 todo_list->items = items;
5596 todo_list->alloc = alloc;
5601 for (i = 0; i < todo_list->nr; i++)
5604 hashmap_clear_and_free(&subject2item, struct subject2item_entry, entry);
5606 clear_commit_todo_item(&commit_todo);
5611 int sequencer_determine_whence(struct repository *r, enum commit_whence *whence)
5613 if (refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD")) {
5614 struct object_id cherry_pick_head, rebase_head;
5616 if (file_exists(git_path_seq_dir()))
5617 *whence = FROM_CHERRY_PICK_MULTI;
5618 if (file_exists(rebase_path()) &&
5619 !get_oid("REBASE_HEAD", &rebase_head) &&
5620 !get_oid("CHERRY_PICK_HEAD", &cherry_pick_head) &&
5621 oideq(&rebase_head, &cherry_pick_head))
5622 *whence = FROM_REBASE_PICK;
5624 *whence = FROM_CHERRY_PICK_SINGLE;