wrapper: use trace2 counters to collect fsync stats
[git.git] / sequencer.c
blobcc9821ece2c752b30ba07133cefc1c08c6d1e6d6
1 #include "git-compat-util.h"
2 #include "abspath.h"
3 #include "advice.h"
4 #include "config.h"
5 #include "copy.h"
6 #include "environment.h"
7 #include "gettext.h"
8 #include "hex.h"
9 #include "lockfile.h"
10 #include "dir.h"
11 #include "object-file.h"
12 #include "object-name.h"
13 #include "object-store-ll.h"
14 #include "object.h"
15 #include "pager.h"
16 #include "commit.h"
17 #include "sequencer.h"
18 #include "tag.h"
19 #include "run-command.h"
20 #include "hook.h"
21 #include "exec-cmd.h"
22 #include "utf8.h"
23 #include "cache-tree.h"
24 #include "diff.h"
25 #include "path.h"
26 #include "revision.h"
27 #include "rerere.h"
28 #include "merge.h"
29 #include "merge-ort.h"
30 #include "merge-ort-wrappers.h"
31 #include "refs.h"
32 #include "sparse-index.h"
33 #include "strvec.h"
34 #include "quote.h"
35 #include "trailer.h"
36 #include "log-tree.h"
37 #include "wt-status.h"
38 #include "hashmap.h"
39 #include "notes-utils.h"
40 #include "sigchain.h"
41 #include "unpack-trees.h"
42 #include "worktree.h"
43 #include "oidmap.h"
44 #include "oidset.h"
45 #include "commit-slab.h"
46 #include "alias.h"
47 #include "commit-reach.h"
48 #include "rebase-interactive.h"
49 #include "reset.h"
50 #include "branch.h"
52 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
54 static const char sign_off_header[] = "Signed-off-by: ";
55 static const char cherry_picked_prefix[] = "(cherry picked from commit ";
57 GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
59 static GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
61 static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
62 static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
63 static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
64 static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
66 static GIT_PATH_FUNC(rebase_path, "rebase-merge")
68 * The file containing rebase commands, comments, and empty lines.
69 * This file is created by "git rebase -i" then edited by the user. As
70 * the lines are processed, they are removed from the front of this
71 * file and written to the tail of 'done'.
73 GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
74 GIT_PATH_FUNC(rebase_path_todo_backup, "rebase-merge/git-rebase-todo.backup")
76 GIT_PATH_FUNC(rebase_path_dropped, "rebase-merge/dropped")
79 * The rebase command lines that have already been processed. A line
80 * is moved here when it is first handled, before any associated user
81 * actions.
83 static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
85 * The file to keep track of how many commands were already processed (e.g.
86 * for the prompt).
88 static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum")
90 * The file to keep track of how many commands are to be processed in total
91 * (e.g. for the prompt).
93 static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end")
95 * The commit message that is planned to be used for any changes that
96 * need to be committed following a user interaction.
98 static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
100 * The file into which is accumulated the suggested commit message for
101 * squash/fixup commands. When the first of a series of squash/fixups
102 * is seen, the file is created and the commit message from the
103 * previous commit and from the first squash/fixup commit are written
104 * to it. The commit message for each subsequent squash/fixup commit
105 * is appended to the file as it is processed.
107 static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
109 * If the current series of squash/fixups has not yet included a squash
110 * command, then this file exists and holds the commit message of the
111 * original "pick" commit. (If the series ends without a "squash"
112 * command, then this can be used as the commit message of the combined
113 * commit without opening the editor.)
115 static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
117 * This file contains the list fixup/squash commands that have been
118 * accumulated into message-fixup or message-squash so far.
120 static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")
122 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
123 * GIT_AUTHOR_DATE that will be used for the commit that is currently
124 * being rebased.
126 static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
128 * When an "edit" rebase command is being processed, the SHA1 of the
129 * commit to be edited is recorded in this file. When "git rebase
130 * --continue" is executed, if there are any staged changes then they
131 * will be amended to the HEAD commit, but only provided the HEAD
132 * commit is still the commit to be edited. When any other rebase
133 * command is processed, this file is deleted.
135 static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
137 * When we stop at a given patch via the "edit" command, this file contains
138 * the commit object name of the corresponding patch.
140 static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
142 * For the post-rewrite hook, we make a list of rewritten commits and
143 * their new sha1s. The rewritten-pending list keeps the sha1s of
144 * commits that have been processed, but not committed yet,
145 * e.g. because they are waiting for a 'squash' command.
147 static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
148 static GIT_PATH_FUNC(rebase_path_rewritten_pending,
149 "rebase-merge/rewritten-pending")
152 * The path of the file containing the OID of the "squash onto" commit, i.e.
153 * the dummy commit used for `reset [new root]`.
155 static GIT_PATH_FUNC(rebase_path_squash_onto, "rebase-merge/squash-onto")
158 * The path of the file listing refs that need to be deleted after the rebase
159 * finishes. This is used by the `label` command to record the need for cleanup.
161 static GIT_PATH_FUNC(rebase_path_refs_to_delete, "rebase-merge/refs-to-delete")
164 * The update-refs file stores a list of refs that will be updated at the end
165 * of the rebase sequence. The 'update-ref <ref>' commands in the todo file
166 * update the OIDs for the refs in this file, but the refs are not updated
167 * until the end of the rebase sequence.
169 * rebase_path_update_refs() returns the path to this file for a given
170 * worktree directory. For the current worktree, pass the_repository->gitdir.
172 static char *rebase_path_update_refs(const char *wt_git_dir)
174 return xstrfmt("%s/rebase-merge/update-refs", wt_git_dir);
178 * The following files are written by git-rebase just after parsing the
179 * command-line.
181 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
182 static GIT_PATH_FUNC(rebase_path_cdate_is_adate, "rebase-merge/cdate_is_adate")
183 static GIT_PATH_FUNC(rebase_path_ignore_date, "rebase-merge/ignore_date")
184 static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
185 static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
186 static GIT_PATH_FUNC(rebase_path_quiet, "rebase-merge/quiet")
187 static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")
188 static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
189 static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
190 static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
191 static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
192 static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
193 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
194 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec, "rebase-merge/reschedule-failed-exec")
195 static GIT_PATH_FUNC(rebase_path_no_reschedule_failed_exec, "rebase-merge/no-reschedule-failed-exec")
196 static GIT_PATH_FUNC(rebase_path_drop_redundant_commits, "rebase-merge/drop_redundant_commits")
197 static GIT_PATH_FUNC(rebase_path_keep_redundant_commits, "rebase-merge/keep_redundant_commits")
200 * A 'struct update_refs_record' represents a value in the update-refs
201 * list. We use a string_list to map refs to these (before, after) pairs.
203 struct update_ref_record {
204 struct object_id before;
205 struct object_id after;
208 static struct update_ref_record *init_update_ref_record(const char *ref)
210 struct update_ref_record *rec;
212 CALLOC_ARRAY(rec, 1);
214 oidcpy(&rec->before, null_oid());
215 oidcpy(&rec->after, null_oid());
217 /* This may fail, but that's fine, we will keep the null OID. */
218 read_ref(ref, &rec->before);
220 return rec;
223 static int git_sequencer_config(const char *k, const char *v,
224 const struct config_context *ctx, void *cb)
226 struct replay_opts *opts = cb;
227 int status;
229 if (!strcmp(k, "commit.cleanup")) {
230 const char *s;
232 status = git_config_string(&s, k, v);
233 if (status)
234 return status;
236 if (!strcmp(s, "verbatim")) {
237 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
238 opts->explicit_cleanup = 1;
239 } else if (!strcmp(s, "whitespace")) {
240 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
241 opts->explicit_cleanup = 1;
242 } else if (!strcmp(s, "strip")) {
243 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
244 opts->explicit_cleanup = 1;
245 } else if (!strcmp(s, "scissors")) {
246 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SCISSORS;
247 opts->explicit_cleanup = 1;
248 } else {
249 warning(_("invalid commit message cleanup mode '%s'"),
253 free((char *)s);
254 return status;
257 if (!strcmp(k, "commit.gpgsign")) {
258 opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
259 return 0;
262 if (!opts->default_strategy && !strcmp(k, "pull.twohead")) {
263 int ret = git_config_string((const char**)&opts->default_strategy, k, v);
264 if (ret == 0) {
266 * pull.twohead is allowed to be multi-valued; we only
267 * care about the first value.
269 char *tmp = strchr(opts->default_strategy, ' ');
270 if (tmp)
271 *tmp = '\0';
273 return ret;
276 if (opts->action == REPLAY_REVERT && !strcmp(k, "revert.reference"))
277 opts->commit_use_reference = git_config_bool(k, v);
279 return git_diff_basic_config(k, v, ctx, NULL);
282 void sequencer_init_config(struct replay_opts *opts)
284 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
285 git_config(git_sequencer_config, opts);
288 static inline int is_rebase_i(const struct replay_opts *opts)
290 return opts->action == REPLAY_INTERACTIVE_REBASE;
293 static const char *get_dir(const struct replay_opts *opts)
295 if (is_rebase_i(opts))
296 return rebase_path();
297 return git_path_seq_dir();
300 static const char *get_todo_path(const struct replay_opts *opts)
302 if (is_rebase_i(opts))
303 return rebase_path_todo();
304 return git_path_todo_file();
308 * Returns 0 for non-conforming footer
309 * Returns 1 for conforming footer
310 * Returns 2 when sob exists within conforming footer
311 * Returns 3 when sob exists within conforming footer as last entry
313 static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
314 size_t ignore_footer)
316 struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
317 struct trailer_info info;
318 size_t i;
319 int found_sob = 0, found_sob_last = 0;
320 char saved_char;
322 opts.no_divider = 1;
324 if (ignore_footer) {
325 saved_char = sb->buf[sb->len - ignore_footer];
326 sb->buf[sb->len - ignore_footer] = '\0';
329 trailer_info_get(&info, sb->buf, &opts);
331 if (ignore_footer)
332 sb->buf[sb->len - ignore_footer] = saved_char;
334 if (info.trailer_start == info.trailer_end)
335 return 0;
337 for (i = 0; i < info.trailer_nr; i++)
338 if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
339 found_sob = 1;
340 if (i == info.trailer_nr - 1)
341 found_sob_last = 1;
344 trailer_info_release(&info);
346 if (found_sob_last)
347 return 3;
348 if (found_sob)
349 return 2;
350 return 1;
353 static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
355 static struct strbuf buf = STRBUF_INIT;
357 strbuf_reset(&buf);
358 if (opts->gpg_sign)
359 sq_quotef(&buf, "-S%s", opts->gpg_sign);
360 return buf.buf;
363 void replay_opts_release(struct replay_opts *opts)
365 free(opts->gpg_sign);
366 free(opts->reflog_action);
367 free(opts->default_strategy);
368 free(opts->strategy);
369 strvec_clear (&opts->xopts);
370 strbuf_release(&opts->current_fixups);
371 if (opts->revs)
372 release_revisions(opts->revs);
373 free(opts->revs);
376 int sequencer_remove_state(struct replay_opts *opts)
378 struct strbuf buf = STRBUF_INIT;
379 int ret = 0;
381 if (is_rebase_i(opts) &&
382 strbuf_read_file(&buf, rebase_path_refs_to_delete(), 0) > 0) {
383 char *p = buf.buf;
384 while (*p) {
385 char *eol = strchr(p, '\n');
386 if (eol)
387 *eol = '\0';
388 if (delete_ref("(rebase) cleanup", p, NULL, 0) < 0) {
389 warning(_("could not delete '%s'"), p);
390 ret = -1;
392 if (!eol)
393 break;
394 p = eol + 1;
398 strbuf_reset(&buf);
399 strbuf_addstr(&buf, get_dir(opts));
400 if (remove_dir_recursively(&buf, 0))
401 ret = error(_("could not remove '%s'"), buf.buf);
402 strbuf_release(&buf);
404 return ret;
407 static const char *action_name(const struct replay_opts *opts)
409 switch (opts->action) {
410 case REPLAY_REVERT:
411 return N_("revert");
412 case REPLAY_PICK:
413 return N_("cherry-pick");
414 case REPLAY_INTERACTIVE_REBASE:
415 return N_("rebase");
417 die(_("unknown action: %d"), opts->action);
420 struct commit_message {
421 char *parent_label;
422 char *label;
423 char *subject;
424 const char *message;
427 static const char *short_commit_name(struct commit *commit)
429 return repo_find_unique_abbrev(the_repository, &commit->object.oid,
430 DEFAULT_ABBREV);
433 static int get_message(struct commit *commit, struct commit_message *out)
435 const char *abbrev, *subject;
436 int subject_len;
438 out->message = repo_logmsg_reencode(the_repository, commit, NULL,
439 get_commit_output_encoding());
440 abbrev = short_commit_name(commit);
442 subject_len = find_commit_subject(out->message, &subject);
444 out->subject = xmemdupz(subject, subject_len);
445 out->label = xstrfmt("%s (%s)", abbrev, out->subject);
446 out->parent_label = xstrfmt("parent of %s", out->label);
448 return 0;
451 static void free_message(struct commit *commit, struct commit_message *msg)
453 free(msg->parent_label);
454 free(msg->label);
455 free(msg->subject);
456 repo_unuse_commit_buffer(the_repository, commit, msg->message);
459 static void print_advice(struct repository *r, int show_hint,
460 struct replay_opts *opts)
462 char *msg = getenv("GIT_CHERRY_PICK_HELP");
464 if (msg) {
465 advise("%s\n", msg);
467 * A conflict has occurred but the porcelain
468 * (typically rebase --interactive) wants to take care
469 * of the commit itself so remove CHERRY_PICK_HEAD
471 refs_delete_ref(get_main_ref_store(r), "", "CHERRY_PICK_HEAD",
472 NULL, 0);
473 return;
476 if (show_hint) {
477 if (opts->no_commit)
478 advise(_("after resolving the conflicts, mark the corrected paths\n"
479 "with 'git add <paths>' or 'git rm <paths>'"));
480 else if (opts->action == REPLAY_PICK)
481 advise(_("After resolving the conflicts, mark them with\n"
482 "\"git add/rm <pathspec>\", then run\n"
483 "\"git cherry-pick --continue\".\n"
484 "You can instead skip this commit with \"git cherry-pick --skip\".\n"
485 "To abort and get back to the state before \"git cherry-pick\",\n"
486 "run \"git cherry-pick --abort\"."));
487 else if (opts->action == REPLAY_REVERT)
488 advise(_("After resolving the conflicts, mark them with\n"
489 "\"git add/rm <pathspec>\", then run\n"
490 "\"git revert --continue\".\n"
491 "You can instead skip this commit with \"git revert --skip\".\n"
492 "To abort and get back to the state before \"git revert\",\n"
493 "run \"git revert --abort\"."));
494 else
495 BUG("unexpected pick action in print_advice()");
499 static int write_message(const void *buf, size_t len, const char *filename,
500 int append_eol)
502 struct lock_file msg_file = LOCK_INIT;
504 int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
505 if (msg_fd < 0)
506 return error_errno(_("could not lock '%s'"), filename);
507 if (write_in_full(msg_fd, buf, len) < 0) {
508 error_errno(_("could not write to '%s'"), filename);
509 rollback_lock_file(&msg_file);
510 return -1;
512 if (append_eol && write(msg_fd, "\n", 1) < 0) {
513 error_errno(_("could not write eol to '%s'"), filename);
514 rollback_lock_file(&msg_file);
515 return -1;
517 if (commit_lock_file(&msg_file) < 0)
518 return error(_("failed to finalize '%s'"), filename);
520 return 0;
523 int read_oneliner(struct strbuf *buf,
524 const char *path, unsigned flags)
526 int orig_len = buf->len;
528 if (strbuf_read_file(buf, path, 0) < 0) {
529 if ((flags & READ_ONELINER_WARN_MISSING) ||
530 (errno != ENOENT && errno != ENOTDIR))
531 warning_errno(_("could not read '%s'"), path);
532 return 0;
535 if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
536 if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
537 --buf->len;
538 buf->buf[buf->len] = '\0';
541 if ((flags & READ_ONELINER_SKIP_IF_EMPTY) && buf->len == orig_len)
542 return 0;
544 return 1;
547 static struct tree *empty_tree(struct repository *r)
549 return lookup_tree(r, the_hash_algo->empty_tree);
552 static int error_dirty_index(struct repository *repo, struct replay_opts *opts)
554 if (repo_read_index_unmerged(repo))
555 return error_resolve_conflict(action_name(opts));
557 error(_("your local changes would be overwritten by %s."),
558 _(action_name(opts)));
560 if (advice_enabled(ADVICE_COMMIT_BEFORE_MERGE))
561 advise(_("commit your changes or stash them to proceed."));
562 return -1;
565 static void update_abort_safety_file(void)
567 struct object_id head;
569 /* Do nothing on a single-pick */
570 if (!file_exists(git_path_seq_dir()))
571 return;
573 if (!repo_get_oid(the_repository, "HEAD", &head))
574 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
575 else
576 write_file(git_path_abort_safety_file(), "%s", "");
579 static int fast_forward_to(struct repository *r,
580 const struct object_id *to,
581 const struct object_id *from,
582 int unborn,
583 struct replay_opts *opts)
585 struct ref_transaction *transaction;
586 struct strbuf sb = STRBUF_INIT;
587 struct strbuf err = STRBUF_INIT;
589 repo_read_index(r);
590 if (checkout_fast_forward(r, from, to, 1))
591 return -1; /* the callee should have complained already */
593 strbuf_addf(&sb, "%s: fast-forward", action_name(opts));
595 transaction = ref_transaction_begin(&err);
596 if (!transaction ||
597 ref_transaction_update(transaction, "HEAD",
598 to, unborn && !is_rebase_i(opts) ?
599 null_oid() : from,
600 0, sb.buf, &err) ||
601 ref_transaction_commit(transaction, &err)) {
602 ref_transaction_free(transaction);
603 error("%s", err.buf);
604 strbuf_release(&sb);
605 strbuf_release(&err);
606 return -1;
609 strbuf_release(&sb);
610 strbuf_release(&err);
611 ref_transaction_free(transaction);
612 update_abort_safety_file();
613 return 0;
616 enum commit_msg_cleanup_mode get_cleanup_mode(const char *cleanup_arg,
617 int use_editor)
619 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
620 return use_editor ? COMMIT_MSG_CLEANUP_ALL :
621 COMMIT_MSG_CLEANUP_SPACE;
622 else if (!strcmp(cleanup_arg, "verbatim"))
623 return COMMIT_MSG_CLEANUP_NONE;
624 else if (!strcmp(cleanup_arg, "whitespace"))
625 return COMMIT_MSG_CLEANUP_SPACE;
626 else if (!strcmp(cleanup_arg, "strip"))
627 return COMMIT_MSG_CLEANUP_ALL;
628 else if (!strcmp(cleanup_arg, "scissors"))
629 return use_editor ? COMMIT_MSG_CLEANUP_SCISSORS :
630 COMMIT_MSG_CLEANUP_SPACE;
631 else
632 die(_("Invalid cleanup mode %s"), cleanup_arg);
636 * NB using int rather than enum cleanup_mode to stop clang's
637 * -Wtautological-constant-out-of-range-compare complaining that the comparison
638 * is always true.
640 static const char *describe_cleanup_mode(int cleanup_mode)
642 static const char *modes[] = { "whitespace",
643 "verbatim",
644 "scissors",
645 "strip" };
647 if (cleanup_mode < ARRAY_SIZE(modes))
648 return modes[cleanup_mode];
650 BUG("invalid cleanup_mode provided (%d)", cleanup_mode);
653 void append_conflicts_hint(struct index_state *istate,
654 struct strbuf *msgbuf, enum commit_msg_cleanup_mode cleanup_mode)
656 int i;
658 if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS) {
659 strbuf_addch(msgbuf, '\n');
660 wt_status_append_cut_line(msgbuf);
661 strbuf_addch(msgbuf, comment_line_char);
664 strbuf_addch(msgbuf, '\n');
665 strbuf_commented_addf(msgbuf, comment_line_char, "Conflicts:\n");
666 for (i = 0; i < istate->cache_nr;) {
667 const struct cache_entry *ce = istate->cache[i++];
668 if (ce_stage(ce)) {
669 strbuf_commented_addf(msgbuf, comment_line_char,
670 "\t%s\n", ce->name);
671 while (i < istate->cache_nr &&
672 !strcmp(ce->name, istate->cache[i]->name))
673 i++;
678 static int do_recursive_merge(struct repository *r,
679 struct commit *base, struct commit *next,
680 const char *base_label, const char *next_label,
681 struct object_id *head, struct strbuf *msgbuf,
682 struct replay_opts *opts)
684 struct merge_options o;
685 struct merge_result result;
686 struct tree *next_tree, *base_tree, *head_tree;
687 int clean, show_output;
688 int i;
689 struct lock_file index_lock = LOCK_INIT;
691 if (repo_hold_locked_index(r, &index_lock, LOCK_REPORT_ON_ERROR) < 0)
692 return -1;
694 repo_read_index(r);
696 init_merge_options(&o, r);
697 o.ancestor = base ? base_label : "(empty tree)";
698 o.branch1 = "HEAD";
699 o.branch2 = next ? next_label : "(empty tree)";
700 if (is_rebase_i(opts))
701 o.buffer_output = 2;
702 o.show_rename_progress = 1;
704 head_tree = parse_tree_indirect(head);
705 next_tree = next ? repo_get_commit_tree(r, next) : empty_tree(r);
706 base_tree = base ? repo_get_commit_tree(r, base) : empty_tree(r);
708 for (i = 0; i < opts->xopts.nr; i++)
709 parse_merge_opt(&o, opts->xopts.v[i]);
711 if (!opts->strategy || !strcmp(opts->strategy, "ort")) {
712 memset(&result, 0, sizeof(result));
713 merge_incore_nonrecursive(&o, base_tree, head_tree, next_tree,
714 &result);
715 show_output = !is_rebase_i(opts) || !result.clean;
717 * TODO: merge_switch_to_result will update index/working tree;
718 * we only really want to do that if !result.clean || this is
719 * the final patch to be picked. But determining this is the
720 * final patch would take some work, and "head_tree" would need
721 * to be replace with the tree the index matched before we
722 * started doing any picks.
724 merge_switch_to_result(&o, head_tree, &result, 1, show_output);
725 clean = result.clean;
726 } else {
727 ensure_full_index(r->index);
728 clean = merge_trees(&o, head_tree, next_tree, base_tree);
729 if (is_rebase_i(opts) && clean <= 0)
730 fputs(o.obuf.buf, stdout);
731 strbuf_release(&o.obuf);
733 if (clean < 0) {
734 rollback_lock_file(&index_lock);
735 return clean;
738 if (write_locked_index(r->index, &index_lock,
739 COMMIT_LOCK | SKIP_IF_UNCHANGED))
741 * TRANSLATORS: %s will be "revert", "cherry-pick" or
742 * "rebase".
744 return error(_("%s: Unable to write new index file"),
745 _(action_name(opts)));
747 if (!clean)
748 append_conflicts_hint(r->index, msgbuf,
749 opts->default_msg_cleanup);
751 return !clean;
754 static struct object_id *get_cache_tree_oid(struct index_state *istate)
756 if (!cache_tree_fully_valid(istate->cache_tree))
757 if (cache_tree_update(istate, 0)) {
758 error(_("unable to update cache tree"));
759 return NULL;
762 return &istate->cache_tree->oid;
765 static int is_index_unchanged(struct repository *r)
767 struct object_id head_oid, *cache_tree_oid;
768 struct commit *head_commit;
769 struct index_state *istate = r->index;
771 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
772 return error(_("could not resolve HEAD commit"));
774 head_commit = lookup_commit(r, &head_oid);
777 * If head_commit is NULL, check_commit, called from
778 * lookup_commit, would have indicated that head_commit is not
779 * a commit object already. repo_parse_commit() will return failure
780 * without further complaints in such a case. Otherwise, if
781 * the commit is invalid, repo_parse_commit() will complain. So
782 * there is nothing for us to say here. Just return failure.
784 if (repo_parse_commit(r, head_commit))
785 return -1;
787 if (!(cache_tree_oid = get_cache_tree_oid(istate)))
788 return -1;
790 return oideq(cache_tree_oid, get_commit_tree_oid(head_commit));
793 static int write_author_script(const char *message)
795 struct strbuf buf = STRBUF_INIT;
796 const char *eol;
797 int res;
799 for (;;)
800 if (!*message || starts_with(message, "\n")) {
801 missing_author:
802 /* Missing 'author' line? */
803 unlink(rebase_path_author_script());
804 return 0;
805 } else if (skip_prefix(message, "author ", &message))
806 break;
807 else if ((eol = strchr(message, '\n')))
808 message = eol + 1;
809 else
810 goto missing_author;
812 strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
813 while (*message && *message != '\n' && *message != '\r')
814 if (skip_prefix(message, " <", &message))
815 break;
816 else if (*message != '\'')
817 strbuf_addch(&buf, *(message++));
818 else
819 strbuf_addf(&buf, "'\\%c'", *(message++));
820 strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
821 while (*message && *message != '\n' && *message != '\r')
822 if (skip_prefix(message, "> ", &message))
823 break;
824 else if (*message != '\'')
825 strbuf_addch(&buf, *(message++));
826 else
827 strbuf_addf(&buf, "'\\%c'", *(message++));
828 strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
829 while (*message && *message != '\n' && *message != '\r')
830 if (*message != '\'')
831 strbuf_addch(&buf, *(message++));
832 else
833 strbuf_addf(&buf, "'\\%c'", *(message++));
834 strbuf_addch(&buf, '\'');
835 res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
836 strbuf_release(&buf);
837 return res;
841 * Take a series of KEY='VALUE' lines where VALUE part is
842 * sq-quoted, and append <KEY, VALUE> at the end of the string list
844 static int parse_key_value_squoted(char *buf, struct string_list *list)
846 while (*buf) {
847 struct string_list_item *item;
848 char *np;
849 char *cp = strchr(buf, '=');
850 if (!cp) {
851 np = strchrnul(buf, '\n');
852 return error(_("no key present in '%.*s'"),
853 (int) (np - buf), buf);
855 np = strchrnul(cp, '\n');
856 *cp++ = '\0';
857 item = string_list_append(list, buf);
859 buf = np + (*np == '\n');
860 *np = '\0';
861 cp = sq_dequote(cp);
862 if (!cp)
863 return error(_("unable to dequote value of '%s'"),
864 item->string);
865 item->util = xstrdup(cp);
867 return 0;
871 * Reads and parses the state directory's "author-script" file, and sets name,
872 * email and date accordingly.
873 * Returns 0 on success, -1 if the file could not be parsed.
875 * The author script is of the format:
877 * GIT_AUTHOR_NAME='$author_name'
878 * GIT_AUTHOR_EMAIL='$author_email'
879 * GIT_AUTHOR_DATE='$author_date'
881 * where $author_name, $author_email and $author_date are quoted. We are strict
882 * with our parsing, as the file was meant to be eval'd in the now-removed
883 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
884 * from what this function expects, it is better to bail out than to do
885 * something that the user does not expect.
887 int read_author_script(const char *path, char **name, char **email, char **date,
888 int allow_missing)
890 struct strbuf buf = STRBUF_INIT;
891 struct string_list kv = STRING_LIST_INIT_DUP;
892 int retval = -1; /* assume failure */
893 int i, name_i = -2, email_i = -2, date_i = -2, err = 0;
895 if (strbuf_read_file(&buf, path, 256) <= 0) {
896 strbuf_release(&buf);
897 if (errno == ENOENT && allow_missing)
898 return 0;
899 else
900 return error_errno(_("could not open '%s' for reading"),
901 path);
904 if (parse_key_value_squoted(buf.buf, &kv))
905 goto finish;
907 for (i = 0; i < kv.nr; i++) {
908 if (!strcmp(kv.items[i].string, "GIT_AUTHOR_NAME")) {
909 if (name_i != -2)
910 name_i = error(_("'GIT_AUTHOR_NAME' already given"));
911 else
912 name_i = i;
913 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_EMAIL")) {
914 if (email_i != -2)
915 email_i = error(_("'GIT_AUTHOR_EMAIL' already given"));
916 else
917 email_i = i;
918 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_DATE")) {
919 if (date_i != -2)
920 date_i = error(_("'GIT_AUTHOR_DATE' already given"));
921 else
922 date_i = i;
923 } else {
924 err = error(_("unknown variable '%s'"),
925 kv.items[i].string);
928 if (name_i == -2)
929 error(_("missing 'GIT_AUTHOR_NAME'"));
930 if (email_i == -2)
931 error(_("missing 'GIT_AUTHOR_EMAIL'"));
932 if (date_i == -2)
933 error(_("missing 'GIT_AUTHOR_DATE'"));
934 if (name_i < 0 || email_i < 0 || date_i < 0 || err)
935 goto finish;
936 *name = kv.items[name_i].util;
937 *email = kv.items[email_i].util;
938 *date = kv.items[date_i].util;
939 retval = 0;
940 finish:
941 string_list_clear(&kv, !!retval);
942 strbuf_release(&buf);
943 return retval;
947 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
948 * file with shell quoting into struct strvec. Returns -1 on
949 * error, 0 otherwise.
951 static int read_env_script(struct strvec *env)
953 char *name, *email, *date;
955 if (read_author_script(rebase_path_author_script(),
956 &name, &email, &date, 0))
957 return -1;
959 strvec_pushf(env, "GIT_AUTHOR_NAME=%s", name);
960 strvec_pushf(env, "GIT_AUTHOR_EMAIL=%s", email);
961 strvec_pushf(env, "GIT_AUTHOR_DATE=%s", date);
962 free(name);
963 free(email);
964 free(date);
966 return 0;
969 static char *get_author(const char *message)
971 size_t len;
972 const char *a;
974 a = find_commit_header(message, "author", &len);
975 if (a)
976 return xmemdupz(a, len);
978 return NULL;
981 static const char *author_date_from_env(const struct strvec *env)
983 int i;
984 const char *date;
986 for (i = 0; i < env->nr; i++)
987 if (skip_prefix(env->v[i],
988 "GIT_AUTHOR_DATE=", &date))
989 return date;
991 * If GIT_AUTHOR_DATE is missing we should have already errored out when
992 * reading the script
994 BUG("GIT_AUTHOR_DATE missing from author script");
997 static const char staged_changes_advice[] =
998 N_("you have staged changes in your working tree\n"
999 "If these changes are meant to be squashed into the previous commit, run:\n"
1000 "\n"
1001 " git commit --amend %s\n"
1002 "\n"
1003 "If they are meant to go into a new commit, run:\n"
1004 "\n"
1005 " git commit %s\n"
1006 "\n"
1007 "In both cases, once you're done, continue with:\n"
1008 "\n"
1009 " git rebase --continue\n");
1011 #define ALLOW_EMPTY (1<<0)
1012 #define EDIT_MSG (1<<1)
1013 #define AMEND_MSG (1<<2)
1014 #define CLEANUP_MSG (1<<3)
1015 #define VERIFY_MSG (1<<4)
1016 #define CREATE_ROOT_COMMIT (1<<5)
1017 #define VERBATIM_MSG (1<<6)
1019 static int run_command_silent_on_success(struct child_process *cmd)
1021 struct strbuf buf = STRBUF_INIT;
1022 int rc;
1024 cmd->stdout_to_stderr = 1;
1025 rc = pipe_command(cmd,
1026 NULL, 0,
1027 NULL, 0,
1028 &buf, 0);
1030 if (rc)
1031 fputs(buf.buf, stderr);
1032 strbuf_release(&buf);
1033 return rc;
1037 * If we are cherry-pick, and if the merge did not result in
1038 * hand-editing, we will hit this commit and inherit the original
1039 * author date and name.
1041 * If we are revert, or if our cherry-pick results in a hand merge,
1042 * we had better say that the current user is responsible for that.
1044 * An exception is when run_git_commit() is called during an
1045 * interactive rebase: in that case, we will want to retain the
1046 * author metadata.
1048 static int run_git_commit(const char *defmsg,
1049 struct replay_opts *opts,
1050 unsigned int flags)
1052 struct child_process cmd = CHILD_PROCESS_INIT;
1054 if ((flags & CLEANUP_MSG) && (flags & VERBATIM_MSG))
1055 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1057 cmd.git_cmd = 1;
1059 if (is_rebase_i(opts) &&
1060 ((opts->committer_date_is_author_date && !opts->ignore_date) ||
1061 !(!defmsg && (flags & AMEND_MSG))) &&
1062 read_env_script(&cmd.env)) {
1063 const char *gpg_opt = gpg_sign_opt_quoted(opts);
1065 return error(_(staged_changes_advice),
1066 gpg_opt, gpg_opt);
1069 strvec_pushf(&cmd.env, GIT_REFLOG_ACTION "=%s", opts->reflog_message);
1071 if (opts->committer_date_is_author_date)
1072 strvec_pushf(&cmd.env, "GIT_COMMITTER_DATE=%s",
1073 opts->ignore_date ?
1074 "" :
1075 author_date_from_env(&cmd.env));
1076 if (opts->ignore_date)
1077 strvec_push(&cmd.env, "GIT_AUTHOR_DATE=");
1079 strvec_push(&cmd.args, "commit");
1081 if (!(flags & VERIFY_MSG))
1082 strvec_push(&cmd.args, "-n");
1083 if ((flags & AMEND_MSG))
1084 strvec_push(&cmd.args, "--amend");
1085 if (opts->gpg_sign)
1086 strvec_pushf(&cmd.args, "-S%s", opts->gpg_sign);
1087 else
1088 strvec_push(&cmd.args, "--no-gpg-sign");
1089 if (defmsg)
1090 strvec_pushl(&cmd.args, "-F", defmsg, NULL);
1091 else if (!(flags & EDIT_MSG))
1092 strvec_pushl(&cmd.args, "-C", "HEAD", NULL);
1093 if ((flags & CLEANUP_MSG))
1094 strvec_push(&cmd.args, "--cleanup=strip");
1095 if ((flags & VERBATIM_MSG))
1096 strvec_push(&cmd.args, "--cleanup=verbatim");
1097 if ((flags & EDIT_MSG))
1098 strvec_push(&cmd.args, "-e");
1099 else if (!(flags & CLEANUP_MSG) &&
1100 !opts->signoff && !opts->record_origin &&
1101 !opts->explicit_cleanup)
1102 strvec_push(&cmd.args, "--cleanup=verbatim");
1104 if ((flags & ALLOW_EMPTY))
1105 strvec_push(&cmd.args, "--allow-empty");
1107 if (!(flags & EDIT_MSG))
1108 strvec_push(&cmd.args, "--allow-empty-message");
1110 if (is_rebase_i(opts) && !(flags & EDIT_MSG))
1111 return run_command_silent_on_success(&cmd);
1112 else
1113 return run_command(&cmd);
1116 static int rest_is_empty(const struct strbuf *sb, int start)
1118 int i, eol;
1119 const char *nl;
1121 /* Check if the rest is just whitespace and Signed-off-by's. */
1122 for (i = start; i < sb->len; i++) {
1123 nl = memchr(sb->buf + i, '\n', sb->len - i);
1124 if (nl)
1125 eol = nl - sb->buf;
1126 else
1127 eol = sb->len;
1129 if (strlen(sign_off_header) <= eol - i &&
1130 starts_with(sb->buf + i, sign_off_header)) {
1131 i = eol;
1132 continue;
1134 while (i < eol)
1135 if (!isspace(sb->buf[i++]))
1136 return 0;
1139 return 1;
1142 void cleanup_message(struct strbuf *msgbuf,
1143 enum commit_msg_cleanup_mode cleanup_mode, int verbose)
1145 if (verbose || /* Truncate the message just before the diff, if any. */
1146 cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS)
1147 strbuf_setlen(msgbuf, wt_status_locate_end(msgbuf->buf, msgbuf->len));
1148 if (cleanup_mode != COMMIT_MSG_CLEANUP_NONE)
1149 strbuf_stripspace(msgbuf,
1150 cleanup_mode == COMMIT_MSG_CLEANUP_ALL ? comment_line_char : '\0');
1154 * Find out if the message in the strbuf contains only whitespace and
1155 * Signed-off-by lines.
1157 int message_is_empty(const struct strbuf *sb,
1158 enum commit_msg_cleanup_mode cleanup_mode)
1160 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1161 return 0;
1162 return rest_is_empty(sb, 0);
1166 * See if the user edited the message in the editor or left what
1167 * was in the template intact
1169 int template_untouched(const struct strbuf *sb, const char *template_file,
1170 enum commit_msg_cleanup_mode cleanup_mode)
1172 struct strbuf tmpl = STRBUF_INIT;
1173 const char *start;
1175 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1176 return 0;
1178 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1179 return 0;
1181 strbuf_stripspace(&tmpl,
1182 cleanup_mode == COMMIT_MSG_CLEANUP_ALL ? comment_line_char : '\0');
1183 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1184 start = sb->buf;
1185 strbuf_release(&tmpl);
1186 return rest_is_empty(sb, start - sb->buf);
1189 int update_head_with_reflog(const struct commit *old_head,
1190 const struct object_id *new_head,
1191 const char *action, const struct strbuf *msg,
1192 struct strbuf *err)
1194 struct ref_transaction *transaction;
1195 struct strbuf sb = STRBUF_INIT;
1196 const char *nl;
1197 int ret = 0;
1199 if (action) {
1200 strbuf_addstr(&sb, action);
1201 strbuf_addstr(&sb, ": ");
1204 nl = strchr(msg->buf, '\n');
1205 if (nl) {
1206 strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
1207 } else {
1208 strbuf_addbuf(&sb, msg);
1209 strbuf_addch(&sb, '\n');
1212 transaction = ref_transaction_begin(err);
1213 if (!transaction ||
1214 ref_transaction_update(transaction, "HEAD", new_head,
1215 old_head ? &old_head->object.oid : null_oid(),
1216 0, sb.buf, err) ||
1217 ref_transaction_commit(transaction, err)) {
1218 ret = -1;
1220 ref_transaction_free(transaction);
1221 strbuf_release(&sb);
1223 return ret;
1226 static int run_rewrite_hook(const struct object_id *oldoid,
1227 const struct object_id *newoid)
1229 struct child_process proc = CHILD_PROCESS_INIT;
1230 int code;
1231 struct strbuf sb = STRBUF_INIT;
1232 const char *hook_path = find_hook("post-rewrite");
1234 if (!hook_path)
1235 return 0;
1237 strvec_pushl(&proc.args, hook_path, "amend", NULL);
1238 proc.in = -1;
1239 proc.stdout_to_stderr = 1;
1240 proc.trace2_hook_name = "post-rewrite";
1242 code = start_command(&proc);
1243 if (code)
1244 return code;
1245 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1246 sigchain_push(SIGPIPE, SIG_IGN);
1247 write_in_full(proc.in, sb.buf, sb.len);
1248 close(proc.in);
1249 strbuf_release(&sb);
1250 sigchain_pop(SIGPIPE);
1251 return finish_command(&proc);
1254 void commit_post_rewrite(struct repository *r,
1255 const struct commit *old_head,
1256 const struct object_id *new_head)
1258 struct notes_rewrite_cfg *cfg;
1260 cfg = init_copy_notes_for_rewrite("amend");
1261 if (cfg) {
1262 /* we are amending, so old_head is not NULL */
1263 copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
1264 finish_copy_notes_for_rewrite(r, cfg, "Notes added by 'git commit --amend'");
1266 run_rewrite_hook(&old_head->object.oid, new_head);
1269 static int run_prepare_commit_msg_hook(struct repository *r,
1270 struct strbuf *msg,
1271 const char *commit)
1273 int ret = 0;
1274 const char *name, *arg1 = NULL, *arg2 = NULL;
1276 name = git_path_commit_editmsg();
1277 if (write_message(msg->buf, msg->len, name, 0))
1278 return -1;
1280 if (commit) {
1281 arg1 = "commit";
1282 arg2 = commit;
1283 } else {
1284 arg1 = "message";
1286 if (run_commit_hook(0, r->index_file, NULL, "prepare-commit-msg", name,
1287 arg1, arg2, NULL))
1288 ret = error(_("'prepare-commit-msg' hook failed"));
1290 return ret;
1293 static const char implicit_ident_advice_noconfig[] =
1294 N_("Your name and email address were configured automatically based\n"
1295 "on your username and hostname. Please check that they are accurate.\n"
1296 "You can suppress this message by setting them explicitly. Run the\n"
1297 "following command and follow the instructions in your editor to edit\n"
1298 "your configuration file:\n"
1299 "\n"
1300 " git config --global --edit\n"
1301 "\n"
1302 "After doing this, you may fix the identity used for this commit with:\n"
1303 "\n"
1304 " git commit --amend --reset-author\n");
1306 static const char implicit_ident_advice_config[] =
1307 N_("Your name and email address were configured automatically based\n"
1308 "on your username and hostname. Please check that they are accurate.\n"
1309 "You can suppress this message by setting them explicitly:\n"
1310 "\n"
1311 " git config --global user.name \"Your Name\"\n"
1312 " git config --global user.email you@example.com\n"
1313 "\n"
1314 "After doing this, you may fix the identity used for this commit with:\n"
1315 "\n"
1316 " git commit --amend --reset-author\n");
1318 static const char *implicit_ident_advice(void)
1320 char *user_config = interpolate_path("~/.gitconfig", 0);
1321 char *xdg_config = xdg_config_home("config");
1322 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1324 free(user_config);
1325 free(xdg_config);
1327 if (config_exists)
1328 return _(implicit_ident_advice_config);
1329 else
1330 return _(implicit_ident_advice_noconfig);
1334 void print_commit_summary(struct repository *r,
1335 const char *prefix,
1336 const struct object_id *oid,
1337 unsigned int flags)
1339 struct rev_info rev;
1340 struct commit *commit;
1341 struct strbuf format = STRBUF_INIT;
1342 const char *head;
1343 struct pretty_print_context pctx = {0};
1344 struct strbuf author_ident = STRBUF_INIT;
1345 struct strbuf committer_ident = STRBUF_INIT;
1346 struct ref_store *refs;
1348 commit = lookup_commit(r, oid);
1349 if (!commit)
1350 die(_("couldn't look up newly created commit"));
1351 if (repo_parse_commit(r, commit))
1352 die(_("could not parse newly created commit"));
1354 strbuf_addstr(&format, "format:%h] %s");
1356 repo_format_commit_message(r, commit, "%an <%ae>", &author_ident,
1357 &pctx);
1358 repo_format_commit_message(r, commit, "%cn <%ce>", &committer_ident,
1359 &pctx);
1360 if (strbuf_cmp(&author_ident, &committer_ident)) {
1361 strbuf_addstr(&format, "\n Author: ");
1362 strbuf_addbuf_percentquote(&format, &author_ident);
1364 if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
1365 struct strbuf date = STRBUF_INIT;
1367 repo_format_commit_message(r, commit, "%ad", &date, &pctx);
1368 strbuf_addstr(&format, "\n Date: ");
1369 strbuf_addbuf_percentquote(&format, &date);
1370 strbuf_release(&date);
1372 if (!committer_ident_sufficiently_given()) {
1373 strbuf_addstr(&format, "\n Committer: ");
1374 strbuf_addbuf_percentquote(&format, &committer_ident);
1375 if (advice_enabled(ADVICE_IMPLICIT_IDENTITY)) {
1376 strbuf_addch(&format, '\n');
1377 strbuf_addstr(&format, implicit_ident_advice());
1380 strbuf_release(&author_ident);
1381 strbuf_release(&committer_ident);
1383 repo_init_revisions(r, &rev, prefix);
1384 setup_revisions(0, NULL, &rev, NULL);
1386 rev.diff = 1;
1387 rev.diffopt.output_format =
1388 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1390 rev.verbose_header = 1;
1391 rev.show_root_diff = 1;
1392 get_commit_format(format.buf, &rev);
1393 rev.always_show_header = 0;
1394 rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1395 diff_setup_done(&rev.diffopt);
1397 refs = get_main_ref_store(r);
1398 head = refs_resolve_ref_unsafe(refs, "HEAD", 0, NULL, NULL);
1399 if (!head)
1400 die(_("unable to resolve HEAD after creating commit"));
1401 if (!strcmp(head, "HEAD"))
1402 head = _("detached HEAD");
1403 else
1404 skip_prefix(head, "refs/heads/", &head);
1405 printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1406 _(" (root-commit)") : "");
1408 if (!log_tree_commit(&rev, commit)) {
1409 rev.always_show_header = 1;
1410 rev.use_terminator = 1;
1411 log_tree_commit(&rev, commit);
1414 release_revisions(&rev);
1415 strbuf_release(&format);
1418 static int parse_head(struct repository *r, struct commit **head)
1420 struct commit *current_head;
1421 struct object_id oid;
1423 if (repo_get_oid(r, "HEAD", &oid)) {
1424 current_head = NULL;
1425 } else {
1426 current_head = lookup_commit_reference(r, &oid);
1427 if (!current_head)
1428 return error(_("could not parse HEAD"));
1429 if (!oideq(&oid, &current_head->object.oid)) {
1430 warning(_("HEAD %s is not a commit!"),
1431 oid_to_hex(&oid));
1433 if (repo_parse_commit(r, current_head))
1434 return error(_("could not parse HEAD commit"));
1436 *head = current_head;
1438 return 0;
1442 * Try to commit without forking 'git commit'. In some cases we need
1443 * to run 'git commit' to display an error message
1445 * Returns:
1446 * -1 - error unable to commit
1447 * 0 - success
1448 * 1 - run 'git commit'
1450 static int try_to_commit(struct repository *r,
1451 struct strbuf *msg, const char *author,
1452 struct replay_opts *opts, unsigned int flags,
1453 struct object_id *oid)
1455 struct object_id tree;
1456 struct commit *current_head = NULL;
1457 struct commit_list *parents = NULL;
1458 struct commit_extra_header *extra = NULL;
1459 struct strbuf err = STRBUF_INIT;
1460 struct strbuf commit_msg = STRBUF_INIT;
1461 char *amend_author = NULL;
1462 const char *committer = NULL;
1463 const char *hook_commit = NULL;
1464 enum commit_msg_cleanup_mode cleanup;
1465 int res = 0;
1467 if ((flags & CLEANUP_MSG) && (flags & VERBATIM_MSG))
1468 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1470 if (parse_head(r, &current_head))
1471 return -1;
1473 if (flags & AMEND_MSG) {
1474 const char *exclude_gpgsig[] = { "gpgsig", "gpgsig-sha256", NULL };
1475 const char *out_enc = get_commit_output_encoding();
1476 const char *message = repo_logmsg_reencode(r, current_head,
1477 NULL, out_enc);
1479 if (!msg) {
1480 const char *orig_message = NULL;
1482 find_commit_subject(message, &orig_message);
1483 msg = &commit_msg;
1484 strbuf_addstr(msg, orig_message);
1485 hook_commit = "HEAD";
1487 author = amend_author = get_author(message);
1488 repo_unuse_commit_buffer(r, current_head,
1489 message);
1490 if (!author) {
1491 res = error(_("unable to parse commit author"));
1492 goto out;
1494 parents = copy_commit_list(current_head->parents);
1495 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1496 } else if (current_head &&
1497 (!(flags & CREATE_ROOT_COMMIT) || (flags & AMEND_MSG))) {
1498 commit_list_insert(current_head, &parents);
1501 if (write_index_as_tree(&tree, r->index, r->index_file, 0, NULL)) {
1502 res = error(_("git write-tree failed to write a tree"));
1503 goto out;
1506 if (!(flags & ALLOW_EMPTY)) {
1507 struct commit *first_parent = current_head;
1509 if (flags & AMEND_MSG) {
1510 if (current_head->parents) {
1511 first_parent = current_head->parents->item;
1512 if (repo_parse_commit(r, first_parent)) {
1513 res = error(_("could not parse HEAD commit"));
1514 goto out;
1516 } else {
1517 first_parent = NULL;
1520 if (oideq(first_parent
1521 ? get_commit_tree_oid(first_parent)
1522 : the_hash_algo->empty_tree,
1523 &tree)) {
1524 res = 1; /* run 'git commit' to display error message */
1525 goto out;
1529 if (hook_exists("prepare-commit-msg")) {
1530 res = run_prepare_commit_msg_hook(r, msg, hook_commit);
1531 if (res)
1532 goto out;
1533 if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1534 2048) < 0) {
1535 res = error_errno(_("unable to read commit message "
1536 "from '%s'"),
1537 git_path_commit_editmsg());
1538 goto out;
1540 msg = &commit_msg;
1543 if (flags & CLEANUP_MSG)
1544 cleanup = COMMIT_MSG_CLEANUP_ALL;
1545 else if (flags & VERBATIM_MSG)
1546 cleanup = COMMIT_MSG_CLEANUP_NONE;
1547 else if ((opts->signoff || opts->record_origin) &&
1548 !opts->explicit_cleanup)
1549 cleanup = COMMIT_MSG_CLEANUP_SPACE;
1550 else
1551 cleanup = opts->default_msg_cleanup;
1553 if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1554 strbuf_stripspace(msg,
1555 cleanup == COMMIT_MSG_CLEANUP_ALL ? comment_line_char : '\0');
1556 if ((flags & EDIT_MSG) && message_is_empty(msg, cleanup)) {
1557 res = 1; /* run 'git commit' to display error message */
1558 goto out;
1561 if (opts->committer_date_is_author_date) {
1562 struct ident_split id;
1563 struct strbuf date = STRBUF_INIT;
1565 if (!opts->ignore_date) {
1566 if (split_ident_line(&id, author, (int)strlen(author)) < 0) {
1567 res = error(_("invalid author identity '%s'"),
1568 author);
1569 goto out;
1571 if (!id.date_begin) {
1572 res = error(_(
1573 "corrupt author: missing date information"));
1574 goto out;
1576 strbuf_addf(&date, "@%.*s %.*s",
1577 (int)(id.date_end - id.date_begin),
1578 id.date_begin,
1579 (int)(id.tz_end - id.tz_begin),
1580 id.tz_begin);
1581 } else {
1582 reset_ident_date();
1584 committer = fmt_ident(getenv("GIT_COMMITTER_NAME"),
1585 getenv("GIT_COMMITTER_EMAIL"),
1586 WANT_COMMITTER_IDENT,
1587 opts->ignore_date ? NULL : date.buf,
1588 IDENT_STRICT);
1589 strbuf_release(&date);
1590 } else {
1591 reset_ident_date();
1594 if (opts->ignore_date) {
1595 struct ident_split id;
1596 char *name, *email;
1598 if (split_ident_line(&id, author, strlen(author)) < 0) {
1599 error(_("invalid author identity '%s'"), author);
1600 goto out;
1602 name = xmemdupz(id.name_begin, id.name_end - id.name_begin);
1603 email = xmemdupz(id.mail_begin, id.mail_end - id.mail_begin);
1604 author = fmt_ident(name, email, WANT_AUTHOR_IDENT, NULL,
1605 IDENT_STRICT);
1606 free(name);
1607 free(email);
1610 if (commit_tree_extended(msg->buf, msg->len, &tree, parents, oid,
1611 author, committer, opts->gpg_sign, extra)) {
1612 res = error(_("failed to write commit object"));
1613 goto out;
1616 if (update_head_with_reflog(current_head, oid, opts->reflog_message,
1617 msg, &err)) {
1618 res = error("%s", err.buf);
1619 goto out;
1622 run_commit_hook(0, r->index_file, NULL, "post-commit", NULL);
1623 if (flags & AMEND_MSG)
1624 commit_post_rewrite(r, current_head, oid);
1626 out:
1627 free_commit_extra_headers(extra);
1628 strbuf_release(&err);
1629 strbuf_release(&commit_msg);
1630 free(amend_author);
1632 return res;
1635 static int write_rebase_head(struct object_id *oid)
1637 if (update_ref("rebase", "REBASE_HEAD", oid,
1638 NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1639 return error(_("could not update %s"), "REBASE_HEAD");
1641 return 0;
1644 static int do_commit(struct repository *r,
1645 const char *msg_file, const char *author,
1646 struct replay_opts *opts, unsigned int flags,
1647 struct object_id *oid)
1649 int res = 1;
1651 if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG)) {
1652 struct object_id oid;
1653 struct strbuf sb = STRBUF_INIT;
1655 if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1656 return error_errno(_("unable to read commit message "
1657 "from '%s'"),
1658 msg_file);
1660 res = try_to_commit(r, msg_file ? &sb : NULL,
1661 author, opts, flags, &oid);
1662 strbuf_release(&sb);
1663 if (!res) {
1664 refs_delete_ref(get_main_ref_store(r), "",
1665 "CHERRY_PICK_HEAD", NULL, 0);
1666 unlink(git_path_merge_msg(r));
1667 if (!is_rebase_i(opts))
1668 print_commit_summary(r, NULL, &oid,
1669 SUMMARY_SHOW_AUTHOR_DATE);
1670 return res;
1673 if (res == 1) {
1674 if (is_rebase_i(opts) && oid)
1675 if (write_rebase_head(oid))
1676 return -1;
1677 return run_git_commit(msg_file, opts, flags);
1680 return res;
1683 static int is_original_commit_empty(struct commit *commit)
1685 const struct object_id *ptree_oid;
1687 if (repo_parse_commit(the_repository, commit))
1688 return error(_("could not parse commit %s"),
1689 oid_to_hex(&commit->object.oid));
1690 if (commit->parents) {
1691 struct commit *parent = commit->parents->item;
1692 if (repo_parse_commit(the_repository, parent))
1693 return error(_("could not parse parent commit %s"),
1694 oid_to_hex(&parent->object.oid));
1695 ptree_oid = get_commit_tree_oid(parent);
1696 } else {
1697 ptree_oid = the_hash_algo->empty_tree; /* commit is root */
1700 return oideq(ptree_oid, get_commit_tree_oid(commit));
1704 * Should empty commits be allowed? Return status:
1705 * <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1706 * 0: Halt on empty commit
1707 * 1: Allow empty commit
1708 * 2: Drop empty commit
1710 static int allow_empty(struct repository *r,
1711 struct replay_opts *opts,
1712 struct commit *commit)
1714 int index_unchanged, originally_empty;
1717 * Four cases:
1719 * (1) we do not allow empty at all and error out.
1721 * (2) we allow ones that were initially empty, and
1722 * just drop the ones that become empty
1724 * (3) we allow ones that were initially empty, but
1725 * halt for the ones that become empty;
1727 * (4) we allow both.
1729 if (!opts->allow_empty)
1730 return 0; /* let "git commit" barf as necessary */
1732 index_unchanged = is_index_unchanged(r);
1733 if (index_unchanged < 0)
1734 return index_unchanged;
1735 if (!index_unchanged)
1736 return 0; /* we do not have to say --allow-empty */
1738 if (opts->keep_redundant_commits)
1739 return 1;
1741 originally_empty = is_original_commit_empty(commit);
1742 if (originally_empty < 0)
1743 return originally_empty;
1744 if (originally_empty)
1745 return 1;
1746 else if (opts->drop_redundant_commits)
1747 return 2;
1748 else
1749 return 0;
1752 static struct {
1753 char c;
1754 const char *str;
1755 } todo_command_info[] = {
1756 [TODO_PICK] = { 'p', "pick" },
1757 [TODO_REVERT] = { 0, "revert" },
1758 [TODO_EDIT] = { 'e', "edit" },
1759 [TODO_REWORD] = { 'r', "reword" },
1760 [TODO_FIXUP] = { 'f', "fixup" },
1761 [TODO_SQUASH] = { 's', "squash" },
1762 [TODO_EXEC] = { 'x', "exec" },
1763 [TODO_BREAK] = { 'b', "break" },
1764 [TODO_LABEL] = { 'l', "label" },
1765 [TODO_RESET] = { 't', "reset" },
1766 [TODO_MERGE] = { 'm', "merge" },
1767 [TODO_UPDATE_REF] = { 'u', "update-ref" },
1768 [TODO_NOOP] = { 0, "noop" },
1769 [TODO_DROP] = { 'd', "drop" },
1770 [TODO_COMMENT] = { 0, NULL },
1773 static const char *command_to_string(const enum todo_command command)
1775 if (command < TODO_COMMENT)
1776 return todo_command_info[command].str;
1777 die(_("unknown command: %d"), command);
1780 static char command_to_char(const enum todo_command command)
1782 if (command < TODO_COMMENT)
1783 return todo_command_info[command].c;
1784 return comment_line_char;
1787 static int is_noop(const enum todo_command command)
1789 return TODO_NOOP <= command;
1792 static int is_fixup(enum todo_command command)
1794 return command == TODO_FIXUP || command == TODO_SQUASH;
1797 /* Does this command create a (non-merge) commit? */
1798 static int is_pick_or_similar(enum todo_command command)
1800 switch (command) {
1801 case TODO_PICK:
1802 case TODO_REVERT:
1803 case TODO_EDIT:
1804 case TODO_REWORD:
1805 case TODO_FIXUP:
1806 case TODO_SQUASH:
1807 return 1;
1808 default:
1809 return 0;
1813 enum todo_item_flags {
1814 TODO_EDIT_MERGE_MSG = (1 << 0),
1815 TODO_REPLACE_FIXUP_MSG = (1 << 1),
1816 TODO_EDIT_FIXUP_MSG = (1 << 2),
1819 static const char first_commit_msg_str[] = N_("This is the 1st commit message:");
1820 static const char nth_commit_msg_fmt[] = N_("This is the commit message #%d:");
1821 static const char skip_first_commit_msg_str[] = N_("The 1st commit message will be skipped:");
1822 static const char skip_nth_commit_msg_fmt[] = N_("The commit message #%d will be skipped:");
1823 static const char combined_commit_msg_fmt[] = N_("This is a combination of %d commits.");
1825 static int is_fixup_flag(enum todo_command command, unsigned flag)
1827 return command == TODO_FIXUP && ((flag & TODO_REPLACE_FIXUP_MSG) ||
1828 (flag & TODO_EDIT_FIXUP_MSG));
1832 * Wrapper around strbuf_add_commented_lines() which avoids double
1833 * commenting commit subjects.
1835 static void add_commented_lines(struct strbuf *buf, const void *str, size_t len)
1837 const char *s = str;
1838 while (len > 0 && s[0] == comment_line_char) {
1839 size_t count;
1840 const char *n = memchr(s, '\n', len);
1841 if (!n)
1842 count = len;
1843 else
1844 count = n - s + 1;
1845 strbuf_add(buf, s, count);
1846 s += count;
1847 len -= count;
1849 strbuf_add_commented_lines(buf, s, len, comment_line_char);
1852 /* Does the current fixup chain contain a squash command? */
1853 static int seen_squash(struct replay_opts *opts)
1855 return starts_with(opts->current_fixups.buf, "squash") ||
1856 strstr(opts->current_fixups.buf, "\nsquash");
1859 static void update_comment_bufs(struct strbuf *buf1, struct strbuf *buf2, int n)
1861 strbuf_setlen(buf1, 2);
1862 strbuf_addf(buf1, _(nth_commit_msg_fmt), n);
1863 strbuf_addch(buf1, '\n');
1864 strbuf_setlen(buf2, 2);
1865 strbuf_addf(buf2, _(skip_nth_commit_msg_fmt), n);
1866 strbuf_addch(buf2, '\n');
1870 * Comment out any un-commented commit messages, updating the message comments
1871 * to say they will be skipped but do not comment out the empty lines that
1872 * surround commit messages and their comments.
1874 static void update_squash_message_for_fixup(struct strbuf *msg)
1876 void (*copy_lines)(struct strbuf *, const void *, size_t) = strbuf_add;
1877 struct strbuf buf1 = STRBUF_INIT, buf2 = STRBUF_INIT;
1878 const char *s, *start;
1879 char *orig_msg;
1880 size_t orig_msg_len;
1881 int i = 1;
1883 strbuf_addf(&buf1, "# %s\n", _(first_commit_msg_str));
1884 strbuf_addf(&buf2, "# %s\n", _(skip_first_commit_msg_str));
1885 s = start = orig_msg = strbuf_detach(msg, &orig_msg_len);
1886 while (s) {
1887 const char *next;
1888 size_t off;
1889 if (skip_prefix(s, buf1.buf, &next)) {
1891 * Copy the last message, preserving the blank line
1892 * preceding the current line
1894 off = (s > start + 1 && s[-2] == '\n') ? 1 : 0;
1895 copy_lines(msg, start, s - start - off);
1896 if (off)
1897 strbuf_addch(msg, '\n');
1899 * The next message needs to be commented out but the
1900 * message header is already commented out so just copy
1901 * it and the blank line that follows it.
1903 strbuf_addbuf(msg, &buf2);
1904 if (*next == '\n')
1905 strbuf_addch(msg, *next++);
1906 start = s = next;
1907 copy_lines = add_commented_lines;
1908 update_comment_bufs(&buf1, &buf2, ++i);
1909 } else if (skip_prefix(s, buf2.buf, &next)) {
1910 off = (s > start + 1 && s[-2] == '\n') ? 1 : 0;
1911 copy_lines(msg, start, s - start - off);
1912 start = s - off;
1913 s = next;
1914 copy_lines = strbuf_add;
1915 update_comment_bufs(&buf1, &buf2, ++i);
1916 } else {
1917 s = strchr(s, '\n');
1918 if (s)
1919 s++;
1922 copy_lines(msg, start, orig_msg_len - (start - orig_msg));
1923 free(orig_msg);
1924 strbuf_release(&buf1);
1925 strbuf_release(&buf2);
1928 static int append_squash_message(struct strbuf *buf, const char *body,
1929 enum todo_command command, struct replay_opts *opts,
1930 unsigned flag)
1932 const char *fixup_msg;
1933 size_t commented_len = 0, fixup_off;
1935 * amend is non-interactive and not normally used with fixup!
1936 * or squash! commits, so only comment out those subjects when
1937 * squashing commit messages.
1939 if (starts_with(body, "amend!") ||
1940 ((command == TODO_SQUASH || seen_squash(opts)) &&
1941 (starts_with(body, "squash!") || starts_with(body, "fixup!"))))
1942 commented_len = commit_subject_length(body);
1944 strbuf_addf(buf, "\n%c ", comment_line_char);
1945 strbuf_addf(buf, _(nth_commit_msg_fmt),
1946 ++opts->current_fixup_count + 1);
1947 strbuf_addstr(buf, "\n\n");
1948 strbuf_add_commented_lines(buf, body, commented_len, comment_line_char);
1949 /* buf->buf may be reallocated so store an offset into the buffer */
1950 fixup_off = buf->len;
1951 strbuf_addstr(buf, body + commented_len);
1953 /* fixup -C after squash behaves like squash */
1954 if (is_fixup_flag(command, flag) && !seen_squash(opts)) {
1956 * We're replacing the commit message so we need to
1957 * append the Signed-off-by: trailer if the user
1958 * requested '--signoff'.
1960 if (opts->signoff)
1961 append_signoff(buf, 0, 0);
1963 if ((command == TODO_FIXUP) &&
1964 (flag & TODO_REPLACE_FIXUP_MSG) &&
1965 (file_exists(rebase_path_fixup_msg()) ||
1966 !file_exists(rebase_path_squash_msg()))) {
1967 fixup_msg = skip_blank_lines(buf->buf + fixup_off);
1968 if (write_message(fixup_msg, strlen(fixup_msg),
1969 rebase_path_fixup_msg(), 0) < 0)
1970 return error(_("cannot write '%s'"),
1971 rebase_path_fixup_msg());
1972 } else {
1973 unlink(rebase_path_fixup_msg());
1975 } else {
1976 unlink(rebase_path_fixup_msg());
1979 return 0;
1982 static int update_squash_messages(struct repository *r,
1983 enum todo_command command,
1984 struct commit *commit,
1985 struct replay_opts *opts,
1986 unsigned flag)
1988 struct strbuf buf = STRBUF_INIT;
1989 int res = 0;
1990 const char *message, *body;
1991 const char *encoding = get_commit_output_encoding();
1993 if (opts->current_fixup_count > 0) {
1994 struct strbuf header = STRBUF_INIT;
1995 char *eol;
1997 if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
1998 return error(_("could not read '%s'"),
1999 rebase_path_squash_msg());
2001 eol = buf.buf[0] != comment_line_char ?
2002 buf.buf : strchrnul(buf.buf, '\n');
2004 strbuf_addf(&header, "%c ", comment_line_char);
2005 strbuf_addf(&header, _(combined_commit_msg_fmt),
2006 opts->current_fixup_count + 2);
2007 strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
2008 strbuf_release(&header);
2009 if (is_fixup_flag(command, flag) && !seen_squash(opts))
2010 update_squash_message_for_fixup(&buf);
2011 } else {
2012 struct object_id head;
2013 struct commit *head_commit;
2014 const char *head_message, *body;
2016 if (repo_get_oid(r, "HEAD", &head))
2017 return error(_("need a HEAD to fixup"));
2018 if (!(head_commit = lookup_commit_reference(r, &head)))
2019 return error(_("could not read HEAD"));
2020 if (!(head_message = repo_logmsg_reencode(r, head_commit, NULL,
2021 encoding)))
2022 return error(_("could not read HEAD's commit message"));
2024 find_commit_subject(head_message, &body);
2025 if (command == TODO_FIXUP && !flag && write_message(body, strlen(body),
2026 rebase_path_fixup_msg(), 0) < 0) {
2027 repo_unuse_commit_buffer(r, head_commit, head_message);
2028 return error(_("cannot write '%s'"), rebase_path_fixup_msg());
2030 strbuf_addf(&buf, "%c ", comment_line_char);
2031 strbuf_addf(&buf, _(combined_commit_msg_fmt), 2);
2032 strbuf_addf(&buf, "\n%c ", comment_line_char);
2033 strbuf_addstr(&buf, is_fixup_flag(command, flag) ?
2034 _(skip_first_commit_msg_str) :
2035 _(first_commit_msg_str));
2036 strbuf_addstr(&buf, "\n\n");
2037 if (is_fixup_flag(command, flag))
2038 strbuf_add_commented_lines(&buf, body, strlen(body),
2039 comment_line_char);
2040 else
2041 strbuf_addstr(&buf, body);
2043 repo_unuse_commit_buffer(r, head_commit, head_message);
2046 if (!(message = repo_logmsg_reencode(r, commit, NULL, encoding)))
2047 return error(_("could not read commit message of %s"),
2048 oid_to_hex(&commit->object.oid));
2049 find_commit_subject(message, &body);
2051 if (command == TODO_SQUASH || is_fixup_flag(command, flag)) {
2052 res = append_squash_message(&buf, body, command, opts, flag);
2053 } else if (command == TODO_FIXUP) {
2054 strbuf_addf(&buf, "\n%c ", comment_line_char);
2055 strbuf_addf(&buf, _(skip_nth_commit_msg_fmt),
2056 ++opts->current_fixup_count + 1);
2057 strbuf_addstr(&buf, "\n\n");
2058 strbuf_add_commented_lines(&buf, body, strlen(body),
2059 comment_line_char);
2060 } else
2061 return error(_("unknown command: %d"), command);
2062 repo_unuse_commit_buffer(r, commit, message);
2064 if (!res)
2065 res = write_message(buf.buf, buf.len, rebase_path_squash_msg(),
2067 strbuf_release(&buf);
2069 if (!res) {
2070 strbuf_addf(&opts->current_fixups, "%s%s %s",
2071 opts->current_fixups.len ? "\n" : "",
2072 command_to_string(command),
2073 oid_to_hex(&commit->object.oid));
2074 res = write_message(opts->current_fixups.buf,
2075 opts->current_fixups.len,
2076 rebase_path_current_fixups(), 0);
2079 return res;
2082 static void flush_rewritten_pending(void)
2084 struct strbuf buf = STRBUF_INIT;
2085 struct object_id newoid;
2086 FILE *out;
2088 if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
2089 !repo_get_oid(the_repository, "HEAD", &newoid) &&
2090 (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
2091 char *bol = buf.buf, *eol;
2093 while (*bol) {
2094 eol = strchrnul(bol, '\n');
2095 fprintf(out, "%.*s %s\n", (int)(eol - bol),
2096 bol, oid_to_hex(&newoid));
2097 if (!*eol)
2098 break;
2099 bol = eol + 1;
2101 fclose(out);
2102 unlink(rebase_path_rewritten_pending());
2104 strbuf_release(&buf);
2107 static void record_in_rewritten(struct object_id *oid,
2108 enum todo_command next_command)
2110 FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
2112 if (!out)
2113 return;
2115 fprintf(out, "%s\n", oid_to_hex(oid));
2116 fclose(out);
2118 if (!is_fixup(next_command))
2119 flush_rewritten_pending();
2122 static int should_edit(struct replay_opts *opts) {
2123 if (opts->edit < 0)
2125 * Note that we only handle the case of non-conflicted
2126 * commits; continue_single_pick() handles the conflicted
2127 * commits itself instead of calling this function.
2129 return (opts->action == REPLAY_REVERT && isatty(0)) ? 1 : 0;
2130 return opts->edit;
2133 static void refer_to_commit(struct replay_opts *opts,
2134 struct strbuf *msgbuf, struct commit *commit)
2136 if (opts->commit_use_reference) {
2137 struct pretty_print_context ctx = {
2138 .abbrev = DEFAULT_ABBREV,
2139 .date_mode.type = DATE_SHORT,
2141 repo_format_commit_message(the_repository, commit,
2142 "%h (%s, %ad)", msgbuf, &ctx);
2143 } else {
2144 strbuf_addstr(msgbuf, oid_to_hex(&commit->object.oid));
2148 static int do_pick_commit(struct repository *r,
2149 struct todo_item *item,
2150 struct replay_opts *opts,
2151 int final_fixup, int *check_todo)
2153 unsigned int flags = should_edit(opts) ? EDIT_MSG : 0;
2154 const char *msg_file = should_edit(opts) ? NULL : git_path_merge_msg(r);
2155 struct object_id head;
2156 struct commit *base, *next, *parent;
2157 const char *base_label, *next_label;
2158 char *author = NULL;
2159 struct commit_message msg = { NULL, NULL, NULL, NULL };
2160 struct strbuf msgbuf = STRBUF_INIT;
2161 int res, unborn = 0, reword = 0, allow, drop_commit;
2162 enum todo_command command = item->command;
2163 struct commit *commit = item->commit;
2165 if (opts->no_commit) {
2167 * We do not intend to commit immediately. We just want to
2168 * merge the differences in, so let's compute the tree
2169 * that represents the "current" state for the merge machinery
2170 * to work on.
2172 if (write_index_as_tree(&head, r->index, r->index_file, 0, NULL))
2173 return error(_("your index file is unmerged."));
2174 } else {
2175 unborn = repo_get_oid(r, "HEAD", &head);
2176 /* Do we want to generate a root commit? */
2177 if (is_pick_or_similar(command) && opts->have_squash_onto &&
2178 oideq(&head, &opts->squash_onto)) {
2179 if (is_fixup(command))
2180 return error(_("cannot fixup root commit"));
2181 flags |= CREATE_ROOT_COMMIT;
2182 unborn = 1;
2183 } else if (unborn)
2184 oidcpy(&head, the_hash_algo->empty_tree);
2185 if (index_differs_from(r, unborn ? empty_tree_oid_hex() : "HEAD",
2186 NULL, 0))
2187 return error_dirty_index(r, opts);
2189 discard_index(r->index);
2191 if (!commit->parents)
2192 parent = NULL;
2193 else if (commit->parents->next) {
2194 /* Reverting or cherry-picking a merge commit */
2195 int cnt;
2196 struct commit_list *p;
2198 if (!opts->mainline)
2199 return error(_("commit %s is a merge but no -m option was given."),
2200 oid_to_hex(&commit->object.oid));
2202 for (cnt = 1, p = commit->parents;
2203 cnt != opts->mainline && p;
2204 cnt++)
2205 p = p->next;
2206 if (cnt != opts->mainline || !p)
2207 return error(_("commit %s does not have parent %d"),
2208 oid_to_hex(&commit->object.oid), opts->mainline);
2209 parent = p->item;
2210 } else if (1 < opts->mainline)
2212 * Non-first parent explicitly specified as mainline for
2213 * non-merge commit
2215 return error(_("commit %s does not have parent %d"),
2216 oid_to_hex(&commit->object.oid), opts->mainline);
2217 else
2218 parent = commit->parents->item;
2220 if (get_message(commit, &msg) != 0)
2221 return error(_("cannot get commit message for %s"),
2222 oid_to_hex(&commit->object.oid));
2224 if (opts->allow_ff && !is_fixup(command) &&
2225 ((parent && oideq(&parent->object.oid, &head)) ||
2226 (!parent && unborn))) {
2227 if (is_rebase_i(opts))
2228 write_author_script(msg.message);
2229 res = fast_forward_to(r, &commit->object.oid, &head, unborn,
2230 opts);
2231 if (res || command != TODO_REWORD)
2232 goto leave;
2233 reword = 1;
2234 msg_file = NULL;
2235 goto fast_forward_edit;
2237 if (parent && repo_parse_commit(r, parent) < 0)
2238 /* TRANSLATORS: The first %s will be a "todo" command like
2239 "revert" or "pick", the second %s a SHA1. */
2240 return error(_("%s: cannot parse parent commit %s"),
2241 command_to_string(command),
2242 oid_to_hex(&parent->object.oid));
2245 * "commit" is an existing commit. We would want to apply
2246 * the difference it introduces since its first parent "prev"
2247 * on top of the current HEAD if we are cherry-pick. Or the
2248 * reverse of it if we are revert.
2251 if (command == TODO_REVERT) {
2252 base = commit;
2253 base_label = msg.label;
2254 next = parent;
2255 next_label = msg.parent_label;
2256 if (opts->commit_use_reference) {
2257 strbuf_addstr(&msgbuf,
2258 "# *** SAY WHY WE ARE REVERTING ON THE TITLE LINE ***");
2259 } else {
2260 strbuf_addstr(&msgbuf, "Revert \"");
2261 strbuf_addstr(&msgbuf, msg.subject);
2262 strbuf_addstr(&msgbuf, "\"");
2264 strbuf_addstr(&msgbuf, "\n\nThis reverts commit ");
2265 refer_to_commit(opts, &msgbuf, commit);
2267 if (commit->parents && commit->parents->next) {
2268 strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
2269 refer_to_commit(opts, &msgbuf, parent);
2271 strbuf_addstr(&msgbuf, ".\n");
2272 } else {
2273 const char *p;
2275 base = parent;
2276 base_label = msg.parent_label;
2277 next = commit;
2278 next_label = msg.label;
2280 /* Append the commit log message to msgbuf. */
2281 if (find_commit_subject(msg.message, &p))
2282 strbuf_addstr(&msgbuf, p);
2284 if (opts->record_origin) {
2285 strbuf_complete_line(&msgbuf);
2286 if (!has_conforming_footer(&msgbuf, NULL, 0))
2287 strbuf_addch(&msgbuf, '\n');
2288 strbuf_addstr(&msgbuf, cherry_picked_prefix);
2289 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
2290 strbuf_addstr(&msgbuf, ")\n");
2292 if (!is_fixup(command))
2293 author = get_author(msg.message);
2296 if (command == TODO_REWORD)
2297 reword = 1;
2298 else if (is_fixup(command)) {
2299 if (update_squash_messages(r, command, commit,
2300 opts, item->flags)) {
2301 res = -1;
2302 goto leave;
2304 flags |= AMEND_MSG;
2305 if (!final_fixup)
2306 msg_file = rebase_path_squash_msg();
2307 else if (file_exists(rebase_path_fixup_msg())) {
2308 flags |= VERBATIM_MSG;
2309 msg_file = rebase_path_fixup_msg();
2310 } else {
2311 const char *dest = git_path_squash_msg(r);
2312 unlink(dest);
2313 if (copy_file(dest, rebase_path_squash_msg(), 0666)) {
2314 res = error(_("could not rename '%s' to '%s'"),
2315 rebase_path_squash_msg(), dest);
2316 goto leave;
2318 unlink(git_path_merge_msg(r));
2319 msg_file = dest;
2320 flags |= EDIT_MSG;
2324 if (opts->signoff && !is_fixup(command))
2325 append_signoff(&msgbuf, 0, 0);
2327 if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
2328 res = -1;
2329 else if (!opts->strategy ||
2330 !strcmp(opts->strategy, "recursive") ||
2331 !strcmp(opts->strategy, "ort") ||
2332 command == TODO_REVERT) {
2333 res = do_recursive_merge(r, base, next, base_label, next_label,
2334 &head, &msgbuf, opts);
2335 if (res < 0)
2336 goto leave;
2338 res |= write_message(msgbuf.buf, msgbuf.len,
2339 git_path_merge_msg(r), 0);
2340 } else {
2341 struct commit_list *common = NULL;
2342 struct commit_list *remotes = NULL;
2344 res = write_message(msgbuf.buf, msgbuf.len,
2345 git_path_merge_msg(r), 0);
2347 commit_list_insert(base, &common);
2348 commit_list_insert(next, &remotes);
2349 res |= try_merge_command(r, opts->strategy,
2350 opts->xopts.nr, opts->xopts.v,
2351 common, oid_to_hex(&head), remotes);
2352 free_commit_list(common);
2353 free_commit_list(remotes);
2357 * If the merge was clean or if it failed due to conflict, we write
2358 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
2359 * However, if the merge did not even start, then we don't want to
2360 * write it at all.
2362 if ((command == TODO_PICK || command == TODO_REWORD ||
2363 command == TODO_EDIT) && !opts->no_commit &&
2364 (res == 0 || res == 1) &&
2365 update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
2366 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2367 res = -1;
2368 if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
2369 update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
2370 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2371 res = -1;
2373 if (res) {
2374 error(command == TODO_REVERT
2375 ? _("could not revert %s... %s")
2376 : _("could not apply %s... %s"),
2377 short_commit_name(commit), msg.subject);
2378 print_advice(r, res == 1, opts);
2379 repo_rerere(r, opts->allow_rerere_auto);
2380 goto leave;
2383 drop_commit = 0;
2384 allow = allow_empty(r, opts, commit);
2385 if (allow < 0) {
2386 res = allow;
2387 goto leave;
2388 } else if (allow == 1) {
2389 flags |= ALLOW_EMPTY;
2390 } else if (allow == 2) {
2391 drop_commit = 1;
2392 refs_delete_ref(get_main_ref_store(r), "", "CHERRY_PICK_HEAD",
2393 NULL, 0);
2394 unlink(git_path_merge_msg(r));
2395 unlink(git_path_auto_merge(r));
2396 fprintf(stderr,
2397 _("dropping %s %s -- patch contents already upstream\n"),
2398 oid_to_hex(&commit->object.oid), msg.subject);
2399 } /* else allow == 0 and there's nothing special to do */
2400 if (!opts->no_commit && !drop_commit) {
2401 if (author || command == TODO_REVERT || (flags & AMEND_MSG))
2402 res = do_commit(r, msg_file, author, opts, flags,
2403 commit? &commit->object.oid : NULL);
2404 else
2405 res = error(_("unable to parse commit author"));
2406 *check_todo = !!(flags & EDIT_MSG);
2407 if (!res && reword) {
2408 fast_forward_edit:
2409 res = run_git_commit(NULL, opts, EDIT_MSG |
2410 VERIFY_MSG | AMEND_MSG |
2411 (flags & ALLOW_EMPTY));
2412 *check_todo = 1;
2417 if (!res && final_fixup) {
2418 unlink(rebase_path_fixup_msg());
2419 unlink(rebase_path_squash_msg());
2420 unlink(rebase_path_current_fixups());
2421 strbuf_reset(&opts->current_fixups);
2422 opts->current_fixup_count = 0;
2425 leave:
2426 free_message(commit, &msg);
2427 free(author);
2428 strbuf_release(&msgbuf);
2429 update_abort_safety_file();
2431 return res;
2434 static int prepare_revs(struct replay_opts *opts)
2437 * picking (but not reverting) ranges (but not individual revisions)
2438 * should be done in reverse
2440 if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
2441 opts->revs->reverse ^= 1;
2443 if (prepare_revision_walk(opts->revs))
2444 return error(_("revision walk setup failed"));
2446 return 0;
2449 static int read_and_refresh_cache(struct repository *r,
2450 struct replay_opts *opts)
2452 struct lock_file index_lock = LOCK_INIT;
2453 int index_fd = repo_hold_locked_index(r, &index_lock, 0);
2454 if (repo_read_index(r) < 0) {
2455 rollback_lock_file(&index_lock);
2456 return error(_("git %s: failed to read the index"),
2457 action_name(opts));
2459 refresh_index(r->index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
2461 if (index_fd >= 0) {
2462 if (write_locked_index(r->index, &index_lock,
2463 COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
2464 return error(_("git %s: failed to refresh the index"),
2465 action_name(opts));
2470 * If we are resolving merges in any way other than "ort", then
2471 * expand the sparse index.
2473 if (opts->strategy && strcmp(opts->strategy, "ort"))
2474 ensure_full_index(r->index);
2475 return 0;
2478 void todo_list_release(struct todo_list *todo_list)
2480 strbuf_release(&todo_list->buf);
2481 FREE_AND_NULL(todo_list->items);
2482 todo_list->nr = todo_list->alloc = 0;
2485 static struct todo_item *append_new_todo(struct todo_list *todo_list)
2487 ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
2488 return todo_list->items + todo_list->nr++;
2491 const char *todo_item_get_arg(struct todo_list *todo_list,
2492 struct todo_item *item)
2494 return todo_list->buf.buf + item->arg_offset;
2497 static int is_command(enum todo_command command, const char **bol)
2499 const char *str = todo_command_info[command].str;
2500 const char nick = todo_command_info[command].c;
2501 const char *p = *bol;
2503 return (skip_prefix(p, str, &p) || (nick && *p++ == nick)) &&
2504 (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r' || !*p) &&
2505 (*bol = p);
2508 static int check_label_or_ref_arg(enum todo_command command, const char *arg)
2510 switch (command) {
2511 case TODO_LABEL:
2513 * '#' is not a valid label as the merge command uses it to
2514 * separate merge parents from the commit subject.
2516 if (!strcmp(arg, "#") ||
2517 check_refname_format(arg, REFNAME_ALLOW_ONELEVEL))
2518 return error(_("'%s' is not a valid label"), arg);
2519 break;
2521 case TODO_UPDATE_REF:
2522 if (check_refname_format(arg, REFNAME_ALLOW_ONELEVEL))
2523 return error(_("'%s' is not a valid refname"), arg);
2524 if (check_refname_format(arg, 0))
2525 return error(_("update-ref requires a fully qualified "
2526 "refname e.g. refs/heads/%s"), arg);
2527 break;
2529 default:
2530 BUG("unexpected todo_command");
2533 return 0;
2536 static int parse_insn_line(struct repository *r, struct todo_item *item,
2537 const char *buf, const char *bol, char *eol)
2539 struct object_id commit_oid;
2540 char *end_of_object_name;
2541 int i, saved, status, padding;
2543 item->flags = 0;
2545 /* left-trim */
2546 bol += strspn(bol, " \t");
2548 if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
2549 item->command = TODO_COMMENT;
2550 item->commit = NULL;
2551 item->arg_offset = bol - buf;
2552 item->arg_len = eol - bol;
2553 return 0;
2556 for (i = 0; i < TODO_COMMENT; i++)
2557 if (is_command(i, &bol)) {
2558 item->command = i;
2559 break;
2561 if (i >= TODO_COMMENT)
2562 return error(_("invalid command '%.*s'"),
2563 (int)strcspn(bol, " \t\r\n"), bol);
2565 /* Eat up extra spaces/ tabs before object name */
2566 padding = strspn(bol, " \t");
2567 bol += padding;
2569 if (item->command == TODO_NOOP || item->command == TODO_BREAK) {
2570 if (bol != eol)
2571 return error(_("%s does not accept arguments: '%s'"),
2572 command_to_string(item->command), bol);
2573 item->commit = NULL;
2574 item->arg_offset = bol - buf;
2575 item->arg_len = eol - bol;
2576 return 0;
2579 if (!padding)
2580 return error(_("missing arguments for %s"),
2581 command_to_string(item->command));
2583 if (item->command == TODO_EXEC || item->command == TODO_LABEL ||
2584 item->command == TODO_RESET || item->command == TODO_UPDATE_REF) {
2585 int ret = 0;
2587 item->commit = NULL;
2588 item->arg_offset = bol - buf;
2589 item->arg_len = (int)(eol - bol);
2590 if (item->command == TODO_LABEL ||
2591 item->command == TODO_UPDATE_REF) {
2592 saved = *eol;
2593 *eol = '\0';
2594 ret = check_label_or_ref_arg(item->command, bol);
2595 *eol = saved;
2597 return ret;
2600 if (item->command == TODO_FIXUP) {
2601 if (skip_prefix(bol, "-C", &bol)) {
2602 bol += strspn(bol, " \t");
2603 item->flags |= TODO_REPLACE_FIXUP_MSG;
2604 } else if (skip_prefix(bol, "-c", &bol)) {
2605 bol += strspn(bol, " \t");
2606 item->flags |= TODO_EDIT_FIXUP_MSG;
2610 if (item->command == TODO_MERGE) {
2611 if (skip_prefix(bol, "-C", &bol))
2612 bol += strspn(bol, " \t");
2613 else if (skip_prefix(bol, "-c", &bol)) {
2614 bol += strspn(bol, " \t");
2615 item->flags |= TODO_EDIT_MERGE_MSG;
2616 } else {
2617 item->flags |= TODO_EDIT_MERGE_MSG;
2618 item->commit = NULL;
2619 item->arg_offset = bol - buf;
2620 item->arg_len = (int)(eol - bol);
2621 return 0;
2625 end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
2626 saved = *end_of_object_name;
2627 *end_of_object_name = '\0';
2628 status = repo_get_oid(r, bol, &commit_oid);
2629 if (status < 0)
2630 error(_("could not parse '%s'"), bol); /* return later */
2631 *end_of_object_name = saved;
2633 bol = end_of_object_name + strspn(end_of_object_name, " \t");
2634 item->arg_offset = bol - buf;
2635 item->arg_len = (int)(eol - bol);
2637 if (status < 0)
2638 return status;
2640 item->commit = lookup_commit_reference(r, &commit_oid);
2641 return item->commit ? 0 : -1;
2644 int sequencer_get_last_command(struct repository *r, enum replay_action *action)
2646 const char *todo_file, *bol;
2647 struct strbuf buf = STRBUF_INIT;
2648 int ret = 0;
2650 todo_file = git_path_todo_file();
2651 if (strbuf_read_file(&buf, todo_file, 0) < 0) {
2652 if (errno == ENOENT || errno == ENOTDIR)
2653 return -1;
2654 else
2655 return error_errno("unable to open '%s'", todo_file);
2657 bol = buf.buf + strspn(buf.buf, " \t\r\n");
2658 if (is_command(TODO_PICK, &bol) && (*bol == ' ' || *bol == '\t'))
2659 *action = REPLAY_PICK;
2660 else if (is_command(TODO_REVERT, &bol) &&
2661 (*bol == ' ' || *bol == '\t'))
2662 *action = REPLAY_REVERT;
2663 else
2664 ret = -1;
2666 strbuf_release(&buf);
2668 return ret;
2671 int todo_list_parse_insn_buffer(struct repository *r, char *buf,
2672 struct todo_list *todo_list)
2674 struct todo_item *item;
2675 char *p = buf, *next_p;
2676 int i, res = 0, fixup_okay = file_exists(rebase_path_done());
2678 todo_list->current = todo_list->nr = todo_list->total_nr = 0;
2680 for (i = 1; *p; i++, p = next_p) {
2681 char *eol = strchrnul(p, '\n');
2683 next_p = *eol ? eol + 1 /* skip LF */ : eol;
2685 if (p != eol && eol[-1] == '\r')
2686 eol--; /* strip Carriage Return */
2688 item = append_new_todo(todo_list);
2689 item->offset_in_buf = p - todo_list->buf.buf;
2690 if (parse_insn_line(r, item, buf, p, eol)) {
2691 res = error(_("invalid line %d: %.*s"),
2692 i, (int)(eol - p), p);
2693 item->command = TODO_COMMENT + 1;
2694 item->arg_offset = p - buf;
2695 item->arg_len = (int)(eol - p);
2696 item->commit = NULL;
2699 if (item->command != TODO_COMMENT)
2700 todo_list->total_nr++;
2702 if (fixup_okay)
2703 ; /* do nothing */
2704 else if (is_fixup(item->command))
2705 return error(_("cannot '%s' without a previous commit"),
2706 command_to_string(item->command));
2707 else if (!is_noop(item->command))
2708 fixup_okay = 1;
2711 return res;
2714 static int count_commands(struct todo_list *todo_list)
2716 int count = 0, i;
2718 for (i = 0; i < todo_list->nr; i++)
2719 if (todo_list->items[i].command != TODO_COMMENT)
2720 count++;
2722 return count;
2725 static int get_item_line_offset(struct todo_list *todo_list, int index)
2727 return index < todo_list->nr ?
2728 todo_list->items[index].offset_in_buf : todo_list->buf.len;
2731 static const char *get_item_line(struct todo_list *todo_list, int index)
2733 return todo_list->buf.buf + get_item_line_offset(todo_list, index);
2736 static int get_item_line_length(struct todo_list *todo_list, int index)
2738 return get_item_line_offset(todo_list, index + 1)
2739 - get_item_line_offset(todo_list, index);
2742 static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
2744 int fd;
2745 ssize_t len;
2747 fd = open(path, O_RDONLY);
2748 if (fd < 0)
2749 return error_errno(_("could not open '%s'"), path);
2750 len = strbuf_read(sb, fd, 0);
2751 close(fd);
2752 if (len < 0)
2753 return error(_("could not read '%s'."), path);
2754 return len;
2757 static int have_finished_the_last_pick(void)
2759 struct strbuf buf = STRBUF_INIT;
2760 const char *eol;
2761 const char *todo_path = git_path_todo_file();
2762 int ret = 0;
2764 if (strbuf_read_file(&buf, todo_path, 0) < 0) {
2765 if (errno == ENOENT) {
2766 return 0;
2767 } else {
2768 error_errno("unable to open '%s'", todo_path);
2769 return 0;
2772 /* If there is only one line then we are done */
2773 eol = strchr(buf.buf, '\n');
2774 if (!eol || !eol[1])
2775 ret = 1;
2777 strbuf_release(&buf);
2779 return ret;
2782 void sequencer_post_commit_cleanup(struct repository *r, int verbose)
2784 struct replay_opts opts = REPLAY_OPTS_INIT;
2785 int need_cleanup = 0;
2787 if (refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD")) {
2788 if (!refs_delete_ref(get_main_ref_store(r), "",
2789 "CHERRY_PICK_HEAD", NULL, 0) &&
2790 verbose)
2791 warning(_("cancelling a cherry picking in progress"));
2792 opts.action = REPLAY_PICK;
2793 need_cleanup = 1;
2796 if (refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD")) {
2797 if (!refs_delete_ref(get_main_ref_store(r), "", "REVERT_HEAD",
2798 NULL, 0) &&
2799 verbose)
2800 warning(_("cancelling a revert in progress"));
2801 opts.action = REPLAY_REVERT;
2802 need_cleanup = 1;
2805 unlink(git_path_auto_merge(r));
2807 if (!need_cleanup)
2808 return;
2810 if (!have_finished_the_last_pick())
2811 return;
2813 sequencer_remove_state(&opts);
2816 static void todo_list_write_total_nr(struct todo_list *todo_list)
2818 FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
2820 if (f) {
2821 fprintf(f, "%d\n", todo_list->total_nr);
2822 fclose(f);
2826 static int read_populate_todo(struct repository *r,
2827 struct todo_list *todo_list,
2828 struct replay_opts *opts)
2830 const char *todo_file = get_todo_path(opts);
2831 int res;
2833 strbuf_reset(&todo_list->buf);
2834 if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
2835 return -1;
2837 res = todo_list_parse_insn_buffer(r, todo_list->buf.buf, todo_list);
2838 if (res) {
2839 if (is_rebase_i(opts))
2840 return error(_("please fix this using "
2841 "'git rebase --edit-todo'."));
2842 return error(_("unusable instruction sheet: '%s'"), todo_file);
2845 if (!todo_list->nr &&
2846 (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
2847 return error(_("no commits parsed."));
2849 if (!is_rebase_i(opts)) {
2850 enum todo_command valid =
2851 opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
2852 int i;
2854 for (i = 0; i < todo_list->nr; i++)
2855 if (valid == todo_list->items[i].command)
2856 continue;
2857 else if (valid == TODO_PICK)
2858 return error(_("cannot cherry-pick during a revert."));
2859 else
2860 return error(_("cannot revert during a cherry-pick."));
2863 if (is_rebase_i(opts)) {
2864 struct todo_list done = TODO_LIST_INIT;
2866 if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
2867 !todo_list_parse_insn_buffer(r, done.buf.buf, &done))
2868 todo_list->done_nr = count_commands(&done);
2869 else
2870 todo_list->done_nr = 0;
2872 todo_list->total_nr = todo_list->done_nr
2873 + count_commands(todo_list);
2874 todo_list_release(&done);
2876 todo_list_write_total_nr(todo_list);
2879 return 0;
2882 static int git_config_string_dup(char **dest,
2883 const char *var, const char *value)
2885 if (!value)
2886 return config_error_nonbool(var);
2887 free(*dest);
2888 *dest = xstrdup(value);
2889 return 0;
2892 static int populate_opts_cb(const char *key, const char *value,
2893 const struct config_context *ctx,
2894 void *data)
2896 struct replay_opts *opts = data;
2897 int error_flag = 1;
2899 if (!value)
2900 error_flag = 0;
2901 else if (!strcmp(key, "options.no-commit"))
2902 opts->no_commit = git_config_bool_or_int(key, value, ctx->kvi, &error_flag);
2903 else if (!strcmp(key, "options.edit"))
2904 opts->edit = git_config_bool_or_int(key, value, ctx->kvi, &error_flag);
2905 else if (!strcmp(key, "options.allow-empty"))
2906 opts->allow_empty =
2907 git_config_bool_or_int(key, value, ctx->kvi, &error_flag);
2908 else if (!strcmp(key, "options.allow-empty-message"))
2909 opts->allow_empty_message =
2910 git_config_bool_or_int(key, value, ctx->kvi, &error_flag);
2911 else if (!strcmp(key, "options.keep-redundant-commits"))
2912 opts->keep_redundant_commits =
2913 git_config_bool_or_int(key, value, ctx->kvi, &error_flag);
2914 else if (!strcmp(key, "options.signoff"))
2915 opts->signoff = git_config_bool_or_int(key, value, ctx->kvi, &error_flag);
2916 else if (!strcmp(key, "options.record-origin"))
2917 opts->record_origin = git_config_bool_or_int(key, value, ctx->kvi, &error_flag);
2918 else if (!strcmp(key, "options.allow-ff"))
2919 opts->allow_ff = git_config_bool_or_int(key, value, ctx->kvi, &error_flag);
2920 else if (!strcmp(key, "options.mainline"))
2921 opts->mainline = git_config_int(key, value, ctx->kvi);
2922 else if (!strcmp(key, "options.strategy"))
2923 git_config_string_dup(&opts->strategy, key, value);
2924 else if (!strcmp(key, "options.gpg-sign"))
2925 git_config_string_dup(&opts->gpg_sign, key, value);
2926 else if (!strcmp(key, "options.strategy-option")) {
2927 strvec_push(&opts->xopts, value);
2928 } else if (!strcmp(key, "options.allow-rerere-auto"))
2929 opts->allow_rerere_auto =
2930 git_config_bool_or_int(key, value, ctx->kvi, &error_flag) ?
2931 RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
2932 else if (!strcmp(key, "options.default-msg-cleanup")) {
2933 opts->explicit_cleanup = 1;
2934 opts->default_msg_cleanup = get_cleanup_mode(value, 1);
2935 } else
2936 return error(_("invalid key: %s"), key);
2938 if (!error_flag)
2939 return error(_("invalid value for '%s': '%s'"), key, value);
2941 return 0;
2944 static void parse_strategy_opts(struct replay_opts *opts, char *raw_opts)
2946 int i;
2947 int count;
2948 const char **argv;
2949 char *strategy_opts_string = raw_opts;
2951 if (*strategy_opts_string == ' ')
2952 strategy_opts_string++;
2954 count = split_cmdline(strategy_opts_string, &argv);
2955 if (count < 0)
2956 BUG("could not split '%s': %s", strategy_opts_string,
2957 split_cmdline_strerror(count));
2958 for (i = 0; i < count; i++) {
2959 const char *arg = argv[i];
2961 skip_prefix(arg, "--", &arg);
2962 strvec_push(&opts->xopts, arg);
2964 free(argv);
2967 static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
2969 strbuf_reset(buf);
2970 if (!read_oneliner(buf, rebase_path_strategy(), 0))
2971 return;
2972 opts->strategy = strbuf_detach(buf, NULL);
2973 if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2974 return;
2976 parse_strategy_opts(opts, buf->buf);
2979 static int read_populate_opts(struct replay_opts *opts)
2981 if (is_rebase_i(opts)) {
2982 struct strbuf buf = STRBUF_INIT;
2983 int ret = 0;
2985 if (read_oneliner(&buf, rebase_path_gpg_sign_opt(),
2986 READ_ONELINER_SKIP_IF_EMPTY)) {
2987 if (!starts_with(buf.buf, "-S"))
2988 strbuf_reset(&buf);
2989 else {
2990 free(opts->gpg_sign);
2991 opts->gpg_sign = xstrdup(buf.buf + 2);
2993 strbuf_reset(&buf);
2996 if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(),
2997 READ_ONELINER_SKIP_IF_EMPTY)) {
2998 if (!strcmp(buf.buf, "--rerere-autoupdate"))
2999 opts->allow_rerere_auto = RERERE_AUTOUPDATE;
3000 else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
3001 opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
3002 strbuf_reset(&buf);
3005 if (file_exists(rebase_path_verbose()))
3006 opts->verbose = 1;
3008 if (file_exists(rebase_path_quiet()))
3009 opts->quiet = 1;
3011 if (file_exists(rebase_path_signoff())) {
3012 opts->allow_ff = 0;
3013 opts->signoff = 1;
3016 if (file_exists(rebase_path_cdate_is_adate())) {
3017 opts->allow_ff = 0;
3018 opts->committer_date_is_author_date = 1;
3021 if (file_exists(rebase_path_ignore_date())) {
3022 opts->allow_ff = 0;
3023 opts->ignore_date = 1;
3026 if (file_exists(rebase_path_reschedule_failed_exec()))
3027 opts->reschedule_failed_exec = 1;
3028 else if (file_exists(rebase_path_no_reschedule_failed_exec()))
3029 opts->reschedule_failed_exec = 0;
3031 if (file_exists(rebase_path_drop_redundant_commits()))
3032 opts->drop_redundant_commits = 1;
3034 if (file_exists(rebase_path_keep_redundant_commits()))
3035 opts->keep_redundant_commits = 1;
3037 read_strategy_opts(opts, &buf);
3038 strbuf_reset(&buf);
3040 if (read_oneliner(&opts->current_fixups,
3041 rebase_path_current_fixups(),
3042 READ_ONELINER_SKIP_IF_EMPTY)) {
3043 const char *p = opts->current_fixups.buf;
3044 opts->current_fixup_count = 1;
3045 while ((p = strchr(p, '\n'))) {
3046 opts->current_fixup_count++;
3047 p++;
3051 if (read_oneliner(&buf, rebase_path_squash_onto(), 0)) {
3052 if (repo_get_oid_committish(the_repository, buf.buf, &opts->squash_onto) < 0) {
3053 ret = error(_("unusable squash-onto"));
3054 goto done_rebase_i;
3056 opts->have_squash_onto = 1;
3059 done_rebase_i:
3060 strbuf_release(&buf);
3061 return ret;
3064 if (!file_exists(git_path_opts_file()))
3065 return 0;
3067 * The function git_parse_source(), called from git_config_from_file(),
3068 * may die() in case of a syntactically incorrect file. We do not care
3069 * about this case, though, because we wrote that file ourselves, so we
3070 * are pretty certain that it is syntactically correct.
3072 if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
3073 return error(_("malformed options sheet: '%s'"),
3074 git_path_opts_file());
3075 return 0;
3078 static void write_strategy_opts(struct replay_opts *opts)
3080 struct strbuf buf = STRBUF_INIT;
3083 * Quote strategy options so that they can be read correctly
3084 * by split_cmdline().
3086 quote_cmdline(&buf, opts->xopts.v);
3087 write_file(rebase_path_strategy_opts(), "%s\n", buf.buf);
3088 strbuf_release(&buf);
3091 int write_basic_state(struct replay_opts *opts, const char *head_name,
3092 struct commit *onto, const struct object_id *orig_head)
3094 if (head_name)
3095 write_file(rebase_path_head_name(), "%s\n", head_name);
3096 if (onto)
3097 write_file(rebase_path_onto(), "%s\n",
3098 oid_to_hex(&onto->object.oid));
3099 if (orig_head)
3100 write_file(rebase_path_orig_head(), "%s\n",
3101 oid_to_hex(orig_head));
3103 if (opts->quiet)
3104 write_file(rebase_path_quiet(), "%s", "");
3105 if (opts->verbose)
3106 write_file(rebase_path_verbose(), "%s", "");
3107 if (opts->strategy)
3108 write_file(rebase_path_strategy(), "%s\n", opts->strategy);
3109 if (opts->xopts.nr > 0)
3110 write_strategy_opts(opts);
3112 if (opts->allow_rerere_auto == RERERE_AUTOUPDATE)
3113 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
3114 else if (opts->allow_rerere_auto == RERERE_NOAUTOUPDATE)
3115 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
3117 if (opts->gpg_sign)
3118 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts->gpg_sign);
3119 if (opts->signoff)
3120 write_file(rebase_path_signoff(), "--signoff\n");
3121 if (opts->drop_redundant_commits)
3122 write_file(rebase_path_drop_redundant_commits(), "%s", "");
3123 if (opts->keep_redundant_commits)
3124 write_file(rebase_path_keep_redundant_commits(), "%s", "");
3125 if (opts->committer_date_is_author_date)
3126 write_file(rebase_path_cdate_is_adate(), "%s", "");
3127 if (opts->ignore_date)
3128 write_file(rebase_path_ignore_date(), "%s", "");
3129 if (opts->reschedule_failed_exec)
3130 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
3131 else
3132 write_file(rebase_path_no_reschedule_failed_exec(), "%s", "");
3134 return 0;
3137 static int walk_revs_populate_todo(struct todo_list *todo_list,
3138 struct replay_opts *opts)
3140 enum todo_command command = opts->action == REPLAY_PICK ?
3141 TODO_PICK : TODO_REVERT;
3142 const char *command_string = todo_command_info[command].str;
3143 const char *encoding;
3144 struct commit *commit;
3146 if (prepare_revs(opts))
3147 return -1;
3149 encoding = get_log_output_encoding();
3151 while ((commit = get_revision(opts->revs))) {
3152 struct todo_item *item = append_new_todo(todo_list);
3153 const char *commit_buffer = repo_logmsg_reencode(the_repository,
3154 commit, NULL,
3155 encoding);
3156 const char *subject;
3157 int subject_len;
3159 item->command = command;
3160 item->commit = commit;
3161 item->arg_offset = 0;
3162 item->arg_len = 0;
3163 item->offset_in_buf = todo_list->buf.len;
3164 subject_len = find_commit_subject(commit_buffer, &subject);
3165 strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
3166 short_commit_name(commit), subject_len, subject);
3167 repo_unuse_commit_buffer(the_repository, commit,
3168 commit_buffer);
3171 if (!todo_list->nr)
3172 return error(_("empty commit set passed"));
3174 return 0;
3177 static int create_seq_dir(struct repository *r)
3179 enum replay_action action;
3180 const char *in_progress_error = NULL;
3181 const char *in_progress_advice = NULL;
3182 unsigned int advise_skip =
3183 refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD") ||
3184 refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD");
3186 if (!sequencer_get_last_command(r, &action)) {
3187 switch (action) {
3188 case REPLAY_REVERT:
3189 in_progress_error = _("revert is already in progress");
3190 in_progress_advice =
3191 _("try \"git revert (--continue | %s--abort | --quit)\"");
3192 break;
3193 case REPLAY_PICK:
3194 in_progress_error = _("cherry-pick is already in progress");
3195 in_progress_advice =
3196 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
3197 break;
3198 default:
3199 BUG("unexpected action in create_seq_dir");
3202 if (in_progress_error) {
3203 error("%s", in_progress_error);
3204 if (advice_enabled(ADVICE_SEQUENCER_IN_USE))
3205 advise(in_progress_advice,
3206 advise_skip ? "--skip | " : "");
3207 return -1;
3209 if (mkdir(git_path_seq_dir(), 0777) < 0)
3210 return error_errno(_("could not create sequencer directory '%s'"),
3211 git_path_seq_dir());
3213 return 0;
3216 static int save_head(const char *head)
3218 return write_message(head, strlen(head), git_path_head_file(), 1);
3221 static int rollback_is_safe(void)
3223 struct strbuf sb = STRBUF_INIT;
3224 struct object_id expected_head, actual_head;
3226 if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
3227 strbuf_trim(&sb);
3228 if (get_oid_hex(sb.buf, &expected_head)) {
3229 strbuf_release(&sb);
3230 die(_("could not parse %s"), git_path_abort_safety_file());
3232 strbuf_release(&sb);
3234 else if (errno == ENOENT)
3235 oidclr(&expected_head);
3236 else
3237 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
3239 if (repo_get_oid(the_repository, "HEAD", &actual_head))
3240 oidclr(&actual_head);
3242 return oideq(&actual_head, &expected_head);
3245 static int reset_merge(const struct object_id *oid)
3247 struct child_process cmd = CHILD_PROCESS_INIT;
3249 cmd.git_cmd = 1;
3250 strvec_pushl(&cmd.args, "reset", "--merge", NULL);
3252 if (!is_null_oid(oid))
3253 strvec_push(&cmd.args, oid_to_hex(oid));
3255 return run_command(&cmd);
3258 static int rollback_single_pick(struct repository *r)
3260 struct object_id head_oid;
3262 if (!refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD") &&
3263 !refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD"))
3264 return error(_("no cherry-pick or revert in progress"));
3265 if (read_ref_full("HEAD", 0, &head_oid, NULL))
3266 return error(_("cannot resolve HEAD"));
3267 if (is_null_oid(&head_oid))
3268 return error(_("cannot abort from a branch yet to be born"));
3269 return reset_merge(&head_oid);
3272 static int skip_single_pick(void)
3274 struct object_id head;
3276 if (read_ref_full("HEAD", 0, &head, NULL))
3277 return error(_("cannot resolve HEAD"));
3278 return reset_merge(&head);
3281 int sequencer_rollback(struct repository *r, struct replay_opts *opts)
3283 FILE *f;
3284 struct object_id oid;
3285 struct strbuf buf = STRBUF_INIT;
3286 const char *p;
3288 f = fopen(git_path_head_file(), "r");
3289 if (!f && errno == ENOENT) {
3291 * There is no multiple-cherry-pick in progress.
3292 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
3293 * a single-cherry-pick in progress, abort that.
3295 return rollback_single_pick(r);
3297 if (!f)
3298 return error_errno(_("cannot open '%s'"), git_path_head_file());
3299 if (strbuf_getline_lf(&buf, f)) {
3300 error(_("cannot read '%s': %s"), git_path_head_file(),
3301 ferror(f) ? strerror(errno) : _("unexpected end of file"));
3302 fclose(f);
3303 goto fail;
3305 fclose(f);
3306 if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
3307 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
3308 git_path_head_file());
3309 goto fail;
3311 if (is_null_oid(&oid)) {
3312 error(_("cannot abort from a branch yet to be born"));
3313 goto fail;
3316 if (!rollback_is_safe()) {
3317 /* Do not error, just do not rollback */
3318 warning(_("You seem to have moved HEAD. "
3319 "Not rewinding, check your HEAD!"));
3320 } else
3321 if (reset_merge(&oid))
3322 goto fail;
3323 strbuf_release(&buf);
3324 return sequencer_remove_state(opts);
3325 fail:
3326 strbuf_release(&buf);
3327 return -1;
3330 int sequencer_skip(struct repository *r, struct replay_opts *opts)
3332 enum replay_action action = -1;
3333 sequencer_get_last_command(r, &action);
3336 * Check whether the subcommand requested to skip the commit is actually
3337 * in progress and that it's safe to skip the commit.
3339 * opts->action tells us which subcommand requested to skip the commit.
3340 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
3341 * action is in progress and we can skip the commit.
3343 * Otherwise we check that the last instruction was related to the
3344 * particular subcommand we're trying to execute and barf if that's not
3345 * the case.
3347 * Finally we check that the rollback is "safe", i.e., has the HEAD
3348 * moved? In this case, it doesn't make sense to "reset the merge" and
3349 * "skip the commit" as the user already handled this by committing. But
3350 * we'd not want to barf here, instead give advice on how to proceed. We
3351 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
3352 * it gets removed when the user commits, so if it still exists we're
3353 * sure the user can't have committed before.
3355 switch (opts->action) {
3356 case REPLAY_REVERT:
3357 if (!refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD")) {
3358 if (action != REPLAY_REVERT)
3359 return error(_("no revert in progress"));
3360 if (!rollback_is_safe())
3361 goto give_advice;
3363 break;
3364 case REPLAY_PICK:
3365 if (!refs_ref_exists(get_main_ref_store(r),
3366 "CHERRY_PICK_HEAD")) {
3367 if (action != REPLAY_PICK)
3368 return error(_("no cherry-pick in progress"));
3369 if (!rollback_is_safe())
3370 goto give_advice;
3372 break;
3373 default:
3374 BUG("unexpected action in sequencer_skip");
3377 if (skip_single_pick())
3378 return error(_("failed to skip the commit"));
3379 if (!is_directory(git_path_seq_dir()))
3380 return 0;
3382 return sequencer_continue(r, opts);
3384 give_advice:
3385 error(_("there is nothing to skip"));
3387 if (advice_enabled(ADVICE_RESOLVE_CONFLICT)) {
3388 advise(_("have you committed already?\n"
3389 "try \"git %s --continue\""),
3390 action == REPLAY_REVERT ? "revert" : "cherry-pick");
3392 return -1;
3395 static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
3397 struct lock_file todo_lock = LOCK_INIT;
3398 const char *todo_path = get_todo_path(opts);
3399 int next = todo_list->current, offset, fd;
3402 * rebase -i writes "git-rebase-todo" without the currently executing
3403 * command, appending it to "done" instead.
3405 if (is_rebase_i(opts))
3406 next++;
3408 fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
3409 if (fd < 0)
3410 return error_errno(_("could not lock '%s'"), todo_path);
3411 offset = get_item_line_offset(todo_list, next);
3412 if (write_in_full(fd, todo_list->buf.buf + offset,
3413 todo_list->buf.len - offset) < 0)
3414 return error_errno(_("could not write to '%s'"), todo_path);
3415 if (commit_lock_file(&todo_lock) < 0)
3416 return error(_("failed to finalize '%s'"), todo_path);
3418 if (is_rebase_i(opts) && next > 0) {
3419 const char *done = rebase_path_done();
3420 int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
3421 int ret = 0;
3423 if (fd < 0)
3424 return 0;
3425 if (write_in_full(fd, get_item_line(todo_list, next - 1),
3426 get_item_line_length(todo_list, next - 1))
3427 < 0)
3428 ret = error_errno(_("could not write to '%s'"), done);
3429 if (close(fd) < 0)
3430 ret = error_errno(_("failed to finalize '%s'"), done);
3431 return ret;
3433 return 0;
3436 static int save_opts(struct replay_opts *opts)
3438 const char *opts_file = git_path_opts_file();
3439 int res = 0;
3441 if (opts->no_commit)
3442 res |= git_config_set_in_file_gently(opts_file,
3443 "options.no-commit", "true");
3444 if (opts->edit >= 0)
3445 res |= git_config_set_in_file_gently(opts_file, "options.edit",
3446 opts->edit ? "true" : "false");
3447 if (opts->allow_empty)
3448 res |= git_config_set_in_file_gently(opts_file,
3449 "options.allow-empty", "true");
3450 if (opts->allow_empty_message)
3451 res |= git_config_set_in_file_gently(opts_file,
3452 "options.allow-empty-message", "true");
3453 if (opts->keep_redundant_commits)
3454 res |= git_config_set_in_file_gently(opts_file,
3455 "options.keep-redundant-commits", "true");
3456 if (opts->signoff)
3457 res |= git_config_set_in_file_gently(opts_file,
3458 "options.signoff", "true");
3459 if (opts->record_origin)
3460 res |= git_config_set_in_file_gently(opts_file,
3461 "options.record-origin", "true");
3462 if (opts->allow_ff)
3463 res |= git_config_set_in_file_gently(opts_file,
3464 "options.allow-ff", "true");
3465 if (opts->mainline) {
3466 struct strbuf buf = STRBUF_INIT;
3467 strbuf_addf(&buf, "%d", opts->mainline);
3468 res |= git_config_set_in_file_gently(opts_file,
3469 "options.mainline", buf.buf);
3470 strbuf_release(&buf);
3472 if (opts->strategy)
3473 res |= git_config_set_in_file_gently(opts_file,
3474 "options.strategy", opts->strategy);
3475 if (opts->gpg_sign)
3476 res |= git_config_set_in_file_gently(opts_file,
3477 "options.gpg-sign", opts->gpg_sign);
3478 for (size_t i = 0; i < opts->xopts.nr; i++)
3479 res |= git_config_set_multivar_in_file_gently(opts_file,
3480 "options.strategy-option",
3481 opts->xopts.v[i], "^$", 0);
3482 if (opts->allow_rerere_auto)
3483 res |= git_config_set_in_file_gently(opts_file,
3484 "options.allow-rerere-auto",
3485 opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
3486 "true" : "false");
3488 if (opts->explicit_cleanup)
3489 res |= git_config_set_in_file_gently(opts_file,
3490 "options.default-msg-cleanup",
3491 describe_cleanup_mode(opts->default_msg_cleanup));
3492 return res;
3495 static int make_patch(struct repository *r,
3496 struct commit *commit,
3497 struct replay_opts *opts)
3499 struct strbuf buf = STRBUF_INIT;
3500 struct rev_info log_tree_opt;
3501 const char *subject;
3502 char hex[GIT_MAX_HEXSZ + 1];
3503 int res = 0;
3505 oid_to_hex_r(hex, &commit->object.oid);
3506 if (write_message(hex, strlen(hex), rebase_path_stopped_sha(), 1) < 0)
3507 return -1;
3508 res |= write_rebase_head(&commit->object.oid);
3510 strbuf_addf(&buf, "%s/patch", get_dir(opts));
3511 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
3512 repo_init_revisions(r, &log_tree_opt, NULL);
3513 log_tree_opt.abbrev = 0;
3514 log_tree_opt.diff = 1;
3515 log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
3516 log_tree_opt.disable_stdin = 1;
3517 log_tree_opt.no_commit_id = 1;
3518 log_tree_opt.diffopt.file = fopen(buf.buf, "w");
3519 log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
3520 if (!log_tree_opt.diffopt.file)
3521 res |= error_errno(_("could not open '%s'"), buf.buf);
3522 else {
3523 res |= log_tree_commit(&log_tree_opt, commit);
3524 fclose(log_tree_opt.diffopt.file);
3526 strbuf_reset(&buf);
3528 strbuf_addf(&buf, "%s/message", get_dir(opts));
3529 if (!file_exists(buf.buf)) {
3530 const char *encoding = get_commit_output_encoding();
3531 const char *commit_buffer = repo_logmsg_reencode(r,
3532 commit, NULL,
3533 encoding);
3534 find_commit_subject(commit_buffer, &subject);
3535 res |= write_message(subject, strlen(subject), buf.buf, 1);
3536 repo_unuse_commit_buffer(r, commit,
3537 commit_buffer);
3539 strbuf_release(&buf);
3540 release_revisions(&log_tree_opt);
3542 return res;
3545 static int intend_to_amend(void)
3547 struct object_id head;
3548 char *p;
3550 if (repo_get_oid(the_repository, "HEAD", &head))
3551 return error(_("cannot read HEAD"));
3553 p = oid_to_hex(&head);
3554 return write_message(p, strlen(p), rebase_path_amend(), 1);
3557 static int error_with_patch(struct repository *r,
3558 struct commit *commit,
3559 const char *subject, int subject_len,
3560 struct replay_opts *opts,
3561 int exit_code, int to_amend)
3563 if (commit) {
3564 if (make_patch(r, commit, opts))
3565 return -1;
3566 } else if (copy_file(rebase_path_message(),
3567 git_path_merge_msg(r), 0666))
3568 return error(_("unable to copy '%s' to '%s'"),
3569 git_path_merge_msg(r), rebase_path_message());
3571 if (to_amend) {
3572 if (intend_to_amend())
3573 return -1;
3575 fprintf(stderr,
3576 _("You can amend the commit now, with\n"
3577 "\n"
3578 " git commit --amend %s\n"
3579 "\n"
3580 "Once you are satisfied with your changes, run\n"
3581 "\n"
3582 " git rebase --continue\n"),
3583 gpg_sign_opt_quoted(opts));
3584 } else if (exit_code) {
3585 if (commit)
3586 fprintf_ln(stderr, _("Could not apply %s... %.*s"),
3587 short_commit_name(commit), subject_len, subject);
3588 else
3590 * We don't have the hash of the parent so
3591 * just print the line from the todo file.
3593 fprintf_ln(stderr, _("Could not merge %.*s"),
3594 subject_len, subject);
3597 return exit_code;
3600 static int error_failed_squash(struct repository *r,
3601 struct commit *commit,
3602 struct replay_opts *opts,
3603 int subject_len,
3604 const char *subject)
3606 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3607 return error(_("could not copy '%s' to '%s'"),
3608 rebase_path_squash_msg(), rebase_path_message());
3609 unlink(git_path_merge_msg(r));
3610 if (copy_file(git_path_merge_msg(r), rebase_path_message(), 0666))
3611 return error(_("could not copy '%s' to '%s'"),
3612 rebase_path_message(),
3613 git_path_merge_msg(r));
3614 return error_with_patch(r, commit, subject, subject_len, opts, 1, 0);
3617 static int do_exec(struct repository *r, const char *command_line)
3619 struct child_process cmd = CHILD_PROCESS_INIT;
3620 int dirty, status;
3622 fprintf(stderr, _("Executing: %s\n"), command_line);
3623 cmd.use_shell = 1;
3624 strvec_push(&cmd.args, command_line);
3625 status = run_command(&cmd);
3627 /* force re-reading of the cache */
3628 discard_index(r->index);
3629 if (repo_read_index(r) < 0)
3630 return error(_("could not read index"));
3632 dirty = require_clean_work_tree(r, "rebase", NULL, 1, 1);
3634 if (status) {
3635 warning(_("execution failed: %s\n%s"
3636 "You can fix the problem, and then run\n"
3637 "\n"
3638 " git rebase --continue\n"
3639 "\n"),
3640 command_line,
3641 dirty ? _("and made changes to the index and/or the "
3642 "working tree.\n") : "");
3643 if (status == 127)
3644 /* command not found */
3645 status = 1;
3646 } else if (dirty) {
3647 warning(_("execution succeeded: %s\nbut "
3648 "left changes to the index and/or the working tree.\n"
3649 "Commit or stash your changes, and then run\n"
3650 "\n"
3651 " git rebase --continue\n"
3652 "\n"), command_line);
3653 status = 1;
3656 return status;
3659 __attribute__((format (printf, 2, 3)))
3660 static int safe_append(const char *filename, const char *fmt, ...)
3662 va_list ap;
3663 struct lock_file lock = LOCK_INIT;
3664 int fd = hold_lock_file_for_update(&lock, filename,
3665 LOCK_REPORT_ON_ERROR);
3666 struct strbuf buf = STRBUF_INIT;
3668 if (fd < 0)
3669 return -1;
3671 if (strbuf_read_file(&buf, filename, 0) < 0 && errno != ENOENT) {
3672 error_errno(_("could not read '%s'"), filename);
3673 rollback_lock_file(&lock);
3674 return -1;
3676 strbuf_complete(&buf, '\n');
3677 va_start(ap, fmt);
3678 strbuf_vaddf(&buf, fmt, ap);
3679 va_end(ap);
3681 if (write_in_full(fd, buf.buf, buf.len) < 0) {
3682 error_errno(_("could not write to '%s'"), filename);
3683 strbuf_release(&buf);
3684 rollback_lock_file(&lock);
3685 return -1;
3687 if (commit_lock_file(&lock) < 0) {
3688 strbuf_release(&buf);
3689 return error(_("failed to finalize '%s'"), filename);
3692 strbuf_release(&buf);
3693 return 0;
3696 static int do_label(struct repository *r, const char *name, int len)
3698 struct ref_store *refs = get_main_ref_store(r);
3699 struct ref_transaction *transaction;
3700 struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
3701 struct strbuf msg = STRBUF_INIT;
3702 int ret = 0;
3703 struct object_id head_oid;
3705 if (len == 1 && *name == '#')
3706 return error(_("illegal label name: '%.*s'"), len, name);
3708 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3709 strbuf_addf(&msg, "rebase (label) '%.*s'", len, name);
3711 transaction = ref_store_transaction_begin(refs, &err);
3712 if (!transaction) {
3713 error("%s", err.buf);
3714 ret = -1;
3715 } else if (repo_get_oid(r, "HEAD", &head_oid)) {
3716 error(_("could not read HEAD"));
3717 ret = -1;
3718 } else if (ref_transaction_update(transaction, ref_name.buf, &head_oid,
3719 NULL, 0, msg.buf, &err) < 0 ||
3720 ref_transaction_commit(transaction, &err)) {
3721 error("%s", err.buf);
3722 ret = -1;
3724 ref_transaction_free(transaction);
3725 strbuf_release(&err);
3726 strbuf_release(&msg);
3728 if (!ret)
3729 ret = safe_append(rebase_path_refs_to_delete(),
3730 "%s\n", ref_name.buf);
3731 strbuf_release(&ref_name);
3733 return ret;
3736 static const char *sequencer_reflog_action(struct replay_opts *opts)
3738 if (!opts->reflog_action) {
3739 opts->reflog_action = getenv(GIT_REFLOG_ACTION);
3740 opts->reflog_action =
3741 xstrdup(opts->reflog_action ? opts->reflog_action
3742 : action_name(opts));
3745 return opts->reflog_action;
3748 __attribute__((format (printf, 3, 4)))
3749 static const char *reflog_message(struct replay_opts *opts,
3750 const char *sub_action, const char *fmt, ...)
3752 va_list ap;
3753 static struct strbuf buf = STRBUF_INIT;
3755 va_start(ap, fmt);
3756 strbuf_reset(&buf);
3757 strbuf_addstr(&buf, sequencer_reflog_action(opts));
3758 if (sub_action)
3759 strbuf_addf(&buf, " (%s)", sub_action);
3760 if (fmt) {
3761 strbuf_addstr(&buf, ": ");
3762 strbuf_vaddf(&buf, fmt, ap);
3764 va_end(ap);
3766 return buf.buf;
3769 static struct commit *lookup_label(struct repository *r, const char *label,
3770 int len, struct strbuf *buf)
3772 struct commit *commit;
3773 struct object_id oid;
3775 strbuf_reset(buf);
3776 strbuf_addf(buf, "refs/rewritten/%.*s", len, label);
3777 if (!read_ref(buf->buf, &oid)) {
3778 commit = lookup_commit_object(r, &oid);
3779 } else {
3780 /* fall back to non-rewritten ref or commit */
3781 strbuf_splice(buf, 0, strlen("refs/rewritten/"), "", 0);
3782 commit = lookup_commit_reference_by_name(buf->buf);
3785 if (!commit)
3786 error(_("could not resolve '%s'"), buf->buf);
3788 return commit;
3791 static int do_reset(struct repository *r,
3792 const char *name, int len,
3793 struct replay_opts *opts)
3795 struct strbuf ref_name = STRBUF_INIT;
3796 struct object_id oid;
3797 struct lock_file lock = LOCK_INIT;
3798 struct tree_desc desc = { 0 };
3799 struct tree *tree;
3800 struct unpack_trees_options unpack_tree_opts = { 0 };
3801 int ret = 0;
3803 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0)
3804 return -1;
3806 if (len == 10 && !strncmp("[new root]", name, len)) {
3807 if (!opts->have_squash_onto) {
3808 const char *hex;
3809 if (commit_tree("", 0, the_hash_algo->empty_tree,
3810 NULL, &opts->squash_onto,
3811 NULL, NULL))
3812 return error(_("writing fake root commit"));
3813 opts->have_squash_onto = 1;
3814 hex = oid_to_hex(&opts->squash_onto);
3815 if (write_message(hex, strlen(hex),
3816 rebase_path_squash_onto(), 0))
3817 return error(_("writing squash-onto"));
3819 oidcpy(&oid, &opts->squash_onto);
3820 } else {
3821 int i;
3822 struct commit *commit;
3824 /* Determine the length of the label */
3825 for (i = 0; i < len; i++)
3826 if (isspace(name[i]))
3827 break;
3828 len = i;
3830 commit = lookup_label(r, name, len, &ref_name);
3831 if (!commit) {
3832 ret = -1;
3833 goto cleanup;
3835 oid = commit->object.oid;
3838 setup_unpack_trees_porcelain(&unpack_tree_opts, "reset");
3839 unpack_tree_opts.head_idx = 1;
3840 unpack_tree_opts.src_index = r->index;
3841 unpack_tree_opts.dst_index = r->index;
3842 unpack_tree_opts.fn = oneway_merge;
3843 unpack_tree_opts.merge = 1;
3844 unpack_tree_opts.update = 1;
3845 unpack_tree_opts.preserve_ignored = 0; /* FIXME: !overwrite_ignore */
3846 unpack_tree_opts.skip_cache_tree_update = 1;
3847 init_checkout_metadata(&unpack_tree_opts.meta, name, &oid, NULL);
3849 if (repo_read_index_unmerged(r)) {
3850 ret = error_resolve_conflict(action_name(opts));
3851 goto cleanup;
3854 if (!fill_tree_descriptor(r, &desc, &oid)) {
3855 ret = error(_("failed to find tree of %s"), oid_to_hex(&oid));
3856 goto cleanup;
3859 if (unpack_trees(1, &desc, &unpack_tree_opts)) {
3860 ret = -1;
3861 goto cleanup;
3864 tree = parse_tree_indirect(&oid);
3865 prime_cache_tree(r, r->index, tree);
3867 if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
3868 ret = error(_("could not write index"));
3870 if (!ret)
3871 ret = update_ref(reflog_message(opts, "reset", "'%.*s'",
3872 len, name), "HEAD", &oid,
3873 NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3874 cleanup:
3875 free((void *)desc.buffer);
3876 if (ret < 0)
3877 rollback_lock_file(&lock);
3878 strbuf_release(&ref_name);
3879 clear_unpack_trees_porcelain(&unpack_tree_opts);
3880 return ret;
3883 static int do_merge(struct repository *r,
3884 struct commit *commit,
3885 const char *arg, int arg_len,
3886 int flags, int *check_todo, struct replay_opts *opts)
3888 int run_commit_flags = 0;
3889 struct strbuf ref_name = STRBUF_INIT;
3890 struct commit *head_commit, *merge_commit, *i;
3891 struct commit_list *bases, *j;
3892 struct commit_list *to_merge = NULL, **tail = &to_merge;
3893 const char *strategy = !opts->xopts.nr &&
3894 (!opts->strategy ||
3895 !strcmp(opts->strategy, "recursive") ||
3896 !strcmp(opts->strategy, "ort")) ?
3897 NULL : opts->strategy;
3898 struct merge_options o;
3899 int merge_arg_len, oneline_offset, can_fast_forward, ret, k;
3900 static struct lock_file lock;
3901 const char *p;
3903 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0) {
3904 ret = -1;
3905 goto leave_merge;
3908 head_commit = lookup_commit_reference_by_name("HEAD");
3909 if (!head_commit) {
3910 ret = error(_("cannot merge without a current revision"));
3911 goto leave_merge;
3915 * For octopus merges, the arg starts with the list of revisions to be
3916 * merged. The list is optionally followed by '#' and the oneline.
3918 merge_arg_len = oneline_offset = arg_len;
3919 for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {
3920 if (!*p)
3921 break;
3922 if (*p == '#' && (!p[1] || isspace(p[1]))) {
3923 p += 1 + strspn(p + 1, " \t\n");
3924 oneline_offset = p - arg;
3925 break;
3927 k = strcspn(p, " \t\n");
3928 if (!k)
3929 continue;
3930 merge_commit = lookup_label(r, p, k, &ref_name);
3931 if (!merge_commit) {
3932 ret = error(_("unable to parse '%.*s'"), k, p);
3933 goto leave_merge;
3935 tail = &commit_list_insert(merge_commit, tail)->next;
3936 p += k;
3937 merge_arg_len = p - arg;
3940 if (!to_merge) {
3941 ret = error(_("nothing to merge: '%.*s'"), arg_len, arg);
3942 goto leave_merge;
3945 if (opts->have_squash_onto &&
3946 oideq(&head_commit->object.oid, &opts->squash_onto)) {
3948 * When the user tells us to "merge" something into a
3949 * "[new root]", let's simply fast-forward to the merge head.
3951 rollback_lock_file(&lock);
3952 if (to_merge->next)
3953 ret = error(_("octopus merge cannot be executed on "
3954 "top of a [new root]"));
3955 else
3956 ret = fast_forward_to(r, &to_merge->item->object.oid,
3957 &head_commit->object.oid, 0,
3958 opts);
3959 goto leave_merge;
3963 * If HEAD is not identical to the first parent of the original merge
3964 * commit, we cannot fast-forward.
3966 can_fast_forward = opts->allow_ff && commit && commit->parents &&
3967 oideq(&commit->parents->item->object.oid,
3968 &head_commit->object.oid);
3971 * If any merge head is different from the original one, we cannot
3972 * fast-forward.
3974 if (can_fast_forward) {
3975 struct commit_list *p = commit->parents->next;
3977 for (j = to_merge; j && p; j = j->next, p = p->next)
3978 if (!oideq(&j->item->object.oid,
3979 &p->item->object.oid)) {
3980 can_fast_forward = 0;
3981 break;
3984 * If the number of merge heads differs from the original merge
3985 * commit, we cannot fast-forward.
3987 if (j || p)
3988 can_fast_forward = 0;
3991 if (can_fast_forward) {
3992 rollback_lock_file(&lock);
3993 ret = fast_forward_to(r, &commit->object.oid,
3994 &head_commit->object.oid, 0, opts);
3995 if (flags & TODO_EDIT_MERGE_MSG)
3996 goto fast_forward_edit;
3998 goto leave_merge;
4001 if (commit) {
4002 const char *encoding = get_commit_output_encoding();
4003 const char *message = repo_logmsg_reencode(r, commit, NULL,
4004 encoding);
4005 const char *body;
4006 int len;
4008 if (!message) {
4009 ret = error(_("could not get commit message of '%s'"),
4010 oid_to_hex(&commit->object.oid));
4011 goto leave_merge;
4013 write_author_script(message);
4014 find_commit_subject(message, &body);
4015 len = strlen(body);
4016 ret = write_message(body, len, git_path_merge_msg(r), 0);
4017 repo_unuse_commit_buffer(r, commit, message);
4018 if (ret) {
4019 error_errno(_("could not write '%s'"),
4020 git_path_merge_msg(r));
4021 goto leave_merge;
4023 } else {
4024 struct strbuf buf = STRBUF_INIT;
4025 int len;
4027 strbuf_addf(&buf, "author %s", git_author_info(0));
4028 write_author_script(buf.buf);
4029 strbuf_reset(&buf);
4031 if (oneline_offset < arg_len) {
4032 p = arg + oneline_offset;
4033 len = arg_len - oneline_offset;
4034 } else {
4035 strbuf_addf(&buf, "Merge %s '%.*s'",
4036 to_merge->next ? "branches" : "branch",
4037 merge_arg_len, arg);
4038 p = buf.buf;
4039 len = buf.len;
4042 ret = write_message(p, len, git_path_merge_msg(r), 0);
4043 strbuf_release(&buf);
4044 if (ret) {
4045 error_errno(_("could not write '%s'"),
4046 git_path_merge_msg(r));
4047 goto leave_merge;
4051 if (strategy || to_merge->next) {
4052 /* Octopus merge */
4053 struct child_process cmd = CHILD_PROCESS_INIT;
4055 if (read_env_script(&cmd.env)) {
4056 const char *gpg_opt = gpg_sign_opt_quoted(opts);
4058 ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
4059 goto leave_merge;
4062 if (opts->committer_date_is_author_date)
4063 strvec_pushf(&cmd.env, "GIT_COMMITTER_DATE=%s",
4064 opts->ignore_date ?
4065 "" :
4066 author_date_from_env(&cmd.env));
4067 if (opts->ignore_date)
4068 strvec_push(&cmd.env, "GIT_AUTHOR_DATE=");
4070 cmd.git_cmd = 1;
4071 strvec_push(&cmd.args, "merge");
4072 strvec_push(&cmd.args, "-s");
4073 if (!strategy)
4074 strvec_push(&cmd.args, "octopus");
4075 else {
4076 strvec_push(&cmd.args, strategy);
4077 for (k = 0; k < opts->xopts.nr; k++)
4078 strvec_pushf(&cmd.args,
4079 "-X%s", opts->xopts.v[k]);
4081 if (!(flags & TODO_EDIT_MERGE_MSG))
4082 strvec_push(&cmd.args, "--no-edit");
4083 else
4084 strvec_push(&cmd.args, "--edit");
4085 strvec_push(&cmd.args, "--no-ff");
4086 strvec_push(&cmd.args, "--no-log");
4087 strvec_push(&cmd.args, "--no-stat");
4088 strvec_push(&cmd.args, "-F");
4089 strvec_push(&cmd.args, git_path_merge_msg(r));
4090 if (opts->gpg_sign)
4091 strvec_pushf(&cmd.args, "-S%s", opts->gpg_sign);
4092 else
4093 strvec_push(&cmd.args, "--no-gpg-sign");
4095 /* Add the tips to be merged */
4096 for (j = to_merge; j; j = j->next)
4097 strvec_push(&cmd.args,
4098 oid_to_hex(&j->item->object.oid));
4100 strbuf_release(&ref_name);
4101 refs_delete_ref(get_main_ref_store(r), "", "CHERRY_PICK_HEAD",
4102 NULL, 0);
4103 rollback_lock_file(&lock);
4105 ret = run_command(&cmd);
4107 /* force re-reading of the cache */
4108 if (!ret) {
4109 discard_index(r->index);
4110 if (repo_read_index(r) < 0)
4111 ret = error(_("could not read index"));
4113 goto leave_merge;
4116 merge_commit = to_merge->item;
4117 bases = repo_get_merge_bases(r, head_commit, merge_commit);
4118 if (bases && oideq(&merge_commit->object.oid,
4119 &bases->item->object.oid)) {
4120 ret = 0;
4121 /* skip merging an ancestor of HEAD */
4122 goto leave_merge;
4125 write_message(oid_to_hex(&merge_commit->object.oid), the_hash_algo->hexsz,
4126 git_path_merge_head(r), 0);
4127 write_message("no-ff", 5, git_path_merge_mode(r), 0);
4129 bases = reverse_commit_list(bases);
4131 repo_read_index(r);
4132 init_merge_options(&o, r);
4133 o.branch1 = "HEAD";
4134 o.branch2 = ref_name.buf;
4135 o.buffer_output = 2;
4137 if (!opts->strategy || !strcmp(opts->strategy, "ort")) {
4139 * TODO: Should use merge_incore_recursive() and
4140 * merge_switch_to_result(), skipping the call to
4141 * merge_switch_to_result() when we don't actually need to
4142 * update the index and working copy immediately.
4144 ret = merge_ort_recursive(&o,
4145 head_commit, merge_commit, bases,
4146 &i);
4147 } else {
4148 ret = merge_recursive(&o, head_commit, merge_commit, bases,
4149 &i);
4151 if (ret <= 0)
4152 fputs(o.obuf.buf, stdout);
4153 strbuf_release(&o.obuf);
4154 if (ret < 0) {
4155 error(_("could not even attempt to merge '%.*s'"),
4156 merge_arg_len, arg);
4157 goto leave_merge;
4160 * The return value of merge_recursive() is 1 on clean, and 0 on
4161 * unclean merge.
4163 * Let's reverse that, so that do_merge() returns 0 upon success and
4164 * 1 upon failed merge (keeping the return value -1 for the cases where
4165 * we will want to reschedule the `merge` command).
4167 ret = !ret;
4169 if (r->index->cache_changed &&
4170 write_locked_index(r->index, &lock, COMMIT_LOCK)) {
4171 ret = error(_("merge: Unable to write new index file"));
4172 goto leave_merge;
4175 rollback_lock_file(&lock);
4176 if (ret)
4177 repo_rerere(r, opts->allow_rerere_auto);
4178 else
4180 * In case of problems, we now want to return a positive
4181 * value (a negative one would indicate that the `merge`
4182 * command needs to be rescheduled).
4184 ret = !!run_git_commit(git_path_merge_msg(r), opts,
4185 run_commit_flags);
4187 if (!ret && flags & TODO_EDIT_MERGE_MSG) {
4188 fast_forward_edit:
4189 *check_todo = 1;
4190 run_commit_flags |= AMEND_MSG | EDIT_MSG | VERIFY_MSG;
4191 ret = !!run_git_commit(NULL, opts, run_commit_flags);
4195 leave_merge:
4196 strbuf_release(&ref_name);
4197 rollback_lock_file(&lock);
4198 free_commit_list(to_merge);
4199 return ret;
4202 static int write_update_refs_state(struct string_list *refs_to_oids)
4204 int result = 0;
4205 struct lock_file lock = LOCK_INIT;
4206 FILE *fp = NULL;
4207 struct string_list_item *item;
4208 char *path;
4210 path = rebase_path_update_refs(the_repository->gitdir);
4212 if (!refs_to_oids->nr) {
4213 if (unlink(path) && errno != ENOENT)
4214 result = error_errno(_("could not unlink: %s"), path);
4215 goto cleanup;
4218 if (safe_create_leading_directories(path)) {
4219 result = error(_("unable to create leading directories of %s"),
4220 path);
4221 goto cleanup;
4224 if (hold_lock_file_for_update(&lock, path, 0) < 0) {
4225 result = error(_("another 'rebase' process appears to be running; "
4226 "'%s.lock' already exists"),
4227 path);
4228 goto cleanup;
4231 fp = fdopen_lock_file(&lock, "w");
4232 if (!fp) {
4233 result = error_errno(_("could not open '%s' for writing"), path);
4234 rollback_lock_file(&lock);
4235 goto cleanup;
4238 for_each_string_list_item(item, refs_to_oids) {
4239 struct update_ref_record *rec = item->util;
4240 fprintf(fp, "%s\n%s\n%s\n", item->string,
4241 oid_to_hex(&rec->before), oid_to_hex(&rec->after));
4244 result = commit_lock_file(&lock);
4246 cleanup:
4247 free(path);
4248 return result;
4252 * Parse the update-refs file for the current rebase, then remove the
4253 * refs that do not appear in the todo_list (and have not had updated
4254 * values stored) and add refs that are in the todo_list but not
4255 * represented in the update-refs file.
4257 * If there are changes to the update-refs list, then write the new state
4258 * to disk.
4260 void todo_list_filter_update_refs(struct repository *r,
4261 struct todo_list *todo_list)
4263 int i;
4264 int updated = 0;
4265 struct string_list update_refs = STRING_LIST_INIT_DUP;
4267 sequencer_get_update_refs_state(r->gitdir, &update_refs);
4270 * For each item in the update_refs list, if it has no updated
4271 * value and does not appear in the todo_list, then remove it
4272 * from the update_refs list.
4274 for (i = 0; i < update_refs.nr; i++) {
4275 int j;
4276 int found = 0;
4277 const char *ref = update_refs.items[i].string;
4278 size_t reflen = strlen(ref);
4279 struct update_ref_record *rec = update_refs.items[i].util;
4281 /* OID already stored as updated. */
4282 if (!is_null_oid(&rec->after))
4283 continue;
4285 for (j = 0; !found && j < todo_list->nr; j++) {
4286 struct todo_item *item = &todo_list->items[j];
4287 const char *arg = todo_list->buf.buf + item->arg_offset;
4289 if (item->command != TODO_UPDATE_REF)
4290 continue;
4292 if (item->arg_len != reflen ||
4293 strncmp(arg, ref, reflen))
4294 continue;
4296 found = 1;
4299 if (!found) {
4300 free(update_refs.items[i].string);
4301 free(update_refs.items[i].util);
4303 update_refs.nr--;
4304 MOVE_ARRAY(update_refs.items + i, update_refs.items + i + 1, update_refs.nr - i);
4306 updated = 1;
4307 i--;
4312 * For each todo_item, check if its ref is in the update_refs list.
4313 * If not, then add it as an un-updated ref.
4315 for (i = 0; i < todo_list->nr; i++) {
4316 struct todo_item *item = &todo_list->items[i];
4317 const char *arg = todo_list->buf.buf + item->arg_offset;
4318 int j, found = 0;
4320 if (item->command != TODO_UPDATE_REF)
4321 continue;
4323 for (j = 0; !found && j < update_refs.nr; j++) {
4324 const char *ref = update_refs.items[j].string;
4326 found = strlen(ref) == item->arg_len &&
4327 !strncmp(ref, arg, item->arg_len);
4330 if (!found) {
4331 struct string_list_item *inserted;
4332 struct strbuf argref = STRBUF_INIT;
4334 strbuf_add(&argref, arg, item->arg_len);
4335 inserted = string_list_insert(&update_refs, argref.buf);
4336 inserted->util = init_update_ref_record(argref.buf);
4337 strbuf_release(&argref);
4338 updated = 1;
4342 if (updated)
4343 write_update_refs_state(&update_refs);
4344 string_list_clear(&update_refs, 1);
4347 static int do_update_ref(struct repository *r, const char *refname)
4349 struct string_list_item *item;
4350 struct string_list list = STRING_LIST_INIT_DUP;
4352 if (sequencer_get_update_refs_state(r->gitdir, &list))
4353 return -1;
4355 for_each_string_list_item(item, &list) {
4356 if (!strcmp(item->string, refname)) {
4357 struct update_ref_record *rec = item->util;
4358 if (read_ref("HEAD", &rec->after))
4359 return -1;
4360 break;
4364 write_update_refs_state(&list);
4365 string_list_clear(&list, 1);
4366 return 0;
4369 static int do_update_refs(struct repository *r, int quiet)
4371 int res = 0;
4372 struct string_list_item *item;
4373 struct string_list refs_to_oids = STRING_LIST_INIT_DUP;
4374 struct ref_store *refs = get_main_ref_store(r);
4375 struct strbuf update_msg = STRBUF_INIT;
4376 struct strbuf error_msg = STRBUF_INIT;
4378 if ((res = sequencer_get_update_refs_state(r->gitdir, &refs_to_oids)))
4379 return res;
4381 for_each_string_list_item(item, &refs_to_oids) {
4382 struct update_ref_record *rec = item->util;
4383 int loop_res;
4385 loop_res = refs_update_ref(refs, "rewritten during rebase",
4386 item->string,
4387 &rec->after, &rec->before,
4388 0, UPDATE_REFS_MSG_ON_ERR);
4389 res |= loop_res;
4391 if (quiet)
4392 continue;
4394 if (loop_res)
4395 strbuf_addf(&error_msg, "\t%s\n", item->string);
4396 else
4397 strbuf_addf(&update_msg, "\t%s\n", item->string);
4400 if (!quiet &&
4401 (update_msg.len || error_msg.len)) {
4402 fprintf(stderr,
4403 _("Updated the following refs with %s:\n%s"),
4404 "--update-refs",
4405 update_msg.buf);
4407 if (res)
4408 fprintf(stderr,
4409 _("Failed to update the following refs with %s:\n%s"),
4410 "--update-refs",
4411 error_msg.buf);
4414 string_list_clear(&refs_to_oids, 1);
4415 strbuf_release(&update_msg);
4416 strbuf_release(&error_msg);
4417 return res;
4420 static int is_final_fixup(struct todo_list *todo_list)
4422 int i = todo_list->current;
4424 if (!is_fixup(todo_list->items[i].command))
4425 return 0;
4427 while (++i < todo_list->nr)
4428 if (is_fixup(todo_list->items[i].command))
4429 return 0;
4430 else if (!is_noop(todo_list->items[i].command))
4431 break;
4432 return 1;
4435 static enum todo_command peek_command(struct todo_list *todo_list, int offset)
4437 int i;
4439 for (i = todo_list->current + offset; i < todo_list->nr; i++)
4440 if (!is_noop(todo_list->items[i].command))
4441 return todo_list->items[i].command;
4443 return -1;
4446 void create_autostash(struct repository *r, const char *path)
4448 struct strbuf buf = STRBUF_INIT;
4449 struct lock_file lock_file = LOCK_INIT;
4450 int fd;
4452 fd = repo_hold_locked_index(r, &lock_file, 0);
4453 refresh_index(r->index, REFRESH_QUIET, NULL, NULL, NULL);
4454 if (0 <= fd)
4455 repo_update_index_if_able(r, &lock_file);
4456 rollback_lock_file(&lock_file);
4458 if (has_unstaged_changes(r, 1) ||
4459 has_uncommitted_changes(r, 1)) {
4460 struct child_process stash = CHILD_PROCESS_INIT;
4461 struct reset_head_opts ropts = { .flags = RESET_HEAD_HARD };
4462 struct object_id oid;
4464 strvec_pushl(&stash.args,
4465 "stash", "create", "autostash", NULL);
4466 stash.git_cmd = 1;
4467 stash.no_stdin = 1;
4468 strbuf_reset(&buf);
4469 if (capture_command(&stash, &buf, GIT_MAX_HEXSZ))
4470 die(_("Cannot autostash"));
4471 strbuf_trim_trailing_newline(&buf);
4472 if (repo_get_oid(r, buf.buf, &oid))
4473 die(_("Unexpected stash response: '%s'"),
4474 buf.buf);
4475 strbuf_reset(&buf);
4476 strbuf_add_unique_abbrev(&buf, &oid, DEFAULT_ABBREV);
4478 if (safe_create_leading_directories_const(path))
4479 die(_("Could not create directory for '%s'"),
4480 path);
4481 write_file(path, "%s", oid_to_hex(&oid));
4482 printf(_("Created autostash: %s\n"), buf.buf);
4483 if (reset_head(r, &ropts) < 0)
4484 die(_("could not reset --hard"));
4485 discard_index(r->index);
4486 if (repo_read_index(r) < 0)
4487 die(_("could not read index"));
4489 strbuf_release(&buf);
4492 static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply)
4494 struct child_process child = CHILD_PROCESS_INIT;
4495 int ret = 0;
4497 if (attempt_apply) {
4498 child.git_cmd = 1;
4499 child.no_stdout = 1;
4500 child.no_stderr = 1;
4501 strvec_push(&child.args, "stash");
4502 strvec_push(&child.args, "apply");
4503 strvec_push(&child.args, stash_oid);
4504 ret = run_command(&child);
4507 if (attempt_apply && !ret)
4508 fprintf(stderr, _("Applied autostash.\n"));
4509 else {
4510 struct child_process store = CHILD_PROCESS_INIT;
4512 store.git_cmd = 1;
4513 strvec_push(&store.args, "stash");
4514 strvec_push(&store.args, "store");
4515 strvec_push(&store.args, "-m");
4516 strvec_push(&store.args, "autostash");
4517 strvec_push(&store.args, "-q");
4518 strvec_push(&store.args, stash_oid);
4519 if (run_command(&store))
4520 ret = error(_("cannot store %s"), stash_oid);
4521 else
4522 fprintf(stderr,
4523 _("%s\n"
4524 "Your changes are safe in the stash.\n"
4525 "You can run \"git stash pop\" or"
4526 " \"git stash drop\" at any time.\n"),
4527 attempt_apply ?
4528 _("Applying autostash resulted in conflicts.") :
4529 _("Autostash exists; creating a new stash entry."));
4532 return ret;
4535 static int apply_save_autostash(const char *path, int attempt_apply)
4537 struct strbuf stash_oid = STRBUF_INIT;
4538 int ret = 0;
4540 if (!read_oneliner(&stash_oid, path,
4541 READ_ONELINER_SKIP_IF_EMPTY)) {
4542 strbuf_release(&stash_oid);
4543 return 0;
4545 strbuf_trim(&stash_oid);
4547 ret = apply_save_autostash_oid(stash_oid.buf, attempt_apply);
4549 unlink(path);
4550 strbuf_release(&stash_oid);
4551 return ret;
4554 int save_autostash(const char *path)
4556 return apply_save_autostash(path, 0);
4559 int apply_autostash(const char *path)
4561 return apply_save_autostash(path, 1);
4564 int apply_autostash_oid(const char *stash_oid)
4566 return apply_save_autostash_oid(stash_oid, 1);
4569 static int checkout_onto(struct repository *r, struct replay_opts *opts,
4570 const char *onto_name, const struct object_id *onto,
4571 const struct object_id *orig_head)
4573 struct reset_head_opts ropts = {
4574 .oid = onto,
4575 .orig_head = orig_head,
4576 .flags = RESET_HEAD_DETACH | RESET_ORIG_HEAD |
4577 RESET_HEAD_RUN_POST_CHECKOUT_HOOK,
4578 .head_msg = reflog_message(opts, "start", "checkout %s",
4579 onto_name),
4580 .default_reflog_action = sequencer_reflog_action(opts)
4582 if (reset_head(r, &ropts)) {
4583 apply_autostash(rebase_path_autostash());
4584 sequencer_remove_state(opts);
4585 return error(_("could not detach HEAD"));
4588 return 0;
4591 static int stopped_at_head(struct repository *r)
4593 struct object_id head;
4594 struct commit *commit;
4595 struct commit_message message;
4597 if (repo_get_oid(r, "HEAD", &head) ||
4598 !(commit = lookup_commit(r, &head)) ||
4599 repo_parse_commit(r, commit) || get_message(commit, &message))
4600 fprintf(stderr, _("Stopped at HEAD\n"));
4601 else {
4602 fprintf(stderr, _("Stopped at %s\n"), message.label);
4603 free_message(commit, &message);
4605 return 0;
4609 static int reread_todo_if_changed(struct repository *r,
4610 struct todo_list *todo_list,
4611 struct replay_opts *opts)
4613 int offset;
4614 struct strbuf buf = STRBUF_INIT;
4616 if (strbuf_read_file_or_whine(&buf, get_todo_path(opts)) < 0)
4617 return -1;
4618 offset = get_item_line_offset(todo_list, todo_list->current + 1);
4619 if (buf.len != todo_list->buf.len - offset ||
4620 memcmp(buf.buf, todo_list->buf.buf + offset, buf.len)) {
4621 /* Reread the todo file if it has changed. */
4622 todo_list_release(todo_list);
4623 if (read_populate_todo(r, todo_list, opts))
4624 return -1; /* message was printed */
4625 /* `current` will be incremented on return */
4626 todo_list->current = -1;
4628 strbuf_release(&buf);
4630 return 0;
4633 static const char rescheduled_advice[] =
4634 N_("Could not execute the todo command\n"
4635 "\n"
4636 " %.*s"
4637 "\n"
4638 "It has been rescheduled; To edit the command before continuing, please\n"
4639 "edit the todo list first:\n"
4640 "\n"
4641 " git rebase --edit-todo\n"
4642 " git rebase --continue\n");
4644 static int pick_commits(struct repository *r,
4645 struct todo_list *todo_list,
4646 struct replay_opts *opts)
4648 int res = 0, reschedule = 0;
4650 opts->reflog_message = sequencer_reflog_action(opts);
4651 if (opts->allow_ff)
4652 assert(!(opts->signoff || opts->no_commit ||
4653 opts->record_origin || should_edit(opts) ||
4654 opts->committer_date_is_author_date ||
4655 opts->ignore_date));
4656 if (read_and_refresh_cache(r, opts))
4657 return -1;
4659 while (todo_list->current < todo_list->nr) {
4660 struct todo_item *item = todo_list->items + todo_list->current;
4661 const char *arg = todo_item_get_arg(todo_list, item);
4662 int check_todo = 0;
4664 if (save_todo(todo_list, opts))
4665 return -1;
4666 if (is_rebase_i(opts)) {
4667 if (item->command != TODO_COMMENT) {
4668 FILE *f = fopen(rebase_path_msgnum(), "w");
4670 todo_list->done_nr++;
4672 if (f) {
4673 fprintf(f, "%d\n", todo_list->done_nr);
4674 fclose(f);
4676 if (!opts->quiet)
4677 fprintf(stderr, _("Rebasing (%d/%d)%s"),
4678 todo_list->done_nr,
4679 todo_list->total_nr,
4680 opts->verbose ? "\n" : "\r");
4682 unlink(rebase_path_message());
4683 unlink(rebase_path_author_script());
4684 unlink(rebase_path_stopped_sha());
4685 unlink(rebase_path_amend());
4686 unlink(git_path_merge_head(r));
4687 unlink(git_path_auto_merge(r));
4688 delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
4690 if (item->command == TODO_BREAK) {
4691 if (!opts->verbose)
4692 term_clear_line();
4693 return stopped_at_head(r);
4696 if (item->command <= TODO_SQUASH) {
4697 if (is_rebase_i(opts))
4698 opts->reflog_message = reflog_message(opts,
4699 command_to_string(item->command), NULL);
4701 res = do_pick_commit(r, item, opts,
4702 is_final_fixup(todo_list),
4703 &check_todo);
4704 if (is_rebase_i(opts) && res < 0) {
4705 /* Reschedule */
4706 advise(_(rescheduled_advice),
4707 get_item_line_length(todo_list,
4708 todo_list->current),
4709 get_item_line(todo_list,
4710 todo_list->current));
4711 todo_list->current--;
4712 if (save_todo(todo_list, opts))
4713 return -1;
4715 if (item->command == TODO_EDIT) {
4716 struct commit *commit = item->commit;
4717 if (!res) {
4718 if (!opts->verbose)
4719 term_clear_line();
4720 fprintf(stderr,
4721 _("Stopped at %s... %.*s\n"),
4722 short_commit_name(commit),
4723 item->arg_len, arg);
4725 return error_with_patch(r, commit,
4726 arg, item->arg_len, opts, res, !res);
4728 if (is_rebase_i(opts) && !res)
4729 record_in_rewritten(&item->commit->object.oid,
4730 peek_command(todo_list, 1));
4731 if (res && is_fixup(item->command)) {
4732 if (res == 1)
4733 intend_to_amend();
4734 return error_failed_squash(r, item->commit, opts,
4735 item->arg_len, arg);
4736 } else if (res && is_rebase_i(opts) && item->commit) {
4737 int to_amend = 0;
4738 struct object_id oid;
4741 * If we are rewording and have either
4742 * fast-forwarded already, or are about to
4743 * create a new root commit, we want to amend,
4744 * otherwise we do not.
4746 if (item->command == TODO_REWORD &&
4747 !repo_get_oid(r, "HEAD", &oid) &&
4748 (oideq(&item->commit->object.oid, &oid) ||
4749 (opts->have_squash_onto &&
4750 oideq(&opts->squash_onto, &oid))))
4751 to_amend = 1;
4753 return res | error_with_patch(r, item->commit,
4754 arg, item->arg_len, opts,
4755 res, to_amend);
4757 } else if (item->command == TODO_EXEC) {
4758 char *end_of_arg = (char *)(arg + item->arg_len);
4759 int saved = *end_of_arg;
4761 if (!opts->verbose)
4762 term_clear_line();
4763 *end_of_arg = '\0';
4764 res = do_exec(r, arg);
4765 *end_of_arg = saved;
4767 if (res) {
4768 if (opts->reschedule_failed_exec)
4769 reschedule = 1;
4771 check_todo = 1;
4772 } else if (item->command == TODO_LABEL) {
4773 if ((res = do_label(r, arg, item->arg_len)))
4774 reschedule = 1;
4775 } else if (item->command == TODO_RESET) {
4776 if ((res = do_reset(r, arg, item->arg_len, opts)))
4777 reschedule = 1;
4778 } else if (item->command == TODO_MERGE) {
4779 if ((res = do_merge(r, item->commit, arg, item->arg_len,
4780 item->flags, &check_todo, opts)) < 0)
4781 reschedule = 1;
4782 else if (item->commit)
4783 record_in_rewritten(&item->commit->object.oid,
4784 peek_command(todo_list, 1));
4785 if (res > 0)
4786 /* failed with merge conflicts */
4787 return error_with_patch(r, item->commit,
4788 arg, item->arg_len,
4789 opts, res, 0);
4790 } else if (item->command == TODO_UPDATE_REF) {
4791 struct strbuf ref = STRBUF_INIT;
4792 strbuf_add(&ref, arg, item->arg_len);
4793 if ((res = do_update_ref(r, ref.buf)))
4794 reschedule = 1;
4795 strbuf_release(&ref);
4796 } else if (!is_noop(item->command))
4797 return error(_("unknown command %d"), item->command);
4799 if (reschedule) {
4800 advise(_(rescheduled_advice),
4801 get_item_line_length(todo_list,
4802 todo_list->current),
4803 get_item_line(todo_list, todo_list->current));
4804 todo_list->current--;
4805 if (save_todo(todo_list, opts))
4806 return -1;
4807 if (item->commit)
4808 return error_with_patch(r,
4809 item->commit,
4810 arg, item->arg_len,
4811 opts, res, 0);
4812 } else if (is_rebase_i(opts) && check_todo && !res &&
4813 reread_todo_if_changed(r, todo_list, opts)) {
4814 return -1;
4817 todo_list->current++;
4818 if (res)
4819 return res;
4822 if (is_rebase_i(opts)) {
4823 struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
4824 struct stat st;
4826 /* Stopped in the middle, as planned? */
4827 if (todo_list->current < todo_list->nr)
4828 return 0;
4830 if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
4831 starts_with(head_ref.buf, "refs/")) {
4832 const char *msg;
4833 struct object_id head, orig;
4834 int res;
4836 if (repo_get_oid(r, "HEAD", &head)) {
4837 res = error(_("cannot read HEAD"));
4838 cleanup_head_ref:
4839 strbuf_release(&head_ref);
4840 strbuf_release(&buf);
4841 return res;
4843 if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
4844 get_oid_hex(buf.buf, &orig)) {
4845 res = error(_("could not read orig-head"));
4846 goto cleanup_head_ref;
4848 strbuf_reset(&buf);
4849 if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
4850 res = error(_("could not read 'onto'"));
4851 goto cleanup_head_ref;
4853 msg = reflog_message(opts, "finish", "%s onto %s",
4854 head_ref.buf, buf.buf);
4855 if (update_ref(msg, head_ref.buf, &head, &orig,
4856 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
4857 res = error(_("could not update %s"),
4858 head_ref.buf);
4859 goto cleanup_head_ref;
4861 msg = reflog_message(opts, "finish", "returning to %s",
4862 head_ref.buf);
4863 if (create_symref("HEAD", head_ref.buf, msg)) {
4864 res = error(_("could not update HEAD to %s"),
4865 head_ref.buf);
4866 goto cleanup_head_ref;
4868 strbuf_reset(&buf);
4871 if (opts->verbose) {
4872 struct rev_info log_tree_opt;
4873 struct object_id orig, head;
4875 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
4876 repo_init_revisions(r, &log_tree_opt, NULL);
4877 log_tree_opt.diff = 1;
4878 log_tree_opt.diffopt.output_format =
4879 DIFF_FORMAT_DIFFSTAT;
4880 log_tree_opt.disable_stdin = 1;
4882 if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
4883 !repo_get_oid(r, buf.buf, &orig) &&
4884 !repo_get_oid(r, "HEAD", &head)) {
4885 diff_tree_oid(&orig, &head, "",
4886 &log_tree_opt.diffopt);
4887 log_tree_diff_flush(&log_tree_opt);
4889 release_revisions(&log_tree_opt);
4891 flush_rewritten_pending();
4892 if (!stat(rebase_path_rewritten_list(), &st) &&
4893 st.st_size > 0) {
4894 struct child_process child = CHILD_PROCESS_INIT;
4895 struct run_hooks_opt hook_opt = RUN_HOOKS_OPT_INIT;
4897 child.in = open(rebase_path_rewritten_list(), O_RDONLY);
4898 child.git_cmd = 1;
4899 strvec_push(&child.args, "notes");
4900 strvec_push(&child.args, "copy");
4901 strvec_push(&child.args, "--for-rewrite=rebase");
4902 /* we don't care if this copying failed */
4903 run_command(&child);
4905 hook_opt.path_to_stdin = rebase_path_rewritten_list();
4906 strvec_push(&hook_opt.args, "rebase");
4907 run_hooks_opt("post-rewrite", &hook_opt);
4909 apply_autostash(rebase_path_autostash());
4911 if (!opts->quiet) {
4912 if (!opts->verbose)
4913 term_clear_line();
4914 fprintf(stderr,
4915 _("Successfully rebased and updated %s.\n"),
4916 head_ref.buf);
4919 strbuf_release(&buf);
4920 strbuf_release(&head_ref);
4922 if (do_update_refs(r, opts->quiet))
4923 return -1;
4927 * Sequence of picks finished successfully; cleanup by
4928 * removing the .git/sequencer directory
4930 return sequencer_remove_state(opts);
4933 static int continue_single_pick(struct repository *r, struct replay_opts *opts)
4935 struct child_process cmd = CHILD_PROCESS_INIT;
4937 if (!refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD") &&
4938 !refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD"))
4939 return error(_("no cherry-pick or revert in progress"));
4941 cmd.git_cmd = 1;
4942 strvec_push(&cmd.args, "commit");
4945 * continue_single_pick() handles the case of recovering from a
4946 * conflict. should_edit() doesn't handle that case; for a conflict,
4947 * we want to edit if the user asked for it, or if they didn't specify
4948 * and stdin is a tty.
4950 if (!opts->edit || (opts->edit < 0 && !isatty(0)))
4952 * Include --cleanup=strip as well because we don't want the
4953 * "# Conflicts:" messages.
4955 strvec_pushl(&cmd.args, "--no-edit", "--cleanup=strip", NULL);
4957 return run_command(&cmd);
4960 static int commit_staged_changes(struct repository *r,
4961 struct replay_opts *opts,
4962 struct todo_list *todo_list)
4964 unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
4965 unsigned int final_fixup = 0, is_clean;
4967 if (has_unstaged_changes(r, 1))
4968 return error(_("cannot rebase: You have unstaged changes."));
4970 is_clean = !has_uncommitted_changes(r, 0);
4972 if (file_exists(rebase_path_amend())) {
4973 struct strbuf rev = STRBUF_INIT;
4974 struct object_id head, to_amend;
4976 if (repo_get_oid(r, "HEAD", &head))
4977 return error(_("cannot amend non-existing commit"));
4978 if (!read_oneliner(&rev, rebase_path_amend(), 0))
4979 return error(_("invalid file: '%s'"), rebase_path_amend());
4980 if (get_oid_hex(rev.buf, &to_amend))
4981 return error(_("invalid contents: '%s'"),
4982 rebase_path_amend());
4983 if (!is_clean && !oideq(&head, &to_amend))
4984 return error(_("\nYou have uncommitted changes in your "
4985 "working tree. Please, commit them\n"
4986 "first and then run 'git rebase "
4987 "--continue' again."));
4989 * When skipping a failed fixup/squash, we need to edit the
4990 * commit message, the current fixup list and count, and if it
4991 * was the last fixup/squash in the chain, we need to clean up
4992 * the commit message and if there was a squash, let the user
4993 * edit it.
4995 if (!is_clean || !opts->current_fixup_count)
4996 ; /* this is not the final fixup */
4997 else if (!oideq(&head, &to_amend) ||
4998 !file_exists(rebase_path_stopped_sha())) {
4999 /* was a final fixup or squash done manually? */
5000 if (!is_fixup(peek_command(todo_list, 0))) {
5001 unlink(rebase_path_fixup_msg());
5002 unlink(rebase_path_squash_msg());
5003 unlink(rebase_path_current_fixups());
5004 strbuf_reset(&opts->current_fixups);
5005 opts->current_fixup_count = 0;
5007 } else {
5008 /* we are in a fixup/squash chain */
5009 const char *p = opts->current_fixups.buf;
5010 int len = opts->current_fixups.len;
5012 opts->current_fixup_count--;
5013 if (!len)
5014 BUG("Incorrect current_fixups:\n%s", p);
5015 while (len && p[len - 1] != '\n')
5016 len--;
5017 strbuf_setlen(&opts->current_fixups, len);
5018 if (write_message(p, len, rebase_path_current_fixups(),
5019 0) < 0)
5020 return error(_("could not write file: '%s'"),
5021 rebase_path_current_fixups());
5024 * If a fixup/squash in a fixup/squash chain failed, the
5025 * commit message is already correct, no need to commit
5026 * it again.
5028 * Only if it is the final command in the fixup/squash
5029 * chain, and only if the chain is longer than a single
5030 * fixup/squash command (which was just skipped), do we
5031 * actually need to re-commit with a cleaned up commit
5032 * message.
5034 if (opts->current_fixup_count > 0 &&
5035 !is_fixup(peek_command(todo_list, 0))) {
5036 final_fixup = 1;
5038 * If there was not a single "squash" in the
5039 * chain, we only need to clean up the commit
5040 * message, no need to bother the user with
5041 * opening the commit message in the editor.
5043 if (!starts_with(p, "squash ") &&
5044 !strstr(p, "\nsquash "))
5045 flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;
5046 } else if (is_fixup(peek_command(todo_list, 0))) {
5048 * We need to update the squash message to skip
5049 * the latest commit message.
5051 struct commit *commit;
5052 const char *path = rebase_path_squash_msg();
5053 const char *encoding = get_commit_output_encoding();
5055 if (parse_head(r, &commit) ||
5056 !(p = repo_logmsg_reencode(r, commit, NULL, encoding)) ||
5057 write_message(p, strlen(p), path, 0)) {
5058 repo_unuse_commit_buffer(r, commit, p);
5059 return error(_("could not write file: "
5060 "'%s'"), path);
5062 repo_unuse_commit_buffer(r,
5063 commit, p);
5067 strbuf_release(&rev);
5068 flags |= AMEND_MSG;
5071 if (is_clean) {
5072 if (refs_ref_exists(get_main_ref_store(r),
5073 "CHERRY_PICK_HEAD") &&
5074 refs_delete_ref(get_main_ref_store(r), "",
5075 "CHERRY_PICK_HEAD", NULL, 0))
5076 return error(_("could not remove CHERRY_PICK_HEAD"));
5077 if (unlink(git_path_merge_msg(r)) && errno != ENOENT)
5078 return error_errno(_("could not remove '%s'"),
5079 git_path_merge_msg(r));
5080 if (!final_fixup)
5081 return 0;
5084 if (run_git_commit(final_fixup ? NULL : rebase_path_message(),
5085 opts, flags))
5086 return error(_("could not commit staged changes."));
5087 unlink(rebase_path_amend());
5088 unlink(git_path_merge_head(r));
5089 unlink(git_path_auto_merge(r));
5090 if (final_fixup) {
5091 unlink(rebase_path_fixup_msg());
5092 unlink(rebase_path_squash_msg());
5094 if (opts->current_fixup_count > 0) {
5096 * Whether final fixup or not, we just cleaned up the commit
5097 * message...
5099 unlink(rebase_path_current_fixups());
5100 strbuf_reset(&opts->current_fixups);
5101 opts->current_fixup_count = 0;
5103 return 0;
5106 int sequencer_continue(struct repository *r, struct replay_opts *opts)
5108 struct todo_list todo_list = TODO_LIST_INIT;
5109 int res;
5111 if (read_and_refresh_cache(r, opts))
5112 return -1;
5114 if (read_populate_opts(opts))
5115 return -1;
5116 if (is_rebase_i(opts)) {
5117 if ((res = read_populate_todo(r, &todo_list, opts)))
5118 goto release_todo_list;
5120 if (file_exists(rebase_path_dropped())) {
5121 if ((res = todo_list_check_against_backup(r, &todo_list)))
5122 goto release_todo_list;
5124 unlink(rebase_path_dropped());
5127 opts->reflog_message = reflog_message(opts, "continue", NULL);
5128 if (commit_staged_changes(r, opts, &todo_list)) {
5129 res = -1;
5130 goto release_todo_list;
5132 } else if (!file_exists(get_todo_path(opts)))
5133 return continue_single_pick(r, opts);
5134 else if ((res = read_populate_todo(r, &todo_list, opts)))
5135 goto release_todo_list;
5137 if (!is_rebase_i(opts)) {
5138 /* Verify that the conflict has been resolved */
5139 if (refs_ref_exists(get_main_ref_store(r),
5140 "CHERRY_PICK_HEAD") ||
5141 refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD")) {
5142 res = continue_single_pick(r, opts);
5143 if (res)
5144 goto release_todo_list;
5146 if (index_differs_from(r, "HEAD", NULL, 0)) {
5147 res = error_dirty_index(r, opts);
5148 goto release_todo_list;
5150 todo_list.current++;
5151 } else if (file_exists(rebase_path_stopped_sha())) {
5152 struct strbuf buf = STRBUF_INIT;
5153 struct object_id oid;
5155 if (read_oneliner(&buf, rebase_path_stopped_sha(),
5156 READ_ONELINER_SKIP_IF_EMPTY) &&
5157 !get_oid_hex(buf.buf, &oid))
5158 record_in_rewritten(&oid, peek_command(&todo_list, 0));
5159 strbuf_release(&buf);
5162 res = pick_commits(r, &todo_list, opts);
5163 release_todo_list:
5164 todo_list_release(&todo_list);
5165 return res;
5168 static int single_pick(struct repository *r,
5169 struct commit *cmit,
5170 struct replay_opts *opts)
5172 int check_todo;
5173 struct todo_item item;
5175 item.command = opts->action == REPLAY_PICK ?
5176 TODO_PICK : TODO_REVERT;
5177 item.commit = cmit;
5179 opts->reflog_message = sequencer_reflog_action(opts);
5180 return do_pick_commit(r, &item, opts, 0, &check_todo);
5183 int sequencer_pick_revisions(struct repository *r,
5184 struct replay_opts *opts)
5186 struct todo_list todo_list = TODO_LIST_INIT;
5187 struct object_id oid;
5188 int i, res;
5190 assert(opts->revs);
5191 if (read_and_refresh_cache(r, opts))
5192 return -1;
5194 for (i = 0; i < opts->revs->pending.nr; i++) {
5195 struct object_id oid;
5196 const char *name = opts->revs->pending.objects[i].name;
5198 /* This happens when using --stdin. */
5199 if (!strlen(name))
5200 continue;
5202 if (!repo_get_oid(r, name, &oid)) {
5203 if (!lookup_commit_reference_gently(r, &oid, 1)) {
5204 enum object_type type = oid_object_info(r,
5205 &oid,
5206 NULL);
5207 return error(_("%s: can't cherry-pick a %s"),
5208 name, type_name(type));
5210 } else
5211 return error(_("%s: bad revision"), name);
5215 * If we were called as "git cherry-pick <commit>", just
5216 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
5217 * REVERT_HEAD, and don't touch the sequencer state.
5218 * This means it is possible to cherry-pick in the middle
5219 * of a cherry-pick sequence.
5221 if (opts->revs->cmdline.nr == 1 &&
5222 opts->revs->cmdline.rev->whence == REV_CMD_REV &&
5223 opts->revs->no_walk &&
5224 !opts->revs->cmdline.rev->flags) {
5225 struct commit *cmit;
5226 if (prepare_revision_walk(opts->revs))
5227 return error(_("revision walk setup failed"));
5228 cmit = get_revision(opts->revs);
5229 if (!cmit)
5230 return error(_("empty commit set passed"));
5231 if (get_revision(opts->revs))
5232 BUG("unexpected extra commit from walk");
5233 return single_pick(r, cmit, opts);
5237 * Start a new cherry-pick/ revert sequence; but
5238 * first, make sure that an existing one isn't in
5239 * progress
5242 if (walk_revs_populate_todo(&todo_list, opts) ||
5243 create_seq_dir(r) < 0)
5244 return -1;
5245 if (repo_get_oid(r, "HEAD", &oid) && (opts->action == REPLAY_REVERT))
5246 return error(_("can't revert as initial commit"));
5247 if (save_head(oid_to_hex(&oid)))
5248 return -1;
5249 if (save_opts(opts))
5250 return -1;
5251 update_abort_safety_file();
5252 res = pick_commits(r, &todo_list, opts);
5253 todo_list_release(&todo_list);
5254 return res;
5257 void append_signoff(struct strbuf *msgbuf, size_t ignore_footer, unsigned flag)
5259 unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
5260 struct strbuf sob = STRBUF_INIT;
5261 int has_footer;
5263 strbuf_addstr(&sob, sign_off_header);
5264 strbuf_addstr(&sob, fmt_name(WANT_COMMITTER_IDENT));
5265 strbuf_addch(&sob, '\n');
5267 if (!ignore_footer)
5268 strbuf_complete_line(msgbuf);
5271 * If the whole message buffer is equal to the sob, pretend that we
5272 * found a conforming footer with a matching sob
5274 if (msgbuf->len - ignore_footer == sob.len &&
5275 !strncmp(msgbuf->buf, sob.buf, sob.len))
5276 has_footer = 3;
5277 else
5278 has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
5280 if (!has_footer) {
5281 const char *append_newlines = NULL;
5282 size_t len = msgbuf->len - ignore_footer;
5284 if (!len) {
5286 * The buffer is completely empty. Leave foom for
5287 * the title and body to be filled in by the user.
5289 append_newlines = "\n\n";
5290 } else if (len == 1) {
5292 * Buffer contains a single newline. Add another
5293 * so that we leave room for the title and body.
5295 append_newlines = "\n";
5296 } else if (msgbuf->buf[len - 2] != '\n') {
5298 * Buffer ends with a single newline. Add another
5299 * so that there is an empty line between the message
5300 * body and the sob.
5302 append_newlines = "\n";
5303 } /* else, the buffer already ends with two newlines. */
5305 if (append_newlines)
5306 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
5307 append_newlines, strlen(append_newlines));
5310 if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
5311 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
5312 sob.buf, sob.len);
5314 strbuf_release(&sob);
5317 struct labels_entry {
5318 struct hashmap_entry entry;
5319 char label[FLEX_ARRAY];
5322 static int labels_cmp(const void *fndata UNUSED,
5323 const struct hashmap_entry *eptr,
5324 const struct hashmap_entry *entry_or_key, const void *key)
5326 const struct labels_entry *a, *b;
5328 a = container_of(eptr, const struct labels_entry, entry);
5329 b = container_of(entry_or_key, const struct labels_entry, entry);
5331 return key ? strcmp(a->label, key) : strcmp(a->label, b->label);
5334 struct string_entry {
5335 struct oidmap_entry entry;
5336 char string[FLEX_ARRAY];
5339 struct label_state {
5340 struct oidmap commit2label;
5341 struct hashmap labels;
5342 struct strbuf buf;
5345 static const char *label_oid(struct object_id *oid, const char *label,
5346 struct label_state *state)
5348 struct labels_entry *labels_entry;
5349 struct string_entry *string_entry;
5350 struct object_id dummy;
5351 int i;
5353 string_entry = oidmap_get(&state->commit2label, oid);
5354 if (string_entry)
5355 return string_entry->string;
5358 * For "uninteresting" commits, i.e. commits that are not to be
5359 * rebased, and which can therefore not be labeled, we use a unique
5360 * abbreviation of the commit name. This is slightly more complicated
5361 * than calling repo_find_unique_abbrev() because we also need to make
5362 * sure that the abbreviation does not conflict with any other
5363 * label.
5365 * We disallow "interesting" commits to be labeled by a string that
5366 * is a valid full-length hash, to ensure that we always can find an
5367 * abbreviation for any uninteresting commit's names that does not
5368 * clash with any other label.
5370 strbuf_reset(&state->buf);
5371 if (!label) {
5372 char *p;
5374 strbuf_grow(&state->buf, GIT_MAX_HEXSZ);
5375 label = p = state->buf.buf;
5377 repo_find_unique_abbrev_r(the_repository, p, oid,
5378 default_abbrev);
5381 * We may need to extend the abbreviated hash so that there is
5382 * no conflicting label.
5384 if (hashmap_get_from_hash(&state->labels, strihash(p), p)) {
5385 size_t i = strlen(p) + 1;
5387 oid_to_hex_r(p, oid);
5388 for (; i < the_hash_algo->hexsz; i++) {
5389 char save = p[i];
5390 p[i] = '\0';
5391 if (!hashmap_get_from_hash(&state->labels,
5392 strihash(p), p))
5393 break;
5394 p[i] = save;
5397 } else {
5398 struct strbuf *buf = &state->buf;
5401 * Sanitize labels by replacing non-alpha-numeric characters
5402 * (including white-space ones) by dashes, as they might be
5403 * illegal in file names (and hence in ref names).
5405 * Note that we retain non-ASCII UTF-8 characters (identified
5406 * via the most significant bit). They should be all acceptable
5407 * in file names. We do not validate the UTF-8 here, that's not
5408 * the job of this function.
5410 for (; *label; label++)
5411 if ((*label & 0x80) || isalnum(*label))
5412 strbuf_addch(buf, *label);
5413 /* avoid leading dash and double-dashes */
5414 else if (buf->len && buf->buf[buf->len - 1] != '-')
5415 strbuf_addch(buf, '-');
5416 if (!buf->len) {
5417 strbuf_addstr(buf, "rev-");
5418 strbuf_add_unique_abbrev(buf, oid, default_abbrev);
5420 label = buf->buf;
5422 if ((buf->len == the_hash_algo->hexsz &&
5423 !get_oid_hex(label, &dummy)) ||
5424 (buf->len == 1 && *label == '#') ||
5425 hashmap_get_from_hash(&state->labels,
5426 strihash(label), label)) {
5428 * If the label already exists, or if the label is a
5429 * valid full OID, or the label is a '#' (which we use
5430 * as a separator between merge heads and oneline), we
5431 * append a dash and a number to make it unique.
5433 size_t len = buf->len;
5435 for (i = 2; ; i++) {
5436 strbuf_setlen(buf, len);
5437 strbuf_addf(buf, "-%d", i);
5438 if (!hashmap_get_from_hash(&state->labels,
5439 strihash(buf->buf),
5440 buf->buf))
5441 break;
5444 label = buf->buf;
5448 FLEX_ALLOC_STR(labels_entry, label, label);
5449 hashmap_entry_init(&labels_entry->entry, strihash(label));
5450 hashmap_add(&state->labels, &labels_entry->entry);
5452 FLEX_ALLOC_STR(string_entry, string, label);
5453 oidcpy(&string_entry->entry.oid, oid);
5454 oidmap_put(&state->commit2label, string_entry);
5456 return string_entry->string;
5459 static int make_script_with_merges(struct pretty_print_context *pp,
5460 struct rev_info *revs, struct strbuf *out,
5461 unsigned flags)
5463 int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
5464 int rebase_cousins = flags & TODO_LIST_REBASE_COUSINS;
5465 int root_with_onto = flags & TODO_LIST_ROOT_WITH_ONTO;
5466 int skipped_commit = 0;
5467 struct strbuf buf = STRBUF_INIT, oneline = STRBUF_INIT;
5468 struct strbuf label = STRBUF_INIT;
5469 struct commit_list *commits = NULL, **tail = &commits, *iter;
5470 struct commit_list *tips = NULL, **tips_tail = &tips;
5471 struct commit *commit;
5472 struct oidmap commit2todo = OIDMAP_INIT;
5473 struct string_entry *entry;
5474 struct oidset interesting = OIDSET_INIT, child_seen = OIDSET_INIT,
5475 shown = OIDSET_INIT;
5476 struct label_state state = { OIDMAP_INIT, { NULL }, STRBUF_INIT };
5478 int abbr = flags & TODO_LIST_ABBREVIATE_CMDS;
5479 const char *cmd_pick = abbr ? "p" : "pick",
5480 *cmd_label = abbr ? "l" : "label",
5481 *cmd_reset = abbr ? "t" : "reset",
5482 *cmd_merge = abbr ? "m" : "merge";
5484 oidmap_init(&commit2todo, 0);
5485 oidmap_init(&state.commit2label, 0);
5486 hashmap_init(&state.labels, labels_cmp, NULL, 0);
5487 strbuf_init(&state.buf, 32);
5489 if (revs->cmdline.nr && (revs->cmdline.rev[0].flags & BOTTOM)) {
5490 struct labels_entry *onto_label_entry;
5491 struct object_id *oid = &revs->cmdline.rev[0].item->oid;
5492 FLEX_ALLOC_STR(entry, string, "onto");
5493 oidcpy(&entry->entry.oid, oid);
5494 oidmap_put(&state.commit2label, entry);
5496 FLEX_ALLOC_STR(onto_label_entry, label, "onto");
5497 hashmap_entry_init(&onto_label_entry->entry, strihash("onto"));
5498 hashmap_add(&state.labels, &onto_label_entry->entry);
5502 * First phase:
5503 * - get onelines for all commits
5504 * - gather all branch tips (i.e. 2nd or later parents of merges)
5505 * - label all branch tips
5507 while ((commit = get_revision(revs))) {
5508 struct commit_list *to_merge;
5509 const char *p1, *p2;
5510 struct object_id *oid;
5511 int is_empty;
5513 tail = &commit_list_insert(commit, tail)->next;
5514 oidset_insert(&interesting, &commit->object.oid);
5516 is_empty = is_original_commit_empty(commit);
5517 if (!is_empty && (commit->object.flags & PATCHSAME)) {
5518 if (flags & TODO_LIST_WARN_SKIPPED_CHERRY_PICKS)
5519 warning(_("skipped previously applied commit %s"),
5520 short_commit_name(commit));
5521 skipped_commit = 1;
5522 continue;
5524 if (is_empty && !keep_empty)
5525 continue;
5527 strbuf_reset(&oneline);
5528 pretty_print_commit(pp, commit, &oneline);
5530 to_merge = commit->parents ? commit->parents->next : NULL;
5531 if (!to_merge) {
5532 /* non-merge commit: easy case */
5533 strbuf_reset(&buf);
5534 strbuf_addf(&buf, "%s %s %s", cmd_pick,
5535 oid_to_hex(&commit->object.oid),
5536 oneline.buf);
5537 if (is_empty)
5538 strbuf_addf(&buf, " %c empty",
5539 comment_line_char);
5541 FLEX_ALLOC_STR(entry, string, buf.buf);
5542 oidcpy(&entry->entry.oid, &commit->object.oid);
5543 oidmap_put(&commit2todo, entry);
5545 continue;
5548 /* Create a label */
5549 strbuf_reset(&label);
5550 if (skip_prefix(oneline.buf, "Merge ", &p1) &&
5551 (p1 = strchr(p1, '\'')) &&
5552 (p2 = strchr(++p1, '\'')))
5553 strbuf_add(&label, p1, p2 - p1);
5554 else if (skip_prefix(oneline.buf, "Merge pull request ",
5555 &p1) &&
5556 (p1 = strstr(p1, " from ")))
5557 strbuf_addstr(&label, p1 + strlen(" from "));
5558 else
5559 strbuf_addbuf(&label, &oneline);
5561 strbuf_reset(&buf);
5562 strbuf_addf(&buf, "%s -C %s",
5563 cmd_merge, oid_to_hex(&commit->object.oid));
5565 /* label the tips of merged branches */
5566 for (; to_merge; to_merge = to_merge->next) {
5567 oid = &to_merge->item->object.oid;
5568 strbuf_addch(&buf, ' ');
5570 if (!oidset_contains(&interesting, oid)) {
5571 strbuf_addstr(&buf, label_oid(oid, NULL,
5572 &state));
5573 continue;
5576 tips_tail = &commit_list_insert(to_merge->item,
5577 tips_tail)->next;
5579 strbuf_addstr(&buf, label_oid(oid, label.buf, &state));
5581 strbuf_addf(&buf, " # %s", oneline.buf);
5583 FLEX_ALLOC_STR(entry, string, buf.buf);
5584 oidcpy(&entry->entry.oid, &commit->object.oid);
5585 oidmap_put(&commit2todo, entry);
5587 if (skipped_commit)
5588 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS,
5589 _("use --reapply-cherry-picks to include skipped commits"));
5592 * Second phase:
5593 * - label branch points
5594 * - add HEAD to the branch tips
5596 for (iter = commits; iter; iter = iter->next) {
5597 struct commit_list *parent = iter->item->parents;
5598 for (; parent; parent = parent->next) {
5599 struct object_id *oid = &parent->item->object.oid;
5600 if (!oidset_contains(&interesting, oid))
5601 continue;
5602 if (oidset_insert(&child_seen, oid))
5603 label_oid(oid, "branch-point", &state);
5606 /* Add HEAD as implicit "tip of branch" */
5607 if (!iter->next)
5608 tips_tail = &commit_list_insert(iter->item,
5609 tips_tail)->next;
5613 * Third phase: output the todo list. This is a bit tricky, as we
5614 * want to avoid jumping back and forth between revisions. To
5615 * accomplish that goal, we walk backwards from the branch tips,
5616 * gathering commits not yet shown, reversing the list on the fly,
5617 * then outputting that list (labeling revisions as needed).
5619 strbuf_addf(out, "%s onto\n", cmd_label);
5620 for (iter = tips; iter; iter = iter->next) {
5621 struct commit_list *list = NULL, *iter2;
5623 commit = iter->item;
5624 if (oidset_contains(&shown, &commit->object.oid))
5625 continue;
5626 entry = oidmap_get(&state.commit2label, &commit->object.oid);
5628 if (entry)
5629 strbuf_addf(out, "\n%c Branch %s\n", comment_line_char, entry->string);
5630 else
5631 strbuf_addch(out, '\n');
5633 while (oidset_contains(&interesting, &commit->object.oid) &&
5634 !oidset_contains(&shown, &commit->object.oid)) {
5635 commit_list_insert(commit, &list);
5636 if (!commit->parents) {
5637 commit = NULL;
5638 break;
5640 commit = commit->parents->item;
5643 if (!commit)
5644 strbuf_addf(out, "%s %s\n", cmd_reset,
5645 rebase_cousins || root_with_onto ?
5646 "onto" : "[new root]");
5647 else {
5648 const char *to = NULL;
5650 entry = oidmap_get(&state.commit2label,
5651 &commit->object.oid);
5652 if (entry)
5653 to = entry->string;
5654 else if (!rebase_cousins)
5655 to = label_oid(&commit->object.oid, NULL,
5656 &state);
5658 if (!to || !strcmp(to, "onto"))
5659 strbuf_addf(out, "%s onto\n", cmd_reset);
5660 else {
5661 strbuf_reset(&oneline);
5662 pretty_print_commit(pp, commit, &oneline);
5663 strbuf_addf(out, "%s %s # %s\n",
5664 cmd_reset, to, oneline.buf);
5668 for (iter2 = list; iter2; iter2 = iter2->next) {
5669 struct object_id *oid = &iter2->item->object.oid;
5670 entry = oidmap_get(&commit2todo, oid);
5671 /* only show if not already upstream */
5672 if (entry)
5673 strbuf_addf(out, "%s\n", entry->string);
5674 entry = oidmap_get(&state.commit2label, oid);
5675 if (entry)
5676 strbuf_addf(out, "%s %s\n",
5677 cmd_label, entry->string);
5678 oidset_insert(&shown, oid);
5681 free_commit_list(list);
5684 free_commit_list(commits);
5685 free_commit_list(tips);
5687 strbuf_release(&label);
5688 strbuf_release(&oneline);
5689 strbuf_release(&buf);
5691 oidmap_free(&commit2todo, 1);
5692 oidmap_free(&state.commit2label, 1);
5693 hashmap_clear_and_free(&state.labels, struct labels_entry, entry);
5694 strbuf_release(&state.buf);
5696 return 0;
5699 int sequencer_make_script(struct repository *r, struct strbuf *out, int argc,
5700 const char **argv, unsigned flags)
5702 char *format = NULL;
5703 struct pretty_print_context pp = {0};
5704 struct rev_info revs;
5705 struct commit *commit;
5706 int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
5707 const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";
5708 int rebase_merges = flags & TODO_LIST_REBASE_MERGES;
5709 int reapply_cherry_picks = flags & TODO_LIST_REAPPLY_CHERRY_PICKS;
5710 int skipped_commit = 0;
5711 int ret = 0;
5713 repo_init_revisions(r, &revs, NULL);
5714 revs.verbose_header = 1;
5715 if (!rebase_merges)
5716 revs.max_parents = 1;
5717 revs.cherry_mark = !reapply_cherry_picks;
5718 revs.limited = 1;
5719 revs.reverse = 1;
5720 revs.right_only = 1;
5721 revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
5722 revs.topo_order = 1;
5724 revs.pretty_given = 1;
5725 git_config_get_string("rebase.instructionFormat", &format);
5726 if (!format || !*format) {
5727 free(format);
5728 format = xstrdup("%s");
5730 get_commit_format(format, &revs);
5731 free(format);
5732 pp.fmt = revs.commit_format;
5733 pp.output_encoding = get_log_output_encoding();
5735 if (setup_revisions(argc, argv, &revs, NULL) > 1) {
5736 ret = error(_("make_script: unhandled options"));
5737 goto cleanup;
5740 if (prepare_revision_walk(&revs) < 0) {
5741 ret = error(_("make_script: error preparing revisions"));
5742 goto cleanup;
5745 if (rebase_merges) {
5746 ret = make_script_with_merges(&pp, &revs, out, flags);
5747 goto cleanup;
5750 while ((commit = get_revision(&revs))) {
5751 int is_empty = is_original_commit_empty(commit);
5753 if (!is_empty && (commit->object.flags & PATCHSAME)) {
5754 if (flags & TODO_LIST_WARN_SKIPPED_CHERRY_PICKS)
5755 warning(_("skipped previously applied commit %s"),
5756 short_commit_name(commit));
5757 skipped_commit = 1;
5758 continue;
5760 if (is_empty && !keep_empty)
5761 continue;
5762 strbuf_addf(out, "%s %s ", insn,
5763 oid_to_hex(&commit->object.oid));
5764 pretty_print_commit(&pp, commit, out);
5765 if (is_empty)
5766 strbuf_addf(out, " %c empty", comment_line_char);
5767 strbuf_addch(out, '\n');
5769 if (skipped_commit)
5770 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS,
5771 _("use --reapply-cherry-picks to include skipped commits"));
5772 cleanup:
5773 release_revisions(&revs);
5774 return ret;
5778 * Add commands after pick and (series of) squash/fixup commands
5779 * in the todo list.
5781 static void todo_list_add_exec_commands(struct todo_list *todo_list,
5782 struct string_list *commands)
5784 struct strbuf *buf = &todo_list->buf;
5785 size_t base_offset = buf->len;
5786 int i, insert, nr = 0, alloc = 0;
5787 struct todo_item *items = NULL, *base_items = NULL;
5789 CALLOC_ARRAY(base_items, commands->nr);
5790 for (i = 0; i < commands->nr; i++) {
5791 size_t command_len = strlen(commands->items[i].string);
5793 strbuf_addstr(buf, commands->items[i].string);
5794 strbuf_addch(buf, '\n');
5796 base_items[i].command = TODO_EXEC;
5797 base_items[i].offset_in_buf = base_offset;
5798 base_items[i].arg_offset = base_offset;
5799 base_items[i].arg_len = command_len;
5801 base_offset += command_len + 1;
5805 * Insert <commands> after every pick. Here, fixup/squash chains
5806 * are considered part of the pick, so we insert the commands *after*
5807 * those chains if there are any.
5809 * As we insert the exec commands immediately after rearranging
5810 * any fixups and before the user edits the list, a fixup chain
5811 * can never contain comments (any comments are empty picks that
5812 * have been commented out because the user did not specify
5813 * --keep-empty). So, it is safe to insert an exec command
5814 * without looking at the command following a comment.
5816 insert = 0;
5817 for (i = 0; i < todo_list->nr; i++) {
5818 enum todo_command command = todo_list->items[i].command;
5819 if (insert && !is_fixup(command)) {
5820 ALLOC_GROW(items, nr + commands->nr, alloc);
5821 COPY_ARRAY(items + nr, base_items, commands->nr);
5822 nr += commands->nr;
5824 insert = 0;
5827 ALLOC_GROW(items, nr + 1, alloc);
5828 items[nr++] = todo_list->items[i];
5830 if (command == TODO_PICK || command == TODO_MERGE)
5831 insert = 1;
5834 /* insert or append final <commands> */
5835 if (insert) {
5836 ALLOC_GROW(items, nr + commands->nr, alloc);
5837 COPY_ARRAY(items + nr, base_items, commands->nr);
5838 nr += commands->nr;
5841 free(base_items);
5842 FREE_AND_NULL(todo_list->items);
5843 todo_list->items = items;
5844 todo_list->nr = nr;
5845 todo_list->alloc = alloc;
5848 static void todo_list_to_strbuf(struct repository *r, struct todo_list *todo_list,
5849 struct strbuf *buf, int num, unsigned flags)
5851 struct todo_item *item;
5852 int i, max = todo_list->nr;
5854 if (num > 0 && num < max)
5855 max = num;
5857 for (item = todo_list->items, i = 0; i < max; i++, item++) {
5858 char cmd;
5860 /* if the item is not a command write it and continue */
5861 if (item->command >= TODO_COMMENT) {
5862 strbuf_addf(buf, "%.*s\n", item->arg_len,
5863 todo_item_get_arg(todo_list, item));
5864 continue;
5867 /* add command to the buffer */
5868 cmd = command_to_char(item->command);
5869 if ((flags & TODO_LIST_ABBREVIATE_CMDS) && cmd)
5870 strbuf_addch(buf, cmd);
5871 else
5872 strbuf_addstr(buf, command_to_string(item->command));
5874 /* add commit id */
5875 if (item->commit) {
5876 const char *oid = flags & TODO_LIST_SHORTEN_IDS ?
5877 short_commit_name(item->commit) :
5878 oid_to_hex(&item->commit->object.oid);
5880 if (item->command == TODO_FIXUP) {
5881 if (item->flags & TODO_EDIT_FIXUP_MSG)
5882 strbuf_addstr(buf, " -c");
5883 else if (item->flags & TODO_REPLACE_FIXUP_MSG) {
5884 strbuf_addstr(buf, " -C");
5888 if (item->command == TODO_MERGE) {
5889 if (item->flags & TODO_EDIT_MERGE_MSG)
5890 strbuf_addstr(buf, " -c");
5891 else
5892 strbuf_addstr(buf, " -C");
5895 strbuf_addf(buf, " %s", oid);
5898 /* add all the rest */
5899 if (!item->arg_len)
5900 strbuf_addch(buf, '\n');
5901 else
5902 strbuf_addf(buf, " %.*s\n", item->arg_len,
5903 todo_item_get_arg(todo_list, item));
5907 int todo_list_write_to_file(struct repository *r, struct todo_list *todo_list,
5908 const char *file, const char *shortrevisions,
5909 const char *shortonto, int num, unsigned flags)
5911 int res;
5912 struct strbuf buf = STRBUF_INIT;
5914 todo_list_to_strbuf(r, todo_list, &buf, num, flags);
5915 if (flags & TODO_LIST_APPEND_TODO_HELP)
5916 append_todo_help(count_commands(todo_list),
5917 shortrevisions, shortonto, &buf);
5919 res = write_message(buf.buf, buf.len, file, 0);
5920 strbuf_release(&buf);
5922 return res;
5925 /* skip picking commits whose parents are unchanged */
5926 static int skip_unnecessary_picks(struct repository *r,
5927 struct todo_list *todo_list,
5928 struct object_id *base_oid)
5930 struct object_id *parent_oid;
5931 int i;
5933 for (i = 0; i < todo_list->nr; i++) {
5934 struct todo_item *item = todo_list->items + i;
5936 if (item->command >= TODO_NOOP)
5937 continue;
5938 if (item->command != TODO_PICK)
5939 break;
5940 if (repo_parse_commit(r, item->commit)) {
5941 return error(_("could not parse commit '%s'"),
5942 oid_to_hex(&item->commit->object.oid));
5944 if (!item->commit->parents)
5945 break; /* root commit */
5946 if (item->commit->parents->next)
5947 break; /* merge commit */
5948 parent_oid = &item->commit->parents->item->object.oid;
5949 if (!oideq(parent_oid, base_oid))
5950 break;
5951 oidcpy(base_oid, &item->commit->object.oid);
5953 if (i > 0) {
5954 const char *done_path = rebase_path_done();
5956 if (todo_list_write_to_file(r, todo_list, done_path, NULL, NULL, i, 0)) {
5957 error_errno(_("could not write to '%s'"), done_path);
5958 return -1;
5961 MOVE_ARRAY(todo_list->items, todo_list->items + i, todo_list->nr - i);
5962 todo_list->nr -= i;
5963 todo_list->current = 0;
5964 todo_list->done_nr += i;
5966 if (is_fixup(peek_command(todo_list, 0)))
5967 record_in_rewritten(base_oid, peek_command(todo_list, 0));
5970 return 0;
5973 struct todo_add_branch_context {
5974 struct todo_item *items;
5975 size_t items_nr;
5976 size_t items_alloc;
5977 struct strbuf *buf;
5978 struct commit *commit;
5979 struct string_list refs_to_oids;
5982 static int add_decorations_to_list(const struct commit *commit,
5983 struct todo_add_branch_context *ctx)
5985 const struct name_decoration *decoration = get_name_decoration(&commit->object);
5986 const char *head_ref = resolve_ref_unsafe("HEAD",
5987 RESOLVE_REF_READING,
5988 NULL,
5989 NULL);
5991 while (decoration) {
5992 struct todo_item *item;
5993 const char *path;
5994 size_t base_offset = ctx->buf->len;
5997 * If the branch is the current HEAD, then it will be
5998 * updated by the default rebase behavior.
6000 if (head_ref && !strcmp(head_ref, decoration->name)) {
6001 decoration = decoration->next;
6002 continue;
6005 ALLOC_GROW(ctx->items,
6006 ctx->items_nr + 1,
6007 ctx->items_alloc);
6008 item = &ctx->items[ctx->items_nr];
6009 memset(item, 0, sizeof(*item));
6011 /* If the branch is checked out, then leave a comment instead. */
6012 if ((path = branch_checked_out(decoration->name))) {
6013 item->command = TODO_COMMENT;
6014 strbuf_addf(ctx->buf, "# Ref %s checked out at '%s'\n",
6015 decoration->name, path);
6016 } else {
6017 struct string_list_item *sti;
6018 item->command = TODO_UPDATE_REF;
6019 strbuf_addf(ctx->buf, "%s\n", decoration->name);
6021 sti = string_list_insert(&ctx->refs_to_oids,
6022 decoration->name);
6023 sti->util = init_update_ref_record(decoration->name);
6026 item->offset_in_buf = base_offset;
6027 item->arg_offset = base_offset;
6028 item->arg_len = ctx->buf->len - base_offset;
6029 ctx->items_nr++;
6031 decoration = decoration->next;
6034 return 0;
6038 * For each 'pick' command, find out if the commit has a decoration in
6039 * refs/heads/. If so, then add a 'label for-update-refs/' command.
6041 static int todo_list_add_update_ref_commands(struct todo_list *todo_list)
6043 int i, res;
6044 static struct string_list decorate_refs_exclude = STRING_LIST_INIT_NODUP;
6045 static struct string_list decorate_refs_exclude_config = STRING_LIST_INIT_NODUP;
6046 static struct string_list decorate_refs_include = STRING_LIST_INIT_NODUP;
6047 struct decoration_filter decoration_filter = {
6048 .include_ref_pattern = &decorate_refs_include,
6049 .exclude_ref_pattern = &decorate_refs_exclude,
6050 .exclude_ref_config_pattern = &decorate_refs_exclude_config,
6052 struct todo_add_branch_context ctx = {
6053 .buf = &todo_list->buf,
6054 .refs_to_oids = STRING_LIST_INIT_DUP,
6057 ctx.items_alloc = 2 * todo_list->nr + 1;
6058 ALLOC_ARRAY(ctx.items, ctx.items_alloc);
6060 string_list_append(&decorate_refs_include, "refs/heads/");
6061 load_ref_decorations(&decoration_filter, 0);
6063 for (i = 0; i < todo_list->nr; ) {
6064 struct todo_item *item = &todo_list->items[i];
6066 /* insert ith item into new list */
6067 ALLOC_GROW(ctx.items,
6068 ctx.items_nr + 1,
6069 ctx.items_alloc);
6071 ctx.items[ctx.items_nr++] = todo_list->items[i++];
6073 if (item->commit) {
6074 ctx.commit = item->commit;
6075 add_decorations_to_list(item->commit, &ctx);
6079 res = write_update_refs_state(&ctx.refs_to_oids);
6081 string_list_clear(&ctx.refs_to_oids, 1);
6083 if (res) {
6084 /* we failed, so clean up the new list. */
6085 free(ctx.items);
6086 return res;
6089 free(todo_list->items);
6090 todo_list->items = ctx.items;
6091 todo_list->nr = ctx.items_nr;
6092 todo_list->alloc = ctx.items_alloc;
6094 return 0;
6097 int complete_action(struct repository *r, struct replay_opts *opts, unsigned flags,
6098 const char *shortrevisions, const char *onto_name,
6099 struct commit *onto, const struct object_id *orig_head,
6100 struct string_list *commands, unsigned autosquash,
6101 unsigned update_refs,
6102 struct todo_list *todo_list)
6104 char shortonto[GIT_MAX_HEXSZ + 1];
6105 const char *todo_file = rebase_path_todo();
6106 struct todo_list new_todo = TODO_LIST_INIT;
6107 struct strbuf *buf = &todo_list->buf, buf2 = STRBUF_INIT;
6108 struct object_id oid = onto->object.oid;
6109 int res;
6111 repo_find_unique_abbrev_r(r, shortonto, &oid,
6112 DEFAULT_ABBREV);
6114 if (buf->len == 0) {
6115 struct todo_item *item = append_new_todo(todo_list);
6116 item->command = TODO_NOOP;
6117 item->commit = NULL;
6118 item->arg_len = item->arg_offset = item->flags = item->offset_in_buf = 0;
6121 if (update_refs && todo_list_add_update_ref_commands(todo_list))
6122 return -1;
6124 if (autosquash && todo_list_rearrange_squash(todo_list))
6125 return -1;
6127 if (commands->nr)
6128 todo_list_add_exec_commands(todo_list, commands);
6130 if (count_commands(todo_list) == 0) {
6131 apply_autostash(rebase_path_autostash());
6132 sequencer_remove_state(opts);
6134 return error(_("nothing to do"));
6137 res = edit_todo_list(r, todo_list, &new_todo, shortrevisions,
6138 shortonto, flags);
6139 if (res == -1)
6140 return -1;
6141 else if (res == -2) {
6142 apply_autostash(rebase_path_autostash());
6143 sequencer_remove_state(opts);
6145 return -1;
6146 } else if (res == -3) {
6147 apply_autostash(rebase_path_autostash());
6148 sequencer_remove_state(opts);
6149 todo_list_release(&new_todo);
6151 return error(_("nothing to do"));
6152 } else if (res == -4) {
6153 checkout_onto(r, opts, onto_name, &onto->object.oid, orig_head);
6154 todo_list_release(&new_todo);
6156 return -1;
6159 /* Expand the commit IDs */
6160 todo_list_to_strbuf(r, &new_todo, &buf2, -1, 0);
6161 strbuf_swap(&new_todo.buf, &buf2);
6162 strbuf_release(&buf2);
6163 /* Nothing is done yet, and we're reparsing, so let's reset the count */
6164 new_todo.total_nr = 0;
6165 if (todo_list_parse_insn_buffer(r, new_todo.buf.buf, &new_todo) < 0)
6166 BUG("invalid todo list after expanding IDs:\n%s",
6167 new_todo.buf.buf);
6169 if (opts->allow_ff && skip_unnecessary_picks(r, &new_todo, &oid)) {
6170 todo_list_release(&new_todo);
6171 return error(_("could not skip unnecessary pick commands"));
6174 if (todo_list_write_to_file(r, &new_todo, todo_file, NULL, NULL, -1,
6175 flags & ~(TODO_LIST_SHORTEN_IDS))) {
6176 todo_list_release(&new_todo);
6177 return error_errno(_("could not write '%s'"), todo_file);
6180 res = -1;
6182 if (checkout_onto(r, opts, onto_name, &oid, orig_head))
6183 goto cleanup;
6185 if (require_clean_work_tree(r, "rebase", "", 1, 1))
6186 goto cleanup;
6188 todo_list_write_total_nr(&new_todo);
6189 res = pick_commits(r, &new_todo, opts);
6191 cleanup:
6192 todo_list_release(&new_todo);
6194 return res;
6197 struct subject2item_entry {
6198 struct hashmap_entry entry;
6199 int i;
6200 char subject[FLEX_ARRAY];
6203 static int subject2item_cmp(const void *fndata UNUSED,
6204 const struct hashmap_entry *eptr,
6205 const struct hashmap_entry *entry_or_key,
6206 const void *key)
6208 const struct subject2item_entry *a, *b;
6210 a = container_of(eptr, const struct subject2item_entry, entry);
6211 b = container_of(entry_or_key, const struct subject2item_entry, entry);
6213 return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
6216 define_commit_slab(commit_todo_item, struct todo_item *);
6218 static int skip_fixupish(const char *subject, const char **p) {
6219 return skip_prefix(subject, "fixup! ", p) ||
6220 skip_prefix(subject, "amend! ", p) ||
6221 skip_prefix(subject, "squash! ", p);
6225 * Rearrange the todo list that has both "pick commit-id msg" and "pick
6226 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
6227 * after the former, and change "pick" to "fixup"/"squash".
6229 * Note that if the config has specified a custom instruction format, each log
6230 * message will have to be retrieved from the commit (as the oneline in the
6231 * script cannot be trusted) in order to normalize the autosquash arrangement.
6233 int todo_list_rearrange_squash(struct todo_list *todo_list)
6235 struct hashmap subject2item;
6236 int rearranged = 0, *next, *tail, i, nr = 0, alloc = 0;
6237 char **subjects;
6238 struct commit_todo_item commit_todo;
6239 struct todo_item *items = NULL;
6241 init_commit_todo_item(&commit_todo);
6243 * The hashmap maps onelines to the respective todo list index.
6245 * If any items need to be rearranged, the next[i] value will indicate
6246 * which item was moved directly after the i'th.
6248 * In that case, last[i] will indicate the index of the latest item to
6249 * be moved to appear after the i'th.
6251 hashmap_init(&subject2item, subject2item_cmp, NULL, todo_list->nr);
6252 ALLOC_ARRAY(next, todo_list->nr);
6253 ALLOC_ARRAY(tail, todo_list->nr);
6254 ALLOC_ARRAY(subjects, todo_list->nr);
6255 for (i = 0; i < todo_list->nr; i++) {
6256 struct strbuf buf = STRBUF_INIT;
6257 struct todo_item *item = todo_list->items + i;
6258 const char *commit_buffer, *subject, *p;
6259 size_t subject_len;
6260 int i2 = -1;
6261 struct subject2item_entry *entry;
6263 next[i] = tail[i] = -1;
6264 if (!item->commit || item->command == TODO_DROP) {
6265 subjects[i] = NULL;
6266 continue;
6269 if (is_fixup(item->command)) {
6270 clear_commit_todo_item(&commit_todo);
6271 return error(_("the script was already rearranged."));
6274 repo_parse_commit(the_repository, item->commit);
6275 commit_buffer = repo_logmsg_reencode(the_repository,
6276 item->commit, NULL,
6277 "UTF-8");
6278 find_commit_subject(commit_buffer, &subject);
6279 format_subject(&buf, subject, " ");
6280 subject = subjects[i] = strbuf_detach(&buf, &subject_len);
6281 repo_unuse_commit_buffer(the_repository, item->commit,
6282 commit_buffer);
6283 if (skip_fixupish(subject, &p)) {
6284 struct commit *commit2;
6286 for (;;) {
6287 while (isspace(*p))
6288 p++;
6289 if (!skip_fixupish(p, &p))
6290 break;
6293 entry = hashmap_get_entry_from_hash(&subject2item,
6294 strhash(p), p,
6295 struct subject2item_entry,
6296 entry);
6297 if (entry)
6298 /* found by title */
6299 i2 = entry->i;
6300 else if (!strchr(p, ' ') &&
6301 (commit2 =
6302 lookup_commit_reference_by_name(p)) &&
6303 *commit_todo_item_at(&commit_todo, commit2))
6304 /* found by commit name */
6305 i2 = *commit_todo_item_at(&commit_todo, commit2)
6306 - todo_list->items;
6307 else {
6308 /* copy can be a prefix of the commit subject */
6309 for (i2 = 0; i2 < i; i2++)
6310 if (subjects[i2] &&
6311 starts_with(subjects[i2], p))
6312 break;
6313 if (i2 == i)
6314 i2 = -1;
6317 if (i2 >= 0) {
6318 rearranged = 1;
6319 if (starts_with(subject, "fixup!")) {
6320 todo_list->items[i].command = TODO_FIXUP;
6321 } else if (starts_with(subject, "amend!")) {
6322 todo_list->items[i].command = TODO_FIXUP;
6323 todo_list->items[i].flags = TODO_REPLACE_FIXUP_MSG;
6324 } else {
6325 todo_list->items[i].command = TODO_SQUASH;
6327 if (tail[i2] < 0) {
6328 next[i] = next[i2];
6329 next[i2] = i;
6330 } else {
6331 next[i] = next[tail[i2]];
6332 next[tail[i2]] = i;
6334 tail[i2] = i;
6335 } else if (!hashmap_get_from_hash(&subject2item,
6336 strhash(subject), subject)) {
6337 FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
6338 entry->i = i;
6339 hashmap_entry_init(&entry->entry,
6340 strhash(entry->subject));
6341 hashmap_put(&subject2item, &entry->entry);
6344 *commit_todo_item_at(&commit_todo, item->commit) = item;
6347 if (rearranged) {
6348 for (i = 0; i < todo_list->nr; i++) {
6349 enum todo_command command = todo_list->items[i].command;
6350 int cur = i;
6353 * Initially, all commands are 'pick's. If it is a
6354 * fixup or a squash now, we have rearranged it.
6356 if (is_fixup(command))
6357 continue;
6359 while (cur >= 0) {
6360 ALLOC_GROW(items, nr + 1, alloc);
6361 items[nr++] = todo_list->items[cur];
6362 cur = next[cur];
6366 FREE_AND_NULL(todo_list->items);
6367 todo_list->items = items;
6368 todo_list->nr = nr;
6369 todo_list->alloc = alloc;
6372 free(next);
6373 free(tail);
6374 for (i = 0; i < todo_list->nr; i++)
6375 free(subjects[i]);
6376 free(subjects);
6377 hashmap_clear_and_free(&subject2item, struct subject2item_entry, entry);
6379 clear_commit_todo_item(&commit_todo);
6381 return 0;
6384 int sequencer_determine_whence(struct repository *r, enum commit_whence *whence)
6386 if (refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD")) {
6387 struct object_id cherry_pick_head, rebase_head;
6389 if (file_exists(git_path_seq_dir()))
6390 *whence = FROM_CHERRY_PICK_MULTI;
6391 if (file_exists(rebase_path()) &&
6392 !repo_get_oid(r, "REBASE_HEAD", &rebase_head) &&
6393 !repo_get_oid(r, "CHERRY_PICK_HEAD", &cherry_pick_head) &&
6394 oideq(&rebase_head, &cherry_pick_head))
6395 *whence = FROM_REBASE_PICK;
6396 else
6397 *whence = FROM_CHERRY_PICK_SINGLE;
6399 return 1;
6402 return 0;
6405 int sequencer_get_update_refs_state(const char *wt_dir,
6406 struct string_list *refs)
6408 int result = 0;
6409 FILE *fp = NULL;
6410 struct strbuf ref = STRBUF_INIT;
6411 struct strbuf hash = STRBUF_INIT;
6412 struct update_ref_record *rec = NULL;
6414 char *path = rebase_path_update_refs(wt_dir);
6416 fp = fopen(path, "r");
6417 if (!fp)
6418 goto cleanup;
6420 while (strbuf_getline(&ref, fp) != EOF) {
6421 struct string_list_item *item;
6423 CALLOC_ARRAY(rec, 1);
6425 if (strbuf_getline(&hash, fp) == EOF ||
6426 get_oid_hex(hash.buf, &rec->before)) {
6427 warning(_("update-refs file at '%s' is invalid"),
6428 path);
6429 result = -1;
6430 goto cleanup;
6433 if (strbuf_getline(&hash, fp) == EOF ||
6434 get_oid_hex(hash.buf, &rec->after)) {
6435 warning(_("update-refs file at '%s' is invalid"),
6436 path);
6437 result = -1;
6438 goto cleanup;
6441 item = string_list_insert(refs, ref.buf);
6442 item->util = rec;
6443 rec = NULL;
6446 cleanup:
6447 if (fp)
6448 fclose(fp);
6449 free(path);
6450 free(rec);
6451 strbuf_release(&ref);
6452 strbuf_release(&hash);
6453 return result;