5 #include "object-store.h"
10 #include "run-command.h"
13 #include "cache-tree.h"
17 #include "merge-recursive.h"
19 #include "argv-array.h"
23 #include "wt-status.h"
25 #include "notes-utils.h"
27 #include "unpack-trees.h"
31 #include "commit-slab.h"
33 #include "commit-reach.h"
34 #include "rebase-interactive.h"
36 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
38 static const char sign_off_header[] = "Signed-off-by: ";
39 static const char cherry_picked_prefix[] = "(cherry picked from commit ";
41 GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
43 static GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
45 static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
46 static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
47 static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
48 static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
50 static GIT_PATH_FUNC(rebase_path, "rebase-merge")
52 * The file containing rebase commands, comments, and empty lines.
53 * This file is created by "git rebase -i" then edited by the user. As
54 * the lines are processed, they are removed from the front of this
55 * file and written to the tail of 'done'.
57 GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
58 GIT_PATH_FUNC(rebase_path_todo_backup, "rebase-merge/git-rebase-todo.backup")
60 GIT_PATH_FUNC(rebase_path_dropped, "rebase-merge/dropped")
63 * The rebase command lines that have already been processed. A line
64 * is moved here when it is first handled, before any associated user
67 static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
69 * The file to keep track of how many commands were already processed (e.g.
72 static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum")
74 * The file to keep track of how many commands are to be processed in total
75 * (e.g. for the prompt).
77 static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end")
79 * The commit message that is planned to be used for any changes that
80 * need to be committed following a user interaction.
82 static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
84 * The file into which is accumulated the suggested commit message for
85 * squash/fixup commands. When the first of a series of squash/fixups
86 * is seen, the file is created and the commit message from the
87 * previous commit and from the first squash/fixup commit are written
88 * to it. The commit message for each subsequent squash/fixup commit
89 * is appended to the file as it is processed.
91 static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
93 * If the current series of squash/fixups has not yet included a squash
94 * command, then this file exists and holds the commit message of the
95 * original "pick" commit. (If the series ends without a "squash"
96 * command, then this can be used as the commit message of the combined
97 * commit without opening the editor.)
99 static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
101 * This file contains the list fixup/squash commands that have been
102 * accumulated into message-fixup or message-squash so far.
104 static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")
106 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
107 * GIT_AUTHOR_DATE that will be used for the commit that is currently
110 static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
112 * When an "edit" rebase command is being processed, the SHA1 of the
113 * commit to be edited is recorded in this file. When "git rebase
114 * --continue" is executed, if there are any staged changes then they
115 * will be amended to the HEAD commit, but only provided the HEAD
116 * commit is still the commit to be edited. When any other rebase
117 * command is processed, this file is deleted.
119 static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
121 * When we stop at a given patch via the "edit" command, this file contains
122 * the abbreviated commit name of the corresponding patch.
124 static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
126 * For the post-rewrite hook, we make a list of rewritten commits and
127 * their new sha1s. The rewritten-pending list keeps the sha1s of
128 * commits that have been processed, but not committed yet,
129 * e.g. because they are waiting for a 'squash' command.
131 static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
132 static GIT_PATH_FUNC(rebase_path_rewritten_pending,
133 "rebase-merge/rewritten-pending")
136 * The path of the file containing the OID of the "squash onto" commit, i.e.
137 * the dummy commit used for `reset [new root]`.
139 static GIT_PATH_FUNC(rebase_path_squash_onto, "rebase-merge/squash-onto")
142 * The path of the file listing refs that need to be deleted after the rebase
143 * finishes. This is used by the `label` command to record the need for cleanup.
145 static GIT_PATH_FUNC(rebase_path_refs_to_delete, "rebase-merge/refs-to-delete")
148 * The following files are written by git-rebase just after parsing the
151 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
152 static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
153 static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
154 static GIT_PATH_FUNC(rebase_path_quiet, "rebase-merge/quiet")
155 static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")
156 static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
157 static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
158 static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
159 static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
160 static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
161 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
162 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec, "rebase-merge/reschedule-failed-exec")
163 static GIT_PATH_FUNC(rebase_path_drop_redundant_commits, "rebase-merge/drop_redundant_commits")
164 static GIT_PATH_FUNC(rebase_path_keep_redundant_commits, "rebase-merge/keep_redundant_commits")
166 static int git_sequencer_config(const char *k, const char *v, void *cb)
168 struct replay_opts *opts = cb;
171 if (!strcmp(k, "commit.cleanup")) {
174 status = git_config_string(&s, k, v);
178 if (!strcmp(s, "verbatim")) {
179 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
180 opts->explicit_cleanup = 1;
181 } else if (!strcmp(s, "whitespace")) {
182 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
183 opts->explicit_cleanup = 1;
184 } else if (!strcmp(s, "strip")) {
185 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
186 opts->explicit_cleanup = 1;
187 } else if (!strcmp(s, "scissors")) {
188 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SCISSORS;
189 opts->explicit_cleanup = 1;
191 warning(_("invalid commit message cleanup mode '%s'"),
199 if (!strcmp(k, "commit.gpgsign")) {
200 opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
204 status = git_gpg_config(k, v, NULL);
208 return git_diff_basic_config(k, v, NULL);
211 void sequencer_init_config(struct replay_opts *opts)
213 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
214 git_config(git_sequencer_config, opts);
217 static inline int is_rebase_i(const struct replay_opts *opts)
219 return opts->action == REPLAY_INTERACTIVE_REBASE;
222 static const char *get_dir(const struct replay_opts *opts)
224 if (is_rebase_i(opts))
225 return rebase_path();
226 return git_path_seq_dir();
229 static const char *get_todo_path(const struct replay_opts *opts)
231 if (is_rebase_i(opts))
232 return rebase_path_todo();
233 return git_path_todo_file();
237 * Returns 0 for non-conforming footer
238 * Returns 1 for conforming footer
239 * Returns 2 when sob exists within conforming footer
240 * Returns 3 when sob exists within conforming footer as last entry
242 static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
243 size_t ignore_footer)
245 struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
246 struct trailer_info info;
248 int found_sob = 0, found_sob_last = 0;
252 trailer_info_get(&info, sb->buf, &opts);
254 if (info.trailer_start == info.trailer_end)
257 for (i = 0; i < info.trailer_nr; i++)
258 if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
260 if (i == info.trailer_nr - 1)
264 trailer_info_release(&info);
273 static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
275 static struct strbuf buf = STRBUF_INIT;
279 sq_quotef(&buf, "-S%s", opts->gpg_sign);
283 int sequencer_remove_state(struct replay_opts *opts)
285 struct strbuf buf = STRBUF_INIT;
288 if (is_rebase_i(opts) &&
289 strbuf_read_file(&buf, rebase_path_refs_to_delete(), 0) > 0) {
292 char *eol = strchr(p, '\n');
295 if (delete_ref("(rebase) cleanup", p, NULL, 0) < 0) {
296 warning(_("could not delete '%s'"), p);
305 free(opts->gpg_sign);
306 free(opts->strategy);
307 for (i = 0; i < opts->xopts_nr; i++)
308 free(opts->xopts[i]);
310 strbuf_release(&opts->current_fixups);
313 strbuf_addstr(&buf, get_dir(opts));
314 if (remove_dir_recursively(&buf, 0))
315 ret = error(_("could not remove '%s'"), buf.buf);
316 strbuf_release(&buf);
321 static const char *action_name(const struct replay_opts *opts)
323 switch (opts->action) {
327 return N_("cherry-pick");
328 case REPLAY_INTERACTIVE_REBASE:
331 die(_("unknown action: %d"), opts->action);
334 struct commit_message {
341 static const char *short_commit_name(struct commit *commit)
343 return find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV);
346 static int get_message(struct commit *commit, struct commit_message *out)
348 const char *abbrev, *subject;
351 out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
352 abbrev = short_commit_name(commit);
354 subject_len = find_commit_subject(out->message, &subject);
356 out->subject = xmemdupz(subject, subject_len);
357 out->label = xstrfmt("%s... %s", abbrev, out->subject);
358 out->parent_label = xstrfmt("parent of %s", out->label);
363 static void free_message(struct commit *commit, struct commit_message *msg)
365 free(msg->parent_label);
368 unuse_commit_buffer(commit, msg->message);
371 static void print_advice(struct repository *r, int show_hint,
372 struct replay_opts *opts)
374 char *msg = getenv("GIT_CHERRY_PICK_HELP");
377 fprintf(stderr, "%s\n", msg);
379 * A conflict has occurred but the porcelain
380 * (typically rebase --interactive) wants to take care
381 * of the commit itself so remove CHERRY_PICK_HEAD
383 unlink(git_path_cherry_pick_head(r));
389 advise(_("after resolving the conflicts, mark the corrected paths\n"
390 "with 'git add <paths>' or 'git rm <paths>'"));
392 advise(_("after resolving the conflicts, mark the corrected paths\n"
393 "with 'git add <paths>' or 'git rm <paths>'\n"
394 "and commit the result with 'git commit'"));
398 static int write_message(const void *buf, size_t len, const char *filename,
401 struct lock_file msg_file = LOCK_INIT;
403 int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
405 return error_errno(_("could not lock '%s'"), filename);
406 if (write_in_full(msg_fd, buf, len) < 0) {
407 error_errno(_("could not write to '%s'"), filename);
408 rollback_lock_file(&msg_file);
411 if (append_eol && write(msg_fd, "\n", 1) < 0) {
412 error_errno(_("could not write eol to '%s'"), filename);
413 rollback_lock_file(&msg_file);
416 if (commit_lock_file(&msg_file) < 0)
417 return error(_("failed to finalize '%s'"), filename);
423 * Reads a file that was presumably written by a shell script, i.e. with an
424 * end-of-line marker that needs to be stripped.
426 * Note that only the last end-of-line marker is stripped, consistent with the
427 * behavior of "$(cat path)" in a shell script.
429 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
431 static int read_oneliner(struct strbuf *buf,
432 const char *path, int skip_if_empty)
434 int orig_len = buf->len;
436 if (!file_exists(path))
439 if (strbuf_read_file(buf, path, 0) < 0) {
440 warning_errno(_("could not read '%s'"), path);
444 if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
445 if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
447 buf->buf[buf->len] = '\0';
450 if (skip_if_empty && buf->len == orig_len)
456 static struct tree *empty_tree(struct repository *r)
458 return lookup_tree(r, the_hash_algo->empty_tree);
461 static int error_dirty_index(struct repository *repo, struct replay_opts *opts)
463 if (repo_read_index_unmerged(repo))
464 return error_resolve_conflict(_(action_name(opts)));
466 error(_("your local changes would be overwritten by %s."),
467 _(action_name(opts)));
469 if (advice_commit_before_merge)
470 advise(_("commit your changes or stash them to proceed."));
474 static void update_abort_safety_file(void)
476 struct object_id head;
478 /* Do nothing on a single-pick */
479 if (!file_exists(git_path_seq_dir()))
482 if (!get_oid("HEAD", &head))
483 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
485 write_file(git_path_abort_safety_file(), "%s", "");
488 static int fast_forward_to(struct repository *r,
489 const struct object_id *to,
490 const struct object_id *from,
492 struct replay_opts *opts)
494 struct ref_transaction *transaction;
495 struct strbuf sb = STRBUF_INIT;
496 struct strbuf err = STRBUF_INIT;
499 if (checkout_fast_forward(r, from, to, 1))
500 return -1; /* the callee should have complained already */
502 strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
504 transaction = ref_transaction_begin(&err);
506 ref_transaction_update(transaction, "HEAD",
507 to, unborn && !is_rebase_i(opts) ?
510 ref_transaction_commit(transaction, &err)) {
511 ref_transaction_free(transaction);
512 error("%s", err.buf);
514 strbuf_release(&err);
519 strbuf_release(&err);
520 ref_transaction_free(transaction);
521 update_abort_safety_file();
525 enum commit_msg_cleanup_mode get_cleanup_mode(const char *cleanup_arg,
528 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
529 return use_editor ? COMMIT_MSG_CLEANUP_ALL :
530 COMMIT_MSG_CLEANUP_SPACE;
531 else if (!strcmp(cleanup_arg, "verbatim"))
532 return COMMIT_MSG_CLEANUP_NONE;
533 else if (!strcmp(cleanup_arg, "whitespace"))
534 return COMMIT_MSG_CLEANUP_SPACE;
535 else if (!strcmp(cleanup_arg, "strip"))
536 return COMMIT_MSG_CLEANUP_ALL;
537 else if (!strcmp(cleanup_arg, "scissors"))
538 return use_editor ? COMMIT_MSG_CLEANUP_SCISSORS :
539 COMMIT_MSG_CLEANUP_SPACE;
541 die(_("Invalid cleanup mode %s"), cleanup_arg);
545 * NB using int rather than enum cleanup_mode to stop clang's
546 * -Wtautological-constant-out-of-range-compare complaining that the comparison
549 static const char *describe_cleanup_mode(int cleanup_mode)
551 static const char *modes[] = { "whitespace",
556 if (cleanup_mode < ARRAY_SIZE(modes))
557 return modes[cleanup_mode];
559 BUG("invalid cleanup_mode provided (%d)", cleanup_mode);
562 void append_conflicts_hint(struct index_state *istate,
563 struct strbuf *msgbuf, enum commit_msg_cleanup_mode cleanup_mode)
567 if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS) {
568 strbuf_addch(msgbuf, '\n');
569 wt_status_append_cut_line(msgbuf);
570 strbuf_addch(msgbuf, comment_line_char);
573 strbuf_addch(msgbuf, '\n');
574 strbuf_commented_addf(msgbuf, "Conflicts:\n");
575 for (i = 0; i < istate->cache_nr;) {
576 const struct cache_entry *ce = istate->cache[i++];
578 strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
579 while (i < istate->cache_nr &&
580 !strcmp(ce->name, istate->cache[i]->name))
586 static int do_recursive_merge(struct repository *r,
587 struct commit *base, struct commit *next,
588 const char *base_label, const char *next_label,
589 struct object_id *head, struct strbuf *msgbuf,
590 struct replay_opts *opts)
592 struct merge_options o;
593 struct tree *next_tree, *base_tree, *head_tree;
596 struct lock_file index_lock = LOCK_INIT;
598 if (repo_hold_locked_index(r, &index_lock, LOCK_REPORT_ON_ERROR) < 0)
603 init_merge_options(&o, r);
604 o.ancestor = base ? base_label : "(empty tree)";
606 o.branch2 = next ? next_label : "(empty tree)";
607 if (is_rebase_i(opts))
609 o.show_rename_progress = 1;
611 head_tree = parse_tree_indirect(head);
612 next_tree = next ? get_commit_tree(next) : empty_tree(r);
613 base_tree = base ? get_commit_tree(base) : empty_tree(r);
615 for (i = 0; i < opts->xopts_nr; i++)
616 parse_merge_opt(&o, opts->xopts[i]);
618 clean = merge_trees(&o,
620 next_tree, base_tree);
621 if (is_rebase_i(opts) && clean <= 0)
622 fputs(o.obuf.buf, stdout);
623 strbuf_release(&o.obuf);
625 rollback_lock_file(&index_lock);
629 if (write_locked_index(r->index, &index_lock,
630 COMMIT_LOCK | SKIP_IF_UNCHANGED))
632 * TRANSLATORS: %s will be "revert", "cherry-pick" or
635 return error(_("%s: Unable to write new index file"),
636 _(action_name(opts)));
639 append_conflicts_hint(r->index, msgbuf,
640 opts->default_msg_cleanup);
645 static struct object_id *get_cache_tree_oid(struct index_state *istate)
647 if (!istate->cache_tree)
648 istate->cache_tree = cache_tree();
650 if (!cache_tree_fully_valid(istate->cache_tree))
651 if (cache_tree_update(istate, 0)) {
652 error(_("unable to update cache tree"));
656 return &istate->cache_tree->oid;
659 static int is_index_unchanged(struct repository *r)
661 struct object_id head_oid, *cache_tree_oid;
662 struct commit *head_commit;
663 struct index_state *istate = r->index;
665 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
666 return error(_("could not resolve HEAD commit"));
668 head_commit = lookup_commit(r, &head_oid);
671 * If head_commit is NULL, check_commit, called from
672 * lookup_commit, would have indicated that head_commit is not
673 * a commit object already. parse_commit() will return failure
674 * without further complaints in such a case. Otherwise, if
675 * the commit is invalid, parse_commit() will complain. So
676 * there is nothing for us to say here. Just return failure.
678 if (parse_commit(head_commit))
681 if (!(cache_tree_oid = get_cache_tree_oid(istate)))
684 return oideq(cache_tree_oid, get_commit_tree_oid(head_commit));
687 static int write_author_script(const char *message)
689 struct strbuf buf = STRBUF_INIT;
694 if (!*message || starts_with(message, "\n")) {
696 /* Missing 'author' line? */
697 unlink(rebase_path_author_script());
699 } else if (skip_prefix(message, "author ", &message))
701 else if ((eol = strchr(message, '\n')))
706 strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
707 while (*message && *message != '\n' && *message != '\r')
708 if (skip_prefix(message, " <", &message))
710 else if (*message != '\'')
711 strbuf_addch(&buf, *(message++));
713 strbuf_addf(&buf, "'\\%c'", *(message++));
714 strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
715 while (*message && *message != '\n' && *message != '\r')
716 if (skip_prefix(message, "> ", &message))
718 else if (*message != '\'')
719 strbuf_addch(&buf, *(message++));
721 strbuf_addf(&buf, "'\\%c'", *(message++));
722 strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
723 while (*message && *message != '\n' && *message != '\r')
724 if (*message != '\'')
725 strbuf_addch(&buf, *(message++));
727 strbuf_addf(&buf, "'\\%c'", *(message++));
728 strbuf_addch(&buf, '\'');
729 res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
730 strbuf_release(&buf);
735 * Take a series of KEY='VALUE' lines where VALUE part is
736 * sq-quoted, and append <KEY, VALUE> at the end of the string list
738 static int parse_key_value_squoted(char *buf, struct string_list *list)
741 struct string_list_item *item;
743 char *cp = strchr(buf, '=');
745 np = strchrnul(buf, '\n');
746 return error(_("no key present in '%.*s'"),
747 (int) (np - buf), buf);
749 np = strchrnul(cp, '\n');
751 item = string_list_append(list, buf);
753 buf = np + (*np == '\n');
757 return error(_("unable to dequote value of '%s'"),
759 item->util = xstrdup(cp);
765 * Reads and parses the state directory's "author-script" file, and sets name,
766 * email and date accordingly.
767 * Returns 0 on success, -1 if the file could not be parsed.
769 * The author script is of the format:
771 * GIT_AUTHOR_NAME='$author_name'
772 * GIT_AUTHOR_EMAIL='$author_email'
773 * GIT_AUTHOR_DATE='$author_date'
775 * where $author_name, $author_email and $author_date are quoted. We are strict
776 * with our parsing, as the file was meant to be eval'd in the now-removed
777 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
778 * from what this function expects, it is better to bail out than to do
779 * something that the user does not expect.
781 int read_author_script(const char *path, char **name, char **email, char **date,
784 struct strbuf buf = STRBUF_INIT;
785 struct string_list kv = STRING_LIST_INIT_DUP;
786 int retval = -1; /* assume failure */
787 int i, name_i = -2, email_i = -2, date_i = -2, err = 0;
789 if (strbuf_read_file(&buf, path, 256) <= 0) {
790 strbuf_release(&buf);
791 if (errno == ENOENT && allow_missing)
794 return error_errno(_("could not open '%s' for reading"),
798 if (parse_key_value_squoted(buf.buf, &kv))
801 for (i = 0; i < kv.nr; i++) {
802 if (!strcmp(kv.items[i].string, "GIT_AUTHOR_NAME")) {
804 name_i = error(_("'GIT_AUTHOR_NAME' already given"));
807 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_EMAIL")) {
809 email_i = error(_("'GIT_AUTHOR_EMAIL' already given"));
812 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_DATE")) {
814 date_i = error(_("'GIT_AUTHOR_DATE' already given"));
818 err = error(_("unknown variable '%s'"),
823 error(_("missing 'GIT_AUTHOR_NAME'"));
825 error(_("missing 'GIT_AUTHOR_EMAIL'"));
827 error(_("missing 'GIT_AUTHOR_DATE'"));
828 if (date_i < 0 || email_i < 0 || date_i < 0 || err)
830 *name = kv.items[name_i].util;
831 *email = kv.items[email_i].util;
832 *date = kv.items[date_i].util;
835 string_list_clear(&kv, !!retval);
836 strbuf_release(&buf);
841 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
842 * file with shell quoting into struct argv_array. Returns -1 on
843 * error, 0 otherwise.
845 static int read_env_script(struct argv_array *env)
847 char *name, *email, *date;
849 if (read_author_script(rebase_path_author_script(),
850 &name, &email, &date, 0))
853 argv_array_pushf(env, "GIT_AUTHOR_NAME=%s", name);
854 argv_array_pushf(env, "GIT_AUTHOR_EMAIL=%s", email);
855 argv_array_pushf(env, "GIT_AUTHOR_DATE=%s", date);
863 static char *get_author(const char *message)
868 a = find_commit_header(message, "author", &len);
870 return xmemdupz(a, len);
875 static const char staged_changes_advice[] =
876 N_("you have staged changes in your working tree\n"
877 "If these changes are meant to be squashed into the previous commit, run:\n"
879 " git commit --amend %s\n"
881 "If they are meant to go into a new commit, run:\n"
885 "In both cases, once you're done, continue with:\n"
887 " git rebase --continue\n");
889 #define ALLOW_EMPTY (1<<0)
890 #define EDIT_MSG (1<<1)
891 #define AMEND_MSG (1<<2)
892 #define CLEANUP_MSG (1<<3)
893 #define VERIFY_MSG (1<<4)
894 #define CREATE_ROOT_COMMIT (1<<5)
896 static int run_command_silent_on_success(struct child_process *cmd)
898 struct strbuf buf = STRBUF_INIT;
901 cmd->stdout_to_stderr = 1;
902 rc = pipe_command(cmd,
908 fputs(buf.buf, stderr);
909 strbuf_release(&buf);
914 * If we are cherry-pick, and if the merge did not result in
915 * hand-editing, we will hit this commit and inherit the original
916 * author date and name.
918 * If we are revert, or if our cherry-pick results in a hand merge,
919 * we had better say that the current user is responsible for that.
921 * An exception is when run_git_commit() is called during an
922 * interactive rebase: in that case, we will want to retain the
925 static int run_git_commit(struct repository *r,
927 struct replay_opts *opts,
930 struct child_process cmd = CHILD_PROCESS_INIT;
934 if (is_rebase_i(opts) && read_env_script(&cmd.env_array)) {
935 const char *gpg_opt = gpg_sign_opt_quoted(opts);
937 return error(_(staged_changes_advice),
941 argv_array_push(&cmd.args, "commit");
943 if (!(flags & VERIFY_MSG))
944 argv_array_push(&cmd.args, "-n");
945 if ((flags & AMEND_MSG))
946 argv_array_push(&cmd.args, "--amend");
948 argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
950 argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
951 else if (!(flags & EDIT_MSG))
952 argv_array_pushl(&cmd.args, "-C", "HEAD", NULL);
953 if ((flags & CLEANUP_MSG))
954 argv_array_push(&cmd.args, "--cleanup=strip");
955 if ((flags & EDIT_MSG))
956 argv_array_push(&cmd.args, "-e");
957 else if (!(flags & CLEANUP_MSG) &&
958 !opts->signoff && !opts->record_origin &&
959 !opts->explicit_cleanup)
960 argv_array_push(&cmd.args, "--cleanup=verbatim");
962 if ((flags & ALLOW_EMPTY))
963 argv_array_push(&cmd.args, "--allow-empty");
965 if (!(flags & EDIT_MSG))
966 argv_array_push(&cmd.args, "--allow-empty-message");
968 if (is_rebase_i(opts) && !(flags & EDIT_MSG))
969 return run_command_silent_on_success(&cmd);
971 return run_command(&cmd);
974 static int rest_is_empty(const struct strbuf *sb, int start)
979 /* Check if the rest is just whitespace and Signed-off-by's. */
980 for (i = start; i < sb->len; i++) {
981 nl = memchr(sb->buf + i, '\n', sb->len - i);
987 if (strlen(sign_off_header) <= eol - i &&
988 starts_with(sb->buf + i, sign_off_header)) {
993 if (!isspace(sb->buf[i++]))
1000 void cleanup_message(struct strbuf *msgbuf,
1001 enum commit_msg_cleanup_mode cleanup_mode, int verbose)
1003 if (verbose || /* Truncate the message just before the diff, if any. */
1004 cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS)
1005 strbuf_setlen(msgbuf, wt_status_locate_end(msgbuf->buf, msgbuf->len));
1006 if (cleanup_mode != COMMIT_MSG_CLEANUP_NONE)
1007 strbuf_stripspace(msgbuf, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1011 * Find out if the message in the strbuf contains only whitespace and
1012 * Signed-off-by lines.
1014 int message_is_empty(const struct strbuf *sb,
1015 enum commit_msg_cleanup_mode cleanup_mode)
1017 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1019 return rest_is_empty(sb, 0);
1023 * See if the user edited the message in the editor or left what
1024 * was in the template intact
1026 int template_untouched(const struct strbuf *sb, const char *template_file,
1027 enum commit_msg_cleanup_mode cleanup_mode)
1029 struct strbuf tmpl = STRBUF_INIT;
1032 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1035 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1038 strbuf_stripspace(&tmpl, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1039 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1041 strbuf_release(&tmpl);
1042 return rest_is_empty(sb, start - sb->buf);
1045 int update_head_with_reflog(const struct commit *old_head,
1046 const struct object_id *new_head,
1047 const char *action, const struct strbuf *msg,
1050 struct ref_transaction *transaction;
1051 struct strbuf sb = STRBUF_INIT;
1056 strbuf_addstr(&sb, action);
1057 strbuf_addstr(&sb, ": ");
1060 nl = strchr(msg->buf, '\n');
1062 strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
1064 strbuf_addbuf(&sb, msg);
1065 strbuf_addch(&sb, '\n');
1068 transaction = ref_transaction_begin(err);
1070 ref_transaction_update(transaction, "HEAD", new_head,
1071 old_head ? &old_head->object.oid : &null_oid,
1073 ref_transaction_commit(transaction, err)) {
1076 ref_transaction_free(transaction);
1077 strbuf_release(&sb);
1082 static int run_rewrite_hook(const struct object_id *oldoid,
1083 const struct object_id *newoid)
1085 struct child_process proc = CHILD_PROCESS_INIT;
1086 const char *argv[3];
1088 struct strbuf sb = STRBUF_INIT;
1090 argv[0] = find_hook("post-rewrite");
1099 proc.stdout_to_stderr = 1;
1100 proc.trace2_hook_name = "post-rewrite";
1102 code = start_command(&proc);
1105 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1106 sigchain_push(SIGPIPE, SIG_IGN);
1107 write_in_full(proc.in, sb.buf, sb.len);
1109 strbuf_release(&sb);
1110 sigchain_pop(SIGPIPE);
1111 return finish_command(&proc);
1114 void commit_post_rewrite(struct repository *r,
1115 const struct commit *old_head,
1116 const struct object_id *new_head)
1118 struct notes_rewrite_cfg *cfg;
1120 cfg = init_copy_notes_for_rewrite("amend");
1122 /* we are amending, so old_head is not NULL */
1123 copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
1124 finish_copy_notes_for_rewrite(r, cfg, "Notes added by 'git commit --amend'");
1126 run_rewrite_hook(&old_head->object.oid, new_head);
1129 static int run_prepare_commit_msg_hook(struct repository *r,
1134 const char *name, *arg1 = NULL, *arg2 = NULL;
1136 name = git_path_commit_editmsg();
1137 if (write_message(msg->buf, msg->len, name, 0))
1146 if (run_commit_hook(0, r->index_file, "prepare-commit-msg", name,
1148 ret = error(_("'prepare-commit-msg' hook failed"));
1153 static const char implicit_ident_advice_noconfig[] =
1154 N_("Your name and email address were configured automatically based\n"
1155 "on your username and hostname. Please check that they are accurate.\n"
1156 "You can suppress this message by setting them explicitly. Run the\n"
1157 "following command and follow the instructions in your editor to edit\n"
1158 "your configuration file:\n"
1160 " git config --global --edit\n"
1162 "After doing this, you may fix the identity used for this commit with:\n"
1164 " git commit --amend --reset-author\n");
1166 static const char implicit_ident_advice_config[] =
1167 N_("Your name and email address were configured automatically based\n"
1168 "on your username and hostname. Please check that they are accurate.\n"
1169 "You can suppress this message by setting them explicitly:\n"
1171 " git config --global user.name \"Your Name\"\n"
1172 " git config --global user.email you@example.com\n"
1174 "After doing this, you may fix the identity used for this commit with:\n"
1176 " git commit --amend --reset-author\n");
1178 static const char *implicit_ident_advice(void)
1180 char *user_config = expand_user_path("~/.gitconfig", 0);
1181 char *xdg_config = xdg_config_home("config");
1182 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1188 return _(implicit_ident_advice_config);
1190 return _(implicit_ident_advice_noconfig);
1194 void print_commit_summary(struct repository *r,
1196 const struct object_id *oid,
1199 struct rev_info rev;
1200 struct commit *commit;
1201 struct strbuf format = STRBUF_INIT;
1203 struct pretty_print_context pctx = {0};
1204 struct strbuf author_ident = STRBUF_INIT;
1205 struct strbuf committer_ident = STRBUF_INIT;
1207 commit = lookup_commit(r, oid);
1209 die(_("couldn't look up newly created commit"));
1210 if (parse_commit(commit))
1211 die(_("could not parse newly created commit"));
1213 strbuf_addstr(&format, "format:%h] %s");
1215 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1216 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1217 if (strbuf_cmp(&author_ident, &committer_ident)) {
1218 strbuf_addstr(&format, "\n Author: ");
1219 strbuf_addbuf_percentquote(&format, &author_ident);
1221 if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
1222 struct strbuf date = STRBUF_INIT;
1224 format_commit_message(commit, "%ad", &date, &pctx);
1225 strbuf_addstr(&format, "\n Date: ");
1226 strbuf_addbuf_percentquote(&format, &date);
1227 strbuf_release(&date);
1229 if (!committer_ident_sufficiently_given()) {
1230 strbuf_addstr(&format, "\n Committer: ");
1231 strbuf_addbuf_percentquote(&format, &committer_ident);
1232 if (advice_implicit_identity) {
1233 strbuf_addch(&format, '\n');
1234 strbuf_addstr(&format, implicit_ident_advice());
1237 strbuf_release(&author_ident);
1238 strbuf_release(&committer_ident);
1240 repo_init_revisions(r, &rev, prefix);
1241 setup_revisions(0, NULL, &rev, NULL);
1244 rev.diffopt.output_format =
1245 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1247 rev.verbose_header = 1;
1248 rev.show_root_diff = 1;
1249 get_commit_format(format.buf, &rev);
1250 rev.always_show_header = 0;
1251 rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1252 rev.diffopt.break_opt = 0;
1253 diff_setup_done(&rev.diffopt);
1255 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1257 die_errno(_("unable to resolve HEAD after creating commit"));
1258 if (!strcmp(head, "HEAD"))
1259 head = _("detached HEAD");
1261 skip_prefix(head, "refs/heads/", &head);
1262 printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1263 _(" (root-commit)") : "");
1265 if (!log_tree_commit(&rev, commit)) {
1266 rev.always_show_header = 1;
1267 rev.use_terminator = 1;
1268 log_tree_commit(&rev, commit);
1271 strbuf_release(&format);
1274 static int parse_head(struct repository *r, struct commit **head)
1276 struct commit *current_head;
1277 struct object_id oid;
1279 if (get_oid("HEAD", &oid)) {
1280 current_head = NULL;
1282 current_head = lookup_commit_reference(r, &oid);
1284 return error(_("could not parse HEAD"));
1285 if (!oideq(&oid, ¤t_head->object.oid)) {
1286 warning(_("HEAD %s is not a commit!"),
1289 if (parse_commit(current_head))
1290 return error(_("could not parse HEAD commit"));
1292 *head = current_head;
1298 * Try to commit without forking 'git commit'. In some cases we need
1299 * to run 'git commit' to display an error message
1302 * -1 - error unable to commit
1304 * 1 - run 'git commit'
1306 static int try_to_commit(struct repository *r,
1307 struct strbuf *msg, const char *author,
1308 struct replay_opts *opts, unsigned int flags,
1309 struct object_id *oid)
1311 struct object_id tree;
1312 struct commit *current_head = NULL;
1313 struct commit_list *parents = NULL;
1314 struct commit_extra_header *extra = NULL;
1315 struct strbuf err = STRBUF_INIT;
1316 struct strbuf commit_msg = STRBUF_INIT;
1317 char *amend_author = NULL;
1318 const char *hook_commit = NULL;
1319 enum commit_msg_cleanup_mode cleanup;
1322 if (parse_head(r, ¤t_head))
1325 if (flags & AMEND_MSG) {
1326 const char *exclude_gpgsig[] = { "gpgsig", NULL };
1327 const char *out_enc = get_commit_output_encoding();
1328 const char *message = logmsg_reencode(current_head, NULL,
1332 const char *orig_message = NULL;
1334 find_commit_subject(message, &orig_message);
1336 strbuf_addstr(msg, orig_message);
1337 hook_commit = "HEAD";
1339 author = amend_author = get_author(message);
1340 unuse_commit_buffer(current_head, message);
1342 res = error(_("unable to parse commit author"));
1345 parents = copy_commit_list(current_head->parents);
1346 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1347 } else if (current_head &&
1348 (!(flags & CREATE_ROOT_COMMIT) || (flags & AMEND_MSG))) {
1349 commit_list_insert(current_head, &parents);
1352 if (write_index_as_tree(&tree, r->index, r->index_file, 0, NULL)) {
1353 res = error(_("git write-tree failed to write a tree"));
1357 if (!(flags & ALLOW_EMPTY)) {
1358 struct commit *first_parent = current_head;
1360 if (flags & AMEND_MSG) {
1361 if (current_head->parents) {
1362 first_parent = current_head->parents->item;
1363 if (repo_parse_commit(r, first_parent)) {
1364 res = error(_("could not parse HEAD commit"));
1368 first_parent = NULL;
1371 if (oideq(first_parent
1372 ? get_commit_tree_oid(first_parent)
1373 : the_hash_algo->empty_tree,
1375 res = 1; /* run 'git commit' to display error message */
1380 if (find_hook("prepare-commit-msg")) {
1381 res = run_prepare_commit_msg_hook(r, msg, hook_commit);
1384 if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1386 res = error_errno(_("unable to read commit message "
1388 git_path_commit_editmsg());
1394 if (flags & CLEANUP_MSG)
1395 cleanup = COMMIT_MSG_CLEANUP_ALL;
1396 else if ((opts->signoff || opts->record_origin) &&
1397 !opts->explicit_cleanup)
1398 cleanup = COMMIT_MSG_CLEANUP_SPACE;
1400 cleanup = opts->default_msg_cleanup;
1402 if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1403 strbuf_stripspace(msg, cleanup == COMMIT_MSG_CLEANUP_ALL);
1404 if ((flags & EDIT_MSG) && message_is_empty(msg, cleanup)) {
1405 res = 1; /* run 'git commit' to display error message */
1411 if (commit_tree_extended(msg->buf, msg->len, &tree, parents,
1412 oid, author, opts->gpg_sign, extra)) {
1413 res = error(_("failed to write commit object"));
1417 if (update_head_with_reflog(current_head, oid,
1418 getenv("GIT_REFLOG_ACTION"), msg, &err)) {
1419 res = error("%s", err.buf);
1423 run_commit_hook(0, r->index_file, "post-commit", NULL);
1424 if (flags & AMEND_MSG)
1425 commit_post_rewrite(r, current_head, oid);
1428 free_commit_extra_headers(extra);
1429 strbuf_release(&err);
1430 strbuf_release(&commit_msg);
1436 static int write_rebase_head(struct object_id *oid)
1438 if (update_ref("rebase", "REBASE_HEAD", oid,
1439 NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1440 return error(_("could not update %s"), "REBASE_HEAD");
1445 static int do_commit(struct repository *r,
1446 const char *msg_file, const char *author,
1447 struct replay_opts *opts, unsigned int flags,
1448 struct object_id *oid)
1452 if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG)) {
1453 struct object_id oid;
1454 struct strbuf sb = STRBUF_INIT;
1456 if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1457 return error_errno(_("unable to read commit message "
1461 res = try_to_commit(r, msg_file ? &sb : NULL,
1462 author, opts, flags, &oid);
1463 strbuf_release(&sb);
1465 unlink(git_path_cherry_pick_head(r));
1466 unlink(git_path_merge_msg(r));
1467 if (!is_rebase_i(opts))
1468 print_commit_summary(r, NULL, &oid,
1469 SUMMARY_SHOW_AUTHOR_DATE);
1474 if (is_rebase_i(opts) && oid)
1475 if (write_rebase_head(oid))
1477 return run_git_commit(r, msg_file, opts, flags);
1483 static int is_original_commit_empty(struct commit *commit)
1485 const struct object_id *ptree_oid;
1487 if (parse_commit(commit))
1488 return error(_("could not parse commit %s"),
1489 oid_to_hex(&commit->object.oid));
1490 if (commit->parents) {
1491 struct commit *parent = commit->parents->item;
1492 if (parse_commit(parent))
1493 return error(_("could not parse parent commit %s"),
1494 oid_to_hex(&parent->object.oid));
1495 ptree_oid = get_commit_tree_oid(parent);
1497 ptree_oid = the_hash_algo->empty_tree; /* commit is root */
1500 return oideq(ptree_oid, get_commit_tree_oid(commit));
1504 * Should empty commits be allowed? Return status:
1505 * <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1506 * 0: Halt on empty commit
1507 * 1: Allow empty commit
1508 * 2: Drop empty commit
1510 static int allow_empty(struct repository *r,
1511 struct replay_opts *opts,
1512 struct commit *commit)
1514 int index_unchanged, originally_empty;
1519 * (1) we do not allow empty at all and error out.
1521 * (2) we allow ones that were initially empty, and
1522 * just drop the ones that become empty
1524 * (3) we allow ones that were initially empty, but
1525 * halt for the ones that become empty;
1527 * (4) we allow both.
1529 if (!opts->allow_empty)
1530 return 0; /* let "git commit" barf as necessary */
1532 index_unchanged = is_index_unchanged(r);
1533 if (index_unchanged < 0)
1534 return index_unchanged;
1535 if (!index_unchanged)
1536 return 0; /* we do not have to say --allow-empty */
1538 if (opts->keep_redundant_commits)
1541 originally_empty = is_original_commit_empty(commit);
1542 if (originally_empty < 0)
1543 return originally_empty;
1544 if (originally_empty)
1546 else if (opts->drop_redundant_commits)
1555 } todo_command_info[] = {
1572 static const char *command_to_string(const enum todo_command command)
1574 if (command < TODO_COMMENT)
1575 return todo_command_info[command].str;
1576 die(_("unknown command: %d"), command);
1579 static char command_to_char(const enum todo_command command)
1581 if (command < TODO_COMMENT && todo_command_info[command].c)
1582 return todo_command_info[command].c;
1583 return comment_line_char;
1586 static int is_noop(const enum todo_command command)
1588 return TODO_NOOP <= command;
1591 static int is_fixup(enum todo_command command)
1593 return command == TODO_FIXUP || command == TODO_SQUASH;
1596 /* Does this command create a (non-merge) commit? */
1597 static int is_pick_or_similar(enum todo_command command)
1612 static int update_squash_messages(struct repository *r,
1613 enum todo_command command,
1614 struct commit *commit,
1615 struct replay_opts *opts)
1617 struct strbuf buf = STRBUF_INIT;
1619 const char *message, *body;
1620 const char *encoding = get_commit_output_encoding();
1622 if (opts->current_fixup_count > 0) {
1623 struct strbuf header = STRBUF_INIT;
1626 if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
1627 return error(_("could not read '%s'"),
1628 rebase_path_squash_msg());
1630 eol = buf.buf[0] != comment_line_char ?
1631 buf.buf : strchrnul(buf.buf, '\n');
1633 strbuf_addf(&header, "%c ", comment_line_char);
1634 strbuf_addf(&header, _("This is a combination of %d commits."),
1635 opts->current_fixup_count + 2);
1636 strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
1637 strbuf_release(&header);
1639 struct object_id head;
1640 struct commit *head_commit;
1641 const char *head_message, *body;
1643 if (get_oid("HEAD", &head))
1644 return error(_("need a HEAD to fixup"));
1645 if (!(head_commit = lookup_commit_reference(r, &head)))
1646 return error(_("could not read HEAD"));
1647 if (!(head_message = logmsg_reencode(head_commit, NULL, encoding)))
1648 return error(_("could not read HEAD's commit message"));
1650 find_commit_subject(head_message, &body);
1651 if (write_message(body, strlen(body),
1652 rebase_path_fixup_msg(), 0)) {
1653 unuse_commit_buffer(head_commit, head_message);
1654 return error(_("cannot write '%s'"),
1655 rebase_path_fixup_msg());
1658 strbuf_addf(&buf, "%c ", comment_line_char);
1659 strbuf_addf(&buf, _("This is a combination of %d commits."), 2);
1660 strbuf_addf(&buf, "\n%c ", comment_line_char);
1661 strbuf_addstr(&buf, _("This is the 1st commit message:"));
1662 strbuf_addstr(&buf, "\n\n");
1663 strbuf_addstr(&buf, body);
1665 unuse_commit_buffer(head_commit, head_message);
1668 if (!(message = logmsg_reencode(commit, NULL, encoding)))
1669 return error(_("could not read commit message of %s"),
1670 oid_to_hex(&commit->object.oid));
1671 find_commit_subject(message, &body);
1673 if (command == TODO_SQUASH) {
1674 unlink(rebase_path_fixup_msg());
1675 strbuf_addf(&buf, "\n%c ", comment_line_char);
1676 strbuf_addf(&buf, _("This is the commit message #%d:"),
1677 ++opts->current_fixup_count + 1);
1678 strbuf_addstr(&buf, "\n\n");
1679 strbuf_addstr(&buf, body);
1680 } else if (command == TODO_FIXUP) {
1681 strbuf_addf(&buf, "\n%c ", comment_line_char);
1682 strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
1683 ++opts->current_fixup_count + 1);
1684 strbuf_addstr(&buf, "\n\n");
1685 strbuf_add_commented_lines(&buf, body, strlen(body));
1687 return error(_("unknown command: %d"), command);
1688 unuse_commit_buffer(commit, message);
1690 res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
1691 strbuf_release(&buf);
1694 strbuf_addf(&opts->current_fixups, "%s%s %s",
1695 opts->current_fixups.len ? "\n" : "",
1696 command_to_string(command),
1697 oid_to_hex(&commit->object.oid));
1698 res = write_message(opts->current_fixups.buf,
1699 opts->current_fixups.len,
1700 rebase_path_current_fixups(), 0);
1706 static void flush_rewritten_pending(void)
1708 struct strbuf buf = STRBUF_INIT;
1709 struct object_id newoid;
1712 if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
1713 !get_oid("HEAD", &newoid) &&
1714 (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1715 char *bol = buf.buf, *eol;
1718 eol = strchrnul(bol, '\n');
1719 fprintf(out, "%.*s %s\n", (int)(eol - bol),
1720 bol, oid_to_hex(&newoid));
1726 unlink(rebase_path_rewritten_pending());
1728 strbuf_release(&buf);
1731 static void record_in_rewritten(struct object_id *oid,
1732 enum todo_command next_command)
1734 FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
1739 fprintf(out, "%s\n", oid_to_hex(oid));
1742 if (!is_fixup(next_command))
1743 flush_rewritten_pending();
1746 static int do_pick_commit(struct repository *r,
1747 enum todo_command command,
1748 struct commit *commit,
1749 struct replay_opts *opts,
1750 int final_fixup, int *check_todo)
1752 unsigned int flags = opts->edit ? EDIT_MSG : 0;
1753 const char *msg_file = opts->edit ? NULL : git_path_merge_msg(r);
1754 struct object_id head;
1755 struct commit *base, *next, *parent;
1756 const char *base_label, *next_label;
1757 char *author = NULL;
1758 struct commit_message msg = { NULL, NULL, NULL, NULL };
1759 struct strbuf msgbuf = STRBUF_INIT;
1760 int res, unborn = 0, reword = 0, allow, drop_commit;
1762 if (opts->no_commit) {
1764 * We do not intend to commit immediately. We just want to
1765 * merge the differences in, so let's compute the tree
1766 * that represents the "current" state for merge-recursive
1769 if (write_index_as_tree(&head, r->index, r->index_file, 0, NULL))
1770 return error(_("your index file is unmerged."));
1772 unborn = get_oid("HEAD", &head);
1773 /* Do we want to generate a root commit? */
1774 if (is_pick_or_similar(command) && opts->have_squash_onto &&
1775 oideq(&head, &opts->squash_onto)) {
1776 if (is_fixup(command))
1777 return error(_("cannot fixup root commit"));
1778 flags |= CREATE_ROOT_COMMIT;
1781 oidcpy(&head, the_hash_algo->empty_tree);
1782 if (index_differs_from(r, unborn ? empty_tree_oid_hex() : "HEAD",
1784 return error_dirty_index(r, opts);
1786 discard_index(r->index);
1788 if (!commit->parents)
1790 else if (commit->parents->next) {
1791 /* Reverting or cherry-picking a merge commit */
1793 struct commit_list *p;
1795 if (!opts->mainline)
1796 return error(_("commit %s is a merge but no -m option was given."),
1797 oid_to_hex(&commit->object.oid));
1799 for (cnt = 1, p = commit->parents;
1800 cnt != opts->mainline && p;
1803 if (cnt != opts->mainline || !p)
1804 return error(_("commit %s does not have parent %d"),
1805 oid_to_hex(&commit->object.oid), opts->mainline);
1807 } else if (1 < opts->mainline)
1809 * Non-first parent explicitly specified as mainline for
1812 return error(_("commit %s does not have parent %d"),
1813 oid_to_hex(&commit->object.oid), opts->mainline);
1815 parent = commit->parents->item;
1817 if (get_message(commit, &msg) != 0)
1818 return error(_("cannot get commit message for %s"),
1819 oid_to_hex(&commit->object.oid));
1821 if (opts->allow_ff && !is_fixup(command) &&
1822 ((parent && oideq(&parent->object.oid, &head)) ||
1823 (!parent && unborn))) {
1824 if (is_rebase_i(opts))
1825 write_author_script(msg.message);
1826 res = fast_forward_to(r, &commit->object.oid, &head, unborn,
1828 if (res || command != TODO_REWORD)
1832 goto fast_forward_edit;
1834 if (parent && parse_commit(parent) < 0)
1835 /* TRANSLATORS: The first %s will be a "todo" command like
1836 "revert" or "pick", the second %s a SHA1. */
1837 return error(_("%s: cannot parse parent commit %s"),
1838 command_to_string(command),
1839 oid_to_hex(&parent->object.oid));
1842 * "commit" is an existing commit. We would want to apply
1843 * the difference it introduces since its first parent "prev"
1844 * on top of the current HEAD if we are cherry-pick. Or the
1845 * reverse of it if we are revert.
1848 if (command == TODO_REVERT) {
1850 base_label = msg.label;
1852 next_label = msg.parent_label;
1853 strbuf_addstr(&msgbuf, "Revert \"");
1854 strbuf_addstr(&msgbuf, msg.subject);
1855 strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
1856 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1858 if (commit->parents && commit->parents->next) {
1859 strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
1860 strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
1862 strbuf_addstr(&msgbuf, ".\n");
1867 base_label = msg.parent_label;
1869 next_label = msg.label;
1871 /* Append the commit log message to msgbuf. */
1872 if (find_commit_subject(msg.message, &p))
1873 strbuf_addstr(&msgbuf, p);
1875 if (opts->record_origin) {
1876 strbuf_complete_line(&msgbuf);
1877 if (!has_conforming_footer(&msgbuf, NULL, 0))
1878 strbuf_addch(&msgbuf, '\n');
1879 strbuf_addstr(&msgbuf, cherry_picked_prefix);
1880 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1881 strbuf_addstr(&msgbuf, ")\n");
1883 if (!is_fixup(command))
1884 author = get_author(msg.message);
1887 if (command == TODO_REWORD)
1889 else if (is_fixup(command)) {
1890 if (update_squash_messages(r, command, commit, opts))
1894 msg_file = rebase_path_squash_msg();
1895 else if (file_exists(rebase_path_fixup_msg())) {
1896 flags |= CLEANUP_MSG;
1897 msg_file = rebase_path_fixup_msg();
1899 const char *dest = git_path_squash_msg(r);
1901 if (copy_file(dest, rebase_path_squash_msg(), 0666))
1902 return error(_("could not rename '%s' to '%s'"),
1903 rebase_path_squash_msg(), dest);
1904 unlink(git_path_merge_msg(r));
1910 if (opts->signoff && !is_fixup(command))
1911 append_signoff(&msgbuf, 0, 0);
1913 if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1915 else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
1916 res = do_recursive_merge(r, base, next, base_label, next_label,
1917 &head, &msgbuf, opts);
1921 res |= write_message(msgbuf.buf, msgbuf.len,
1922 git_path_merge_msg(r), 0);
1924 struct commit_list *common = NULL;
1925 struct commit_list *remotes = NULL;
1927 res = write_message(msgbuf.buf, msgbuf.len,
1928 git_path_merge_msg(r), 0);
1930 commit_list_insert(base, &common);
1931 commit_list_insert(next, &remotes);
1932 res |= try_merge_command(r, opts->strategy,
1933 opts->xopts_nr, (const char **)opts->xopts,
1934 common, oid_to_hex(&head), remotes);
1935 free_commit_list(common);
1936 free_commit_list(remotes);
1938 strbuf_release(&msgbuf);
1941 * If the merge was clean or if it failed due to conflict, we write
1942 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1943 * However, if the merge did not even start, then we don't want to
1946 if ((command == TODO_PICK || command == TODO_REWORD ||
1947 command == TODO_EDIT) && !opts->no_commit &&
1948 (res == 0 || res == 1) &&
1949 update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
1950 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1952 if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
1953 update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
1954 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1958 error(command == TODO_REVERT
1959 ? _("could not revert %s... %s")
1960 : _("could not apply %s... %s"),
1961 short_commit_name(commit), msg.subject);
1962 print_advice(r, res == 1, opts);
1963 repo_rerere(r, opts->allow_rerere_auto);
1968 allow = allow_empty(r, opts, commit);
1972 } else if (allow == 1) {
1973 flags |= ALLOW_EMPTY;
1974 } else if (allow == 2) {
1976 unlink(git_path_cherry_pick_head(r));
1977 unlink(git_path_merge_msg(r));
1979 _("dropping %s %s -- patch contents already upstream\n"),
1980 oid_to_hex(&commit->object.oid), msg.subject);
1981 } /* else allow == 0 and there's nothing special to do */
1982 if (!opts->no_commit && !drop_commit) {
1983 if (author || command == TODO_REVERT || (flags & AMEND_MSG))
1984 res = do_commit(r, msg_file, author, opts, flags,
1985 commit? &commit->object.oid : NULL);
1987 res = error(_("unable to parse commit author"));
1988 *check_todo = !!(flags & EDIT_MSG);
1989 if (!res && reword) {
1991 res = run_git_commit(r, NULL, opts, EDIT_MSG |
1992 VERIFY_MSG | AMEND_MSG |
1993 (flags & ALLOW_EMPTY));
1999 if (!res && final_fixup) {
2000 unlink(rebase_path_fixup_msg());
2001 unlink(rebase_path_squash_msg());
2002 unlink(rebase_path_current_fixups());
2003 strbuf_reset(&opts->current_fixups);
2004 opts->current_fixup_count = 0;
2008 free_message(commit, &msg);
2010 update_abort_safety_file();
2015 static int prepare_revs(struct replay_opts *opts)
2018 * picking (but not reverting) ranges (but not individual revisions)
2019 * should be done in reverse
2021 if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
2022 opts->revs->reverse ^= 1;
2024 if (prepare_revision_walk(opts->revs))
2025 return error(_("revision walk setup failed"));
2030 static int read_and_refresh_cache(struct repository *r,
2031 struct replay_opts *opts)
2033 struct lock_file index_lock = LOCK_INIT;
2034 int index_fd = repo_hold_locked_index(r, &index_lock, 0);
2035 if (repo_read_index(r) < 0) {
2036 rollback_lock_file(&index_lock);
2037 return error(_("git %s: failed to read the index"),
2038 _(action_name(opts)));
2040 refresh_index(r->index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
2041 if (index_fd >= 0) {
2042 if (write_locked_index(r->index, &index_lock,
2043 COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
2044 return error(_("git %s: failed to refresh the index"),
2045 _(action_name(opts)));
2051 enum todo_item_flags {
2052 TODO_EDIT_MERGE_MSG = 1
2055 void todo_list_release(struct todo_list *todo_list)
2057 strbuf_release(&todo_list->buf);
2058 FREE_AND_NULL(todo_list->items);
2059 todo_list->nr = todo_list->alloc = 0;
2062 static struct todo_item *append_new_todo(struct todo_list *todo_list)
2064 ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
2065 todo_list->total_nr++;
2066 return todo_list->items + todo_list->nr++;
2069 const char *todo_item_get_arg(struct todo_list *todo_list,
2070 struct todo_item *item)
2072 return todo_list->buf.buf + item->arg_offset;
2075 static int is_command(enum todo_command command, const char **bol)
2077 const char *str = todo_command_info[command].str;
2078 const char nick = todo_command_info[command].c;
2079 const char *p = *bol + 1;
2081 return skip_prefix(*bol, str, bol) ||
2082 ((nick && **bol == nick) &&
2083 (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r' || !*p) &&
2087 static int parse_insn_line(struct repository *r, struct todo_item *item,
2088 const char *buf, const char *bol, char *eol)
2090 struct object_id commit_oid;
2091 char *end_of_object_name;
2092 int i, saved, status, padding;
2097 bol += strspn(bol, " \t");
2099 if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
2100 item->command = TODO_COMMENT;
2101 item->commit = NULL;
2102 item->arg_offset = bol - buf;
2103 item->arg_len = eol - bol;
2107 for (i = 0; i < TODO_COMMENT; i++)
2108 if (is_command(i, &bol)) {
2112 if (i >= TODO_COMMENT)
2115 /* Eat up extra spaces/ tabs before object name */
2116 padding = strspn(bol, " \t");
2119 if (item->command == TODO_NOOP || item->command == TODO_BREAK) {
2121 return error(_("%s does not accept arguments: '%s'"),
2122 command_to_string(item->command), bol);
2123 item->commit = NULL;
2124 item->arg_offset = bol - buf;
2125 item->arg_len = eol - bol;
2130 return error(_("missing arguments for %s"),
2131 command_to_string(item->command));
2133 if (item->command == TODO_EXEC || item->command == TODO_LABEL ||
2134 item->command == TODO_RESET) {
2135 item->commit = NULL;
2136 item->arg_offset = bol - buf;
2137 item->arg_len = (int)(eol - bol);
2141 if (item->command == TODO_MERGE) {
2142 if (skip_prefix(bol, "-C", &bol))
2143 bol += strspn(bol, " \t");
2144 else if (skip_prefix(bol, "-c", &bol)) {
2145 bol += strspn(bol, " \t");
2146 item->flags |= TODO_EDIT_MERGE_MSG;
2148 item->flags |= TODO_EDIT_MERGE_MSG;
2149 item->commit = NULL;
2150 item->arg_offset = bol - buf;
2151 item->arg_len = (int)(eol - bol);
2156 end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
2157 saved = *end_of_object_name;
2158 *end_of_object_name = '\0';
2159 status = get_oid(bol, &commit_oid);
2161 error(_("could not parse '%s'"), bol); /* return later */
2162 *end_of_object_name = saved;
2164 bol = end_of_object_name + strspn(end_of_object_name, " \t");
2165 item->arg_offset = bol - buf;
2166 item->arg_len = (int)(eol - bol);
2171 item->commit = lookup_commit_reference(r, &commit_oid);
2172 return item->commit ? 0 : -1;
2175 int sequencer_get_last_command(struct repository *r, enum replay_action *action)
2177 const char *todo_file, *bol;
2178 struct strbuf buf = STRBUF_INIT;
2181 todo_file = git_path_todo_file();
2182 if (strbuf_read_file(&buf, todo_file, 0) < 0) {
2183 if (errno == ENOENT || errno == ENOTDIR)
2186 return error_errno("unable to open '%s'", todo_file);
2188 bol = buf.buf + strspn(buf.buf, " \t\r\n");
2189 if (is_command(TODO_PICK, &bol) && (*bol == ' ' || *bol == '\t'))
2190 *action = REPLAY_PICK;
2191 else if (is_command(TODO_REVERT, &bol) &&
2192 (*bol == ' ' || *bol == '\t'))
2193 *action = REPLAY_REVERT;
2197 strbuf_release(&buf);
2202 int todo_list_parse_insn_buffer(struct repository *r, char *buf,
2203 struct todo_list *todo_list)
2205 struct todo_item *item;
2206 char *p = buf, *next_p;
2207 int i, res = 0, fixup_okay = file_exists(rebase_path_done());
2209 todo_list->current = todo_list->nr = 0;
2211 for (i = 1; *p; i++, p = next_p) {
2212 char *eol = strchrnul(p, '\n');
2214 next_p = *eol ? eol + 1 /* skip LF */ : eol;
2216 if (p != eol && eol[-1] == '\r')
2217 eol--; /* strip Carriage Return */
2219 item = append_new_todo(todo_list);
2220 item->offset_in_buf = p - todo_list->buf.buf;
2221 if (parse_insn_line(r, item, buf, p, eol)) {
2222 res = error(_("invalid line %d: %.*s"),
2223 i, (int)(eol - p), p);
2224 item->command = TODO_COMMENT + 1;
2225 item->arg_offset = p - buf;
2226 item->arg_len = (int)(eol - p);
2227 item->commit = NULL;
2232 else if (is_fixup(item->command))
2233 return error(_("cannot '%s' without a previous commit"),
2234 command_to_string(item->command));
2235 else if (!is_noop(item->command))
2242 static int count_commands(struct todo_list *todo_list)
2246 for (i = 0; i < todo_list->nr; i++)
2247 if (todo_list->items[i].command != TODO_COMMENT)
2253 static int get_item_line_offset(struct todo_list *todo_list, int index)
2255 return index < todo_list->nr ?
2256 todo_list->items[index].offset_in_buf : todo_list->buf.len;
2259 static const char *get_item_line(struct todo_list *todo_list, int index)
2261 return todo_list->buf.buf + get_item_line_offset(todo_list, index);
2264 static int get_item_line_length(struct todo_list *todo_list, int index)
2266 return get_item_line_offset(todo_list, index + 1)
2267 - get_item_line_offset(todo_list, index);
2270 static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
2275 fd = open(path, O_RDONLY);
2277 return error_errno(_("could not open '%s'"), path);
2278 len = strbuf_read(sb, fd, 0);
2281 return error(_("could not read '%s'."), path);
2285 static int have_finished_the_last_pick(void)
2287 struct strbuf buf = STRBUF_INIT;
2289 const char *todo_path = git_path_todo_file();
2292 if (strbuf_read_file(&buf, todo_path, 0) < 0) {
2293 if (errno == ENOENT) {
2296 error_errno("unable to open '%s'", todo_path);
2300 /* If there is only one line then we are done */
2301 eol = strchr(buf.buf, '\n');
2302 if (!eol || !eol[1])
2305 strbuf_release(&buf);
2310 void sequencer_post_commit_cleanup(struct repository *r, int verbose)
2312 struct replay_opts opts = REPLAY_OPTS_INIT;
2313 int need_cleanup = 0;
2315 if (file_exists(git_path_cherry_pick_head(r))) {
2316 if (!unlink(git_path_cherry_pick_head(r)) && verbose)
2317 warning(_("cancelling a cherry picking in progress"));
2318 opts.action = REPLAY_PICK;
2322 if (file_exists(git_path_revert_head(r))) {
2323 if (!unlink(git_path_revert_head(r)) && verbose)
2324 warning(_("cancelling a revert in progress"));
2325 opts.action = REPLAY_REVERT;
2332 if (!have_finished_the_last_pick())
2335 sequencer_remove_state(&opts);
2338 static void todo_list_write_total_nr(struct todo_list *todo_list)
2340 FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
2343 fprintf(f, "%d\n", todo_list->total_nr);
2348 static int read_populate_todo(struct repository *r,
2349 struct todo_list *todo_list,
2350 struct replay_opts *opts)
2353 const char *todo_file = get_todo_path(opts);
2356 strbuf_reset(&todo_list->buf);
2357 if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
2360 res = stat(todo_file, &st);
2362 return error(_("could not stat '%s'"), todo_file);
2363 fill_stat_data(&todo_list->stat, &st);
2365 res = todo_list_parse_insn_buffer(r, todo_list->buf.buf, todo_list);
2367 if (is_rebase_i(opts))
2368 return error(_("please fix this using "
2369 "'git rebase --edit-todo'."));
2370 return error(_("unusable instruction sheet: '%s'"), todo_file);
2373 if (!todo_list->nr &&
2374 (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
2375 return error(_("no commits parsed."));
2377 if (!is_rebase_i(opts)) {
2378 enum todo_command valid =
2379 opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
2382 for (i = 0; i < todo_list->nr; i++)
2383 if (valid == todo_list->items[i].command)
2385 else if (valid == TODO_PICK)
2386 return error(_("cannot cherry-pick during a revert."));
2388 return error(_("cannot revert during a cherry-pick."));
2391 if (is_rebase_i(opts)) {
2392 struct todo_list done = TODO_LIST_INIT;
2394 if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
2395 !todo_list_parse_insn_buffer(r, done.buf.buf, &done))
2396 todo_list->done_nr = count_commands(&done);
2398 todo_list->done_nr = 0;
2400 todo_list->total_nr = todo_list->done_nr
2401 + count_commands(todo_list);
2402 todo_list_release(&done);
2404 todo_list_write_total_nr(todo_list);
2410 static int git_config_string_dup(char **dest,
2411 const char *var, const char *value)
2414 return config_error_nonbool(var);
2416 *dest = xstrdup(value);
2420 static int populate_opts_cb(const char *key, const char *value, void *data)
2422 struct replay_opts *opts = data;
2427 else if (!strcmp(key, "options.no-commit"))
2428 opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
2429 else if (!strcmp(key, "options.edit"))
2430 opts->edit = git_config_bool_or_int(key, value, &error_flag);
2431 else if (!strcmp(key, "options.allow-empty"))
2433 git_config_bool_or_int(key, value, &error_flag);
2434 else if (!strcmp(key, "options.allow-empty-message"))
2435 opts->allow_empty_message =
2436 git_config_bool_or_int(key, value, &error_flag);
2437 else if (!strcmp(key, "options.keep-redundant-commits"))
2438 opts->keep_redundant_commits =
2439 git_config_bool_or_int(key, value, &error_flag);
2440 else if (!strcmp(key, "options.signoff"))
2441 opts->signoff = git_config_bool_or_int(key, value, &error_flag);
2442 else if (!strcmp(key, "options.record-origin"))
2443 opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
2444 else if (!strcmp(key, "options.allow-ff"))
2445 opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
2446 else if (!strcmp(key, "options.mainline"))
2447 opts->mainline = git_config_int(key, value);
2448 else if (!strcmp(key, "options.strategy"))
2449 git_config_string_dup(&opts->strategy, key, value);
2450 else if (!strcmp(key, "options.gpg-sign"))
2451 git_config_string_dup(&opts->gpg_sign, key, value);
2452 else if (!strcmp(key, "options.strategy-option")) {
2453 ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
2454 opts->xopts[opts->xopts_nr++] = xstrdup(value);
2455 } else if (!strcmp(key, "options.allow-rerere-auto"))
2456 opts->allow_rerere_auto =
2457 git_config_bool_or_int(key, value, &error_flag) ?
2458 RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
2459 else if (!strcmp(key, "options.default-msg-cleanup")) {
2460 opts->explicit_cleanup = 1;
2461 opts->default_msg_cleanup = get_cleanup_mode(value, 1);
2463 return error(_("invalid key: %s"), key);
2466 return error(_("invalid value for %s: %s"), key, value);
2471 void parse_strategy_opts(struct replay_opts *opts, char *raw_opts)
2474 char *strategy_opts_string = raw_opts;
2476 if (*strategy_opts_string == ' ')
2477 strategy_opts_string++;
2479 opts->xopts_nr = split_cmdline(strategy_opts_string,
2480 (const char ***)&opts->xopts);
2481 for (i = 0; i < opts->xopts_nr; i++) {
2482 const char *arg = opts->xopts[i];
2484 skip_prefix(arg, "--", &arg);
2485 opts->xopts[i] = xstrdup(arg);
2489 static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
2492 if (!read_oneliner(buf, rebase_path_strategy(), 0))
2494 opts->strategy = strbuf_detach(buf, NULL);
2495 if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2498 parse_strategy_opts(opts, buf->buf);
2501 static int read_populate_opts(struct replay_opts *opts)
2503 if (is_rebase_i(opts)) {
2504 struct strbuf buf = STRBUF_INIT;
2506 if (read_oneliner(&buf, rebase_path_gpg_sign_opt(), 1)) {
2507 if (!starts_with(buf.buf, "-S"))
2510 free(opts->gpg_sign);
2511 opts->gpg_sign = xstrdup(buf.buf + 2);
2516 if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(), 1)) {
2517 if (!strcmp(buf.buf, "--rerere-autoupdate"))
2518 opts->allow_rerere_auto = RERERE_AUTOUPDATE;
2519 else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
2520 opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
2524 if (file_exists(rebase_path_verbose()))
2527 if (file_exists(rebase_path_quiet()))
2530 if (file_exists(rebase_path_signoff())) {
2535 if (file_exists(rebase_path_reschedule_failed_exec()))
2536 opts->reschedule_failed_exec = 1;
2538 if (file_exists(rebase_path_drop_redundant_commits()))
2539 opts->drop_redundant_commits = 1;
2541 if (file_exists(rebase_path_keep_redundant_commits()))
2542 opts->keep_redundant_commits = 1;
2544 read_strategy_opts(opts, &buf);
2545 strbuf_release(&buf);
2547 if (read_oneliner(&opts->current_fixups,
2548 rebase_path_current_fixups(), 1)) {
2549 const char *p = opts->current_fixups.buf;
2550 opts->current_fixup_count = 1;
2551 while ((p = strchr(p, '\n'))) {
2552 opts->current_fixup_count++;
2557 if (read_oneliner(&buf, rebase_path_squash_onto(), 0)) {
2558 if (get_oid_hex(buf.buf, &opts->squash_onto) < 0)
2559 return error(_("unusable squash-onto"));
2560 opts->have_squash_onto = 1;
2566 if (!file_exists(git_path_opts_file()))
2569 * The function git_parse_source(), called from git_config_from_file(),
2570 * may die() in case of a syntactically incorrect file. We do not care
2571 * about this case, though, because we wrote that file ourselves, so we
2572 * are pretty certain that it is syntactically correct.
2574 if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
2575 return error(_("malformed options sheet: '%s'"),
2576 git_path_opts_file());
2580 static void write_strategy_opts(struct replay_opts *opts)
2583 struct strbuf buf = STRBUF_INIT;
2585 for (i = 0; i < opts->xopts_nr; ++i)
2586 strbuf_addf(&buf, " --%s", opts->xopts[i]);
2588 write_file(rebase_path_strategy_opts(), "%s\n", buf.buf);
2589 strbuf_release(&buf);
2592 int write_basic_state(struct replay_opts *opts, const char *head_name,
2593 struct commit *onto, const char *orig_head)
2596 write_file(rebase_path_head_name(), "%s\n", head_name);
2598 write_file(rebase_path_onto(), "%s\n",
2599 oid_to_hex(&onto->object.oid));
2601 write_file(rebase_path_orig_head(), "%s\n", orig_head);
2604 write_file(rebase_path_quiet(), "%s", "");
2606 write_file(rebase_path_verbose(), "%s", "");
2608 write_file(rebase_path_strategy(), "%s\n", opts->strategy);
2609 if (opts->xopts_nr > 0)
2610 write_strategy_opts(opts);
2612 if (opts->allow_rerere_auto == RERERE_AUTOUPDATE)
2613 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2614 else if (opts->allow_rerere_auto == RERERE_NOAUTOUPDATE)
2615 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2618 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts->gpg_sign);
2620 write_file(rebase_path_signoff(), "--signoff\n");
2621 if (opts->drop_redundant_commits)
2622 write_file(rebase_path_drop_redundant_commits(), "%s", "");
2623 if (opts->keep_redundant_commits)
2624 write_file(rebase_path_keep_redundant_commits(), "%s", "");
2625 if (opts->reschedule_failed_exec)
2626 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
2631 static int walk_revs_populate_todo(struct todo_list *todo_list,
2632 struct replay_opts *opts)
2634 enum todo_command command = opts->action == REPLAY_PICK ?
2635 TODO_PICK : TODO_REVERT;
2636 const char *command_string = todo_command_info[command].str;
2637 const char *encoding;
2638 struct commit *commit;
2640 if (prepare_revs(opts))
2643 encoding = get_log_output_encoding();
2645 while ((commit = get_revision(opts->revs))) {
2646 struct todo_item *item = append_new_todo(todo_list);
2647 const char *commit_buffer = logmsg_reencode(commit, NULL, encoding);
2648 const char *subject;
2651 item->command = command;
2652 item->commit = commit;
2653 item->arg_offset = 0;
2655 item->offset_in_buf = todo_list->buf.len;
2656 subject_len = find_commit_subject(commit_buffer, &subject);
2657 strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
2658 short_commit_name(commit), subject_len, subject);
2659 unuse_commit_buffer(commit, commit_buffer);
2663 return error(_("empty commit set passed"));
2668 static int create_seq_dir(struct repository *r)
2670 enum replay_action action;
2671 const char *in_progress_error = NULL;
2672 const char *in_progress_advice = NULL;
2673 unsigned int advise_skip = file_exists(git_path_revert_head(r)) ||
2674 file_exists(git_path_cherry_pick_head(r));
2676 if (!sequencer_get_last_command(r, &action)) {
2679 in_progress_error = _("revert is already in progress");
2680 in_progress_advice =
2681 _("try \"git revert (--continue | %s--abort | --quit)\"");
2684 in_progress_error = _("cherry-pick is already in progress");
2685 in_progress_advice =
2686 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
2689 BUG("unexpected action in create_seq_dir");
2692 if (in_progress_error) {
2693 error("%s", in_progress_error);
2694 if (advice_sequencer_in_use)
2695 advise(in_progress_advice,
2696 advise_skip ? "--skip | " : "");
2699 if (mkdir(git_path_seq_dir(), 0777) < 0)
2700 return error_errno(_("could not create sequencer directory '%s'"),
2701 git_path_seq_dir());
2706 static int save_head(const char *head)
2708 struct lock_file head_lock = LOCK_INIT;
2709 struct strbuf buf = STRBUF_INIT;
2713 fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
2715 return error_errno(_("could not lock HEAD"));
2716 strbuf_addf(&buf, "%s\n", head);
2717 written = write_in_full(fd, buf.buf, buf.len);
2718 strbuf_release(&buf);
2720 error_errno(_("could not write to '%s'"), git_path_head_file());
2721 rollback_lock_file(&head_lock);
2724 if (commit_lock_file(&head_lock) < 0)
2725 return error(_("failed to finalize '%s'"), git_path_head_file());
2729 static int rollback_is_safe(void)
2731 struct strbuf sb = STRBUF_INIT;
2732 struct object_id expected_head, actual_head;
2734 if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2736 if (get_oid_hex(sb.buf, &expected_head)) {
2737 strbuf_release(&sb);
2738 die(_("could not parse %s"), git_path_abort_safety_file());
2740 strbuf_release(&sb);
2742 else if (errno == ENOENT)
2743 oidclr(&expected_head);
2745 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2747 if (get_oid("HEAD", &actual_head))
2748 oidclr(&actual_head);
2750 return oideq(&actual_head, &expected_head);
2753 static int reset_merge(const struct object_id *oid)
2756 struct argv_array argv = ARGV_ARRAY_INIT;
2758 argv_array_pushl(&argv, "reset", "--merge", NULL);
2760 if (!is_null_oid(oid))
2761 argv_array_push(&argv, oid_to_hex(oid));
2763 ret = run_command_v_opt(argv.argv, RUN_GIT_CMD);
2764 argv_array_clear(&argv);
2769 static int rollback_single_pick(struct repository *r)
2771 struct object_id head_oid;
2773 if (!file_exists(git_path_cherry_pick_head(r)) &&
2774 !file_exists(git_path_revert_head(r)))
2775 return error(_("no cherry-pick or revert in progress"));
2776 if (read_ref_full("HEAD", 0, &head_oid, NULL))
2777 return error(_("cannot resolve HEAD"));
2778 if (is_null_oid(&head_oid))
2779 return error(_("cannot abort from a branch yet to be born"));
2780 return reset_merge(&head_oid);
2783 static int skip_single_pick(void)
2785 struct object_id head;
2787 if (read_ref_full("HEAD", 0, &head, NULL))
2788 return error(_("cannot resolve HEAD"));
2789 return reset_merge(&head);
2792 int sequencer_rollback(struct repository *r, struct replay_opts *opts)
2795 struct object_id oid;
2796 struct strbuf buf = STRBUF_INIT;
2799 f = fopen(git_path_head_file(), "r");
2800 if (!f && errno == ENOENT) {
2802 * There is no multiple-cherry-pick in progress.
2803 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2804 * a single-cherry-pick in progress, abort that.
2806 return rollback_single_pick(r);
2809 return error_errno(_("cannot open '%s'"), git_path_head_file());
2810 if (strbuf_getline_lf(&buf, f)) {
2811 error(_("cannot read '%s': %s"), git_path_head_file(),
2812 ferror(f) ? strerror(errno) : _("unexpected end of file"));
2817 if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
2818 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2819 git_path_head_file());
2822 if (is_null_oid(&oid)) {
2823 error(_("cannot abort from a branch yet to be born"));
2827 if (!rollback_is_safe()) {
2828 /* Do not error, just do not rollback */
2829 warning(_("You seem to have moved HEAD. "
2830 "Not rewinding, check your HEAD!"));
2832 if (reset_merge(&oid))
2834 strbuf_release(&buf);
2835 return sequencer_remove_state(opts);
2837 strbuf_release(&buf);
2841 int sequencer_skip(struct repository *r, struct replay_opts *opts)
2843 enum replay_action action = -1;
2844 sequencer_get_last_command(r, &action);
2847 * Check whether the subcommand requested to skip the commit is actually
2848 * in progress and that it's safe to skip the commit.
2850 * opts->action tells us which subcommand requested to skip the commit.
2851 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
2852 * action is in progress and we can skip the commit.
2854 * Otherwise we check that the last instruction was related to the
2855 * particular subcommand we're trying to execute and barf if that's not
2858 * Finally we check that the rollback is "safe", i.e., has the HEAD
2859 * moved? In this case, it doesn't make sense to "reset the merge" and
2860 * "skip the commit" as the user already handled this by committing. But
2861 * we'd not want to barf here, instead give advice on how to proceed. We
2862 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
2863 * it gets removed when the user commits, so if it still exists we're
2864 * sure the user can't have committed before.
2866 switch (opts->action) {
2868 if (!file_exists(git_path_revert_head(r))) {
2869 if (action != REPLAY_REVERT)
2870 return error(_("no revert in progress"));
2871 if (!rollback_is_safe())
2876 if (!file_exists(git_path_cherry_pick_head(r))) {
2877 if (action != REPLAY_PICK)
2878 return error(_("no cherry-pick in progress"));
2879 if (!rollback_is_safe())
2884 BUG("unexpected action in sequencer_skip");
2887 if (skip_single_pick())
2888 return error(_("failed to skip the commit"));
2889 if (!is_directory(git_path_seq_dir()))
2892 return sequencer_continue(r, opts);
2895 error(_("there is nothing to skip"));
2897 if (advice_resolve_conflict) {
2898 advise(_("have you committed already?\n"
2899 "try \"git %s --continue\""),
2900 action == REPLAY_REVERT ? "revert" : "cherry-pick");
2905 static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
2907 struct lock_file todo_lock = LOCK_INIT;
2908 const char *todo_path = get_todo_path(opts);
2909 int next = todo_list->current, offset, fd;
2912 * rebase -i writes "git-rebase-todo" without the currently executing
2913 * command, appending it to "done" instead.
2915 if (is_rebase_i(opts))
2918 fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
2920 return error_errno(_("could not lock '%s'"), todo_path);
2921 offset = get_item_line_offset(todo_list, next);
2922 if (write_in_full(fd, todo_list->buf.buf + offset,
2923 todo_list->buf.len - offset) < 0)
2924 return error_errno(_("could not write to '%s'"), todo_path);
2925 if (commit_lock_file(&todo_lock) < 0)
2926 return error(_("failed to finalize '%s'"), todo_path);
2928 if (is_rebase_i(opts) && next > 0) {
2929 const char *done = rebase_path_done();
2930 int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
2935 if (write_in_full(fd, get_item_line(todo_list, next - 1),
2936 get_item_line_length(todo_list, next - 1))
2938 ret = error_errno(_("could not write to '%s'"), done);
2940 ret = error_errno(_("failed to finalize '%s'"), done);
2946 static int save_opts(struct replay_opts *opts)
2948 const char *opts_file = git_path_opts_file();
2951 if (opts->no_commit)
2952 res |= git_config_set_in_file_gently(opts_file,
2953 "options.no-commit", "true");
2955 res |= git_config_set_in_file_gently(opts_file,
2956 "options.edit", "true");
2957 if (opts->allow_empty)
2958 res |= git_config_set_in_file_gently(opts_file,
2959 "options.allow-empty", "true");
2960 if (opts->allow_empty_message)
2961 res |= git_config_set_in_file_gently(opts_file,
2962 "options.allow-empty-message", "true");
2963 if (opts->keep_redundant_commits)
2964 res |= git_config_set_in_file_gently(opts_file,
2965 "options.keep-redundant-commits", "true");
2967 res |= git_config_set_in_file_gently(opts_file,
2968 "options.signoff", "true");
2969 if (opts->record_origin)
2970 res |= git_config_set_in_file_gently(opts_file,
2971 "options.record-origin", "true");
2973 res |= git_config_set_in_file_gently(opts_file,
2974 "options.allow-ff", "true");
2975 if (opts->mainline) {
2976 struct strbuf buf = STRBUF_INIT;
2977 strbuf_addf(&buf, "%d", opts->mainline);
2978 res |= git_config_set_in_file_gently(opts_file,
2979 "options.mainline", buf.buf);
2980 strbuf_release(&buf);
2983 res |= git_config_set_in_file_gently(opts_file,
2984 "options.strategy", opts->strategy);
2986 res |= git_config_set_in_file_gently(opts_file,
2987 "options.gpg-sign", opts->gpg_sign);
2990 for (i = 0; i < opts->xopts_nr; i++)
2991 res |= git_config_set_multivar_in_file_gently(opts_file,
2992 "options.strategy-option",
2993 opts->xopts[i], "^$", 0);
2995 if (opts->allow_rerere_auto)
2996 res |= git_config_set_in_file_gently(opts_file,
2997 "options.allow-rerere-auto",
2998 opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
3001 if (opts->explicit_cleanup)
3002 res |= git_config_set_in_file_gently(opts_file,
3003 "options.default-msg-cleanup",
3004 describe_cleanup_mode(opts->default_msg_cleanup));
3008 static int make_patch(struct repository *r,
3009 struct commit *commit,
3010 struct replay_opts *opts)
3012 struct strbuf buf = STRBUF_INIT;
3013 struct rev_info log_tree_opt;
3014 const char *subject, *p;
3017 p = short_commit_name(commit);
3018 if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
3020 res |= write_rebase_head(&commit->object.oid);
3022 strbuf_addf(&buf, "%s/patch", get_dir(opts));
3023 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
3024 repo_init_revisions(r, &log_tree_opt, NULL);
3025 log_tree_opt.abbrev = 0;
3026 log_tree_opt.diff = 1;
3027 log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
3028 log_tree_opt.disable_stdin = 1;
3029 log_tree_opt.no_commit_id = 1;
3030 log_tree_opt.diffopt.file = fopen(buf.buf, "w");
3031 log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
3032 if (!log_tree_opt.diffopt.file)
3033 res |= error_errno(_("could not open '%s'"), buf.buf);
3035 res |= log_tree_commit(&log_tree_opt, commit);
3036 fclose(log_tree_opt.diffopt.file);
3040 strbuf_addf(&buf, "%s/message", get_dir(opts));
3041 if (!file_exists(buf.buf)) {
3042 const char *encoding = get_commit_output_encoding();
3043 const char *commit_buffer = logmsg_reencode(commit, NULL, encoding);
3044 find_commit_subject(commit_buffer, &subject);
3045 res |= write_message(subject, strlen(subject), buf.buf, 1);
3046 unuse_commit_buffer(commit, commit_buffer);
3048 strbuf_release(&buf);
3053 static int intend_to_amend(void)
3055 struct object_id head;
3058 if (get_oid("HEAD", &head))
3059 return error(_("cannot read HEAD"));
3061 p = oid_to_hex(&head);
3062 return write_message(p, strlen(p), rebase_path_amend(), 1);
3065 static int error_with_patch(struct repository *r,
3066 struct commit *commit,
3067 const char *subject, int subject_len,
3068 struct replay_opts *opts,
3069 int exit_code, int to_amend)
3072 if (make_patch(r, commit, opts))
3074 } else if (copy_file(rebase_path_message(),
3075 git_path_merge_msg(r), 0666))
3076 return error(_("unable to copy '%s' to '%s'"),
3077 git_path_merge_msg(r), rebase_path_message());
3080 if (intend_to_amend())
3084 _("You can amend the commit now, with\n"
3086 " git commit --amend %s\n"
3088 "Once you are satisfied with your changes, run\n"
3090 " git rebase --continue\n"),
3091 gpg_sign_opt_quoted(opts));
3092 } else if (exit_code) {
3094 fprintf_ln(stderr, _("Could not apply %s... %.*s"),
3095 short_commit_name(commit), subject_len, subject);
3098 * We don't have the hash of the parent so
3099 * just print the line from the todo file.
3101 fprintf_ln(stderr, _("Could not merge %.*s"),
3102 subject_len, subject);
3108 static int error_failed_squash(struct repository *r,
3109 struct commit *commit,
3110 struct replay_opts *opts,
3112 const char *subject)
3114 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3115 return error(_("could not copy '%s' to '%s'"),
3116 rebase_path_squash_msg(), rebase_path_message());
3117 unlink(git_path_merge_msg(r));
3118 if (copy_file(git_path_merge_msg(r), rebase_path_message(), 0666))
3119 return error(_("could not copy '%s' to '%s'"),
3120 rebase_path_message(),
3121 git_path_merge_msg(r));
3122 return error_with_patch(r, commit, subject, subject_len, opts, 1, 0);
3125 static int do_exec(struct repository *r, const char *command_line)
3127 struct argv_array child_env = ARGV_ARRAY_INIT;
3128 const char *child_argv[] = { NULL, NULL };
3131 fprintf(stderr, "Executing: %s\n", command_line);
3132 child_argv[0] = command_line;
3133 argv_array_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
3134 argv_array_pushf(&child_env, "GIT_WORK_TREE=%s",
3135 absolute_path(get_git_work_tree()));
3136 status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
3139 /* force re-reading of the cache */
3140 if (discard_index(r->index) < 0 || repo_read_index(r) < 0)
3141 return error(_("could not read index"));
3143 dirty = require_clean_work_tree(r, "rebase", NULL, 1, 1);
3146 warning(_("execution failed: %s\n%s"
3147 "You can fix the problem, and then run\n"
3149 " git rebase --continue\n"
3152 dirty ? N_("and made changes to the index and/or the "
3153 "working tree\n") : "");
3155 /* command not found */
3158 warning(_("execution succeeded: %s\nbut "
3159 "left changes to the index and/or the working tree\n"
3160 "Commit or stash your changes, and then run\n"
3162 " git rebase --continue\n"
3163 "\n"), command_line);
3167 argv_array_clear(&child_env);
3172 static int safe_append(const char *filename, const char *fmt, ...)
3175 struct lock_file lock = LOCK_INIT;
3176 int fd = hold_lock_file_for_update(&lock, filename,
3177 LOCK_REPORT_ON_ERROR);
3178 struct strbuf buf = STRBUF_INIT;
3183 if (strbuf_read_file(&buf, filename, 0) < 0 && errno != ENOENT) {
3184 error_errno(_("could not read '%s'"), filename);
3185 rollback_lock_file(&lock);
3188 strbuf_complete(&buf, '\n');
3190 strbuf_vaddf(&buf, fmt, ap);
3193 if (write_in_full(fd, buf.buf, buf.len) < 0) {
3194 error_errno(_("could not write to '%s'"), filename);
3195 strbuf_release(&buf);
3196 rollback_lock_file(&lock);
3199 if (commit_lock_file(&lock) < 0) {
3200 strbuf_release(&buf);
3201 rollback_lock_file(&lock);
3202 return error(_("failed to finalize '%s'"), filename);
3205 strbuf_release(&buf);
3209 static int do_label(struct repository *r, const char *name, int len)
3211 struct ref_store *refs = get_main_ref_store(r);
3212 struct ref_transaction *transaction;
3213 struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
3214 struct strbuf msg = STRBUF_INIT;
3216 struct object_id head_oid;
3218 if (len == 1 && *name == '#')
3219 return error(_("illegal label name: '%.*s'"), len, name);
3221 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3222 strbuf_addf(&msg, "rebase (label) '%.*s'", len, name);
3224 transaction = ref_store_transaction_begin(refs, &err);
3226 error("%s", err.buf);
3228 } else if (get_oid("HEAD", &head_oid)) {
3229 error(_("could not read HEAD"));
3231 } else if (ref_transaction_update(transaction, ref_name.buf, &head_oid,
3232 NULL, 0, msg.buf, &err) < 0 ||
3233 ref_transaction_commit(transaction, &err)) {
3234 error("%s", err.buf);
3237 ref_transaction_free(transaction);
3238 strbuf_release(&err);
3239 strbuf_release(&msg);
3242 ret = safe_append(rebase_path_refs_to_delete(),
3243 "%s\n", ref_name.buf);
3244 strbuf_release(&ref_name);
3249 static const char *reflog_message(struct replay_opts *opts,
3250 const char *sub_action, const char *fmt, ...);
3252 static int do_reset(struct repository *r,
3253 const char *name, int len,
3254 struct replay_opts *opts)
3256 struct strbuf ref_name = STRBUF_INIT;
3257 struct object_id oid;
3258 struct lock_file lock = LOCK_INIT;
3259 struct tree_desc desc;
3261 struct unpack_trees_options unpack_tree_opts;
3264 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0)
3267 if (len == 10 && !strncmp("[new root]", name, len)) {
3268 if (!opts->have_squash_onto) {
3270 if (commit_tree("", 0, the_hash_algo->empty_tree,
3271 NULL, &opts->squash_onto,
3273 return error(_("writing fake root commit"));
3274 opts->have_squash_onto = 1;
3275 hex = oid_to_hex(&opts->squash_onto);
3276 if (write_message(hex, strlen(hex),
3277 rebase_path_squash_onto(), 0))
3278 return error(_("writing squash-onto"));
3280 oidcpy(&oid, &opts->squash_onto);
3284 /* Determine the length of the label */
3285 for (i = 0; i < len; i++)
3286 if (isspace(name[i]))
3290 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3291 if (get_oid(ref_name.buf, &oid) &&
3292 get_oid(ref_name.buf + strlen("refs/rewritten/"), &oid)) {
3293 error(_("could not read '%s'"), ref_name.buf);
3294 rollback_lock_file(&lock);
3295 strbuf_release(&ref_name);
3300 memset(&unpack_tree_opts, 0, sizeof(unpack_tree_opts));
3301 setup_unpack_trees_porcelain(&unpack_tree_opts, "reset");
3302 unpack_tree_opts.head_idx = 1;
3303 unpack_tree_opts.src_index = r->index;
3304 unpack_tree_opts.dst_index = r->index;
3305 unpack_tree_opts.fn = oneway_merge;
3306 unpack_tree_opts.merge = 1;
3307 unpack_tree_opts.update = 1;
3309 if (repo_read_index_unmerged(r)) {
3310 rollback_lock_file(&lock);
3311 strbuf_release(&ref_name);
3312 return error_resolve_conflict(_(action_name(opts)));
3315 if (!fill_tree_descriptor(r, &desc, &oid)) {
3316 error(_("failed to find tree of %s"), oid_to_hex(&oid));
3317 rollback_lock_file(&lock);
3318 free((void *)desc.buffer);
3319 strbuf_release(&ref_name);
3323 if (unpack_trees(1, &desc, &unpack_tree_opts)) {
3324 rollback_lock_file(&lock);
3325 free((void *)desc.buffer);
3326 strbuf_release(&ref_name);
3330 tree = parse_tree_indirect(&oid);
3331 prime_cache_tree(r, r->index, tree);
3333 if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
3334 ret = error(_("could not write index"));
3335 free((void *)desc.buffer);
3338 ret = update_ref(reflog_message(opts, "reset", "'%.*s'",
3339 len, name), "HEAD", &oid,
3340 NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3342 strbuf_release(&ref_name);
3346 static struct commit *lookup_label(const char *label, int len,
3349 struct commit *commit;
3352 strbuf_addf(buf, "refs/rewritten/%.*s", len, label);
3353 commit = lookup_commit_reference_by_name(buf->buf);
3355 /* fall back to non-rewritten ref or commit */
3356 strbuf_splice(buf, 0, strlen("refs/rewritten/"), "", 0);
3357 commit = lookup_commit_reference_by_name(buf->buf);
3361 error(_("could not resolve '%s'"), buf->buf);
3366 static int do_merge(struct repository *r,
3367 struct commit *commit,
3368 const char *arg, int arg_len,
3369 int flags, struct replay_opts *opts)
3371 int run_commit_flags = (flags & TODO_EDIT_MERGE_MSG) ?
3372 EDIT_MSG | VERIFY_MSG : 0;
3373 struct strbuf ref_name = STRBUF_INIT;
3374 struct commit *head_commit, *merge_commit, *i;
3375 struct commit_list *bases, *j, *reversed = NULL;
3376 struct commit_list *to_merge = NULL, **tail = &to_merge;
3377 const char *strategy = !opts->xopts_nr &&
3378 (!opts->strategy || !strcmp(opts->strategy, "recursive")) ?
3379 NULL : opts->strategy;
3380 struct merge_options o;
3381 int merge_arg_len, oneline_offset, can_fast_forward, ret, k;
3382 static struct lock_file lock;
3385 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0) {
3390 head_commit = lookup_commit_reference_by_name("HEAD");
3392 ret = error(_("cannot merge without a current revision"));
3397 * For octopus merges, the arg starts with the list of revisions to be
3398 * merged. The list is optionally followed by '#' and the oneline.
3400 merge_arg_len = oneline_offset = arg_len;
3401 for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {
3404 if (*p == '#' && (!p[1] || isspace(p[1]))) {
3405 p += 1 + strspn(p + 1, " \t\n");
3406 oneline_offset = p - arg;
3409 k = strcspn(p, " \t\n");
3412 merge_commit = lookup_label(p, k, &ref_name);
3413 if (!merge_commit) {
3414 ret = error(_("unable to parse '%.*s'"), k, p);
3417 tail = &commit_list_insert(merge_commit, tail)->next;
3419 merge_arg_len = p - arg;
3423 ret = error(_("nothing to merge: '%.*s'"), arg_len, arg);
3427 if (opts->have_squash_onto &&
3428 oideq(&head_commit->object.oid, &opts->squash_onto)) {
3430 * When the user tells us to "merge" something into a
3431 * "[new root]", let's simply fast-forward to the merge head.
3433 rollback_lock_file(&lock);
3435 ret = error(_("octopus merge cannot be executed on "
3436 "top of a [new root]"));
3438 ret = fast_forward_to(r, &to_merge->item->object.oid,
3439 &head_commit->object.oid, 0,
3445 const char *encoding = get_commit_output_encoding();
3446 const char *message = logmsg_reencode(commit, NULL, encoding);
3451 ret = error(_("could not get commit message of '%s'"),
3452 oid_to_hex(&commit->object.oid));
3455 write_author_script(message);
3456 find_commit_subject(message, &body);
3458 ret = write_message(body, len, git_path_merge_msg(r), 0);
3459 unuse_commit_buffer(commit, message);
3461 error_errno(_("could not write '%s'"),
3462 git_path_merge_msg(r));
3466 struct strbuf buf = STRBUF_INIT;
3469 strbuf_addf(&buf, "author %s", git_author_info(0));
3470 write_author_script(buf.buf);
3473 if (oneline_offset < arg_len) {
3474 p = arg + oneline_offset;
3475 len = arg_len - oneline_offset;
3477 strbuf_addf(&buf, "Merge %s '%.*s'",
3478 to_merge->next ? "branches" : "branch",
3479 merge_arg_len, arg);
3484 ret = write_message(p, len, git_path_merge_msg(r), 0);
3485 strbuf_release(&buf);
3487 error_errno(_("could not write '%s'"),
3488 git_path_merge_msg(r));
3494 * If HEAD is not identical to the first parent of the original merge
3495 * commit, we cannot fast-forward.
3497 can_fast_forward = opts->allow_ff && commit && commit->parents &&
3498 oideq(&commit->parents->item->object.oid,
3499 &head_commit->object.oid);
3502 * If any merge head is different from the original one, we cannot
3505 if (can_fast_forward) {
3506 struct commit_list *p = commit->parents->next;
3508 for (j = to_merge; j && p; j = j->next, p = p->next)
3509 if (!oideq(&j->item->object.oid,
3510 &p->item->object.oid)) {
3511 can_fast_forward = 0;
3515 * If the number of merge heads differs from the original merge
3516 * commit, we cannot fast-forward.
3519 can_fast_forward = 0;
3522 if (can_fast_forward) {
3523 rollback_lock_file(&lock);
3524 ret = fast_forward_to(r, &commit->object.oid,
3525 &head_commit->object.oid, 0, opts);
3526 if (flags & TODO_EDIT_MERGE_MSG) {
3527 run_commit_flags |= AMEND_MSG;
3528 goto fast_forward_edit;
3533 if (strategy || to_merge->next) {
3535 struct child_process cmd = CHILD_PROCESS_INIT;
3537 if (read_env_script(&cmd.env_array)) {
3538 const char *gpg_opt = gpg_sign_opt_quoted(opts);
3540 ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
3545 argv_array_push(&cmd.args, "merge");
3546 argv_array_push(&cmd.args, "-s");
3548 argv_array_push(&cmd.args, "octopus");
3550 argv_array_push(&cmd.args, strategy);
3551 for (k = 0; k < opts->xopts_nr; k++)
3552 argv_array_pushf(&cmd.args,
3553 "-X%s", opts->xopts[k]);
3555 argv_array_push(&cmd.args, "--no-edit");
3556 argv_array_push(&cmd.args, "--no-ff");
3557 argv_array_push(&cmd.args, "--no-log");
3558 argv_array_push(&cmd.args, "--no-stat");
3559 argv_array_push(&cmd.args, "-F");
3560 argv_array_push(&cmd.args, git_path_merge_msg(r));
3562 argv_array_push(&cmd.args, opts->gpg_sign);
3564 /* Add the tips to be merged */
3565 for (j = to_merge; j; j = j->next)
3566 argv_array_push(&cmd.args,
3567 oid_to_hex(&j->item->object.oid));
3569 strbuf_release(&ref_name);
3570 unlink(git_path_cherry_pick_head(r));
3571 rollback_lock_file(&lock);
3573 rollback_lock_file(&lock);
3574 ret = run_command(&cmd);
3576 /* force re-reading of the cache */
3577 if (!ret && (discard_index(r->index) < 0 ||
3578 repo_read_index(r) < 0))
3579 ret = error(_("could not read index"));
3583 merge_commit = to_merge->item;
3584 bases = get_merge_bases(head_commit, merge_commit);
3585 if (bases && oideq(&merge_commit->object.oid,
3586 &bases->item->object.oid)) {
3588 /* skip merging an ancestor of HEAD */
3592 write_message(oid_to_hex(&merge_commit->object.oid), the_hash_algo->hexsz,
3593 git_path_merge_head(r), 0);
3594 write_message("no-ff", 5, git_path_merge_mode(r), 0);
3596 for (j = bases; j; j = j->next)
3597 commit_list_insert(j->item, &reversed);
3598 free_commit_list(bases);
3601 init_merge_options(&o, r);
3603 o.branch2 = ref_name.buf;
3604 o.buffer_output = 2;
3606 ret = merge_recursive(&o, head_commit, merge_commit, reversed, &i);
3608 fputs(o.obuf.buf, stdout);
3609 strbuf_release(&o.obuf);
3611 error(_("could not even attempt to merge '%.*s'"),
3612 merge_arg_len, arg);
3616 * The return value of merge_recursive() is 1 on clean, and 0 on
3619 * Let's reverse that, so that do_merge() returns 0 upon success and
3620 * 1 upon failed merge (keeping the return value -1 for the cases where
3621 * we will want to reschedule the `merge` command).
3625 if (r->index->cache_changed &&
3626 write_locked_index(r->index, &lock, COMMIT_LOCK)) {
3627 ret = error(_("merge: Unable to write new index file"));
3631 rollback_lock_file(&lock);
3633 repo_rerere(r, opts->allow_rerere_auto);
3636 * In case of problems, we now want to return a positive
3637 * value (a negative one would indicate that the `merge`
3638 * command needs to be rescheduled).
3641 ret = !!run_git_commit(r, git_path_merge_msg(r), opts,
3645 strbuf_release(&ref_name);
3646 rollback_lock_file(&lock);
3647 free_commit_list(to_merge);
3651 static int is_final_fixup(struct todo_list *todo_list)
3653 int i = todo_list->current;
3655 if (!is_fixup(todo_list->items[i].command))
3658 while (++i < todo_list->nr)
3659 if (is_fixup(todo_list->items[i].command))
3661 else if (!is_noop(todo_list->items[i].command))
3666 static enum todo_command peek_command(struct todo_list *todo_list, int offset)
3670 for (i = todo_list->current + offset; i < todo_list->nr; i++)
3671 if (!is_noop(todo_list->items[i].command))
3672 return todo_list->items[i].command;
3677 static int apply_autostash(struct replay_opts *opts)
3679 struct strbuf stash_sha1 = STRBUF_INIT;
3680 struct child_process child = CHILD_PROCESS_INIT;
3683 if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
3684 strbuf_release(&stash_sha1);
3687 strbuf_trim(&stash_sha1);
3690 child.no_stdout = 1;
3691 child.no_stderr = 1;
3692 argv_array_push(&child.args, "stash");
3693 argv_array_push(&child.args, "apply");
3694 argv_array_push(&child.args, stash_sha1.buf);
3695 if (!run_command(&child))
3696 fprintf(stderr, _("Applied autostash.\n"));
3698 struct child_process store = CHILD_PROCESS_INIT;
3701 argv_array_push(&store.args, "stash");
3702 argv_array_push(&store.args, "store");
3703 argv_array_push(&store.args, "-m");
3704 argv_array_push(&store.args, "autostash");
3705 argv_array_push(&store.args, "-q");
3706 argv_array_push(&store.args, stash_sha1.buf);
3707 if (run_command(&store))
3708 ret = error(_("cannot store %s"), stash_sha1.buf);
3711 _("Applying autostash resulted in conflicts.\n"
3712 "Your changes are safe in the stash.\n"
3713 "You can run \"git stash pop\" or"
3714 " \"git stash drop\" at any time.\n"));
3717 strbuf_release(&stash_sha1);
3721 static const char *reflog_message(struct replay_opts *opts,
3722 const char *sub_action, const char *fmt, ...)
3725 static struct strbuf buf = STRBUF_INIT;
3729 strbuf_addstr(&buf, action_name(opts));
3731 strbuf_addf(&buf, " (%s)", sub_action);
3733 strbuf_addstr(&buf, ": ");
3734 strbuf_vaddf(&buf, fmt, ap);
3741 static int run_git_checkout(struct repository *r, struct replay_opts *opts,
3742 const char *commit, const char *action)
3744 struct child_process cmd = CHILD_PROCESS_INIT;
3749 argv_array_push(&cmd.args, "checkout");
3750 argv_array_push(&cmd.args, commit);
3751 argv_array_pushf(&cmd.env_array, GIT_REFLOG_ACTION "=%s", action);
3754 ret = run_command(&cmd);
3756 ret = run_command_silent_on_success(&cmd);
3759 discard_index(r->index);
3764 static int checkout_onto(struct repository *r, struct replay_opts *opts,
3765 const char *onto_name, const struct object_id *onto,
3766 const char *orig_head)
3768 struct object_id oid;
3769 const char *action = reflog_message(opts, "start", "checkout %s", onto_name);
3771 if (get_oid(orig_head, &oid))
3772 return error(_("%s: not a valid OID"), orig_head);
3774 if (run_git_checkout(r, opts, oid_to_hex(onto), action)) {
3775 apply_autostash(opts);
3776 sequencer_remove_state(opts);
3777 return error(_("could not detach HEAD"));
3780 return update_ref(NULL, "ORIG_HEAD", &oid, NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3783 static int stopped_at_head(struct repository *r)
3785 struct object_id head;
3786 struct commit *commit;
3787 struct commit_message message;
3789 if (get_oid("HEAD", &head) ||
3790 !(commit = lookup_commit(r, &head)) ||
3791 parse_commit(commit) || get_message(commit, &message))
3792 fprintf(stderr, _("Stopped at HEAD\n"));
3794 fprintf(stderr, _("Stopped at %s\n"), message.label);
3795 free_message(commit, &message);
3801 static const char rescheduled_advice[] =
3802 N_("Could not execute the todo command\n"
3806 "It has been rescheduled; To edit the command before continuing, please\n"
3807 "edit the todo list first:\n"
3809 " git rebase --edit-todo\n"
3810 " git rebase --continue\n");
3812 static int pick_commits(struct repository *r,
3813 struct todo_list *todo_list,
3814 struct replay_opts *opts)
3816 int res = 0, reschedule = 0;
3818 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
3820 assert(!(opts->signoff || opts->no_commit ||
3821 opts->record_origin || opts->edit));
3822 if (read_and_refresh_cache(r, opts))
3825 while (todo_list->current < todo_list->nr) {
3826 struct todo_item *item = todo_list->items + todo_list->current;
3827 const char *arg = todo_item_get_arg(todo_list, item);
3830 if (save_todo(todo_list, opts))
3832 if (is_rebase_i(opts)) {
3833 if (item->command != TODO_COMMENT) {
3834 FILE *f = fopen(rebase_path_msgnum(), "w");
3836 todo_list->done_nr++;
3839 fprintf(f, "%d\n", todo_list->done_nr);
3843 fprintf(stderr, "Rebasing (%d/%d)%s",
3845 todo_list->total_nr,
3846 opts->verbose ? "\n" : "\r");
3848 unlink(rebase_path_message());
3849 unlink(rebase_path_author_script());
3850 unlink(rebase_path_stopped_sha());
3851 unlink(rebase_path_amend());
3852 unlink(git_path_merge_head(r));
3853 delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
3855 if (item->command == TODO_BREAK) {
3858 return stopped_at_head(r);
3861 if (item->command <= TODO_SQUASH) {
3862 if (is_rebase_i(opts))
3863 setenv("GIT_REFLOG_ACTION", reflog_message(opts,
3864 command_to_string(item->command), NULL),
3866 res = do_pick_commit(r, item->command, item->commit,
3867 opts, is_final_fixup(todo_list),
3869 if (is_rebase_i(opts) && res < 0) {
3871 advise(_(rescheduled_advice),
3872 get_item_line_length(todo_list,
3873 todo_list->current),
3874 get_item_line(todo_list,
3875 todo_list->current));
3876 todo_list->current--;
3877 if (save_todo(todo_list, opts))
3880 if (item->command == TODO_EDIT) {
3881 struct commit *commit = item->commit;
3886 _("Stopped at %s... %.*s\n"),
3887 short_commit_name(commit),
3888 item->arg_len, arg);
3890 return error_with_patch(r, commit,
3891 arg, item->arg_len, opts, res, !res);
3893 if (is_rebase_i(opts) && !res)
3894 record_in_rewritten(&item->commit->object.oid,
3895 peek_command(todo_list, 1));
3896 if (res && is_fixup(item->command)) {
3899 return error_failed_squash(r, item->commit, opts,
3900 item->arg_len, arg);
3901 } else if (res && is_rebase_i(opts) && item->commit) {
3903 struct object_id oid;
3906 * If we are rewording and have either
3907 * fast-forwarded already, or are about to
3908 * create a new root commit, we want to amend,
3909 * otherwise we do not.
3911 if (item->command == TODO_REWORD &&
3912 !get_oid("HEAD", &oid) &&
3913 (oideq(&item->commit->object.oid, &oid) ||
3914 (opts->have_squash_onto &&
3915 oideq(&opts->squash_onto, &oid))))
3918 return res | error_with_patch(r, item->commit,
3919 arg, item->arg_len, opts,
3922 } else if (item->command == TODO_EXEC) {
3923 char *end_of_arg = (char *)(arg + item->arg_len);
3924 int saved = *end_of_arg;
3929 res = do_exec(r, arg);
3930 *end_of_arg = saved;
3933 if (opts->reschedule_failed_exec)
3937 } else if (item->command == TODO_LABEL) {
3938 if ((res = do_label(r, arg, item->arg_len)))
3940 } else if (item->command == TODO_RESET) {
3941 if ((res = do_reset(r, arg, item->arg_len, opts)))
3943 } else if (item->command == TODO_MERGE) {
3944 if ((res = do_merge(r, item->commit,
3946 item->flags, opts)) < 0)
3948 else if (item->commit)
3949 record_in_rewritten(&item->commit->object.oid,
3950 peek_command(todo_list, 1));
3952 /* failed with merge conflicts */
3953 return error_with_patch(r, item->commit,
3956 } else if (!is_noop(item->command))
3957 return error(_("unknown command %d"), item->command);
3960 advise(_(rescheduled_advice),
3961 get_item_line_length(todo_list,
3962 todo_list->current),
3963 get_item_line(todo_list, todo_list->current));
3964 todo_list->current--;
3965 if (save_todo(todo_list, opts))
3968 return error_with_patch(r,
3972 } else if (is_rebase_i(opts) && check_todo && !res) {
3975 if (stat(get_todo_path(opts), &st)) {
3976 res = error_errno(_("could not stat '%s'"),
3977 get_todo_path(opts));
3978 } else if (match_stat_data(&todo_list->stat, &st)) {
3979 /* Reread the todo file if it has changed. */
3980 todo_list_release(todo_list);
3981 if (read_populate_todo(r, todo_list, opts))
3982 res = -1; /* message was printed */
3983 /* `current` will be incremented below */
3984 todo_list->current = -1;
3988 todo_list->current++;
3993 if (is_rebase_i(opts)) {
3994 struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
3997 /* Stopped in the middle, as planned? */
3998 if (todo_list->current < todo_list->nr)
4001 if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
4002 starts_with(head_ref.buf, "refs/")) {
4004 struct object_id head, orig;
4007 if (get_oid("HEAD", &head)) {
4008 res = error(_("cannot read HEAD"));
4010 strbuf_release(&head_ref);
4011 strbuf_release(&buf);
4014 if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
4015 get_oid_hex(buf.buf, &orig)) {
4016 res = error(_("could not read orig-head"));
4017 goto cleanup_head_ref;
4020 if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
4021 res = error(_("could not read 'onto'"));
4022 goto cleanup_head_ref;
4024 msg = reflog_message(opts, "finish", "%s onto %s",
4025 head_ref.buf, buf.buf);
4026 if (update_ref(msg, head_ref.buf, &head, &orig,
4027 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
4028 res = error(_("could not update %s"),
4030 goto cleanup_head_ref;
4032 msg = reflog_message(opts, "finish", "returning to %s",
4034 if (create_symref("HEAD", head_ref.buf, msg)) {
4035 res = error(_("could not update HEAD to %s"),
4037 goto cleanup_head_ref;
4042 if (opts->verbose) {
4043 struct rev_info log_tree_opt;
4044 struct object_id orig, head;
4046 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
4047 repo_init_revisions(r, &log_tree_opt, NULL);
4048 log_tree_opt.diff = 1;
4049 log_tree_opt.diffopt.output_format =
4050 DIFF_FORMAT_DIFFSTAT;
4051 log_tree_opt.disable_stdin = 1;
4053 if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
4054 !get_oid(buf.buf, &orig) &&
4055 !get_oid("HEAD", &head)) {
4056 diff_tree_oid(&orig, &head, "",
4057 &log_tree_opt.diffopt);
4058 log_tree_diff_flush(&log_tree_opt);
4061 flush_rewritten_pending();
4062 if (!stat(rebase_path_rewritten_list(), &st) &&
4064 struct child_process child = CHILD_PROCESS_INIT;
4065 const char *post_rewrite_hook =
4066 find_hook("post-rewrite");
4068 child.in = open(rebase_path_rewritten_list(), O_RDONLY);
4070 argv_array_push(&child.args, "notes");
4071 argv_array_push(&child.args, "copy");
4072 argv_array_push(&child.args, "--for-rewrite=rebase");
4073 /* we don't care if this copying failed */
4074 run_command(&child);
4076 if (post_rewrite_hook) {
4077 struct child_process hook = CHILD_PROCESS_INIT;
4079 hook.in = open(rebase_path_rewritten_list(),
4081 hook.stdout_to_stderr = 1;
4082 hook.trace2_hook_name = "post-rewrite";
4083 argv_array_push(&hook.args, post_rewrite_hook);
4084 argv_array_push(&hook.args, "rebase");
4085 /* we don't care if this hook failed */
4089 apply_autostash(opts);
4095 "Successfully rebased and updated %s.\n",
4099 strbuf_release(&buf);
4100 strbuf_release(&head_ref);
4104 * Sequence of picks finished successfully; cleanup by
4105 * removing the .git/sequencer directory
4107 return sequencer_remove_state(opts);
4110 static int continue_single_pick(struct repository *r)
4112 const char *argv[] = { "commit", NULL };
4114 if (!file_exists(git_path_cherry_pick_head(r)) &&
4115 !file_exists(git_path_revert_head(r)))
4116 return error(_("no cherry-pick or revert in progress"));
4117 return run_command_v_opt(argv, RUN_GIT_CMD);
4120 static int commit_staged_changes(struct repository *r,
4121 struct replay_opts *opts,
4122 struct todo_list *todo_list)
4124 unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
4125 unsigned int final_fixup = 0, is_clean;
4127 if (has_unstaged_changes(r, 1))
4128 return error(_("cannot rebase: You have unstaged changes."));
4130 is_clean = !has_uncommitted_changes(r, 0);
4132 if (file_exists(rebase_path_amend())) {
4133 struct strbuf rev = STRBUF_INIT;
4134 struct object_id head, to_amend;
4136 if (get_oid("HEAD", &head))
4137 return error(_("cannot amend non-existing commit"));
4138 if (!read_oneliner(&rev, rebase_path_amend(), 0))
4139 return error(_("invalid file: '%s'"), rebase_path_amend());
4140 if (get_oid_hex(rev.buf, &to_amend))
4141 return error(_("invalid contents: '%s'"),
4142 rebase_path_amend());
4143 if (!is_clean && !oideq(&head, &to_amend))
4144 return error(_("\nYou have uncommitted changes in your "
4145 "working tree. Please, commit them\n"
4146 "first and then run 'git rebase "
4147 "--continue' again."));
4149 * When skipping a failed fixup/squash, we need to edit the
4150 * commit message, the current fixup list and count, and if it
4151 * was the last fixup/squash in the chain, we need to clean up
4152 * the commit message and if there was a squash, let the user
4155 if (!is_clean || !opts->current_fixup_count)
4156 ; /* this is not the final fixup */
4157 else if (!oideq(&head, &to_amend) ||
4158 !file_exists(rebase_path_stopped_sha())) {
4159 /* was a final fixup or squash done manually? */
4160 if (!is_fixup(peek_command(todo_list, 0))) {
4161 unlink(rebase_path_fixup_msg());
4162 unlink(rebase_path_squash_msg());
4163 unlink(rebase_path_current_fixups());
4164 strbuf_reset(&opts->current_fixups);
4165 opts->current_fixup_count = 0;
4168 /* we are in a fixup/squash chain */
4169 const char *p = opts->current_fixups.buf;
4170 int len = opts->current_fixups.len;
4172 opts->current_fixup_count--;
4174 BUG("Incorrect current_fixups:\n%s", p);
4175 while (len && p[len - 1] != '\n')
4177 strbuf_setlen(&opts->current_fixups, len);
4178 if (write_message(p, len, rebase_path_current_fixups(),
4180 return error(_("could not write file: '%s'"),
4181 rebase_path_current_fixups());
4184 * If a fixup/squash in a fixup/squash chain failed, the
4185 * commit message is already correct, no need to commit
4188 * Only if it is the final command in the fixup/squash
4189 * chain, and only if the chain is longer than a single
4190 * fixup/squash command (which was just skipped), do we
4191 * actually need to re-commit with a cleaned up commit
4194 if (opts->current_fixup_count > 0 &&
4195 !is_fixup(peek_command(todo_list, 0))) {
4198 * If there was not a single "squash" in the
4199 * chain, we only need to clean up the commit
4200 * message, no need to bother the user with
4201 * opening the commit message in the editor.
4203 if (!starts_with(p, "squash ") &&
4204 !strstr(p, "\nsquash "))
4205 flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;
4206 } else if (is_fixup(peek_command(todo_list, 0))) {
4208 * We need to update the squash message to skip
4209 * the latest commit message.
4211 struct commit *commit;
4212 const char *path = rebase_path_squash_msg();
4213 const char *encoding = get_commit_output_encoding();
4215 if (parse_head(r, &commit) ||
4216 !(p = logmsg_reencode(commit, NULL, encoding)) ||
4217 write_message(p, strlen(p), path, 0)) {
4218 unuse_commit_buffer(commit, p);
4219 return error(_("could not write file: "
4222 unuse_commit_buffer(commit, p);
4226 strbuf_release(&rev);
4231 const char *cherry_pick_head = git_path_cherry_pick_head(r);
4233 if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
4234 return error(_("could not remove CHERRY_PICK_HEAD"));
4239 if (run_git_commit(r, final_fixup ? NULL : rebase_path_message(),
4241 return error(_("could not commit staged changes."));
4242 unlink(rebase_path_amend());
4243 unlink(git_path_merge_head(r));
4245 unlink(rebase_path_fixup_msg());
4246 unlink(rebase_path_squash_msg());
4248 if (opts->current_fixup_count > 0) {
4250 * Whether final fixup or not, we just cleaned up the commit
4253 unlink(rebase_path_current_fixups());
4254 strbuf_reset(&opts->current_fixups);
4255 opts->current_fixup_count = 0;
4260 int sequencer_continue(struct repository *r, struct replay_opts *opts)
4262 struct todo_list todo_list = TODO_LIST_INIT;
4265 if (read_and_refresh_cache(r, opts))
4268 if (read_populate_opts(opts))
4270 if (is_rebase_i(opts)) {
4271 if ((res = read_populate_todo(r, &todo_list, opts)))
4272 goto release_todo_list;
4274 if (file_exists(rebase_path_dropped())) {
4275 if ((res = todo_list_check_against_backup(r, &todo_list)))
4276 goto release_todo_list;
4278 unlink(rebase_path_dropped());
4281 if (commit_staged_changes(r, opts, &todo_list)) {
4283 goto release_todo_list;
4285 } else if (!file_exists(get_todo_path(opts)))
4286 return continue_single_pick(r);
4287 else if ((res = read_populate_todo(r, &todo_list, opts)))
4288 goto release_todo_list;
4290 if (!is_rebase_i(opts)) {
4291 /* Verify that the conflict has been resolved */
4292 if (file_exists(git_path_cherry_pick_head(r)) ||
4293 file_exists(git_path_revert_head(r))) {
4294 res = continue_single_pick(r);
4296 goto release_todo_list;
4298 if (index_differs_from(r, "HEAD", NULL, 0)) {
4299 res = error_dirty_index(r, opts);
4300 goto release_todo_list;
4302 todo_list.current++;
4303 } else if (file_exists(rebase_path_stopped_sha())) {
4304 struct strbuf buf = STRBUF_INIT;
4305 struct object_id oid;
4307 if (read_oneliner(&buf, rebase_path_stopped_sha(), 1) &&
4308 !get_oid_committish(buf.buf, &oid))
4309 record_in_rewritten(&oid, peek_command(&todo_list, 0));
4310 strbuf_release(&buf);
4313 res = pick_commits(r, &todo_list, opts);
4315 todo_list_release(&todo_list);
4319 static int single_pick(struct repository *r,
4320 struct commit *cmit,
4321 struct replay_opts *opts)
4325 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
4326 return do_pick_commit(r, opts->action == REPLAY_PICK ?
4327 TODO_PICK : TODO_REVERT, cmit, opts, 0,
4331 int sequencer_pick_revisions(struct repository *r,
4332 struct replay_opts *opts)
4334 struct todo_list todo_list = TODO_LIST_INIT;
4335 struct object_id oid;
4339 if (read_and_refresh_cache(r, opts))
4342 for (i = 0; i < opts->revs->pending.nr; i++) {
4343 struct object_id oid;
4344 const char *name = opts->revs->pending.objects[i].name;
4346 /* This happens when using --stdin. */
4350 if (!get_oid(name, &oid)) {
4351 if (!lookup_commit_reference_gently(r, &oid, 1)) {
4352 enum object_type type = oid_object_info(r,
4355 return error(_("%s: can't cherry-pick a %s"),
4356 name, type_name(type));
4359 return error(_("%s: bad revision"), name);
4363 * If we were called as "git cherry-pick <commit>", just
4364 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4365 * REVERT_HEAD, and don't touch the sequencer state.
4366 * This means it is possible to cherry-pick in the middle
4367 * of a cherry-pick sequence.
4369 if (opts->revs->cmdline.nr == 1 &&
4370 opts->revs->cmdline.rev->whence == REV_CMD_REV &&
4371 opts->revs->no_walk &&
4372 !opts->revs->cmdline.rev->flags) {
4373 struct commit *cmit;
4374 if (prepare_revision_walk(opts->revs))
4375 return error(_("revision walk setup failed"));
4376 cmit = get_revision(opts->revs);
4378 return error(_("empty commit set passed"));
4379 if (get_revision(opts->revs))
4380 BUG("unexpected extra commit from walk");
4381 return single_pick(r, cmit, opts);
4385 * Start a new cherry-pick/ revert sequence; but
4386 * first, make sure that an existing one isn't in
4390 if (walk_revs_populate_todo(&todo_list, opts) ||
4391 create_seq_dir(r) < 0)
4393 if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
4394 return error(_("can't revert as initial commit"));
4395 if (save_head(oid_to_hex(&oid)))
4397 if (save_opts(opts))
4399 update_abort_safety_file();
4400 res = pick_commits(r, &todo_list, opts);
4401 todo_list_release(&todo_list);
4405 void append_signoff(struct strbuf *msgbuf, size_t ignore_footer, unsigned flag)
4407 unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
4408 struct strbuf sob = STRBUF_INIT;
4411 strbuf_addstr(&sob, sign_off_header);
4412 strbuf_addstr(&sob, fmt_name(WANT_COMMITTER_IDENT));
4413 strbuf_addch(&sob, '\n');
4416 strbuf_complete_line(msgbuf);
4419 * If the whole message buffer is equal to the sob, pretend that we
4420 * found a conforming footer with a matching sob
4422 if (msgbuf->len - ignore_footer == sob.len &&
4423 !strncmp(msgbuf->buf, sob.buf, sob.len))
4426 has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
4429 const char *append_newlines = NULL;
4430 size_t len = msgbuf->len - ignore_footer;
4434 * The buffer is completely empty. Leave foom for
4435 * the title and body to be filled in by the user.
4437 append_newlines = "\n\n";
4438 } else if (len == 1) {
4440 * Buffer contains a single newline. Add another
4441 * so that we leave room for the title and body.
4443 append_newlines = "\n";
4444 } else if (msgbuf->buf[len - 2] != '\n') {
4446 * Buffer ends with a single newline. Add another
4447 * so that there is an empty line between the message
4450 append_newlines = "\n";
4451 } /* else, the buffer already ends with two newlines. */
4453 if (append_newlines)
4454 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4455 append_newlines, strlen(append_newlines));
4458 if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
4459 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4462 strbuf_release(&sob);
4465 struct labels_entry {
4466 struct hashmap_entry entry;
4467 char label[FLEX_ARRAY];
4470 static int labels_cmp(const void *fndata, const struct hashmap_entry *eptr,
4471 const struct hashmap_entry *entry_or_key, const void *key)
4473 const struct labels_entry *a, *b;
4475 a = container_of(eptr, const struct labels_entry, entry);
4476 b = container_of(entry_or_key, const struct labels_entry, entry);
4478 return key ? strcmp(a->label, key) : strcmp(a->label, b->label);
4481 struct string_entry {
4482 struct oidmap_entry entry;
4483 char string[FLEX_ARRAY];
4486 struct label_state {
4487 struct oidmap commit2label;
4488 struct hashmap labels;
4492 static const char *label_oid(struct object_id *oid, const char *label,
4493 struct label_state *state)
4495 struct labels_entry *labels_entry;
4496 struct string_entry *string_entry;
4497 struct object_id dummy;
4500 string_entry = oidmap_get(&state->commit2label, oid);
4502 return string_entry->string;
4505 * For "uninteresting" commits, i.e. commits that are not to be
4506 * rebased, and which can therefore not be labeled, we use a unique
4507 * abbreviation of the commit name. This is slightly more complicated
4508 * than calling find_unique_abbrev() because we also need to make
4509 * sure that the abbreviation does not conflict with any other
4512 * We disallow "interesting" commits to be labeled by a string that
4513 * is a valid full-length hash, to ensure that we always can find an
4514 * abbreviation for any uninteresting commit's names that does not
4515 * clash with any other label.
4517 strbuf_reset(&state->buf);
4521 strbuf_grow(&state->buf, GIT_MAX_HEXSZ);
4522 label = p = state->buf.buf;
4524 find_unique_abbrev_r(p, oid, default_abbrev);
4527 * We may need to extend the abbreviated hash so that there is
4528 * no conflicting label.
4530 if (hashmap_get_from_hash(&state->labels, strihash(p), p)) {
4531 size_t i = strlen(p) + 1;
4533 oid_to_hex_r(p, oid);
4534 for (; i < the_hash_algo->hexsz; i++) {
4537 if (!hashmap_get_from_hash(&state->labels,
4544 struct strbuf *buf = &state->buf;
4547 * Sanitize labels by replacing non-alpha-numeric characters
4548 * (including white-space ones) by dashes, as they might be
4549 * illegal in file names (and hence in ref names).
4551 * Note that we retain non-ASCII UTF-8 characters (identified
4552 * via the most significant bit). They should be all acceptable
4553 * in file names. We do not validate the UTF-8 here, that's not
4554 * the job of this function.
4556 for (; *label; label++)
4557 if ((*label & 0x80) || isalnum(*label))
4558 strbuf_addch(buf, *label);
4559 /* avoid leading dash and double-dashes */
4560 else if (buf->len && buf->buf[buf->len - 1] != '-')
4561 strbuf_addch(buf, '-');
4563 strbuf_addstr(buf, "rev-");
4564 strbuf_add_unique_abbrev(buf, oid, default_abbrev);
4568 if ((buf->len == the_hash_algo->hexsz &&
4569 !get_oid_hex(label, &dummy)) ||
4570 (buf->len == 1 && *label == '#') ||
4571 hashmap_get_from_hash(&state->labels,
4572 strihash(label), label)) {
4574 * If the label already exists, or if the label is a
4575 * valid full OID, or the label is a '#' (which we use
4576 * as a separator between merge heads and oneline), we
4577 * append a dash and a number to make it unique.
4579 size_t len = buf->len;
4581 for (i = 2; ; i++) {
4582 strbuf_setlen(buf, len);
4583 strbuf_addf(buf, "-%d", i);
4584 if (!hashmap_get_from_hash(&state->labels,
4594 FLEX_ALLOC_STR(labels_entry, label, label);
4595 hashmap_entry_init(&labels_entry->entry, strihash(label));
4596 hashmap_add(&state->labels, &labels_entry->entry);
4598 FLEX_ALLOC_STR(string_entry, string, label);
4599 oidcpy(&string_entry->entry.oid, oid);
4600 oidmap_put(&state->commit2label, string_entry);
4602 return string_entry->string;
4605 static int make_script_with_merges(struct pretty_print_context *pp,
4606 struct rev_info *revs, struct strbuf *out,
4609 int rebase_cousins = flags & TODO_LIST_REBASE_COUSINS;
4610 int root_with_onto = flags & TODO_LIST_ROOT_WITH_ONTO;
4611 struct strbuf buf = STRBUF_INIT, oneline = STRBUF_INIT;
4612 struct strbuf label = STRBUF_INIT;
4613 struct commit_list *commits = NULL, **tail = &commits, *iter;
4614 struct commit_list *tips = NULL, **tips_tail = &tips;
4615 struct commit *commit;
4616 struct oidmap commit2todo = OIDMAP_INIT;
4617 struct string_entry *entry;
4618 struct oidset interesting = OIDSET_INIT, child_seen = OIDSET_INIT,
4619 shown = OIDSET_INIT;
4620 struct label_state state = { OIDMAP_INIT, { NULL }, STRBUF_INIT };
4622 int abbr = flags & TODO_LIST_ABBREVIATE_CMDS;
4623 const char *cmd_pick = abbr ? "p" : "pick",
4624 *cmd_label = abbr ? "l" : "label",
4625 *cmd_reset = abbr ? "t" : "reset",
4626 *cmd_merge = abbr ? "m" : "merge";
4628 oidmap_init(&commit2todo, 0);
4629 oidmap_init(&state.commit2label, 0);
4630 hashmap_init(&state.labels, labels_cmp, NULL, 0);
4631 strbuf_init(&state.buf, 32);
4633 if (revs->cmdline.nr && (revs->cmdline.rev[0].flags & BOTTOM)) {
4634 struct labels_entry *onto_label_entry;
4635 struct object_id *oid = &revs->cmdline.rev[0].item->oid;
4636 FLEX_ALLOC_STR(entry, string, "onto");
4637 oidcpy(&entry->entry.oid, oid);
4638 oidmap_put(&state.commit2label, entry);
4640 FLEX_ALLOC_STR(onto_label_entry, label, "onto");
4641 hashmap_entry_init(&onto_label_entry->entry, strihash("onto"));
4642 hashmap_add(&state.labels, &onto_label_entry->entry);
4647 * - get onelines for all commits
4648 * - gather all branch tips (i.e. 2nd or later parents of merges)
4649 * - label all branch tips
4651 while ((commit = get_revision(revs))) {
4652 struct commit_list *to_merge;
4653 const char *p1, *p2;
4654 struct object_id *oid;
4657 tail = &commit_list_insert(commit, tail)->next;
4658 oidset_insert(&interesting, &commit->object.oid);
4660 is_empty = is_original_commit_empty(commit);
4661 if (!is_empty && (commit->object.flags & PATCHSAME))
4664 strbuf_reset(&oneline);
4665 pretty_print_commit(pp, commit, &oneline);
4667 to_merge = commit->parents ? commit->parents->next : NULL;
4669 /* non-merge commit: easy case */
4671 strbuf_addf(&buf, "%s %s %s", cmd_pick,
4672 oid_to_hex(&commit->object.oid),
4675 FLEX_ALLOC_STR(entry, string, buf.buf);
4676 oidcpy(&entry->entry.oid, &commit->object.oid);
4677 oidmap_put(&commit2todo, entry);
4682 /* Create a label */
4683 strbuf_reset(&label);
4684 if (skip_prefix(oneline.buf, "Merge ", &p1) &&
4685 (p1 = strchr(p1, '\'')) &&
4686 (p2 = strchr(++p1, '\'')))
4687 strbuf_add(&label, p1, p2 - p1);
4688 else if (skip_prefix(oneline.buf, "Merge pull request ",
4690 (p1 = strstr(p1, " from ")))
4691 strbuf_addstr(&label, p1 + strlen(" from "));
4693 strbuf_addbuf(&label, &oneline);
4696 strbuf_addf(&buf, "%s -C %s",
4697 cmd_merge, oid_to_hex(&commit->object.oid));
4699 /* label the tips of merged branches */
4700 for (; to_merge; to_merge = to_merge->next) {
4701 oid = &to_merge->item->object.oid;
4702 strbuf_addch(&buf, ' ');
4704 if (!oidset_contains(&interesting, oid)) {
4705 strbuf_addstr(&buf, label_oid(oid, NULL,
4710 tips_tail = &commit_list_insert(to_merge->item,
4713 strbuf_addstr(&buf, label_oid(oid, label.buf, &state));
4715 strbuf_addf(&buf, " # %s", oneline.buf);
4717 FLEX_ALLOC_STR(entry, string, buf.buf);
4718 oidcpy(&entry->entry.oid, &commit->object.oid);
4719 oidmap_put(&commit2todo, entry);
4724 * - label branch points
4725 * - add HEAD to the branch tips
4727 for (iter = commits; iter; iter = iter->next) {
4728 struct commit_list *parent = iter->item->parents;
4729 for (; parent; parent = parent->next) {
4730 struct object_id *oid = &parent->item->object.oid;
4731 if (!oidset_contains(&interesting, oid))
4733 if (oidset_insert(&child_seen, oid))
4734 label_oid(oid, "branch-point", &state);
4737 /* Add HEAD as implicit "tip of branch" */
4739 tips_tail = &commit_list_insert(iter->item,
4744 * Third phase: output the todo list. This is a bit tricky, as we
4745 * want to avoid jumping back and forth between revisions. To
4746 * accomplish that goal, we walk backwards from the branch tips,
4747 * gathering commits not yet shown, reversing the list on the fly,
4748 * then outputting that list (labeling revisions as needed).
4750 strbuf_addf(out, "%s onto\n", cmd_label);
4751 for (iter = tips; iter; iter = iter->next) {
4752 struct commit_list *list = NULL, *iter2;
4754 commit = iter->item;
4755 if (oidset_contains(&shown, &commit->object.oid))
4757 entry = oidmap_get(&state.commit2label, &commit->object.oid);
4760 strbuf_addf(out, "\n%c Branch %s\n", comment_line_char, entry->string);
4762 strbuf_addch(out, '\n');
4764 while (oidset_contains(&interesting, &commit->object.oid) &&
4765 !oidset_contains(&shown, &commit->object.oid)) {
4766 commit_list_insert(commit, &list);
4767 if (!commit->parents) {
4771 commit = commit->parents->item;
4775 strbuf_addf(out, "%s %s\n", cmd_reset,
4776 rebase_cousins || root_with_onto ?
4777 "onto" : "[new root]");
4779 const char *to = NULL;
4781 entry = oidmap_get(&state.commit2label,
4782 &commit->object.oid);
4785 else if (!rebase_cousins)
4786 to = label_oid(&commit->object.oid, NULL,
4789 if (!to || !strcmp(to, "onto"))
4790 strbuf_addf(out, "%s onto\n", cmd_reset);
4792 strbuf_reset(&oneline);
4793 pretty_print_commit(pp, commit, &oneline);
4794 strbuf_addf(out, "%s %s # %s\n",
4795 cmd_reset, to, oneline.buf);
4799 for (iter2 = list; iter2; iter2 = iter2->next) {
4800 struct object_id *oid = &iter2->item->object.oid;
4801 entry = oidmap_get(&commit2todo, oid);
4802 /* only show if not already upstream */
4804 strbuf_addf(out, "%s\n", entry->string);
4805 entry = oidmap_get(&state.commit2label, oid);
4807 strbuf_addf(out, "%s %s\n",
4808 cmd_label, entry->string);
4809 oidset_insert(&shown, oid);
4812 free_commit_list(list);
4815 free_commit_list(commits);
4816 free_commit_list(tips);
4818 strbuf_release(&label);
4819 strbuf_release(&oneline);
4820 strbuf_release(&buf);
4822 oidmap_free(&commit2todo, 1);
4823 oidmap_free(&state.commit2label, 1);
4824 hashmap_free_entries(&state.labels, struct labels_entry, entry);
4825 strbuf_release(&state.buf);
4830 int sequencer_make_script(struct repository *r, struct strbuf *out, int argc,
4831 const char **argv, unsigned flags)
4833 char *format = NULL;
4834 struct pretty_print_context pp = {0};
4835 struct rev_info revs;
4836 struct commit *commit;
4837 const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";
4838 int rebase_merges = flags & TODO_LIST_REBASE_MERGES;
4840 repo_init_revisions(r, &revs, NULL);
4841 revs.verbose_header = 1;
4843 revs.max_parents = 1;
4844 revs.cherry_mark = 1;
4847 revs.right_only = 1;
4848 revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
4849 revs.topo_order = 1;
4851 revs.pretty_given = 1;
4852 git_config_get_string("rebase.instructionFormat", &format);
4853 if (!format || !*format) {
4855 format = xstrdup("%s");
4857 get_commit_format(format, &revs);
4859 pp.fmt = revs.commit_format;
4860 pp.output_encoding = get_log_output_encoding();
4862 if (setup_revisions(argc, argv, &revs, NULL) > 1)
4863 return error(_("make_script: unhandled options"));
4865 if (prepare_revision_walk(&revs) < 0)
4866 return error(_("make_script: error preparing revisions"));
4869 return make_script_with_merges(&pp, &revs, out, flags);
4871 while ((commit = get_revision(&revs))) {
4872 int is_empty = is_original_commit_empty(commit);
4874 if (!is_empty && (commit->object.flags & PATCHSAME))
4876 strbuf_addf(out, "%s %s ", insn,
4877 oid_to_hex(&commit->object.oid));
4878 pretty_print_commit(&pp, commit, out);
4879 strbuf_addch(out, '\n');
4885 * Add commands after pick and (series of) squash/fixup commands
4888 void todo_list_add_exec_commands(struct todo_list *todo_list,
4889 struct string_list *commands)
4891 struct strbuf *buf = &todo_list->buf;
4892 size_t base_offset = buf->len;
4893 int i, insert, nr = 0, alloc = 0;
4894 struct todo_item *items = NULL, *base_items = NULL;
4896 base_items = xcalloc(commands->nr, sizeof(struct todo_item));
4897 for (i = 0; i < commands->nr; i++) {
4898 size_t command_len = strlen(commands->items[i].string);
4900 strbuf_addstr(buf, commands->items[i].string);
4901 strbuf_addch(buf, '\n');
4903 base_items[i].command = TODO_EXEC;
4904 base_items[i].offset_in_buf = base_offset;
4905 base_items[i].arg_offset = base_offset + strlen("exec ");
4906 base_items[i].arg_len = command_len - strlen("exec ");
4908 base_offset += command_len + 1;
4912 * Insert <commands> after every pick. Here, fixup/squash chains
4913 * are considered part of the pick, so we insert the commands *after*
4914 * those chains if there are any.
4916 * As we insert the exec commands immediately after rearranging
4917 * any fixups and before the user edits the list, a fixup chain
4918 * can never contain comments (any comments are empty picks that
4919 * have been commented out because the user did not specify
4920 * --keep-empty). So, it is safe to insert an exec command
4921 * without looking at the command following a comment.
4924 for (i = 0; i < todo_list->nr; i++) {
4925 enum todo_command command = todo_list->items[i].command;
4926 if (insert && !is_fixup(command)) {
4927 ALLOC_GROW(items, nr + commands->nr, alloc);
4928 COPY_ARRAY(items + nr, base_items, commands->nr);
4934 ALLOC_GROW(items, nr + 1, alloc);
4935 items[nr++] = todo_list->items[i];
4937 if (command == TODO_PICK || command == TODO_MERGE)
4941 /* insert or append final <commands> */
4942 if (insert || nr == todo_list->nr) {
4943 ALLOC_GROW(items, nr + commands->nr, alloc);
4944 COPY_ARRAY(items + nr, base_items, commands->nr);
4949 FREE_AND_NULL(todo_list->items);
4950 todo_list->items = items;
4952 todo_list->alloc = alloc;
4955 static void todo_list_to_strbuf(struct repository *r, struct todo_list *todo_list,
4956 struct strbuf *buf, int num, unsigned flags)
4958 struct todo_item *item;
4959 int i, max = todo_list->nr;
4961 if (num > 0 && num < max)
4964 for (item = todo_list->items, i = 0; i < max; i++, item++) {
4965 /* if the item is not a command write it and continue */
4966 if (item->command >= TODO_COMMENT) {
4967 strbuf_addf(buf, "%.*s\n", item->arg_len,
4968 todo_item_get_arg(todo_list, item));
4972 /* add command to the buffer */
4973 if (flags & TODO_LIST_ABBREVIATE_CMDS)
4974 strbuf_addch(buf, command_to_char(item->command));
4976 strbuf_addstr(buf, command_to_string(item->command));
4980 const char *oid = flags & TODO_LIST_SHORTEN_IDS ?
4981 short_commit_name(item->commit) :
4982 oid_to_hex(&item->commit->object.oid);
4984 if (item->command == TODO_MERGE) {
4985 if (item->flags & TODO_EDIT_MERGE_MSG)
4986 strbuf_addstr(buf, " -c");
4988 strbuf_addstr(buf, " -C");
4991 strbuf_addf(buf, " %s", oid);
4994 /* add all the rest */
4996 strbuf_addch(buf, '\n');
4998 strbuf_addf(buf, " %.*s\n", item->arg_len,
4999 todo_item_get_arg(todo_list, item));
5003 int todo_list_write_to_file(struct repository *r, struct todo_list *todo_list,
5004 const char *file, const char *shortrevisions,
5005 const char *shortonto, int num, unsigned flags)
5008 struct strbuf buf = STRBUF_INIT;
5010 todo_list_to_strbuf(r, todo_list, &buf, num, flags);
5011 if (flags & TODO_LIST_APPEND_TODO_HELP)
5012 append_todo_help(count_commands(todo_list),
5013 shortrevisions, shortonto, &buf);
5015 res = write_message(buf.buf, buf.len, file, 0);
5016 strbuf_release(&buf);
5021 /* skip picking commits whose parents are unchanged */
5022 static int skip_unnecessary_picks(struct repository *r,
5023 struct todo_list *todo_list,
5024 struct object_id *base_oid)
5026 struct object_id *parent_oid;
5029 for (i = 0; i < todo_list->nr; i++) {
5030 struct todo_item *item = todo_list->items + i;
5032 if (item->command >= TODO_NOOP)
5034 if (item->command != TODO_PICK)
5036 if (parse_commit(item->commit)) {
5037 return error(_("could not parse commit '%s'"),
5038 oid_to_hex(&item->commit->object.oid));
5040 if (!item->commit->parents)
5041 break; /* root commit */
5042 if (item->commit->parents->next)
5043 break; /* merge commit */
5044 parent_oid = &item->commit->parents->item->object.oid;
5045 if (!oideq(parent_oid, base_oid))
5047 oidcpy(base_oid, &item->commit->object.oid);
5050 const char *done_path = rebase_path_done();
5052 if (todo_list_write_to_file(r, todo_list, done_path, NULL, NULL, i, 0)) {
5053 error_errno(_("could not write to '%s'"), done_path);
5057 MOVE_ARRAY(todo_list->items, todo_list->items + i, todo_list->nr - i);
5059 todo_list->current = 0;
5060 todo_list->done_nr += i;
5062 if (is_fixup(peek_command(todo_list, 0)))
5063 record_in_rewritten(base_oid, peek_command(todo_list, 0));
5069 int complete_action(struct repository *r, struct replay_opts *opts, unsigned flags,
5070 const char *shortrevisions, const char *onto_name,
5071 struct commit *onto, const char *orig_head,
5072 struct string_list *commands, unsigned autosquash,
5073 struct todo_list *todo_list)
5075 const char *shortonto, *todo_file = rebase_path_todo();
5076 struct todo_list new_todo = TODO_LIST_INIT;
5077 struct strbuf *buf = &todo_list->buf, buf2 = STRBUF_INIT;
5078 struct object_id oid = onto->object.oid;
5081 shortonto = find_unique_abbrev(&oid, DEFAULT_ABBREV);
5083 if (buf->len == 0) {
5084 struct todo_item *item = append_new_todo(todo_list);
5085 item->command = TODO_NOOP;
5086 item->commit = NULL;
5087 item->arg_len = item->arg_offset = item->flags = item->offset_in_buf = 0;
5090 if (autosquash && todo_list_rearrange_squash(todo_list))
5094 todo_list_add_exec_commands(todo_list, commands);
5096 if (count_commands(todo_list) == 0) {
5097 apply_autostash(opts);
5098 sequencer_remove_state(opts);
5100 return error(_("nothing to do"));
5103 res = edit_todo_list(r, todo_list, &new_todo, shortrevisions,
5107 else if (res == -2) {
5108 apply_autostash(opts);
5109 sequencer_remove_state(opts);
5112 } else if (res == -3) {
5113 apply_autostash(opts);
5114 sequencer_remove_state(opts);
5115 todo_list_release(&new_todo);
5117 return error(_("nothing to do"));
5118 } else if (res == -4) {
5119 checkout_onto(r, opts, onto_name, &onto->object.oid, orig_head);
5120 todo_list_release(&new_todo);
5125 /* Expand the commit IDs */
5126 todo_list_to_strbuf(r, &new_todo, &buf2, -1, 0);
5127 strbuf_swap(&new_todo.buf, &buf2);
5128 strbuf_release(&buf2);
5129 new_todo.total_nr -= new_todo.nr;
5130 if (todo_list_parse_insn_buffer(r, new_todo.buf.buf, &new_todo) < 0)
5131 BUG("invalid todo list after expanding IDs:\n%s",
5134 if (opts->allow_ff && skip_unnecessary_picks(r, &new_todo, &oid)) {
5135 todo_list_release(&new_todo);
5136 return error(_("could not skip unnecessary pick commands"));
5139 if (todo_list_write_to_file(r, &new_todo, todo_file, NULL, NULL, -1,
5140 flags & ~(TODO_LIST_SHORTEN_IDS))) {
5141 todo_list_release(&new_todo);
5142 return error_errno(_("could not write '%s'"), todo_file);
5147 if (checkout_onto(r, opts, onto_name, &oid, orig_head))
5150 if (require_clean_work_tree(r, "rebase", "", 1, 1))
5153 todo_list_write_total_nr(&new_todo);
5154 res = pick_commits(r, &new_todo, opts);
5157 todo_list_release(&new_todo);
5162 struct subject2item_entry {
5163 struct hashmap_entry entry;
5165 char subject[FLEX_ARRAY];
5168 static int subject2item_cmp(const void *fndata,
5169 const struct hashmap_entry *eptr,
5170 const struct hashmap_entry *entry_or_key,
5173 const struct subject2item_entry *a, *b;
5175 a = container_of(eptr, const struct subject2item_entry, entry);
5176 b = container_of(entry_or_key, const struct subject2item_entry, entry);
5178 return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
5181 define_commit_slab(commit_todo_item, struct todo_item *);
5184 * Rearrange the todo list that has both "pick commit-id msg" and "pick
5185 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
5186 * after the former, and change "pick" to "fixup"/"squash".
5188 * Note that if the config has specified a custom instruction format, each log
5189 * message will have to be retrieved from the commit (as the oneline in the
5190 * script cannot be trusted) in order to normalize the autosquash arrangement.
5192 int todo_list_rearrange_squash(struct todo_list *todo_list)
5194 struct hashmap subject2item;
5195 int rearranged = 0, *next, *tail, i, nr = 0, alloc = 0;
5197 struct commit_todo_item commit_todo;
5198 struct todo_item *items = NULL;
5200 init_commit_todo_item(&commit_todo);
5202 * The hashmap maps onelines to the respective todo list index.
5204 * If any items need to be rearranged, the next[i] value will indicate
5205 * which item was moved directly after the i'th.
5207 * In that case, last[i] will indicate the index of the latest item to
5208 * be moved to appear after the i'th.
5210 hashmap_init(&subject2item, subject2item_cmp, NULL, todo_list->nr);
5211 ALLOC_ARRAY(next, todo_list->nr);
5212 ALLOC_ARRAY(tail, todo_list->nr);
5213 ALLOC_ARRAY(subjects, todo_list->nr);
5214 for (i = 0; i < todo_list->nr; i++) {
5215 struct strbuf buf = STRBUF_INIT;
5216 struct todo_item *item = todo_list->items + i;
5217 const char *commit_buffer, *subject, *p;
5220 struct subject2item_entry *entry;
5222 next[i] = tail[i] = -1;
5223 if (!item->commit || item->command == TODO_DROP) {
5228 if (is_fixup(item->command)) {
5229 clear_commit_todo_item(&commit_todo);
5230 return error(_("the script was already rearranged."));
5233 *commit_todo_item_at(&commit_todo, item->commit) = item;
5235 parse_commit(item->commit);
5236 commit_buffer = logmsg_reencode(item->commit, NULL, "UTF-8");
5237 find_commit_subject(commit_buffer, &subject);
5238 format_subject(&buf, subject, " ");
5239 subject = subjects[i] = strbuf_detach(&buf, &subject_len);
5240 unuse_commit_buffer(item->commit, commit_buffer);
5241 if ((skip_prefix(subject, "fixup! ", &p) ||
5242 skip_prefix(subject, "squash! ", &p))) {
5243 struct commit *commit2;
5248 if (!skip_prefix(p, "fixup! ", &p) &&
5249 !skip_prefix(p, "squash! ", &p))
5253 entry = hashmap_get_entry_from_hash(&subject2item,
5255 struct subject2item_entry,
5258 /* found by title */
5260 else if (!strchr(p, ' ') &&
5262 lookup_commit_reference_by_name(p)) &&
5263 *commit_todo_item_at(&commit_todo, commit2))
5264 /* found by commit name */
5265 i2 = *commit_todo_item_at(&commit_todo, commit2)
5268 /* copy can be a prefix of the commit subject */
5269 for (i2 = 0; i2 < i; i2++)
5271 starts_with(subjects[i2], p))
5279 todo_list->items[i].command =
5280 starts_with(subject, "fixup!") ?
5281 TODO_FIXUP : TODO_SQUASH;
5287 } else if (!hashmap_get_from_hash(&subject2item,
5288 strhash(subject), subject)) {
5289 FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
5291 hashmap_entry_init(&entry->entry,
5292 strhash(entry->subject));
5293 hashmap_put(&subject2item, &entry->entry);
5298 for (i = 0; i < todo_list->nr; i++) {
5299 enum todo_command command = todo_list->items[i].command;
5303 * Initially, all commands are 'pick's. If it is a
5304 * fixup or a squash now, we have rearranged it.
5306 if (is_fixup(command))
5310 ALLOC_GROW(items, nr + 1, alloc);
5311 items[nr++] = todo_list->items[cur];
5316 FREE_AND_NULL(todo_list->items);
5317 todo_list->items = items;
5319 todo_list->alloc = alloc;
5324 for (i = 0; i < todo_list->nr; i++)
5327 hashmap_free_entries(&subject2item, struct subject2item_entry, entry);
5329 clear_commit_todo_item(&commit_todo);
5334 int sequencer_determine_whence(struct repository *r, enum commit_whence *whence)
5336 if (file_exists(git_path_cherry_pick_head(r))) {
5337 struct object_id cherry_pick_head, rebase_head;
5339 if (file_exists(git_path_seq_dir()))
5340 *whence = FROM_CHERRY_PICK_MULTI;
5341 if (file_exists(rebase_path()) &&
5342 !get_oid("REBASE_HEAD", &rebase_head) &&
5343 !get_oid("CHERRY_PICK_HEAD", &cherry_pick_head) &&
5344 oideq(&rebase_head, &cherry_pick_head))
5345 *whence = FROM_REBASE_PICK;
5347 *whence = FROM_CHERRY_PICK_SINGLE;