rebase -i: use struct object_id rather than looking up commit
[git.git] / sequencer.c
blobf79c3df86142a73628b05980acefbd668f519f61
1 #include "cache.h"
2 #include "config.h"
3 #include "lockfile.h"
4 #include "dir.h"
5 #include "object-store.h"
6 #include "object.h"
7 #include "commit.h"
8 #include "sequencer.h"
9 #include "tag.h"
10 #include "run-command.h"
11 #include "exec-cmd.h"
12 #include "utf8.h"
13 #include "cache-tree.h"
14 #include "diff.h"
15 #include "revision.h"
16 #include "rerere.h"
17 #include "merge-recursive.h"
18 #include "refs.h"
19 #include "strvec.h"
20 #include "quote.h"
21 #include "trailer.h"
22 #include "log-tree.h"
23 #include "wt-status.h"
24 #include "hashmap.h"
25 #include "notes-utils.h"
26 #include "sigchain.h"
27 #include "unpack-trees.h"
28 #include "worktree.h"
29 #include "oidmap.h"
30 #include "oidset.h"
31 #include "commit-slab.h"
32 #include "alias.h"
33 #include "commit-reach.h"
34 #include "rebase-interactive.h"
35 #include "reset.h"
37 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
39 static const char sign_off_header[] = "Signed-off-by: ";
40 static const char cherry_picked_prefix[] = "(cherry picked from commit ";
42 GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
44 static GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
46 static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
47 static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
48 static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
49 static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
51 static GIT_PATH_FUNC(rebase_path, "rebase-merge")
53 * The file containing rebase commands, comments, and empty lines.
54 * This file is created by "git rebase -i" then edited by the user. As
55 * the lines are processed, they are removed from the front of this
56 * file and written to the tail of 'done'.
58 GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
59 GIT_PATH_FUNC(rebase_path_todo_backup, "rebase-merge/git-rebase-todo.backup")
61 GIT_PATH_FUNC(rebase_path_dropped, "rebase-merge/dropped")
64 * The rebase command lines that have already been processed. A line
65 * is moved here when it is first handled, before any associated user
66 * actions.
68 static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
70 * The file to keep track of how many commands were already processed (e.g.
71 * for the prompt).
73 static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum")
75 * The file to keep track of how many commands are to be processed in total
76 * (e.g. for the prompt).
78 static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end")
80 * The commit message that is planned to be used for any changes that
81 * need to be committed following a user interaction.
83 static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
85 * The file into which is accumulated the suggested commit message for
86 * squash/fixup commands. When the first of a series of squash/fixups
87 * is seen, the file is created and the commit message from the
88 * previous commit and from the first squash/fixup commit are written
89 * to it. The commit message for each subsequent squash/fixup commit
90 * is appended to the file as it is processed.
92 static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
94 * If the current series of squash/fixups has not yet included a squash
95 * command, then this file exists and holds the commit message of the
96 * original "pick" commit. (If the series ends without a "squash"
97 * command, then this can be used as the commit message of the combined
98 * commit without opening the editor.)
100 static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
102 * This file contains the list fixup/squash commands that have been
103 * accumulated into message-fixup or message-squash so far.
105 static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")
107 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
108 * GIT_AUTHOR_DATE that will be used for the commit that is currently
109 * being rebased.
111 static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
113 * When an "edit" rebase command is being processed, the SHA1 of the
114 * commit to be edited is recorded in this file. When "git rebase
115 * --continue" is executed, if there are any staged changes then they
116 * will be amended to the HEAD commit, but only provided the HEAD
117 * commit is still the commit to be edited. When any other rebase
118 * command is processed, this file is deleted.
120 static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
122 * When we stop at a given patch via the "edit" command, this file contains
123 * the commit object name of the corresponding patch.
125 static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
127 * For the post-rewrite hook, we make a list of rewritten commits and
128 * their new sha1s. The rewritten-pending list keeps the sha1s of
129 * commits that have been processed, but not committed yet,
130 * e.g. because they are waiting for a 'squash' command.
132 static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
133 static GIT_PATH_FUNC(rebase_path_rewritten_pending,
134 "rebase-merge/rewritten-pending")
137 * The path of the file containing the OID of the "squash onto" commit, i.e.
138 * the dummy commit used for `reset [new root]`.
140 static GIT_PATH_FUNC(rebase_path_squash_onto, "rebase-merge/squash-onto")
143 * The path of the file listing refs that need to be deleted after the rebase
144 * finishes. This is used by the `label` command to record the need for cleanup.
146 static GIT_PATH_FUNC(rebase_path_refs_to_delete, "rebase-merge/refs-to-delete")
149 * The following files are written by git-rebase just after parsing the
150 * command-line.
152 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
153 static GIT_PATH_FUNC(rebase_path_cdate_is_adate, "rebase-merge/cdate_is_adate")
154 static GIT_PATH_FUNC(rebase_path_ignore_date, "rebase-merge/ignore_date")
155 static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
156 static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
157 static GIT_PATH_FUNC(rebase_path_quiet, "rebase-merge/quiet")
158 static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")
159 static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
160 static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
161 static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
162 static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
163 static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
164 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
165 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec, "rebase-merge/reschedule-failed-exec")
166 static GIT_PATH_FUNC(rebase_path_drop_redundant_commits, "rebase-merge/drop_redundant_commits")
167 static GIT_PATH_FUNC(rebase_path_keep_redundant_commits, "rebase-merge/keep_redundant_commits")
169 static int git_sequencer_config(const char *k, const char *v, void *cb)
171 struct replay_opts *opts = cb;
172 int status;
174 if (!strcmp(k, "commit.cleanup")) {
175 const char *s;
177 status = git_config_string(&s, k, v);
178 if (status)
179 return status;
181 if (!strcmp(s, "verbatim")) {
182 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
183 opts->explicit_cleanup = 1;
184 } else if (!strcmp(s, "whitespace")) {
185 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
186 opts->explicit_cleanup = 1;
187 } else if (!strcmp(s, "strip")) {
188 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
189 opts->explicit_cleanup = 1;
190 } else if (!strcmp(s, "scissors")) {
191 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SCISSORS;
192 opts->explicit_cleanup = 1;
193 } else {
194 warning(_("invalid commit message cleanup mode '%s'"),
198 free((char *)s);
199 return status;
202 if (!strcmp(k, "commit.gpgsign")) {
203 opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
204 return 0;
207 status = git_gpg_config(k, v, NULL);
208 if (status)
209 return status;
211 return git_diff_basic_config(k, v, NULL);
214 void sequencer_init_config(struct replay_opts *opts)
216 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
217 git_config(git_sequencer_config, opts);
220 static inline int is_rebase_i(const struct replay_opts *opts)
222 return opts->action == REPLAY_INTERACTIVE_REBASE;
225 static const char *get_dir(const struct replay_opts *opts)
227 if (is_rebase_i(opts))
228 return rebase_path();
229 return git_path_seq_dir();
232 static const char *get_todo_path(const struct replay_opts *opts)
234 if (is_rebase_i(opts))
235 return rebase_path_todo();
236 return git_path_todo_file();
240 * Returns 0 for non-conforming footer
241 * Returns 1 for conforming footer
242 * Returns 2 when sob exists within conforming footer
243 * Returns 3 when sob exists within conforming footer as last entry
245 static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
246 size_t ignore_footer)
248 struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
249 struct trailer_info info;
250 size_t i;
251 int found_sob = 0, found_sob_last = 0;
252 char saved_char;
254 opts.no_divider = 1;
256 if (ignore_footer) {
257 saved_char = sb->buf[sb->len - ignore_footer];
258 sb->buf[sb->len - ignore_footer] = '\0';
261 trailer_info_get(&info, sb->buf, &opts);
263 if (ignore_footer)
264 sb->buf[sb->len - ignore_footer] = saved_char;
266 if (info.trailer_start == info.trailer_end)
267 return 0;
269 for (i = 0; i < info.trailer_nr; i++)
270 if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
271 found_sob = 1;
272 if (i == info.trailer_nr - 1)
273 found_sob_last = 1;
276 trailer_info_release(&info);
278 if (found_sob_last)
279 return 3;
280 if (found_sob)
281 return 2;
282 return 1;
285 static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
287 static struct strbuf buf = STRBUF_INIT;
289 strbuf_reset(&buf);
290 if (opts->gpg_sign)
291 sq_quotef(&buf, "-S%s", opts->gpg_sign);
292 return buf.buf;
295 int sequencer_remove_state(struct replay_opts *opts)
297 struct strbuf buf = STRBUF_INIT;
298 int i, ret = 0;
300 if (is_rebase_i(opts) &&
301 strbuf_read_file(&buf, rebase_path_refs_to_delete(), 0) > 0) {
302 char *p = buf.buf;
303 while (*p) {
304 char *eol = strchr(p, '\n');
305 if (eol)
306 *eol = '\0';
307 if (delete_ref("(rebase) cleanup", p, NULL, 0) < 0) {
308 warning(_("could not delete '%s'"), p);
309 ret = -1;
311 if (!eol)
312 break;
313 p = eol + 1;
317 free(opts->committer_name);
318 free(opts->committer_email);
319 free(opts->gpg_sign);
320 free(opts->strategy);
321 for (i = 0; i < opts->xopts_nr; i++)
322 free(opts->xopts[i]);
323 free(opts->xopts);
324 strbuf_release(&opts->current_fixups);
326 strbuf_reset(&buf);
327 strbuf_addstr(&buf, get_dir(opts));
328 if (remove_dir_recursively(&buf, 0))
329 ret = error(_("could not remove '%s'"), buf.buf);
330 strbuf_release(&buf);
332 return ret;
335 static const char *action_name(const struct replay_opts *opts)
337 switch (opts->action) {
338 case REPLAY_REVERT:
339 return N_("revert");
340 case REPLAY_PICK:
341 return N_("cherry-pick");
342 case REPLAY_INTERACTIVE_REBASE:
343 return N_("rebase");
345 die(_("unknown action: %d"), opts->action);
348 struct commit_message {
349 char *parent_label;
350 char *label;
351 char *subject;
352 const char *message;
355 static const char *short_commit_name(struct commit *commit)
357 return find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV);
360 static int get_message(struct commit *commit, struct commit_message *out)
362 const char *abbrev, *subject;
363 int subject_len;
365 out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
366 abbrev = short_commit_name(commit);
368 subject_len = find_commit_subject(out->message, &subject);
370 out->subject = xmemdupz(subject, subject_len);
371 out->label = xstrfmt("%s (%s)", abbrev, out->subject);
372 out->parent_label = xstrfmt("parent of %s", out->label);
374 return 0;
377 static void free_message(struct commit *commit, struct commit_message *msg)
379 free(msg->parent_label);
380 free(msg->label);
381 free(msg->subject);
382 unuse_commit_buffer(commit, msg->message);
385 static void print_advice(struct repository *r, int show_hint,
386 struct replay_opts *opts)
388 char *msg = getenv("GIT_CHERRY_PICK_HELP");
390 if (msg) {
391 fprintf(stderr, "%s\n", msg);
393 * A conflict has occurred but the porcelain
394 * (typically rebase --interactive) wants to take care
395 * of the commit itself so remove CHERRY_PICK_HEAD
397 refs_delete_ref(get_main_ref_store(r), "", "CHERRY_PICK_HEAD",
398 NULL, 0);
399 return;
402 if (show_hint) {
403 if (opts->no_commit)
404 advise(_("after resolving the conflicts, mark the corrected paths\n"
405 "with 'git add <paths>' or 'git rm <paths>'"));
406 else
407 advise(_("after resolving the conflicts, mark the corrected paths\n"
408 "with 'git add <paths>' or 'git rm <paths>'\n"
409 "and commit the result with 'git commit'"));
413 static int write_message(const void *buf, size_t len, const char *filename,
414 int append_eol)
416 struct lock_file msg_file = LOCK_INIT;
418 int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
419 if (msg_fd < 0)
420 return error_errno(_("could not lock '%s'"), filename);
421 if (write_in_full(msg_fd, buf, len) < 0) {
422 error_errno(_("could not write to '%s'"), filename);
423 rollback_lock_file(&msg_file);
424 return -1;
426 if (append_eol && write(msg_fd, "\n", 1) < 0) {
427 error_errno(_("could not write eol to '%s'"), filename);
428 rollback_lock_file(&msg_file);
429 return -1;
431 if (commit_lock_file(&msg_file) < 0)
432 return error(_("failed to finalize '%s'"), filename);
434 return 0;
437 int read_oneliner(struct strbuf *buf,
438 const char *path, unsigned flags)
440 int orig_len = buf->len;
442 if (strbuf_read_file(buf, path, 0) < 0) {
443 if ((flags & READ_ONELINER_WARN_MISSING) ||
444 (errno != ENOENT && errno != ENOTDIR))
445 warning_errno(_("could not read '%s'"), path);
446 return 0;
449 if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
450 if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
451 --buf->len;
452 buf->buf[buf->len] = '\0';
455 if ((flags & READ_ONELINER_SKIP_IF_EMPTY) && buf->len == orig_len)
456 return 0;
458 return 1;
461 static struct tree *empty_tree(struct repository *r)
463 return lookup_tree(r, the_hash_algo->empty_tree);
466 static int error_dirty_index(struct repository *repo, struct replay_opts *opts)
468 if (repo_read_index_unmerged(repo))
469 return error_resolve_conflict(_(action_name(opts)));
471 error(_("your local changes would be overwritten by %s."),
472 _(action_name(opts)));
474 if (advice_commit_before_merge)
475 advise(_("commit your changes or stash them to proceed."));
476 return -1;
479 static void update_abort_safety_file(void)
481 struct object_id head;
483 /* Do nothing on a single-pick */
484 if (!file_exists(git_path_seq_dir()))
485 return;
487 if (!get_oid("HEAD", &head))
488 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
489 else
490 write_file(git_path_abort_safety_file(), "%s", "");
493 static int fast_forward_to(struct repository *r,
494 const struct object_id *to,
495 const struct object_id *from,
496 int unborn,
497 struct replay_opts *opts)
499 struct ref_transaction *transaction;
500 struct strbuf sb = STRBUF_INIT;
501 struct strbuf err = STRBUF_INIT;
503 repo_read_index(r);
504 if (checkout_fast_forward(r, from, to, 1))
505 return -1; /* the callee should have complained already */
507 strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
509 transaction = ref_transaction_begin(&err);
510 if (!transaction ||
511 ref_transaction_update(transaction, "HEAD",
512 to, unborn && !is_rebase_i(opts) ?
513 &null_oid : from,
514 0, sb.buf, &err) ||
515 ref_transaction_commit(transaction, &err)) {
516 ref_transaction_free(transaction);
517 error("%s", err.buf);
518 strbuf_release(&sb);
519 strbuf_release(&err);
520 return -1;
523 strbuf_release(&sb);
524 strbuf_release(&err);
525 ref_transaction_free(transaction);
526 update_abort_safety_file();
527 return 0;
530 enum commit_msg_cleanup_mode get_cleanup_mode(const char *cleanup_arg,
531 int use_editor)
533 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
534 return use_editor ? COMMIT_MSG_CLEANUP_ALL :
535 COMMIT_MSG_CLEANUP_SPACE;
536 else if (!strcmp(cleanup_arg, "verbatim"))
537 return COMMIT_MSG_CLEANUP_NONE;
538 else if (!strcmp(cleanup_arg, "whitespace"))
539 return COMMIT_MSG_CLEANUP_SPACE;
540 else if (!strcmp(cleanup_arg, "strip"))
541 return COMMIT_MSG_CLEANUP_ALL;
542 else if (!strcmp(cleanup_arg, "scissors"))
543 return use_editor ? COMMIT_MSG_CLEANUP_SCISSORS :
544 COMMIT_MSG_CLEANUP_SPACE;
545 else
546 die(_("Invalid cleanup mode %s"), cleanup_arg);
550 * NB using int rather than enum cleanup_mode to stop clang's
551 * -Wtautological-constant-out-of-range-compare complaining that the comparison
552 * is always true.
554 static const char *describe_cleanup_mode(int cleanup_mode)
556 static const char *modes[] = { "whitespace",
557 "verbatim",
558 "scissors",
559 "strip" };
561 if (cleanup_mode < ARRAY_SIZE(modes))
562 return modes[cleanup_mode];
564 BUG("invalid cleanup_mode provided (%d)", cleanup_mode);
567 void append_conflicts_hint(struct index_state *istate,
568 struct strbuf *msgbuf, enum commit_msg_cleanup_mode cleanup_mode)
570 int i;
572 if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS) {
573 strbuf_addch(msgbuf, '\n');
574 wt_status_append_cut_line(msgbuf);
575 strbuf_addch(msgbuf, comment_line_char);
578 strbuf_addch(msgbuf, '\n');
579 strbuf_commented_addf(msgbuf, "Conflicts:\n");
580 for (i = 0; i < istate->cache_nr;) {
581 const struct cache_entry *ce = istate->cache[i++];
582 if (ce_stage(ce)) {
583 strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
584 while (i < istate->cache_nr &&
585 !strcmp(ce->name, istate->cache[i]->name))
586 i++;
591 static int do_recursive_merge(struct repository *r,
592 struct commit *base, struct commit *next,
593 const char *base_label, const char *next_label,
594 struct object_id *head, struct strbuf *msgbuf,
595 struct replay_opts *opts)
597 struct merge_options o;
598 struct tree *next_tree, *base_tree, *head_tree;
599 int clean;
600 int i;
601 struct lock_file index_lock = LOCK_INIT;
603 if (repo_hold_locked_index(r, &index_lock, LOCK_REPORT_ON_ERROR) < 0)
604 return -1;
606 repo_read_index(r);
608 init_merge_options(&o, r);
609 o.ancestor = base ? base_label : "(empty tree)";
610 o.branch1 = "HEAD";
611 o.branch2 = next ? next_label : "(empty tree)";
612 if (is_rebase_i(opts))
613 o.buffer_output = 2;
614 o.show_rename_progress = 1;
616 head_tree = parse_tree_indirect(head);
617 next_tree = next ? get_commit_tree(next) : empty_tree(r);
618 base_tree = base ? get_commit_tree(base) : empty_tree(r);
620 for (i = 0; i < opts->xopts_nr; i++)
621 parse_merge_opt(&o, opts->xopts[i]);
623 clean = merge_trees(&o,
624 head_tree,
625 next_tree, base_tree);
626 if (is_rebase_i(opts) && clean <= 0)
627 fputs(o.obuf.buf, stdout);
628 strbuf_release(&o.obuf);
629 if (clean < 0) {
630 rollback_lock_file(&index_lock);
631 return clean;
634 if (write_locked_index(r->index, &index_lock,
635 COMMIT_LOCK | SKIP_IF_UNCHANGED))
637 * TRANSLATORS: %s will be "revert", "cherry-pick" or
638 * "rebase".
640 return error(_("%s: Unable to write new index file"),
641 _(action_name(opts)));
643 if (!clean)
644 append_conflicts_hint(r->index, msgbuf,
645 opts->default_msg_cleanup);
647 return !clean;
650 static struct object_id *get_cache_tree_oid(struct index_state *istate)
652 if (!istate->cache_tree)
653 istate->cache_tree = cache_tree();
655 if (!cache_tree_fully_valid(istate->cache_tree))
656 if (cache_tree_update(istate, 0)) {
657 error(_("unable to update cache tree"));
658 return NULL;
661 return &istate->cache_tree->oid;
664 static int is_index_unchanged(struct repository *r)
666 struct object_id head_oid, *cache_tree_oid;
667 struct commit *head_commit;
668 struct index_state *istate = r->index;
670 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
671 return error(_("could not resolve HEAD commit"));
673 head_commit = lookup_commit(r, &head_oid);
676 * If head_commit is NULL, check_commit, called from
677 * lookup_commit, would have indicated that head_commit is not
678 * a commit object already. parse_commit() will return failure
679 * without further complaints in such a case. Otherwise, if
680 * the commit is invalid, parse_commit() will complain. So
681 * there is nothing for us to say here. Just return failure.
683 if (parse_commit(head_commit))
684 return -1;
686 if (!(cache_tree_oid = get_cache_tree_oid(istate)))
687 return -1;
689 return oideq(cache_tree_oid, get_commit_tree_oid(head_commit));
692 static int write_author_script(const char *message)
694 struct strbuf buf = STRBUF_INIT;
695 const char *eol;
696 int res;
698 for (;;)
699 if (!*message || starts_with(message, "\n")) {
700 missing_author:
701 /* Missing 'author' line? */
702 unlink(rebase_path_author_script());
703 return 0;
704 } else if (skip_prefix(message, "author ", &message))
705 break;
706 else if ((eol = strchr(message, '\n')))
707 message = eol + 1;
708 else
709 goto missing_author;
711 strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
712 while (*message && *message != '\n' && *message != '\r')
713 if (skip_prefix(message, " <", &message))
714 break;
715 else if (*message != '\'')
716 strbuf_addch(&buf, *(message++));
717 else
718 strbuf_addf(&buf, "'\\%c'", *(message++));
719 strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
720 while (*message && *message != '\n' && *message != '\r')
721 if (skip_prefix(message, "> ", &message))
722 break;
723 else if (*message != '\'')
724 strbuf_addch(&buf, *(message++));
725 else
726 strbuf_addf(&buf, "'\\%c'", *(message++));
727 strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
728 while (*message && *message != '\n' && *message != '\r')
729 if (*message != '\'')
730 strbuf_addch(&buf, *(message++));
731 else
732 strbuf_addf(&buf, "'\\%c'", *(message++));
733 strbuf_addch(&buf, '\'');
734 res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
735 strbuf_release(&buf);
736 return res;
740 * Take a series of KEY='VALUE' lines where VALUE part is
741 * sq-quoted, and append <KEY, VALUE> at the end of the string list
743 static int parse_key_value_squoted(char *buf, struct string_list *list)
745 while (*buf) {
746 struct string_list_item *item;
747 char *np;
748 char *cp = strchr(buf, '=');
749 if (!cp) {
750 np = strchrnul(buf, '\n');
751 return error(_("no key present in '%.*s'"),
752 (int) (np - buf), buf);
754 np = strchrnul(cp, '\n');
755 *cp++ = '\0';
756 item = string_list_append(list, buf);
758 buf = np + (*np == '\n');
759 *np = '\0';
760 cp = sq_dequote(cp);
761 if (!cp)
762 return error(_("unable to dequote value of '%s'"),
763 item->string);
764 item->util = xstrdup(cp);
766 return 0;
770 * Reads and parses the state directory's "author-script" file, and sets name,
771 * email and date accordingly.
772 * Returns 0 on success, -1 if the file could not be parsed.
774 * The author script is of the format:
776 * GIT_AUTHOR_NAME='$author_name'
777 * GIT_AUTHOR_EMAIL='$author_email'
778 * GIT_AUTHOR_DATE='$author_date'
780 * where $author_name, $author_email and $author_date are quoted. We are strict
781 * with our parsing, as the file was meant to be eval'd in the now-removed
782 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
783 * from what this function expects, it is better to bail out than to do
784 * something that the user does not expect.
786 int read_author_script(const char *path, char **name, char **email, char **date,
787 int allow_missing)
789 struct strbuf buf = STRBUF_INIT;
790 struct string_list kv = STRING_LIST_INIT_DUP;
791 int retval = -1; /* assume failure */
792 int i, name_i = -2, email_i = -2, date_i = -2, err = 0;
794 if (strbuf_read_file(&buf, path, 256) <= 0) {
795 strbuf_release(&buf);
796 if (errno == ENOENT && allow_missing)
797 return 0;
798 else
799 return error_errno(_("could not open '%s' for reading"),
800 path);
803 if (parse_key_value_squoted(buf.buf, &kv))
804 goto finish;
806 for (i = 0; i < kv.nr; i++) {
807 if (!strcmp(kv.items[i].string, "GIT_AUTHOR_NAME")) {
808 if (name_i != -2)
809 name_i = error(_("'GIT_AUTHOR_NAME' already given"));
810 else
811 name_i = i;
812 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_EMAIL")) {
813 if (email_i != -2)
814 email_i = error(_("'GIT_AUTHOR_EMAIL' already given"));
815 else
816 email_i = i;
817 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_DATE")) {
818 if (date_i != -2)
819 date_i = error(_("'GIT_AUTHOR_DATE' already given"));
820 else
821 date_i = i;
822 } else {
823 err = error(_("unknown variable '%s'"),
824 kv.items[i].string);
827 if (name_i == -2)
828 error(_("missing 'GIT_AUTHOR_NAME'"));
829 if (email_i == -2)
830 error(_("missing 'GIT_AUTHOR_EMAIL'"));
831 if (date_i == -2)
832 error(_("missing 'GIT_AUTHOR_DATE'"));
833 if (date_i < 0 || email_i < 0 || date_i < 0 || err)
834 goto finish;
835 *name = kv.items[name_i].util;
836 *email = kv.items[email_i].util;
837 *date = kv.items[date_i].util;
838 retval = 0;
839 finish:
840 string_list_clear(&kv, !!retval);
841 strbuf_release(&buf);
842 return retval;
846 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
847 * file with shell quoting into struct strvec. Returns -1 on
848 * error, 0 otherwise.
850 static int read_env_script(struct strvec *env)
852 char *name, *email, *date;
854 if (read_author_script(rebase_path_author_script(),
855 &name, &email, &date, 0))
856 return -1;
858 strvec_pushf(env, "GIT_AUTHOR_NAME=%s", name);
859 strvec_pushf(env, "GIT_AUTHOR_EMAIL=%s", email);
860 strvec_pushf(env, "GIT_AUTHOR_DATE=%s", date);
861 free(name);
862 free(email);
863 free(date);
865 return 0;
868 static char *get_author(const char *message)
870 size_t len;
871 const char *a;
873 a = find_commit_header(message, "author", &len);
874 if (a)
875 return xmemdupz(a, len);
877 return NULL;
880 static const char *author_date_from_env_array(const struct strvec *env)
882 int i;
883 const char *date;
885 for (i = 0; i < env->nr; i++)
886 if (skip_prefix(env->v[i],
887 "GIT_AUTHOR_DATE=", &date))
888 return date;
890 * If GIT_AUTHOR_DATE is missing we should have already errored out when
891 * reading the script
893 BUG("GIT_AUTHOR_DATE missing from author script");
896 static const char staged_changes_advice[] =
897 N_("you have staged changes in your working tree\n"
898 "If these changes are meant to be squashed into the previous commit, run:\n"
899 "\n"
900 " git commit --amend %s\n"
901 "\n"
902 "If they are meant to go into a new commit, run:\n"
903 "\n"
904 " git commit %s\n"
905 "\n"
906 "In both cases, once you're done, continue with:\n"
907 "\n"
908 " git rebase --continue\n");
910 #define ALLOW_EMPTY (1<<0)
911 #define EDIT_MSG (1<<1)
912 #define AMEND_MSG (1<<2)
913 #define CLEANUP_MSG (1<<3)
914 #define VERIFY_MSG (1<<4)
915 #define CREATE_ROOT_COMMIT (1<<5)
917 static int run_command_silent_on_success(struct child_process *cmd)
919 struct strbuf buf = STRBUF_INIT;
920 int rc;
922 cmd->stdout_to_stderr = 1;
923 rc = pipe_command(cmd,
924 NULL, 0,
925 NULL, 0,
926 &buf, 0);
928 if (rc)
929 fputs(buf.buf, stderr);
930 strbuf_release(&buf);
931 return rc;
935 * If we are cherry-pick, and if the merge did not result in
936 * hand-editing, we will hit this commit and inherit the original
937 * author date and name.
939 * If we are revert, or if our cherry-pick results in a hand merge,
940 * we had better say that the current user is responsible for that.
942 * An exception is when run_git_commit() is called during an
943 * interactive rebase: in that case, we will want to retain the
944 * author metadata.
946 static int run_git_commit(const char *defmsg,
947 struct replay_opts *opts,
948 unsigned int flags)
950 struct child_process cmd = CHILD_PROCESS_INIT;
952 cmd.git_cmd = 1;
954 if (is_rebase_i(opts) && read_env_script(&cmd.env_array)) {
955 const char *gpg_opt = gpg_sign_opt_quoted(opts);
957 return error(_(staged_changes_advice),
958 gpg_opt, gpg_opt);
961 if (opts->committer_date_is_author_date)
962 strvec_pushf(&cmd.env_array, "GIT_COMMITTER_DATE=%s",
963 opts->ignore_date ?
964 "" :
965 author_date_from_env_array(&cmd.env_array));
966 if (opts->ignore_date)
967 strvec_push(&cmd.env_array, "GIT_AUTHOR_DATE=");
969 strvec_push(&cmd.args, "commit");
971 if (!(flags & VERIFY_MSG))
972 strvec_push(&cmd.args, "-n");
973 if ((flags & AMEND_MSG))
974 strvec_push(&cmd.args, "--amend");
975 if (opts->gpg_sign)
976 strvec_pushf(&cmd.args, "-S%s", opts->gpg_sign);
977 else
978 strvec_push(&cmd.args, "--no-gpg-sign");
979 if (defmsg)
980 strvec_pushl(&cmd.args, "-F", defmsg, NULL);
981 else if (!(flags & EDIT_MSG))
982 strvec_pushl(&cmd.args, "-C", "HEAD", NULL);
983 if ((flags & CLEANUP_MSG))
984 strvec_push(&cmd.args, "--cleanup=strip");
985 if ((flags & EDIT_MSG))
986 strvec_push(&cmd.args, "-e");
987 else if (!(flags & CLEANUP_MSG) &&
988 !opts->signoff && !opts->record_origin &&
989 !opts->explicit_cleanup)
990 strvec_push(&cmd.args, "--cleanup=verbatim");
992 if ((flags & ALLOW_EMPTY))
993 strvec_push(&cmd.args, "--allow-empty");
995 if (!(flags & EDIT_MSG))
996 strvec_push(&cmd.args, "--allow-empty-message");
998 if (is_rebase_i(opts) && !(flags & EDIT_MSG))
999 return run_command_silent_on_success(&cmd);
1000 else
1001 return run_command(&cmd);
1004 static int rest_is_empty(const struct strbuf *sb, int start)
1006 int i, eol;
1007 const char *nl;
1009 /* Check if the rest is just whitespace and Signed-off-by's. */
1010 for (i = start; i < sb->len; i++) {
1011 nl = memchr(sb->buf + i, '\n', sb->len - i);
1012 if (nl)
1013 eol = nl - sb->buf;
1014 else
1015 eol = sb->len;
1017 if (strlen(sign_off_header) <= eol - i &&
1018 starts_with(sb->buf + i, sign_off_header)) {
1019 i = eol;
1020 continue;
1022 while (i < eol)
1023 if (!isspace(sb->buf[i++]))
1024 return 0;
1027 return 1;
1030 void cleanup_message(struct strbuf *msgbuf,
1031 enum commit_msg_cleanup_mode cleanup_mode, int verbose)
1033 if (verbose || /* Truncate the message just before the diff, if any. */
1034 cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS)
1035 strbuf_setlen(msgbuf, wt_status_locate_end(msgbuf->buf, msgbuf->len));
1036 if (cleanup_mode != COMMIT_MSG_CLEANUP_NONE)
1037 strbuf_stripspace(msgbuf, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1041 * Find out if the message in the strbuf contains only whitespace and
1042 * Signed-off-by lines.
1044 int message_is_empty(const struct strbuf *sb,
1045 enum commit_msg_cleanup_mode cleanup_mode)
1047 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1048 return 0;
1049 return rest_is_empty(sb, 0);
1053 * See if the user edited the message in the editor or left what
1054 * was in the template intact
1056 int template_untouched(const struct strbuf *sb, const char *template_file,
1057 enum commit_msg_cleanup_mode cleanup_mode)
1059 struct strbuf tmpl = STRBUF_INIT;
1060 const char *start;
1062 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1063 return 0;
1065 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1066 return 0;
1068 strbuf_stripspace(&tmpl, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1069 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1070 start = sb->buf;
1071 strbuf_release(&tmpl);
1072 return rest_is_empty(sb, start - sb->buf);
1075 int update_head_with_reflog(const struct commit *old_head,
1076 const struct object_id *new_head,
1077 const char *action, const struct strbuf *msg,
1078 struct strbuf *err)
1080 struct ref_transaction *transaction;
1081 struct strbuf sb = STRBUF_INIT;
1082 const char *nl;
1083 int ret = 0;
1085 if (action) {
1086 strbuf_addstr(&sb, action);
1087 strbuf_addstr(&sb, ": ");
1090 nl = strchr(msg->buf, '\n');
1091 if (nl) {
1092 strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
1093 } else {
1094 strbuf_addbuf(&sb, msg);
1095 strbuf_addch(&sb, '\n');
1098 transaction = ref_transaction_begin(err);
1099 if (!transaction ||
1100 ref_transaction_update(transaction, "HEAD", new_head,
1101 old_head ? &old_head->object.oid : &null_oid,
1102 0, sb.buf, err) ||
1103 ref_transaction_commit(transaction, err)) {
1104 ret = -1;
1106 ref_transaction_free(transaction);
1107 strbuf_release(&sb);
1109 return ret;
1112 static int run_rewrite_hook(const struct object_id *oldoid,
1113 const struct object_id *newoid)
1115 struct child_process proc = CHILD_PROCESS_INIT;
1116 const char *argv[3];
1117 int code;
1118 struct strbuf sb = STRBUF_INIT;
1120 argv[0] = find_hook("post-rewrite");
1121 if (!argv[0])
1122 return 0;
1124 argv[1] = "amend";
1125 argv[2] = NULL;
1127 proc.argv = argv;
1128 proc.in = -1;
1129 proc.stdout_to_stderr = 1;
1130 proc.trace2_hook_name = "post-rewrite";
1132 code = start_command(&proc);
1133 if (code)
1134 return code;
1135 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1136 sigchain_push(SIGPIPE, SIG_IGN);
1137 write_in_full(proc.in, sb.buf, sb.len);
1138 close(proc.in);
1139 strbuf_release(&sb);
1140 sigchain_pop(SIGPIPE);
1141 return finish_command(&proc);
1144 void commit_post_rewrite(struct repository *r,
1145 const struct commit *old_head,
1146 const struct object_id *new_head)
1148 struct notes_rewrite_cfg *cfg;
1150 cfg = init_copy_notes_for_rewrite("amend");
1151 if (cfg) {
1152 /* we are amending, so old_head is not NULL */
1153 copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
1154 finish_copy_notes_for_rewrite(r, cfg, "Notes added by 'git commit --amend'");
1156 run_rewrite_hook(&old_head->object.oid, new_head);
1159 static int run_prepare_commit_msg_hook(struct repository *r,
1160 struct strbuf *msg,
1161 const char *commit)
1163 int ret = 0;
1164 const char *name, *arg1 = NULL, *arg2 = NULL;
1166 name = git_path_commit_editmsg();
1167 if (write_message(msg->buf, msg->len, name, 0))
1168 return -1;
1170 if (commit) {
1171 arg1 = "commit";
1172 arg2 = commit;
1173 } else {
1174 arg1 = "message";
1176 if (run_commit_hook(0, r->index_file, "prepare-commit-msg", name,
1177 arg1, arg2, NULL))
1178 ret = error(_("'prepare-commit-msg' hook failed"));
1180 return ret;
1183 static const char implicit_ident_advice_noconfig[] =
1184 N_("Your name and email address were configured automatically based\n"
1185 "on your username and hostname. Please check that they are accurate.\n"
1186 "You can suppress this message by setting them explicitly. Run the\n"
1187 "following command and follow the instructions in your editor to edit\n"
1188 "your configuration file:\n"
1189 "\n"
1190 " git config --global --edit\n"
1191 "\n"
1192 "After doing this, you may fix the identity used for this commit with:\n"
1193 "\n"
1194 " git commit --amend --reset-author\n");
1196 static const char implicit_ident_advice_config[] =
1197 N_("Your name and email address were configured automatically based\n"
1198 "on your username and hostname. Please check that they are accurate.\n"
1199 "You can suppress this message by setting them explicitly:\n"
1200 "\n"
1201 " git config --global user.name \"Your Name\"\n"
1202 " git config --global user.email you@example.com\n"
1203 "\n"
1204 "After doing this, you may fix the identity used for this commit with:\n"
1205 "\n"
1206 " git commit --amend --reset-author\n");
1208 static const char *implicit_ident_advice(void)
1210 char *user_config = expand_user_path("~/.gitconfig", 0);
1211 char *xdg_config = xdg_config_home("config");
1212 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1214 free(user_config);
1215 free(xdg_config);
1217 if (config_exists)
1218 return _(implicit_ident_advice_config);
1219 else
1220 return _(implicit_ident_advice_noconfig);
1224 void print_commit_summary(struct repository *r,
1225 const char *prefix,
1226 const struct object_id *oid,
1227 unsigned int flags)
1229 struct rev_info rev;
1230 struct commit *commit;
1231 struct strbuf format = STRBUF_INIT;
1232 const char *head;
1233 struct pretty_print_context pctx = {0};
1234 struct strbuf author_ident = STRBUF_INIT;
1235 struct strbuf committer_ident = STRBUF_INIT;
1237 commit = lookup_commit(r, oid);
1238 if (!commit)
1239 die(_("couldn't look up newly created commit"));
1240 if (parse_commit(commit))
1241 die(_("could not parse newly created commit"));
1243 strbuf_addstr(&format, "format:%h] %s");
1245 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1246 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1247 if (strbuf_cmp(&author_ident, &committer_ident)) {
1248 strbuf_addstr(&format, "\n Author: ");
1249 strbuf_addbuf_percentquote(&format, &author_ident);
1251 if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
1252 struct strbuf date = STRBUF_INIT;
1254 format_commit_message(commit, "%ad", &date, &pctx);
1255 strbuf_addstr(&format, "\n Date: ");
1256 strbuf_addbuf_percentquote(&format, &date);
1257 strbuf_release(&date);
1259 if (!committer_ident_sufficiently_given()) {
1260 strbuf_addstr(&format, "\n Committer: ");
1261 strbuf_addbuf_percentquote(&format, &committer_ident);
1262 if (advice_implicit_identity) {
1263 strbuf_addch(&format, '\n');
1264 strbuf_addstr(&format, implicit_ident_advice());
1267 strbuf_release(&author_ident);
1268 strbuf_release(&committer_ident);
1270 repo_init_revisions(r, &rev, prefix);
1271 setup_revisions(0, NULL, &rev, NULL);
1273 rev.diff = 1;
1274 rev.diffopt.output_format =
1275 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1277 rev.verbose_header = 1;
1278 rev.show_root_diff = 1;
1279 get_commit_format(format.buf, &rev);
1280 rev.always_show_header = 0;
1281 rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1282 rev.diffopt.break_opt = 0;
1283 diff_setup_done(&rev.diffopt);
1285 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1286 if (!head)
1287 die_errno(_("unable to resolve HEAD after creating commit"));
1288 if (!strcmp(head, "HEAD"))
1289 head = _("detached HEAD");
1290 else
1291 skip_prefix(head, "refs/heads/", &head);
1292 printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1293 _(" (root-commit)") : "");
1295 if (!log_tree_commit(&rev, commit)) {
1296 rev.always_show_header = 1;
1297 rev.use_terminator = 1;
1298 log_tree_commit(&rev, commit);
1301 strbuf_release(&format);
1304 static int parse_head(struct repository *r, struct commit **head)
1306 struct commit *current_head;
1307 struct object_id oid;
1309 if (get_oid("HEAD", &oid)) {
1310 current_head = NULL;
1311 } else {
1312 current_head = lookup_commit_reference(r, &oid);
1313 if (!current_head)
1314 return error(_("could not parse HEAD"));
1315 if (!oideq(&oid, &current_head->object.oid)) {
1316 warning(_("HEAD %s is not a commit!"),
1317 oid_to_hex(&oid));
1319 if (parse_commit(current_head))
1320 return error(_("could not parse HEAD commit"));
1322 *head = current_head;
1324 return 0;
1328 * Try to commit without forking 'git commit'. In some cases we need
1329 * to run 'git commit' to display an error message
1331 * Returns:
1332 * -1 - error unable to commit
1333 * 0 - success
1334 * 1 - run 'git commit'
1336 static int try_to_commit(struct repository *r,
1337 struct strbuf *msg, const char *author,
1338 struct replay_opts *opts, unsigned int flags,
1339 struct object_id *oid)
1341 struct object_id tree;
1342 struct commit *current_head = NULL;
1343 struct commit_list *parents = NULL;
1344 struct commit_extra_header *extra = NULL;
1345 struct strbuf err = STRBUF_INIT;
1346 struct strbuf commit_msg = STRBUF_INIT;
1347 char *amend_author = NULL;
1348 const char *committer = NULL;
1349 const char *hook_commit = NULL;
1350 enum commit_msg_cleanup_mode cleanup;
1351 int res = 0;
1353 if (parse_head(r, &current_head))
1354 return -1;
1356 if (flags & AMEND_MSG) {
1357 const char *exclude_gpgsig[] = { "gpgsig", "gpgsig-sha256", NULL };
1358 const char *out_enc = get_commit_output_encoding();
1359 const char *message = logmsg_reencode(current_head, NULL,
1360 out_enc);
1362 if (!msg) {
1363 const char *orig_message = NULL;
1365 find_commit_subject(message, &orig_message);
1366 msg = &commit_msg;
1367 strbuf_addstr(msg, orig_message);
1368 hook_commit = "HEAD";
1370 author = amend_author = get_author(message);
1371 unuse_commit_buffer(current_head, message);
1372 if (!author) {
1373 res = error(_("unable to parse commit author"));
1374 goto out;
1376 parents = copy_commit_list(current_head->parents);
1377 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1378 } else if (current_head &&
1379 (!(flags & CREATE_ROOT_COMMIT) || (flags & AMEND_MSG))) {
1380 commit_list_insert(current_head, &parents);
1383 if (write_index_as_tree(&tree, r->index, r->index_file, 0, NULL)) {
1384 res = error(_("git write-tree failed to write a tree"));
1385 goto out;
1388 if (!(flags & ALLOW_EMPTY)) {
1389 struct commit *first_parent = current_head;
1391 if (flags & AMEND_MSG) {
1392 if (current_head->parents) {
1393 first_parent = current_head->parents->item;
1394 if (repo_parse_commit(r, first_parent)) {
1395 res = error(_("could not parse HEAD commit"));
1396 goto out;
1398 } else {
1399 first_parent = NULL;
1402 if (oideq(first_parent
1403 ? get_commit_tree_oid(first_parent)
1404 : the_hash_algo->empty_tree,
1405 &tree)) {
1406 res = 1; /* run 'git commit' to display error message */
1407 goto out;
1411 if (find_hook("prepare-commit-msg")) {
1412 res = run_prepare_commit_msg_hook(r, msg, hook_commit);
1413 if (res)
1414 goto out;
1415 if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1416 2048) < 0) {
1417 res = error_errno(_("unable to read commit message "
1418 "from '%s'"),
1419 git_path_commit_editmsg());
1420 goto out;
1422 msg = &commit_msg;
1425 if (flags & CLEANUP_MSG)
1426 cleanup = COMMIT_MSG_CLEANUP_ALL;
1427 else if ((opts->signoff || opts->record_origin) &&
1428 !opts->explicit_cleanup)
1429 cleanup = COMMIT_MSG_CLEANUP_SPACE;
1430 else
1431 cleanup = opts->default_msg_cleanup;
1433 if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1434 strbuf_stripspace(msg, cleanup == COMMIT_MSG_CLEANUP_ALL);
1435 if ((flags & EDIT_MSG) && message_is_empty(msg, cleanup)) {
1436 res = 1; /* run 'git commit' to display error message */
1437 goto out;
1440 if (opts->committer_date_is_author_date) {
1441 struct ident_split id;
1442 struct strbuf date = STRBUF_INIT;
1444 if (!opts->ignore_date) {
1445 if (split_ident_line(&id, author, (int)strlen(author)) < 0) {
1446 res = error(_("invalid author identity '%s'"),
1447 author);
1448 goto out;
1450 if (!id.date_begin) {
1451 res = error(_(
1452 "corrupt author: missing date information"));
1453 goto out;
1455 strbuf_addf(&date, "@%.*s %.*s",
1456 (int)(id.date_end - id.date_begin),
1457 id.date_begin,
1458 (int)(id.tz_end - id.tz_begin),
1459 id.tz_begin);
1460 } else {
1461 reset_ident_date();
1463 committer = fmt_ident(opts->committer_name,
1464 opts->committer_email,
1465 WANT_COMMITTER_IDENT,
1466 opts->ignore_date ? NULL : date.buf,
1467 IDENT_STRICT);
1468 strbuf_release(&date);
1469 } else {
1470 reset_ident_date();
1473 if (opts->ignore_date) {
1474 struct ident_split id;
1475 char *name, *email;
1477 if (split_ident_line(&id, author, strlen(author)) < 0) {
1478 error(_("invalid author identity '%s'"), author);
1479 goto out;
1481 name = xmemdupz(id.name_begin, id.name_end - id.name_begin);
1482 email = xmemdupz(id.mail_begin, id.mail_end - id.mail_begin);
1483 author = fmt_ident(name, email, WANT_AUTHOR_IDENT, NULL,
1484 IDENT_STRICT);
1485 free(name);
1486 free(email);
1489 if (commit_tree_extended(msg->buf, msg->len, &tree, parents, oid,
1490 author, committer, opts->gpg_sign, extra)) {
1491 res = error(_("failed to write commit object"));
1492 goto out;
1495 if (update_head_with_reflog(current_head, oid,
1496 getenv("GIT_REFLOG_ACTION"), msg, &err)) {
1497 res = error("%s", err.buf);
1498 goto out;
1501 run_commit_hook(0, r->index_file, "post-commit", NULL);
1502 if (flags & AMEND_MSG)
1503 commit_post_rewrite(r, current_head, oid);
1505 out:
1506 free_commit_extra_headers(extra);
1507 strbuf_release(&err);
1508 strbuf_release(&commit_msg);
1509 free(amend_author);
1511 return res;
1514 static int write_rebase_head(struct object_id *oid)
1516 if (update_ref("rebase", "REBASE_HEAD", oid,
1517 NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1518 return error(_("could not update %s"), "REBASE_HEAD");
1520 return 0;
1523 static int do_commit(struct repository *r,
1524 const char *msg_file, const char *author,
1525 struct replay_opts *opts, unsigned int flags,
1526 struct object_id *oid)
1528 int res = 1;
1530 if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG)) {
1531 struct object_id oid;
1532 struct strbuf sb = STRBUF_INIT;
1534 if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1535 return error_errno(_("unable to read commit message "
1536 "from '%s'"),
1537 msg_file);
1539 res = try_to_commit(r, msg_file ? &sb : NULL,
1540 author, opts, flags, &oid);
1541 strbuf_release(&sb);
1542 if (!res) {
1543 refs_delete_ref(get_main_ref_store(r), "",
1544 "CHERRY_PICK_HEAD", NULL, 0);
1545 unlink(git_path_merge_msg(r));
1546 if (!is_rebase_i(opts))
1547 print_commit_summary(r, NULL, &oid,
1548 SUMMARY_SHOW_AUTHOR_DATE);
1549 return res;
1552 if (res == 1) {
1553 if (is_rebase_i(opts) && oid)
1554 if (write_rebase_head(oid))
1555 return -1;
1556 return run_git_commit(msg_file, opts, flags);
1559 return res;
1562 static int is_original_commit_empty(struct commit *commit)
1564 const struct object_id *ptree_oid;
1566 if (parse_commit(commit))
1567 return error(_("could not parse commit %s"),
1568 oid_to_hex(&commit->object.oid));
1569 if (commit->parents) {
1570 struct commit *parent = commit->parents->item;
1571 if (parse_commit(parent))
1572 return error(_("could not parse parent commit %s"),
1573 oid_to_hex(&parent->object.oid));
1574 ptree_oid = get_commit_tree_oid(parent);
1575 } else {
1576 ptree_oid = the_hash_algo->empty_tree; /* commit is root */
1579 return oideq(ptree_oid, get_commit_tree_oid(commit));
1583 * Should empty commits be allowed? Return status:
1584 * <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1585 * 0: Halt on empty commit
1586 * 1: Allow empty commit
1587 * 2: Drop empty commit
1589 static int allow_empty(struct repository *r,
1590 struct replay_opts *opts,
1591 struct commit *commit)
1593 int index_unchanged, originally_empty;
1596 * Four cases:
1598 * (1) we do not allow empty at all and error out.
1600 * (2) we allow ones that were initially empty, and
1601 * just drop the ones that become empty
1603 * (3) we allow ones that were initially empty, but
1604 * halt for the ones that become empty;
1606 * (4) we allow both.
1608 if (!opts->allow_empty)
1609 return 0; /* let "git commit" barf as necessary */
1611 index_unchanged = is_index_unchanged(r);
1612 if (index_unchanged < 0)
1613 return index_unchanged;
1614 if (!index_unchanged)
1615 return 0; /* we do not have to say --allow-empty */
1617 if (opts->keep_redundant_commits)
1618 return 1;
1620 originally_empty = is_original_commit_empty(commit);
1621 if (originally_empty < 0)
1622 return originally_empty;
1623 if (originally_empty)
1624 return 1;
1625 else if (opts->drop_redundant_commits)
1626 return 2;
1627 else
1628 return 0;
1631 static struct {
1632 char c;
1633 const char *str;
1634 } todo_command_info[] = {
1635 { 'p', "pick" },
1636 { 0, "revert" },
1637 { 'e', "edit" },
1638 { 'r', "reword" },
1639 { 'f', "fixup" },
1640 { 's', "squash" },
1641 { 'x', "exec" },
1642 { 'b', "break" },
1643 { 'l', "label" },
1644 { 't', "reset" },
1645 { 'm', "merge" },
1646 { 0, "noop" },
1647 { 'd', "drop" },
1648 { 0, NULL }
1651 static const char *command_to_string(const enum todo_command command)
1653 if (command < TODO_COMMENT)
1654 return todo_command_info[command].str;
1655 die(_("unknown command: %d"), command);
1658 static char command_to_char(const enum todo_command command)
1660 if (command < TODO_COMMENT)
1661 return todo_command_info[command].c;
1662 return comment_line_char;
1665 static int is_noop(const enum todo_command command)
1667 return TODO_NOOP <= command;
1670 static int is_fixup(enum todo_command command)
1672 return command == TODO_FIXUP || command == TODO_SQUASH;
1675 /* Does this command create a (non-merge) commit? */
1676 static int is_pick_or_similar(enum todo_command command)
1678 switch (command) {
1679 case TODO_PICK:
1680 case TODO_REVERT:
1681 case TODO_EDIT:
1682 case TODO_REWORD:
1683 case TODO_FIXUP:
1684 case TODO_SQUASH:
1685 return 1;
1686 default:
1687 return 0;
1691 static int update_squash_messages(struct repository *r,
1692 enum todo_command command,
1693 struct commit *commit,
1694 struct replay_opts *opts)
1696 struct strbuf buf = STRBUF_INIT;
1697 int res;
1698 const char *message, *body;
1699 const char *encoding = get_commit_output_encoding();
1701 if (opts->current_fixup_count > 0) {
1702 struct strbuf header = STRBUF_INIT;
1703 char *eol;
1705 if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
1706 return error(_("could not read '%s'"),
1707 rebase_path_squash_msg());
1709 eol = buf.buf[0] != comment_line_char ?
1710 buf.buf : strchrnul(buf.buf, '\n');
1712 strbuf_addf(&header, "%c ", comment_line_char);
1713 strbuf_addf(&header, _("This is a combination of %d commits."),
1714 opts->current_fixup_count + 2);
1715 strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
1716 strbuf_release(&header);
1717 } else {
1718 struct object_id head;
1719 struct commit *head_commit;
1720 const char *head_message, *body;
1722 if (get_oid("HEAD", &head))
1723 return error(_("need a HEAD to fixup"));
1724 if (!(head_commit = lookup_commit_reference(r, &head)))
1725 return error(_("could not read HEAD"));
1726 if (!(head_message = logmsg_reencode(head_commit, NULL, encoding)))
1727 return error(_("could not read HEAD's commit message"));
1729 find_commit_subject(head_message, &body);
1730 if (write_message(body, strlen(body),
1731 rebase_path_fixup_msg(), 0)) {
1732 unuse_commit_buffer(head_commit, head_message);
1733 return error(_("cannot write '%s'"),
1734 rebase_path_fixup_msg());
1737 strbuf_addf(&buf, "%c ", comment_line_char);
1738 strbuf_addf(&buf, _("This is a combination of %d commits."), 2);
1739 strbuf_addf(&buf, "\n%c ", comment_line_char);
1740 strbuf_addstr(&buf, _("This is the 1st commit message:"));
1741 strbuf_addstr(&buf, "\n\n");
1742 strbuf_addstr(&buf, body);
1744 unuse_commit_buffer(head_commit, head_message);
1747 if (!(message = logmsg_reencode(commit, NULL, encoding)))
1748 return error(_("could not read commit message of %s"),
1749 oid_to_hex(&commit->object.oid));
1750 find_commit_subject(message, &body);
1752 if (command == TODO_SQUASH) {
1753 unlink(rebase_path_fixup_msg());
1754 strbuf_addf(&buf, "\n%c ", comment_line_char);
1755 strbuf_addf(&buf, _("This is the commit message #%d:"),
1756 ++opts->current_fixup_count + 1);
1757 strbuf_addstr(&buf, "\n\n");
1758 strbuf_addstr(&buf, body);
1759 } else if (command == TODO_FIXUP) {
1760 strbuf_addf(&buf, "\n%c ", comment_line_char);
1761 strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
1762 ++opts->current_fixup_count + 1);
1763 strbuf_addstr(&buf, "\n\n");
1764 strbuf_add_commented_lines(&buf, body, strlen(body));
1765 } else
1766 return error(_("unknown command: %d"), command);
1767 unuse_commit_buffer(commit, message);
1769 res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
1770 strbuf_release(&buf);
1772 if (!res) {
1773 strbuf_addf(&opts->current_fixups, "%s%s %s",
1774 opts->current_fixups.len ? "\n" : "",
1775 command_to_string(command),
1776 oid_to_hex(&commit->object.oid));
1777 res = write_message(opts->current_fixups.buf,
1778 opts->current_fixups.len,
1779 rebase_path_current_fixups(), 0);
1782 return res;
1785 static void flush_rewritten_pending(void)
1787 struct strbuf buf = STRBUF_INIT;
1788 struct object_id newoid;
1789 FILE *out;
1791 if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
1792 !get_oid("HEAD", &newoid) &&
1793 (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1794 char *bol = buf.buf, *eol;
1796 while (*bol) {
1797 eol = strchrnul(bol, '\n');
1798 fprintf(out, "%.*s %s\n", (int)(eol - bol),
1799 bol, oid_to_hex(&newoid));
1800 if (!*eol)
1801 break;
1802 bol = eol + 1;
1804 fclose(out);
1805 unlink(rebase_path_rewritten_pending());
1807 strbuf_release(&buf);
1810 static void record_in_rewritten(struct object_id *oid,
1811 enum todo_command next_command)
1813 FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
1815 if (!out)
1816 return;
1818 fprintf(out, "%s\n", oid_to_hex(oid));
1819 fclose(out);
1821 if (!is_fixup(next_command))
1822 flush_rewritten_pending();
1825 static int do_pick_commit(struct repository *r,
1826 enum todo_command command,
1827 struct commit *commit,
1828 struct replay_opts *opts,
1829 int final_fixup, int *check_todo)
1831 unsigned int flags = opts->edit ? EDIT_MSG : 0;
1832 const char *msg_file = opts->edit ? NULL : git_path_merge_msg(r);
1833 struct object_id head;
1834 struct commit *base, *next, *parent;
1835 const char *base_label, *next_label;
1836 char *author = NULL;
1837 struct commit_message msg = { NULL, NULL, NULL, NULL };
1838 struct strbuf msgbuf = STRBUF_INIT;
1839 int res, unborn = 0, reword = 0, allow, drop_commit;
1841 if (opts->no_commit) {
1843 * We do not intend to commit immediately. We just want to
1844 * merge the differences in, so let's compute the tree
1845 * that represents the "current" state for merge-recursive
1846 * to work on.
1848 if (write_index_as_tree(&head, r->index, r->index_file, 0, NULL))
1849 return error(_("your index file is unmerged."));
1850 } else {
1851 unborn = get_oid("HEAD", &head);
1852 /* Do we want to generate a root commit? */
1853 if (is_pick_or_similar(command) && opts->have_squash_onto &&
1854 oideq(&head, &opts->squash_onto)) {
1855 if (is_fixup(command))
1856 return error(_("cannot fixup root commit"));
1857 flags |= CREATE_ROOT_COMMIT;
1858 unborn = 1;
1859 } else if (unborn)
1860 oidcpy(&head, the_hash_algo->empty_tree);
1861 if (index_differs_from(r, unborn ? empty_tree_oid_hex() : "HEAD",
1862 NULL, 0))
1863 return error_dirty_index(r, opts);
1865 discard_index(r->index);
1867 if (!commit->parents)
1868 parent = NULL;
1869 else if (commit->parents->next) {
1870 /* Reverting or cherry-picking a merge commit */
1871 int cnt;
1872 struct commit_list *p;
1874 if (!opts->mainline)
1875 return error(_("commit %s is a merge but no -m option was given."),
1876 oid_to_hex(&commit->object.oid));
1878 for (cnt = 1, p = commit->parents;
1879 cnt != opts->mainline && p;
1880 cnt++)
1881 p = p->next;
1882 if (cnt != opts->mainline || !p)
1883 return error(_("commit %s does not have parent %d"),
1884 oid_to_hex(&commit->object.oid), opts->mainline);
1885 parent = p->item;
1886 } else if (1 < opts->mainline)
1888 * Non-first parent explicitly specified as mainline for
1889 * non-merge commit
1891 return error(_("commit %s does not have parent %d"),
1892 oid_to_hex(&commit->object.oid), opts->mainline);
1893 else
1894 parent = commit->parents->item;
1896 if (get_message(commit, &msg) != 0)
1897 return error(_("cannot get commit message for %s"),
1898 oid_to_hex(&commit->object.oid));
1900 if (opts->allow_ff && !is_fixup(command) &&
1901 ((parent && oideq(&parent->object.oid, &head)) ||
1902 (!parent && unborn))) {
1903 if (is_rebase_i(opts))
1904 write_author_script(msg.message);
1905 res = fast_forward_to(r, &commit->object.oid, &head, unborn,
1906 opts);
1907 if (res || command != TODO_REWORD)
1908 goto leave;
1909 reword = 1;
1910 msg_file = NULL;
1911 goto fast_forward_edit;
1913 if (parent && parse_commit(parent) < 0)
1914 /* TRANSLATORS: The first %s will be a "todo" command like
1915 "revert" or "pick", the second %s a SHA1. */
1916 return error(_("%s: cannot parse parent commit %s"),
1917 command_to_string(command),
1918 oid_to_hex(&parent->object.oid));
1921 * "commit" is an existing commit. We would want to apply
1922 * the difference it introduces since its first parent "prev"
1923 * on top of the current HEAD if we are cherry-pick. Or the
1924 * reverse of it if we are revert.
1927 if (command == TODO_REVERT) {
1928 base = commit;
1929 base_label = msg.label;
1930 next = parent;
1931 next_label = msg.parent_label;
1932 strbuf_addstr(&msgbuf, "Revert \"");
1933 strbuf_addstr(&msgbuf, msg.subject);
1934 strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
1935 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1937 if (commit->parents && commit->parents->next) {
1938 strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
1939 strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
1941 strbuf_addstr(&msgbuf, ".\n");
1942 } else {
1943 const char *p;
1945 base = parent;
1946 base_label = msg.parent_label;
1947 next = commit;
1948 next_label = msg.label;
1950 /* Append the commit log message to msgbuf. */
1951 if (find_commit_subject(msg.message, &p))
1952 strbuf_addstr(&msgbuf, p);
1954 if (opts->record_origin) {
1955 strbuf_complete_line(&msgbuf);
1956 if (!has_conforming_footer(&msgbuf, NULL, 0))
1957 strbuf_addch(&msgbuf, '\n');
1958 strbuf_addstr(&msgbuf, cherry_picked_prefix);
1959 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1960 strbuf_addstr(&msgbuf, ")\n");
1962 if (!is_fixup(command))
1963 author = get_author(msg.message);
1966 if (command == TODO_REWORD)
1967 reword = 1;
1968 else if (is_fixup(command)) {
1969 if (update_squash_messages(r, command, commit, opts))
1970 return -1;
1971 flags |= AMEND_MSG;
1972 if (!final_fixup)
1973 msg_file = rebase_path_squash_msg();
1974 else if (file_exists(rebase_path_fixup_msg())) {
1975 flags |= CLEANUP_MSG;
1976 msg_file = rebase_path_fixup_msg();
1977 } else {
1978 const char *dest = git_path_squash_msg(r);
1979 unlink(dest);
1980 if (copy_file(dest, rebase_path_squash_msg(), 0666))
1981 return error(_("could not rename '%s' to '%s'"),
1982 rebase_path_squash_msg(), dest);
1983 unlink(git_path_merge_msg(r));
1984 msg_file = dest;
1985 flags |= EDIT_MSG;
1989 if (opts->signoff && !is_fixup(command))
1990 append_signoff(&msgbuf, 0, 0);
1992 if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1993 res = -1;
1994 else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
1995 res = do_recursive_merge(r, base, next, base_label, next_label,
1996 &head, &msgbuf, opts);
1997 if (res < 0)
1998 goto leave;
2000 res |= write_message(msgbuf.buf, msgbuf.len,
2001 git_path_merge_msg(r), 0);
2002 } else {
2003 struct commit_list *common = NULL;
2004 struct commit_list *remotes = NULL;
2006 res = write_message(msgbuf.buf, msgbuf.len,
2007 git_path_merge_msg(r), 0);
2009 commit_list_insert(base, &common);
2010 commit_list_insert(next, &remotes);
2011 res |= try_merge_command(r, opts->strategy,
2012 opts->xopts_nr, (const char **)opts->xopts,
2013 common, oid_to_hex(&head), remotes);
2014 free_commit_list(common);
2015 free_commit_list(remotes);
2017 strbuf_release(&msgbuf);
2020 * If the merge was clean or if it failed due to conflict, we write
2021 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
2022 * However, if the merge did not even start, then we don't want to
2023 * write it at all.
2025 if ((command == TODO_PICK || command == TODO_REWORD ||
2026 command == TODO_EDIT) && !opts->no_commit &&
2027 (res == 0 || res == 1) &&
2028 update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
2029 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2030 res = -1;
2031 if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
2032 update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
2033 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2034 res = -1;
2036 if (res) {
2037 error(command == TODO_REVERT
2038 ? _("could not revert %s... %s")
2039 : _("could not apply %s... %s"),
2040 short_commit_name(commit), msg.subject);
2041 print_advice(r, res == 1, opts);
2042 repo_rerere(r, opts->allow_rerere_auto);
2043 goto leave;
2046 drop_commit = 0;
2047 allow = allow_empty(r, opts, commit);
2048 if (allow < 0) {
2049 res = allow;
2050 goto leave;
2051 } else if (allow == 1) {
2052 flags |= ALLOW_EMPTY;
2053 } else if (allow == 2) {
2054 drop_commit = 1;
2055 refs_delete_ref(get_main_ref_store(r), "", "CHERRY_PICK_HEAD",
2056 NULL, 0);
2057 unlink(git_path_merge_msg(r));
2058 fprintf(stderr,
2059 _("dropping %s %s -- patch contents already upstream\n"),
2060 oid_to_hex(&commit->object.oid), msg.subject);
2061 } /* else allow == 0 and there's nothing special to do */
2062 if (!opts->no_commit && !drop_commit) {
2063 if (author || command == TODO_REVERT || (flags & AMEND_MSG))
2064 res = do_commit(r, msg_file, author, opts, flags,
2065 commit? &commit->object.oid : NULL);
2066 else
2067 res = error(_("unable to parse commit author"));
2068 *check_todo = !!(flags & EDIT_MSG);
2069 if (!res && reword) {
2070 fast_forward_edit:
2071 res = run_git_commit(NULL, opts, EDIT_MSG |
2072 VERIFY_MSG | AMEND_MSG |
2073 (flags & ALLOW_EMPTY));
2074 *check_todo = 1;
2079 if (!res && final_fixup) {
2080 unlink(rebase_path_fixup_msg());
2081 unlink(rebase_path_squash_msg());
2082 unlink(rebase_path_current_fixups());
2083 strbuf_reset(&opts->current_fixups);
2084 opts->current_fixup_count = 0;
2087 leave:
2088 free_message(commit, &msg);
2089 free(author);
2090 update_abort_safety_file();
2092 return res;
2095 static int prepare_revs(struct replay_opts *opts)
2098 * picking (but not reverting) ranges (but not individual revisions)
2099 * should be done in reverse
2101 if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
2102 opts->revs->reverse ^= 1;
2104 if (prepare_revision_walk(opts->revs))
2105 return error(_("revision walk setup failed"));
2107 return 0;
2110 static int read_and_refresh_cache(struct repository *r,
2111 struct replay_opts *opts)
2113 struct lock_file index_lock = LOCK_INIT;
2114 int index_fd = repo_hold_locked_index(r, &index_lock, 0);
2115 if (repo_read_index(r) < 0) {
2116 rollback_lock_file(&index_lock);
2117 return error(_("git %s: failed to read the index"),
2118 _(action_name(opts)));
2120 refresh_index(r->index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
2121 if (index_fd >= 0) {
2122 if (write_locked_index(r->index, &index_lock,
2123 COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
2124 return error(_("git %s: failed to refresh the index"),
2125 _(action_name(opts)));
2128 return 0;
2131 enum todo_item_flags {
2132 TODO_EDIT_MERGE_MSG = 1
2135 void todo_list_release(struct todo_list *todo_list)
2137 strbuf_release(&todo_list->buf);
2138 FREE_AND_NULL(todo_list->items);
2139 todo_list->nr = todo_list->alloc = 0;
2142 static struct todo_item *append_new_todo(struct todo_list *todo_list)
2144 ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
2145 todo_list->total_nr++;
2146 return todo_list->items + todo_list->nr++;
2149 const char *todo_item_get_arg(struct todo_list *todo_list,
2150 struct todo_item *item)
2152 return todo_list->buf.buf + item->arg_offset;
2155 static int is_command(enum todo_command command, const char **bol)
2157 const char *str = todo_command_info[command].str;
2158 const char nick = todo_command_info[command].c;
2159 const char *p = *bol + 1;
2161 return skip_prefix(*bol, str, bol) ||
2162 ((nick && **bol == nick) &&
2163 (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r' || !*p) &&
2164 (*bol = p));
2167 static int parse_insn_line(struct repository *r, struct todo_item *item,
2168 const char *buf, const char *bol, char *eol)
2170 struct object_id commit_oid;
2171 char *end_of_object_name;
2172 int i, saved, status, padding;
2174 item->flags = 0;
2176 /* left-trim */
2177 bol += strspn(bol, " \t");
2179 if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
2180 item->command = TODO_COMMENT;
2181 item->commit = NULL;
2182 item->arg_offset = bol - buf;
2183 item->arg_len = eol - bol;
2184 return 0;
2187 for (i = 0; i < TODO_COMMENT; i++)
2188 if (is_command(i, &bol)) {
2189 item->command = i;
2190 break;
2192 if (i >= TODO_COMMENT)
2193 return -1;
2195 /* Eat up extra spaces/ tabs before object name */
2196 padding = strspn(bol, " \t");
2197 bol += padding;
2199 if (item->command == TODO_NOOP || item->command == TODO_BREAK) {
2200 if (bol != eol)
2201 return error(_("%s does not accept arguments: '%s'"),
2202 command_to_string(item->command), bol);
2203 item->commit = NULL;
2204 item->arg_offset = bol - buf;
2205 item->arg_len = eol - bol;
2206 return 0;
2209 if (!padding)
2210 return error(_("missing arguments for %s"),
2211 command_to_string(item->command));
2213 if (item->command == TODO_EXEC || item->command == TODO_LABEL ||
2214 item->command == TODO_RESET) {
2215 item->commit = NULL;
2216 item->arg_offset = bol - buf;
2217 item->arg_len = (int)(eol - bol);
2218 return 0;
2221 if (item->command == TODO_MERGE) {
2222 if (skip_prefix(bol, "-C", &bol))
2223 bol += strspn(bol, " \t");
2224 else if (skip_prefix(bol, "-c", &bol)) {
2225 bol += strspn(bol, " \t");
2226 item->flags |= TODO_EDIT_MERGE_MSG;
2227 } else {
2228 item->flags |= TODO_EDIT_MERGE_MSG;
2229 item->commit = NULL;
2230 item->arg_offset = bol - buf;
2231 item->arg_len = (int)(eol - bol);
2232 return 0;
2236 end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
2237 saved = *end_of_object_name;
2238 *end_of_object_name = '\0';
2239 status = get_oid(bol, &commit_oid);
2240 if (status < 0)
2241 error(_("could not parse '%s'"), bol); /* return later */
2242 *end_of_object_name = saved;
2244 bol = end_of_object_name + strspn(end_of_object_name, " \t");
2245 item->arg_offset = bol - buf;
2246 item->arg_len = (int)(eol - bol);
2248 if (status < 0)
2249 return status;
2251 item->commit = lookup_commit_reference(r, &commit_oid);
2252 return item->commit ? 0 : -1;
2255 int sequencer_get_last_command(struct repository *r, enum replay_action *action)
2257 const char *todo_file, *bol;
2258 struct strbuf buf = STRBUF_INIT;
2259 int ret = 0;
2261 todo_file = git_path_todo_file();
2262 if (strbuf_read_file(&buf, todo_file, 0) < 0) {
2263 if (errno == ENOENT || errno == ENOTDIR)
2264 return -1;
2265 else
2266 return error_errno("unable to open '%s'", todo_file);
2268 bol = buf.buf + strspn(buf.buf, " \t\r\n");
2269 if (is_command(TODO_PICK, &bol) && (*bol == ' ' || *bol == '\t'))
2270 *action = REPLAY_PICK;
2271 else if (is_command(TODO_REVERT, &bol) &&
2272 (*bol == ' ' || *bol == '\t'))
2273 *action = REPLAY_REVERT;
2274 else
2275 ret = -1;
2277 strbuf_release(&buf);
2279 return ret;
2282 int todo_list_parse_insn_buffer(struct repository *r, char *buf,
2283 struct todo_list *todo_list)
2285 struct todo_item *item;
2286 char *p = buf, *next_p;
2287 int i, res = 0, fixup_okay = file_exists(rebase_path_done());
2289 todo_list->current = todo_list->nr = 0;
2291 for (i = 1; *p; i++, p = next_p) {
2292 char *eol = strchrnul(p, '\n');
2294 next_p = *eol ? eol + 1 /* skip LF */ : eol;
2296 if (p != eol && eol[-1] == '\r')
2297 eol--; /* strip Carriage Return */
2299 item = append_new_todo(todo_list);
2300 item->offset_in_buf = p - todo_list->buf.buf;
2301 if (parse_insn_line(r, item, buf, p, eol)) {
2302 res = error(_("invalid line %d: %.*s"),
2303 i, (int)(eol - p), p);
2304 item->command = TODO_COMMENT + 1;
2305 item->arg_offset = p - buf;
2306 item->arg_len = (int)(eol - p);
2307 item->commit = NULL;
2310 if (fixup_okay)
2311 ; /* do nothing */
2312 else if (is_fixup(item->command))
2313 return error(_("cannot '%s' without a previous commit"),
2314 command_to_string(item->command));
2315 else if (!is_noop(item->command))
2316 fixup_okay = 1;
2319 return res;
2322 static int count_commands(struct todo_list *todo_list)
2324 int count = 0, i;
2326 for (i = 0; i < todo_list->nr; i++)
2327 if (todo_list->items[i].command != TODO_COMMENT)
2328 count++;
2330 return count;
2333 static int get_item_line_offset(struct todo_list *todo_list, int index)
2335 return index < todo_list->nr ?
2336 todo_list->items[index].offset_in_buf : todo_list->buf.len;
2339 static const char *get_item_line(struct todo_list *todo_list, int index)
2341 return todo_list->buf.buf + get_item_line_offset(todo_list, index);
2344 static int get_item_line_length(struct todo_list *todo_list, int index)
2346 return get_item_line_offset(todo_list, index + 1)
2347 - get_item_line_offset(todo_list, index);
2350 static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
2352 int fd;
2353 ssize_t len;
2355 fd = open(path, O_RDONLY);
2356 if (fd < 0)
2357 return error_errno(_("could not open '%s'"), path);
2358 len = strbuf_read(sb, fd, 0);
2359 close(fd);
2360 if (len < 0)
2361 return error(_("could not read '%s'."), path);
2362 return len;
2365 static int have_finished_the_last_pick(void)
2367 struct strbuf buf = STRBUF_INIT;
2368 const char *eol;
2369 const char *todo_path = git_path_todo_file();
2370 int ret = 0;
2372 if (strbuf_read_file(&buf, todo_path, 0) < 0) {
2373 if (errno == ENOENT) {
2374 return 0;
2375 } else {
2376 error_errno("unable to open '%s'", todo_path);
2377 return 0;
2380 /* If there is only one line then we are done */
2381 eol = strchr(buf.buf, '\n');
2382 if (!eol || !eol[1])
2383 ret = 1;
2385 strbuf_release(&buf);
2387 return ret;
2390 void sequencer_post_commit_cleanup(struct repository *r, int verbose)
2392 struct replay_opts opts = REPLAY_OPTS_INIT;
2393 int need_cleanup = 0;
2395 if (refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD")) {
2396 if (!refs_delete_ref(get_main_ref_store(r), "",
2397 "CHERRY_PICK_HEAD", NULL, 0) &&
2398 verbose)
2399 warning(_("cancelling a cherry picking in progress"));
2400 opts.action = REPLAY_PICK;
2401 need_cleanup = 1;
2404 if (refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD")) {
2405 if (!refs_delete_ref(get_main_ref_store(r), "", "REVERT_HEAD",
2406 NULL, 0) &&
2407 verbose)
2408 warning(_("cancelling a revert in progress"));
2409 opts.action = REPLAY_REVERT;
2410 need_cleanup = 1;
2413 if (!need_cleanup)
2414 return;
2416 if (!have_finished_the_last_pick())
2417 return;
2419 sequencer_remove_state(&opts);
2422 static void todo_list_write_total_nr(struct todo_list *todo_list)
2424 FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
2426 if (f) {
2427 fprintf(f, "%d\n", todo_list->total_nr);
2428 fclose(f);
2432 static int read_populate_todo(struct repository *r,
2433 struct todo_list *todo_list,
2434 struct replay_opts *opts)
2436 struct stat st;
2437 const char *todo_file = get_todo_path(opts);
2438 int res;
2440 strbuf_reset(&todo_list->buf);
2441 if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
2442 return -1;
2444 res = stat(todo_file, &st);
2445 if (res)
2446 return error(_("could not stat '%s'"), todo_file);
2447 fill_stat_data(&todo_list->stat, &st);
2449 res = todo_list_parse_insn_buffer(r, todo_list->buf.buf, todo_list);
2450 if (res) {
2451 if (is_rebase_i(opts))
2452 return error(_("please fix this using "
2453 "'git rebase --edit-todo'."));
2454 return error(_("unusable instruction sheet: '%s'"), todo_file);
2457 if (!todo_list->nr &&
2458 (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
2459 return error(_("no commits parsed."));
2461 if (!is_rebase_i(opts)) {
2462 enum todo_command valid =
2463 opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
2464 int i;
2466 for (i = 0; i < todo_list->nr; i++)
2467 if (valid == todo_list->items[i].command)
2468 continue;
2469 else if (valid == TODO_PICK)
2470 return error(_("cannot cherry-pick during a revert."));
2471 else
2472 return error(_("cannot revert during a cherry-pick."));
2475 if (is_rebase_i(opts)) {
2476 struct todo_list done = TODO_LIST_INIT;
2478 if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
2479 !todo_list_parse_insn_buffer(r, done.buf.buf, &done))
2480 todo_list->done_nr = count_commands(&done);
2481 else
2482 todo_list->done_nr = 0;
2484 todo_list->total_nr = todo_list->done_nr
2485 + count_commands(todo_list);
2486 todo_list_release(&done);
2488 todo_list_write_total_nr(todo_list);
2491 return 0;
2494 static int git_config_string_dup(char **dest,
2495 const char *var, const char *value)
2497 if (!value)
2498 return config_error_nonbool(var);
2499 free(*dest);
2500 *dest = xstrdup(value);
2501 return 0;
2504 static int populate_opts_cb(const char *key, const char *value, void *data)
2506 struct replay_opts *opts = data;
2507 int error_flag = 1;
2509 if (!value)
2510 error_flag = 0;
2511 else if (!strcmp(key, "options.no-commit"))
2512 opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
2513 else if (!strcmp(key, "options.edit"))
2514 opts->edit = git_config_bool_or_int(key, value, &error_flag);
2515 else if (!strcmp(key, "options.allow-empty"))
2516 opts->allow_empty =
2517 git_config_bool_or_int(key, value, &error_flag);
2518 else if (!strcmp(key, "options.allow-empty-message"))
2519 opts->allow_empty_message =
2520 git_config_bool_or_int(key, value, &error_flag);
2521 else if (!strcmp(key, "options.keep-redundant-commits"))
2522 opts->keep_redundant_commits =
2523 git_config_bool_or_int(key, value, &error_flag);
2524 else if (!strcmp(key, "options.signoff"))
2525 opts->signoff = git_config_bool_or_int(key, value, &error_flag);
2526 else if (!strcmp(key, "options.record-origin"))
2527 opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
2528 else if (!strcmp(key, "options.allow-ff"))
2529 opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
2530 else if (!strcmp(key, "options.mainline"))
2531 opts->mainline = git_config_int(key, value);
2532 else if (!strcmp(key, "options.strategy"))
2533 git_config_string_dup(&opts->strategy, key, value);
2534 else if (!strcmp(key, "options.gpg-sign"))
2535 git_config_string_dup(&opts->gpg_sign, key, value);
2536 else if (!strcmp(key, "options.strategy-option")) {
2537 ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
2538 opts->xopts[opts->xopts_nr++] = xstrdup(value);
2539 } else if (!strcmp(key, "options.allow-rerere-auto"))
2540 opts->allow_rerere_auto =
2541 git_config_bool_or_int(key, value, &error_flag) ?
2542 RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
2543 else if (!strcmp(key, "options.default-msg-cleanup")) {
2544 opts->explicit_cleanup = 1;
2545 opts->default_msg_cleanup = get_cleanup_mode(value, 1);
2546 } else
2547 return error(_("invalid key: %s"), key);
2549 if (!error_flag)
2550 return error(_("invalid value for %s: %s"), key, value);
2552 return 0;
2555 void parse_strategy_opts(struct replay_opts *opts, char *raw_opts)
2557 int i;
2558 char *strategy_opts_string = raw_opts;
2560 if (*strategy_opts_string == ' ')
2561 strategy_opts_string++;
2563 opts->xopts_nr = split_cmdline(strategy_opts_string,
2564 (const char ***)&opts->xopts);
2565 for (i = 0; i < opts->xopts_nr; i++) {
2566 const char *arg = opts->xopts[i];
2568 skip_prefix(arg, "--", &arg);
2569 opts->xopts[i] = xstrdup(arg);
2573 static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
2575 strbuf_reset(buf);
2576 if (!read_oneliner(buf, rebase_path_strategy(), 0))
2577 return;
2578 opts->strategy = strbuf_detach(buf, NULL);
2579 if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2580 return;
2582 parse_strategy_opts(opts, buf->buf);
2585 static int read_populate_opts(struct replay_opts *opts)
2587 if (is_rebase_i(opts)) {
2588 struct strbuf buf = STRBUF_INIT;
2589 int ret = 0;
2591 if (read_oneliner(&buf, rebase_path_gpg_sign_opt(),
2592 READ_ONELINER_SKIP_IF_EMPTY)) {
2593 if (!starts_with(buf.buf, "-S"))
2594 strbuf_reset(&buf);
2595 else {
2596 free(opts->gpg_sign);
2597 opts->gpg_sign = xstrdup(buf.buf + 2);
2599 strbuf_reset(&buf);
2602 if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(),
2603 READ_ONELINER_SKIP_IF_EMPTY)) {
2604 if (!strcmp(buf.buf, "--rerere-autoupdate"))
2605 opts->allow_rerere_auto = RERERE_AUTOUPDATE;
2606 else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
2607 opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
2608 strbuf_reset(&buf);
2611 if (file_exists(rebase_path_verbose()))
2612 opts->verbose = 1;
2614 if (file_exists(rebase_path_quiet()))
2615 opts->quiet = 1;
2617 if (file_exists(rebase_path_signoff())) {
2618 opts->allow_ff = 0;
2619 opts->signoff = 1;
2622 if (file_exists(rebase_path_cdate_is_adate())) {
2623 opts->allow_ff = 0;
2624 opts->committer_date_is_author_date = 1;
2627 if (file_exists(rebase_path_ignore_date())) {
2628 opts->allow_ff = 0;
2629 opts->ignore_date = 1;
2632 if (file_exists(rebase_path_reschedule_failed_exec()))
2633 opts->reschedule_failed_exec = 1;
2635 if (file_exists(rebase_path_drop_redundant_commits()))
2636 opts->drop_redundant_commits = 1;
2638 if (file_exists(rebase_path_keep_redundant_commits()))
2639 opts->keep_redundant_commits = 1;
2641 read_strategy_opts(opts, &buf);
2642 strbuf_reset(&buf);
2644 if (read_oneliner(&opts->current_fixups,
2645 rebase_path_current_fixups(),
2646 READ_ONELINER_SKIP_IF_EMPTY)) {
2647 const char *p = opts->current_fixups.buf;
2648 opts->current_fixup_count = 1;
2649 while ((p = strchr(p, '\n'))) {
2650 opts->current_fixup_count++;
2651 p++;
2655 if (read_oneliner(&buf, rebase_path_squash_onto(), 0)) {
2656 if (get_oid_hex(buf.buf, &opts->squash_onto) < 0) {
2657 ret = error(_("unusable squash-onto"));
2658 goto done_rebase_i;
2660 opts->have_squash_onto = 1;
2663 done_rebase_i:
2664 strbuf_release(&buf);
2665 return ret;
2668 if (!file_exists(git_path_opts_file()))
2669 return 0;
2671 * The function git_parse_source(), called from git_config_from_file(),
2672 * may die() in case of a syntactically incorrect file. We do not care
2673 * about this case, though, because we wrote that file ourselves, so we
2674 * are pretty certain that it is syntactically correct.
2676 if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
2677 return error(_("malformed options sheet: '%s'"),
2678 git_path_opts_file());
2679 return 0;
2682 static void write_strategy_opts(struct replay_opts *opts)
2684 int i;
2685 struct strbuf buf = STRBUF_INIT;
2687 for (i = 0; i < opts->xopts_nr; ++i)
2688 strbuf_addf(&buf, " --%s", opts->xopts[i]);
2690 write_file(rebase_path_strategy_opts(), "%s\n", buf.buf);
2691 strbuf_release(&buf);
2694 int write_basic_state(struct replay_opts *opts, const char *head_name,
2695 struct commit *onto, const char *orig_head)
2697 if (head_name)
2698 write_file(rebase_path_head_name(), "%s\n", head_name);
2699 if (onto)
2700 write_file(rebase_path_onto(), "%s\n",
2701 oid_to_hex(&onto->object.oid));
2702 if (orig_head)
2703 write_file(rebase_path_orig_head(), "%s\n", orig_head);
2705 if (opts->quiet)
2706 write_file(rebase_path_quiet(), "%s", "");
2707 if (opts->verbose)
2708 write_file(rebase_path_verbose(), "%s", "");
2709 if (opts->strategy)
2710 write_file(rebase_path_strategy(), "%s\n", opts->strategy);
2711 if (opts->xopts_nr > 0)
2712 write_strategy_opts(opts);
2714 if (opts->allow_rerere_auto == RERERE_AUTOUPDATE)
2715 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2716 else if (opts->allow_rerere_auto == RERERE_NOAUTOUPDATE)
2717 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2719 if (opts->gpg_sign)
2720 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts->gpg_sign);
2721 if (opts->signoff)
2722 write_file(rebase_path_signoff(), "--signoff\n");
2723 if (opts->drop_redundant_commits)
2724 write_file(rebase_path_drop_redundant_commits(), "%s", "");
2725 if (opts->keep_redundant_commits)
2726 write_file(rebase_path_keep_redundant_commits(), "%s", "");
2727 if (opts->committer_date_is_author_date)
2728 write_file(rebase_path_cdate_is_adate(), "%s", "");
2729 if (opts->ignore_date)
2730 write_file(rebase_path_ignore_date(), "%s", "");
2731 if (opts->reschedule_failed_exec)
2732 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
2734 return 0;
2737 static int walk_revs_populate_todo(struct todo_list *todo_list,
2738 struct replay_opts *opts)
2740 enum todo_command command = opts->action == REPLAY_PICK ?
2741 TODO_PICK : TODO_REVERT;
2742 const char *command_string = todo_command_info[command].str;
2743 const char *encoding;
2744 struct commit *commit;
2746 if (prepare_revs(opts))
2747 return -1;
2749 encoding = get_log_output_encoding();
2751 while ((commit = get_revision(opts->revs))) {
2752 struct todo_item *item = append_new_todo(todo_list);
2753 const char *commit_buffer = logmsg_reencode(commit, NULL, encoding);
2754 const char *subject;
2755 int subject_len;
2757 item->command = command;
2758 item->commit = commit;
2759 item->arg_offset = 0;
2760 item->arg_len = 0;
2761 item->offset_in_buf = todo_list->buf.len;
2762 subject_len = find_commit_subject(commit_buffer, &subject);
2763 strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
2764 short_commit_name(commit), subject_len, subject);
2765 unuse_commit_buffer(commit, commit_buffer);
2768 if (!todo_list->nr)
2769 return error(_("empty commit set passed"));
2771 return 0;
2774 static int create_seq_dir(struct repository *r)
2776 enum replay_action action;
2777 const char *in_progress_error = NULL;
2778 const char *in_progress_advice = NULL;
2779 unsigned int advise_skip =
2780 refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD") ||
2781 refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD");
2783 if (!sequencer_get_last_command(r, &action)) {
2784 switch (action) {
2785 case REPLAY_REVERT:
2786 in_progress_error = _("revert is already in progress");
2787 in_progress_advice =
2788 _("try \"git revert (--continue | %s--abort | --quit)\"");
2789 break;
2790 case REPLAY_PICK:
2791 in_progress_error = _("cherry-pick is already in progress");
2792 in_progress_advice =
2793 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
2794 break;
2795 default:
2796 BUG("unexpected action in create_seq_dir");
2799 if (in_progress_error) {
2800 error("%s", in_progress_error);
2801 if (advice_sequencer_in_use)
2802 advise(in_progress_advice,
2803 advise_skip ? "--skip | " : "");
2804 return -1;
2806 if (mkdir(git_path_seq_dir(), 0777) < 0)
2807 return error_errno(_("could not create sequencer directory '%s'"),
2808 git_path_seq_dir());
2810 return 0;
2813 static int save_head(const char *head)
2815 struct lock_file head_lock = LOCK_INIT;
2816 struct strbuf buf = STRBUF_INIT;
2817 int fd;
2818 ssize_t written;
2820 fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
2821 if (fd < 0)
2822 return error_errno(_("could not lock HEAD"));
2823 strbuf_addf(&buf, "%s\n", head);
2824 written = write_in_full(fd, buf.buf, buf.len);
2825 strbuf_release(&buf);
2826 if (written < 0) {
2827 error_errno(_("could not write to '%s'"), git_path_head_file());
2828 rollback_lock_file(&head_lock);
2829 return -1;
2831 if (commit_lock_file(&head_lock) < 0)
2832 return error(_("failed to finalize '%s'"), git_path_head_file());
2833 return 0;
2836 static int rollback_is_safe(void)
2838 struct strbuf sb = STRBUF_INIT;
2839 struct object_id expected_head, actual_head;
2841 if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2842 strbuf_trim(&sb);
2843 if (get_oid_hex(sb.buf, &expected_head)) {
2844 strbuf_release(&sb);
2845 die(_("could not parse %s"), git_path_abort_safety_file());
2847 strbuf_release(&sb);
2849 else if (errno == ENOENT)
2850 oidclr(&expected_head);
2851 else
2852 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2854 if (get_oid("HEAD", &actual_head))
2855 oidclr(&actual_head);
2857 return oideq(&actual_head, &expected_head);
2860 static int reset_merge(const struct object_id *oid)
2862 int ret;
2863 struct strvec argv = STRVEC_INIT;
2865 strvec_pushl(&argv, "reset", "--merge", NULL);
2867 if (!is_null_oid(oid))
2868 strvec_push(&argv, oid_to_hex(oid));
2870 ret = run_command_v_opt(argv.v, RUN_GIT_CMD);
2871 strvec_clear(&argv);
2873 return ret;
2876 static int rollback_single_pick(struct repository *r)
2878 struct object_id head_oid;
2880 if (!refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD") &&
2881 !refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD"))
2882 return error(_("no cherry-pick or revert in progress"));
2883 if (read_ref_full("HEAD", 0, &head_oid, NULL))
2884 return error(_("cannot resolve HEAD"));
2885 if (is_null_oid(&head_oid))
2886 return error(_("cannot abort from a branch yet to be born"));
2887 return reset_merge(&head_oid);
2890 static int skip_single_pick(void)
2892 struct object_id head;
2894 if (read_ref_full("HEAD", 0, &head, NULL))
2895 return error(_("cannot resolve HEAD"));
2896 return reset_merge(&head);
2899 int sequencer_rollback(struct repository *r, struct replay_opts *opts)
2901 FILE *f;
2902 struct object_id oid;
2903 struct strbuf buf = STRBUF_INIT;
2904 const char *p;
2906 f = fopen(git_path_head_file(), "r");
2907 if (!f && errno == ENOENT) {
2909 * There is no multiple-cherry-pick in progress.
2910 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2911 * a single-cherry-pick in progress, abort that.
2913 return rollback_single_pick(r);
2915 if (!f)
2916 return error_errno(_("cannot open '%s'"), git_path_head_file());
2917 if (strbuf_getline_lf(&buf, f)) {
2918 error(_("cannot read '%s': %s"), git_path_head_file(),
2919 ferror(f) ? strerror(errno) : _("unexpected end of file"));
2920 fclose(f);
2921 goto fail;
2923 fclose(f);
2924 if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
2925 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2926 git_path_head_file());
2927 goto fail;
2929 if (is_null_oid(&oid)) {
2930 error(_("cannot abort from a branch yet to be born"));
2931 goto fail;
2934 if (!rollback_is_safe()) {
2935 /* Do not error, just do not rollback */
2936 warning(_("You seem to have moved HEAD. "
2937 "Not rewinding, check your HEAD!"));
2938 } else
2939 if (reset_merge(&oid))
2940 goto fail;
2941 strbuf_release(&buf);
2942 return sequencer_remove_state(opts);
2943 fail:
2944 strbuf_release(&buf);
2945 return -1;
2948 int sequencer_skip(struct repository *r, struct replay_opts *opts)
2950 enum replay_action action = -1;
2951 sequencer_get_last_command(r, &action);
2954 * Check whether the subcommand requested to skip the commit is actually
2955 * in progress and that it's safe to skip the commit.
2957 * opts->action tells us which subcommand requested to skip the commit.
2958 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
2959 * action is in progress and we can skip the commit.
2961 * Otherwise we check that the last instruction was related to the
2962 * particular subcommand we're trying to execute and barf if that's not
2963 * the case.
2965 * Finally we check that the rollback is "safe", i.e., has the HEAD
2966 * moved? In this case, it doesn't make sense to "reset the merge" and
2967 * "skip the commit" as the user already handled this by committing. But
2968 * we'd not want to barf here, instead give advice on how to proceed. We
2969 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
2970 * it gets removed when the user commits, so if it still exists we're
2971 * sure the user can't have committed before.
2973 switch (opts->action) {
2974 case REPLAY_REVERT:
2975 if (!refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD")) {
2976 if (action != REPLAY_REVERT)
2977 return error(_("no revert in progress"));
2978 if (!rollback_is_safe())
2979 goto give_advice;
2981 break;
2982 case REPLAY_PICK:
2983 if (!refs_ref_exists(get_main_ref_store(r),
2984 "CHERRY_PICK_HEAD")) {
2985 if (action != REPLAY_PICK)
2986 return error(_("no cherry-pick in progress"));
2987 if (!rollback_is_safe())
2988 goto give_advice;
2990 break;
2991 default:
2992 BUG("unexpected action in sequencer_skip");
2995 if (skip_single_pick())
2996 return error(_("failed to skip the commit"));
2997 if (!is_directory(git_path_seq_dir()))
2998 return 0;
3000 return sequencer_continue(r, opts);
3002 give_advice:
3003 error(_("there is nothing to skip"));
3005 if (advice_resolve_conflict) {
3006 advise(_("have you committed already?\n"
3007 "try \"git %s --continue\""),
3008 action == REPLAY_REVERT ? "revert" : "cherry-pick");
3010 return -1;
3013 static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
3015 struct lock_file todo_lock = LOCK_INIT;
3016 const char *todo_path = get_todo_path(opts);
3017 int next = todo_list->current, offset, fd;
3020 * rebase -i writes "git-rebase-todo" without the currently executing
3021 * command, appending it to "done" instead.
3023 if (is_rebase_i(opts))
3024 next++;
3026 fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
3027 if (fd < 0)
3028 return error_errno(_("could not lock '%s'"), todo_path);
3029 offset = get_item_line_offset(todo_list, next);
3030 if (write_in_full(fd, todo_list->buf.buf + offset,
3031 todo_list->buf.len - offset) < 0)
3032 return error_errno(_("could not write to '%s'"), todo_path);
3033 if (commit_lock_file(&todo_lock) < 0)
3034 return error(_("failed to finalize '%s'"), todo_path);
3036 if (is_rebase_i(opts) && next > 0) {
3037 const char *done = rebase_path_done();
3038 int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
3039 int ret = 0;
3041 if (fd < 0)
3042 return 0;
3043 if (write_in_full(fd, get_item_line(todo_list, next - 1),
3044 get_item_line_length(todo_list, next - 1))
3045 < 0)
3046 ret = error_errno(_("could not write to '%s'"), done);
3047 if (close(fd) < 0)
3048 ret = error_errno(_("failed to finalize '%s'"), done);
3049 return ret;
3051 return 0;
3054 static int save_opts(struct replay_opts *opts)
3056 const char *opts_file = git_path_opts_file();
3057 int res = 0;
3059 if (opts->no_commit)
3060 res |= git_config_set_in_file_gently(opts_file,
3061 "options.no-commit", "true");
3062 if (opts->edit)
3063 res |= git_config_set_in_file_gently(opts_file,
3064 "options.edit", "true");
3065 if (opts->allow_empty)
3066 res |= git_config_set_in_file_gently(opts_file,
3067 "options.allow-empty", "true");
3068 if (opts->allow_empty_message)
3069 res |= git_config_set_in_file_gently(opts_file,
3070 "options.allow-empty-message", "true");
3071 if (opts->keep_redundant_commits)
3072 res |= git_config_set_in_file_gently(opts_file,
3073 "options.keep-redundant-commits", "true");
3074 if (opts->signoff)
3075 res |= git_config_set_in_file_gently(opts_file,
3076 "options.signoff", "true");
3077 if (opts->record_origin)
3078 res |= git_config_set_in_file_gently(opts_file,
3079 "options.record-origin", "true");
3080 if (opts->allow_ff)
3081 res |= git_config_set_in_file_gently(opts_file,
3082 "options.allow-ff", "true");
3083 if (opts->mainline) {
3084 struct strbuf buf = STRBUF_INIT;
3085 strbuf_addf(&buf, "%d", opts->mainline);
3086 res |= git_config_set_in_file_gently(opts_file,
3087 "options.mainline", buf.buf);
3088 strbuf_release(&buf);
3090 if (opts->strategy)
3091 res |= git_config_set_in_file_gently(opts_file,
3092 "options.strategy", opts->strategy);
3093 if (opts->gpg_sign)
3094 res |= git_config_set_in_file_gently(opts_file,
3095 "options.gpg-sign", opts->gpg_sign);
3096 if (opts->xopts) {
3097 int i;
3098 for (i = 0; i < opts->xopts_nr; i++)
3099 res |= git_config_set_multivar_in_file_gently(opts_file,
3100 "options.strategy-option",
3101 opts->xopts[i], "^$", 0);
3103 if (opts->allow_rerere_auto)
3104 res |= git_config_set_in_file_gently(opts_file,
3105 "options.allow-rerere-auto",
3106 opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
3107 "true" : "false");
3109 if (opts->explicit_cleanup)
3110 res |= git_config_set_in_file_gently(opts_file,
3111 "options.default-msg-cleanup",
3112 describe_cleanup_mode(opts->default_msg_cleanup));
3113 return res;
3116 static int make_patch(struct repository *r,
3117 struct commit *commit,
3118 struct replay_opts *opts)
3120 struct strbuf buf = STRBUF_INIT;
3121 struct rev_info log_tree_opt;
3122 const char *subject;
3123 char hex[GIT_MAX_HEXSZ + 1];
3124 int res = 0;
3126 oid_to_hex_r(hex, &commit->object.oid);
3127 if (write_message(hex, strlen(hex), rebase_path_stopped_sha(), 1) < 0)
3128 return -1;
3129 res |= write_rebase_head(&commit->object.oid);
3131 strbuf_addf(&buf, "%s/patch", get_dir(opts));
3132 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
3133 repo_init_revisions(r, &log_tree_opt, NULL);
3134 log_tree_opt.abbrev = 0;
3135 log_tree_opt.diff = 1;
3136 log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
3137 log_tree_opt.disable_stdin = 1;
3138 log_tree_opt.no_commit_id = 1;
3139 log_tree_opt.diffopt.file = fopen(buf.buf, "w");
3140 log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
3141 if (!log_tree_opt.diffopt.file)
3142 res |= error_errno(_("could not open '%s'"), buf.buf);
3143 else {
3144 res |= log_tree_commit(&log_tree_opt, commit);
3145 fclose(log_tree_opt.diffopt.file);
3147 strbuf_reset(&buf);
3149 strbuf_addf(&buf, "%s/message", get_dir(opts));
3150 if (!file_exists(buf.buf)) {
3151 const char *encoding = get_commit_output_encoding();
3152 const char *commit_buffer = logmsg_reencode(commit, NULL, encoding);
3153 find_commit_subject(commit_buffer, &subject);
3154 res |= write_message(subject, strlen(subject), buf.buf, 1);
3155 unuse_commit_buffer(commit, commit_buffer);
3157 strbuf_release(&buf);
3159 return res;
3162 static int intend_to_amend(void)
3164 struct object_id head;
3165 char *p;
3167 if (get_oid("HEAD", &head))
3168 return error(_("cannot read HEAD"));
3170 p = oid_to_hex(&head);
3171 return write_message(p, strlen(p), rebase_path_amend(), 1);
3174 static int error_with_patch(struct repository *r,
3175 struct commit *commit,
3176 const char *subject, int subject_len,
3177 struct replay_opts *opts,
3178 int exit_code, int to_amend)
3180 if (commit) {
3181 if (make_patch(r, commit, opts))
3182 return -1;
3183 } else if (copy_file(rebase_path_message(),
3184 git_path_merge_msg(r), 0666))
3185 return error(_("unable to copy '%s' to '%s'"),
3186 git_path_merge_msg(r), rebase_path_message());
3188 if (to_amend) {
3189 if (intend_to_amend())
3190 return -1;
3192 fprintf(stderr,
3193 _("You can amend the commit now, with\n"
3194 "\n"
3195 " git commit --amend %s\n"
3196 "\n"
3197 "Once you are satisfied with your changes, run\n"
3198 "\n"
3199 " git rebase --continue\n"),
3200 gpg_sign_opt_quoted(opts));
3201 } else if (exit_code) {
3202 if (commit)
3203 fprintf_ln(stderr, _("Could not apply %s... %.*s"),
3204 short_commit_name(commit), subject_len, subject);
3205 else
3207 * We don't have the hash of the parent so
3208 * just print the line from the todo file.
3210 fprintf_ln(stderr, _("Could not merge %.*s"),
3211 subject_len, subject);
3214 return exit_code;
3217 static int error_failed_squash(struct repository *r,
3218 struct commit *commit,
3219 struct replay_opts *opts,
3220 int subject_len,
3221 const char *subject)
3223 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3224 return error(_("could not copy '%s' to '%s'"),
3225 rebase_path_squash_msg(), rebase_path_message());
3226 unlink(git_path_merge_msg(r));
3227 if (copy_file(git_path_merge_msg(r), rebase_path_message(), 0666))
3228 return error(_("could not copy '%s' to '%s'"),
3229 rebase_path_message(),
3230 git_path_merge_msg(r));
3231 return error_with_patch(r, commit, subject, subject_len, opts, 1, 0);
3234 static int do_exec(struct repository *r, const char *command_line)
3236 struct strvec child_env = STRVEC_INIT;
3237 const char *child_argv[] = { NULL, NULL };
3238 int dirty, status;
3240 fprintf(stderr, _("Executing: %s\n"), command_line);
3241 child_argv[0] = command_line;
3242 strvec_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
3243 strvec_pushf(&child_env, "GIT_WORK_TREE=%s",
3244 absolute_path(get_git_work_tree()));
3245 status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
3246 child_env.v);
3248 /* force re-reading of the cache */
3249 if (discard_index(r->index) < 0 || repo_read_index(r) < 0)
3250 return error(_("could not read index"));
3252 dirty = require_clean_work_tree(r, "rebase", NULL, 1, 1);
3254 if (status) {
3255 warning(_("execution failed: %s\n%s"
3256 "You can fix the problem, and then run\n"
3257 "\n"
3258 " git rebase --continue\n"
3259 "\n"),
3260 command_line,
3261 dirty ? N_("and made changes to the index and/or the "
3262 "working tree\n") : "");
3263 if (status == 127)
3264 /* command not found */
3265 status = 1;
3266 } else if (dirty) {
3267 warning(_("execution succeeded: %s\nbut "
3268 "left changes to the index and/or the working tree\n"
3269 "Commit or stash your changes, and then run\n"
3270 "\n"
3271 " git rebase --continue\n"
3272 "\n"), command_line);
3273 status = 1;
3276 strvec_clear(&child_env);
3278 return status;
3281 static int safe_append(const char *filename, const char *fmt, ...)
3283 va_list ap;
3284 struct lock_file lock = LOCK_INIT;
3285 int fd = hold_lock_file_for_update(&lock, filename,
3286 LOCK_REPORT_ON_ERROR);
3287 struct strbuf buf = STRBUF_INIT;
3289 if (fd < 0)
3290 return -1;
3292 if (strbuf_read_file(&buf, filename, 0) < 0 && errno != ENOENT) {
3293 error_errno(_("could not read '%s'"), filename);
3294 rollback_lock_file(&lock);
3295 return -1;
3297 strbuf_complete(&buf, '\n');
3298 va_start(ap, fmt);
3299 strbuf_vaddf(&buf, fmt, ap);
3300 va_end(ap);
3302 if (write_in_full(fd, buf.buf, buf.len) < 0) {
3303 error_errno(_("could not write to '%s'"), filename);
3304 strbuf_release(&buf);
3305 rollback_lock_file(&lock);
3306 return -1;
3308 if (commit_lock_file(&lock) < 0) {
3309 strbuf_release(&buf);
3310 rollback_lock_file(&lock);
3311 return error(_("failed to finalize '%s'"), filename);
3314 strbuf_release(&buf);
3315 return 0;
3318 static int do_label(struct repository *r, const char *name, int len)
3320 struct ref_store *refs = get_main_ref_store(r);
3321 struct ref_transaction *transaction;
3322 struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
3323 struct strbuf msg = STRBUF_INIT;
3324 int ret = 0;
3325 struct object_id head_oid;
3327 if (len == 1 && *name == '#')
3328 return error(_("illegal label name: '%.*s'"), len, name);
3330 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3331 strbuf_addf(&msg, "rebase (label) '%.*s'", len, name);
3333 transaction = ref_store_transaction_begin(refs, &err);
3334 if (!transaction) {
3335 error("%s", err.buf);
3336 ret = -1;
3337 } else if (get_oid("HEAD", &head_oid)) {
3338 error(_("could not read HEAD"));
3339 ret = -1;
3340 } else if (ref_transaction_update(transaction, ref_name.buf, &head_oid,
3341 NULL, 0, msg.buf, &err) < 0 ||
3342 ref_transaction_commit(transaction, &err)) {
3343 error("%s", err.buf);
3344 ret = -1;
3346 ref_transaction_free(transaction);
3347 strbuf_release(&err);
3348 strbuf_release(&msg);
3350 if (!ret)
3351 ret = safe_append(rebase_path_refs_to_delete(),
3352 "%s\n", ref_name.buf);
3353 strbuf_release(&ref_name);
3355 return ret;
3358 static const char *reflog_message(struct replay_opts *opts,
3359 const char *sub_action, const char *fmt, ...);
3361 static int do_reset(struct repository *r,
3362 const char *name, int len,
3363 struct replay_opts *opts)
3365 struct strbuf ref_name = STRBUF_INIT;
3366 struct object_id oid;
3367 struct lock_file lock = LOCK_INIT;
3368 struct tree_desc desc;
3369 struct tree *tree;
3370 struct unpack_trees_options unpack_tree_opts;
3371 int ret = 0;
3373 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0)
3374 return -1;
3376 if (len == 10 && !strncmp("[new root]", name, len)) {
3377 if (!opts->have_squash_onto) {
3378 const char *hex;
3379 if (commit_tree("", 0, the_hash_algo->empty_tree,
3380 NULL, &opts->squash_onto,
3381 NULL, NULL))
3382 return error(_("writing fake root commit"));
3383 opts->have_squash_onto = 1;
3384 hex = oid_to_hex(&opts->squash_onto);
3385 if (write_message(hex, strlen(hex),
3386 rebase_path_squash_onto(), 0))
3387 return error(_("writing squash-onto"));
3389 oidcpy(&oid, &opts->squash_onto);
3390 } else {
3391 int i;
3393 /* Determine the length of the label */
3394 for (i = 0; i < len; i++)
3395 if (isspace(name[i]))
3396 break;
3397 len = i;
3399 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3400 if (get_oid(ref_name.buf, &oid) &&
3401 get_oid(ref_name.buf + strlen("refs/rewritten/"), &oid)) {
3402 error(_("could not read '%s'"), ref_name.buf);
3403 rollback_lock_file(&lock);
3404 strbuf_release(&ref_name);
3405 return -1;
3409 memset(&unpack_tree_opts, 0, sizeof(unpack_tree_opts));
3410 setup_unpack_trees_porcelain(&unpack_tree_opts, "reset");
3411 unpack_tree_opts.head_idx = 1;
3412 unpack_tree_opts.src_index = r->index;
3413 unpack_tree_opts.dst_index = r->index;
3414 unpack_tree_opts.fn = oneway_merge;
3415 unpack_tree_opts.merge = 1;
3416 unpack_tree_opts.update = 1;
3417 init_checkout_metadata(&unpack_tree_opts.meta, name, &oid, NULL);
3419 if (repo_read_index_unmerged(r)) {
3420 rollback_lock_file(&lock);
3421 strbuf_release(&ref_name);
3422 return error_resolve_conflict(_(action_name(opts)));
3425 if (!fill_tree_descriptor(r, &desc, &oid)) {
3426 error(_("failed to find tree of %s"), oid_to_hex(&oid));
3427 rollback_lock_file(&lock);
3428 free((void *)desc.buffer);
3429 strbuf_release(&ref_name);
3430 return -1;
3433 if (unpack_trees(1, &desc, &unpack_tree_opts)) {
3434 rollback_lock_file(&lock);
3435 free((void *)desc.buffer);
3436 strbuf_release(&ref_name);
3437 return -1;
3440 tree = parse_tree_indirect(&oid);
3441 prime_cache_tree(r, r->index, tree);
3443 if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
3444 ret = error(_("could not write index"));
3445 free((void *)desc.buffer);
3447 if (!ret)
3448 ret = update_ref(reflog_message(opts, "reset", "'%.*s'",
3449 len, name), "HEAD", &oid,
3450 NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3452 strbuf_release(&ref_name);
3453 return ret;
3456 static struct commit *lookup_label(const char *label, int len,
3457 struct strbuf *buf)
3459 struct commit *commit;
3461 strbuf_reset(buf);
3462 strbuf_addf(buf, "refs/rewritten/%.*s", len, label);
3463 commit = lookup_commit_reference_by_name(buf->buf);
3464 if (!commit) {
3465 /* fall back to non-rewritten ref or commit */
3466 strbuf_splice(buf, 0, strlen("refs/rewritten/"), "", 0);
3467 commit = lookup_commit_reference_by_name(buf->buf);
3470 if (!commit)
3471 error(_("could not resolve '%s'"), buf->buf);
3473 return commit;
3476 static int do_merge(struct repository *r,
3477 struct commit *commit,
3478 const char *arg, int arg_len,
3479 int flags, struct replay_opts *opts)
3481 int run_commit_flags = (flags & TODO_EDIT_MERGE_MSG) ?
3482 EDIT_MSG | VERIFY_MSG : 0;
3483 struct strbuf ref_name = STRBUF_INIT;
3484 struct commit *head_commit, *merge_commit, *i;
3485 struct commit_list *bases, *j, *reversed = NULL;
3486 struct commit_list *to_merge = NULL, **tail = &to_merge;
3487 const char *strategy = !opts->xopts_nr &&
3488 (!opts->strategy || !strcmp(opts->strategy, "recursive")) ?
3489 NULL : opts->strategy;
3490 struct merge_options o;
3491 int merge_arg_len, oneline_offset, can_fast_forward, ret, k;
3492 static struct lock_file lock;
3493 const char *p;
3495 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0) {
3496 ret = -1;
3497 goto leave_merge;
3500 head_commit = lookup_commit_reference_by_name("HEAD");
3501 if (!head_commit) {
3502 ret = error(_("cannot merge without a current revision"));
3503 goto leave_merge;
3507 * For octopus merges, the arg starts with the list of revisions to be
3508 * merged. The list is optionally followed by '#' and the oneline.
3510 merge_arg_len = oneline_offset = arg_len;
3511 for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {
3512 if (!*p)
3513 break;
3514 if (*p == '#' && (!p[1] || isspace(p[1]))) {
3515 p += 1 + strspn(p + 1, " \t\n");
3516 oneline_offset = p - arg;
3517 break;
3519 k = strcspn(p, " \t\n");
3520 if (!k)
3521 continue;
3522 merge_commit = lookup_label(p, k, &ref_name);
3523 if (!merge_commit) {
3524 ret = error(_("unable to parse '%.*s'"), k, p);
3525 goto leave_merge;
3527 tail = &commit_list_insert(merge_commit, tail)->next;
3528 p += k;
3529 merge_arg_len = p - arg;
3532 if (!to_merge) {
3533 ret = error(_("nothing to merge: '%.*s'"), arg_len, arg);
3534 goto leave_merge;
3537 if (opts->have_squash_onto &&
3538 oideq(&head_commit->object.oid, &opts->squash_onto)) {
3540 * When the user tells us to "merge" something into a
3541 * "[new root]", let's simply fast-forward to the merge head.
3543 rollback_lock_file(&lock);
3544 if (to_merge->next)
3545 ret = error(_("octopus merge cannot be executed on "
3546 "top of a [new root]"));
3547 else
3548 ret = fast_forward_to(r, &to_merge->item->object.oid,
3549 &head_commit->object.oid, 0,
3550 opts);
3551 goto leave_merge;
3554 if (commit) {
3555 const char *encoding = get_commit_output_encoding();
3556 const char *message = logmsg_reencode(commit, NULL, encoding);
3557 const char *body;
3558 int len;
3560 if (!message) {
3561 ret = error(_("could not get commit message of '%s'"),
3562 oid_to_hex(&commit->object.oid));
3563 goto leave_merge;
3565 write_author_script(message);
3566 find_commit_subject(message, &body);
3567 len = strlen(body);
3568 ret = write_message(body, len, git_path_merge_msg(r), 0);
3569 unuse_commit_buffer(commit, message);
3570 if (ret) {
3571 error_errno(_("could not write '%s'"),
3572 git_path_merge_msg(r));
3573 goto leave_merge;
3575 } else {
3576 struct strbuf buf = STRBUF_INIT;
3577 int len;
3579 strbuf_addf(&buf, "author %s", git_author_info(0));
3580 write_author_script(buf.buf);
3581 strbuf_reset(&buf);
3583 if (oneline_offset < arg_len) {
3584 p = arg + oneline_offset;
3585 len = arg_len - oneline_offset;
3586 } else {
3587 strbuf_addf(&buf, "Merge %s '%.*s'",
3588 to_merge->next ? "branches" : "branch",
3589 merge_arg_len, arg);
3590 p = buf.buf;
3591 len = buf.len;
3594 ret = write_message(p, len, git_path_merge_msg(r), 0);
3595 strbuf_release(&buf);
3596 if (ret) {
3597 error_errno(_("could not write '%s'"),
3598 git_path_merge_msg(r));
3599 goto leave_merge;
3604 * If HEAD is not identical to the first parent of the original merge
3605 * commit, we cannot fast-forward.
3607 can_fast_forward = opts->allow_ff && commit && commit->parents &&
3608 oideq(&commit->parents->item->object.oid,
3609 &head_commit->object.oid);
3612 * If any merge head is different from the original one, we cannot
3613 * fast-forward.
3615 if (can_fast_forward) {
3616 struct commit_list *p = commit->parents->next;
3618 for (j = to_merge; j && p; j = j->next, p = p->next)
3619 if (!oideq(&j->item->object.oid,
3620 &p->item->object.oid)) {
3621 can_fast_forward = 0;
3622 break;
3625 * If the number of merge heads differs from the original merge
3626 * commit, we cannot fast-forward.
3628 if (j || p)
3629 can_fast_forward = 0;
3632 if (can_fast_forward) {
3633 rollback_lock_file(&lock);
3634 ret = fast_forward_to(r, &commit->object.oid,
3635 &head_commit->object.oid, 0, opts);
3636 if (flags & TODO_EDIT_MERGE_MSG) {
3637 run_commit_flags |= AMEND_MSG;
3638 goto fast_forward_edit;
3640 goto leave_merge;
3643 if (strategy || to_merge->next) {
3644 /* Octopus merge */
3645 struct child_process cmd = CHILD_PROCESS_INIT;
3647 if (read_env_script(&cmd.env_array)) {
3648 const char *gpg_opt = gpg_sign_opt_quoted(opts);
3650 ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
3651 goto leave_merge;
3654 if (opts->committer_date_is_author_date)
3655 strvec_pushf(&cmd.env_array, "GIT_COMMITTER_DATE=%s",
3656 opts->ignore_date ?
3657 "" :
3658 author_date_from_env_array(&cmd.env_array));
3659 if (opts->ignore_date)
3660 strvec_push(&cmd.env_array, "GIT_AUTHOR_DATE=");
3662 cmd.git_cmd = 1;
3663 strvec_push(&cmd.args, "merge");
3664 strvec_push(&cmd.args, "-s");
3665 if (!strategy)
3666 strvec_push(&cmd.args, "octopus");
3667 else {
3668 strvec_push(&cmd.args, strategy);
3669 for (k = 0; k < opts->xopts_nr; k++)
3670 strvec_pushf(&cmd.args,
3671 "-X%s", opts->xopts[k]);
3673 strvec_push(&cmd.args, "--no-edit");
3674 strvec_push(&cmd.args, "--no-ff");
3675 strvec_push(&cmd.args, "--no-log");
3676 strvec_push(&cmd.args, "--no-stat");
3677 strvec_push(&cmd.args, "-F");
3678 strvec_push(&cmd.args, git_path_merge_msg(r));
3679 if (opts->gpg_sign)
3680 strvec_push(&cmd.args, opts->gpg_sign);
3682 /* Add the tips to be merged */
3683 for (j = to_merge; j; j = j->next)
3684 strvec_push(&cmd.args,
3685 oid_to_hex(&j->item->object.oid));
3687 strbuf_release(&ref_name);
3688 refs_delete_ref(get_main_ref_store(r), "", "CHERRY_PICK_HEAD",
3689 NULL, 0);
3690 rollback_lock_file(&lock);
3692 rollback_lock_file(&lock);
3693 ret = run_command(&cmd);
3695 /* force re-reading of the cache */
3696 if (!ret && (discard_index(r->index) < 0 ||
3697 repo_read_index(r) < 0))
3698 ret = error(_("could not read index"));
3699 goto leave_merge;
3702 merge_commit = to_merge->item;
3703 bases = get_merge_bases(head_commit, merge_commit);
3704 if (bases && oideq(&merge_commit->object.oid,
3705 &bases->item->object.oid)) {
3706 ret = 0;
3707 /* skip merging an ancestor of HEAD */
3708 goto leave_merge;
3711 write_message(oid_to_hex(&merge_commit->object.oid), the_hash_algo->hexsz,
3712 git_path_merge_head(r), 0);
3713 write_message("no-ff", 5, git_path_merge_mode(r), 0);
3715 for (j = bases; j; j = j->next)
3716 commit_list_insert(j->item, &reversed);
3717 free_commit_list(bases);
3719 repo_read_index(r);
3720 init_merge_options(&o, r);
3721 o.branch1 = "HEAD";
3722 o.branch2 = ref_name.buf;
3723 o.buffer_output = 2;
3725 ret = merge_recursive(&o, head_commit, merge_commit, reversed, &i);
3726 if (ret <= 0)
3727 fputs(o.obuf.buf, stdout);
3728 strbuf_release(&o.obuf);
3729 if (ret < 0) {
3730 error(_("could not even attempt to merge '%.*s'"),
3731 merge_arg_len, arg);
3732 goto leave_merge;
3735 * The return value of merge_recursive() is 1 on clean, and 0 on
3736 * unclean merge.
3738 * Let's reverse that, so that do_merge() returns 0 upon success and
3739 * 1 upon failed merge (keeping the return value -1 for the cases where
3740 * we will want to reschedule the `merge` command).
3742 ret = !ret;
3744 if (r->index->cache_changed &&
3745 write_locked_index(r->index, &lock, COMMIT_LOCK)) {
3746 ret = error(_("merge: Unable to write new index file"));
3747 goto leave_merge;
3750 rollback_lock_file(&lock);
3751 if (ret)
3752 repo_rerere(r, opts->allow_rerere_auto);
3753 else
3755 * In case of problems, we now want to return a positive
3756 * value (a negative one would indicate that the `merge`
3757 * command needs to be rescheduled).
3759 fast_forward_edit:
3760 ret = !!run_git_commit(git_path_merge_msg(r), opts,
3761 run_commit_flags);
3763 leave_merge:
3764 strbuf_release(&ref_name);
3765 rollback_lock_file(&lock);
3766 free_commit_list(to_merge);
3767 return ret;
3770 static int is_final_fixup(struct todo_list *todo_list)
3772 int i = todo_list->current;
3774 if (!is_fixup(todo_list->items[i].command))
3775 return 0;
3777 while (++i < todo_list->nr)
3778 if (is_fixup(todo_list->items[i].command))
3779 return 0;
3780 else if (!is_noop(todo_list->items[i].command))
3781 break;
3782 return 1;
3785 static enum todo_command peek_command(struct todo_list *todo_list, int offset)
3787 int i;
3789 for (i = todo_list->current + offset; i < todo_list->nr; i++)
3790 if (!is_noop(todo_list->items[i].command))
3791 return todo_list->items[i].command;
3793 return -1;
3796 void create_autostash(struct repository *r, const char *path,
3797 const char *default_reflog_action)
3799 struct strbuf buf = STRBUF_INIT;
3800 struct lock_file lock_file = LOCK_INIT;
3801 int fd;
3803 fd = repo_hold_locked_index(r, &lock_file, 0);
3804 refresh_index(r->index, REFRESH_QUIET, NULL, NULL, NULL);
3805 if (0 <= fd)
3806 repo_update_index_if_able(r, &lock_file);
3807 rollback_lock_file(&lock_file);
3809 if (has_unstaged_changes(r, 1) ||
3810 has_uncommitted_changes(r, 1)) {
3811 struct child_process stash = CHILD_PROCESS_INIT;
3812 struct object_id oid;
3814 strvec_pushl(&stash.args,
3815 "stash", "create", "autostash", NULL);
3816 stash.git_cmd = 1;
3817 stash.no_stdin = 1;
3818 strbuf_reset(&buf);
3819 if (capture_command(&stash, &buf, GIT_MAX_HEXSZ))
3820 die(_("Cannot autostash"));
3821 strbuf_trim_trailing_newline(&buf);
3822 if (get_oid(buf.buf, &oid))
3823 die(_("Unexpected stash response: '%s'"),
3824 buf.buf);
3825 strbuf_reset(&buf);
3826 strbuf_add_unique_abbrev(&buf, &oid, DEFAULT_ABBREV);
3828 if (safe_create_leading_directories_const(path))
3829 die(_("Could not create directory for '%s'"),
3830 path);
3831 write_file(path, "%s", oid_to_hex(&oid));
3832 printf(_("Created autostash: %s\n"), buf.buf);
3833 if (reset_head(r, NULL, "reset --hard",
3834 NULL, RESET_HEAD_HARD, NULL, NULL,
3835 default_reflog_action) < 0)
3836 die(_("could not reset --hard"));
3838 if (discard_index(r->index) < 0 ||
3839 repo_read_index(r) < 0)
3840 die(_("could not read index"));
3842 strbuf_release(&buf);
3845 static int apply_save_autostash_oid(const char *stash_oid, int attempt_apply)
3847 struct child_process child = CHILD_PROCESS_INIT;
3848 int ret = 0;
3850 if (attempt_apply) {
3851 child.git_cmd = 1;
3852 child.no_stdout = 1;
3853 child.no_stderr = 1;
3854 strvec_push(&child.args, "stash");
3855 strvec_push(&child.args, "apply");
3856 strvec_push(&child.args, stash_oid);
3857 ret = run_command(&child);
3860 if (attempt_apply && !ret)
3861 fprintf(stderr, _("Applied autostash.\n"));
3862 else {
3863 struct child_process store = CHILD_PROCESS_INIT;
3865 store.git_cmd = 1;
3866 strvec_push(&store.args, "stash");
3867 strvec_push(&store.args, "store");
3868 strvec_push(&store.args, "-m");
3869 strvec_push(&store.args, "autostash");
3870 strvec_push(&store.args, "-q");
3871 strvec_push(&store.args, stash_oid);
3872 if (run_command(&store))
3873 ret = error(_("cannot store %s"), stash_oid);
3874 else
3875 fprintf(stderr,
3876 _("%s\n"
3877 "Your changes are safe in the stash.\n"
3878 "You can run \"git stash pop\" or"
3879 " \"git stash drop\" at any time.\n"),
3880 attempt_apply ?
3881 _("Applying autostash resulted in conflicts.") :
3882 _("Autostash exists; creating a new stash entry."));
3885 return ret;
3888 static int apply_save_autostash(const char *path, int attempt_apply)
3890 struct strbuf stash_oid = STRBUF_INIT;
3891 int ret = 0;
3893 if (!read_oneliner(&stash_oid, path,
3894 READ_ONELINER_SKIP_IF_EMPTY)) {
3895 strbuf_release(&stash_oid);
3896 return 0;
3898 strbuf_trim(&stash_oid);
3900 ret = apply_save_autostash_oid(stash_oid.buf, attempt_apply);
3902 unlink(path);
3903 strbuf_release(&stash_oid);
3904 return ret;
3907 int save_autostash(const char *path)
3909 return apply_save_autostash(path, 0);
3912 int apply_autostash(const char *path)
3914 return apply_save_autostash(path, 1);
3917 int apply_autostash_oid(const char *stash_oid)
3919 return apply_save_autostash_oid(stash_oid, 1);
3922 static const char *reflog_message(struct replay_opts *opts,
3923 const char *sub_action, const char *fmt, ...)
3925 va_list ap;
3926 static struct strbuf buf = STRBUF_INIT;
3927 char *reflog_action = getenv(GIT_REFLOG_ACTION);
3929 va_start(ap, fmt);
3930 strbuf_reset(&buf);
3931 strbuf_addstr(&buf, reflog_action ? reflog_action : action_name(opts));
3932 if (sub_action)
3933 strbuf_addf(&buf, " (%s)", sub_action);
3934 if (fmt) {
3935 strbuf_addstr(&buf, ": ");
3936 strbuf_vaddf(&buf, fmt, ap);
3938 va_end(ap);
3940 return buf.buf;
3943 static int run_git_checkout(struct repository *r, struct replay_opts *opts,
3944 const char *commit, const char *action)
3946 struct child_process cmd = CHILD_PROCESS_INIT;
3947 int ret;
3949 cmd.git_cmd = 1;
3951 strvec_push(&cmd.args, "checkout");
3952 strvec_push(&cmd.args, commit);
3953 strvec_pushf(&cmd.env_array, GIT_REFLOG_ACTION "=%s", action);
3955 if (opts->verbose)
3956 ret = run_command(&cmd);
3957 else
3958 ret = run_command_silent_on_success(&cmd);
3960 if (!ret)
3961 discard_index(r->index);
3963 return ret;
3966 static int checkout_onto(struct repository *r, struct replay_opts *opts,
3967 const char *onto_name, const struct object_id *onto,
3968 const struct object_id *orig_head)
3970 const char *action = reflog_message(opts, "start", "checkout %s", onto_name);
3972 if (run_git_checkout(r, opts, oid_to_hex(onto), action)) {
3973 apply_autostash(rebase_path_autostash());
3974 sequencer_remove_state(opts);
3975 return error(_("could not detach HEAD"));
3978 return update_ref(NULL, "ORIG_HEAD", orig_head, NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3981 static int stopped_at_head(struct repository *r)
3983 struct object_id head;
3984 struct commit *commit;
3985 struct commit_message message;
3987 if (get_oid("HEAD", &head) ||
3988 !(commit = lookup_commit(r, &head)) ||
3989 parse_commit(commit) || get_message(commit, &message))
3990 fprintf(stderr, _("Stopped at HEAD\n"));
3991 else {
3992 fprintf(stderr, _("Stopped at %s\n"), message.label);
3993 free_message(commit, &message);
3995 return 0;
3999 static const char rescheduled_advice[] =
4000 N_("Could not execute the todo command\n"
4001 "\n"
4002 " %.*s"
4003 "\n"
4004 "It has been rescheduled; To edit the command before continuing, please\n"
4005 "edit the todo list first:\n"
4006 "\n"
4007 " git rebase --edit-todo\n"
4008 " git rebase --continue\n");
4010 static int pick_commits(struct repository *r,
4011 struct todo_list *todo_list,
4012 struct replay_opts *opts)
4014 int res = 0, reschedule = 0;
4015 char *prev_reflog_action;
4017 /* Note that 0 for 3rd parameter of setenv means set only if not set */
4018 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
4019 prev_reflog_action = xstrdup(getenv(GIT_REFLOG_ACTION));
4020 if (opts->allow_ff)
4021 assert(!(opts->signoff || opts->no_commit ||
4022 opts->record_origin || opts->edit ||
4023 opts->committer_date_is_author_date ||
4024 opts->ignore_date));
4025 if (read_and_refresh_cache(r, opts))
4026 return -1;
4028 while (todo_list->current < todo_list->nr) {
4029 struct todo_item *item = todo_list->items + todo_list->current;
4030 const char *arg = todo_item_get_arg(todo_list, item);
4031 int check_todo = 0;
4033 if (save_todo(todo_list, opts))
4034 return -1;
4035 if (is_rebase_i(opts)) {
4036 if (item->command != TODO_COMMENT) {
4037 FILE *f = fopen(rebase_path_msgnum(), "w");
4039 todo_list->done_nr++;
4041 if (f) {
4042 fprintf(f, "%d\n", todo_list->done_nr);
4043 fclose(f);
4045 if (!opts->quiet)
4046 fprintf(stderr, _("Rebasing (%d/%d)%s"),
4047 todo_list->done_nr,
4048 todo_list->total_nr,
4049 opts->verbose ? "\n" : "\r");
4051 unlink(rebase_path_message());
4052 unlink(rebase_path_author_script());
4053 unlink(rebase_path_stopped_sha());
4054 unlink(rebase_path_amend());
4055 unlink(git_path_merge_head(r));
4056 delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
4058 if (item->command == TODO_BREAK) {
4059 if (!opts->verbose)
4060 term_clear_line();
4061 return stopped_at_head(r);
4064 if (item->command <= TODO_SQUASH) {
4065 if (is_rebase_i(opts))
4066 setenv(GIT_REFLOG_ACTION, reflog_message(opts,
4067 command_to_string(item->command), NULL),
4069 res = do_pick_commit(r, item->command, item->commit,
4070 opts, is_final_fixup(todo_list),
4071 &check_todo);
4072 if (is_rebase_i(opts))
4073 setenv(GIT_REFLOG_ACTION, prev_reflog_action, 1);
4074 if (is_rebase_i(opts) && res < 0) {
4075 /* Reschedule */
4076 advise(_(rescheduled_advice),
4077 get_item_line_length(todo_list,
4078 todo_list->current),
4079 get_item_line(todo_list,
4080 todo_list->current));
4081 todo_list->current--;
4082 if (save_todo(todo_list, opts))
4083 return -1;
4085 if (item->command == TODO_EDIT) {
4086 struct commit *commit = item->commit;
4087 if (!res) {
4088 if (!opts->verbose)
4089 term_clear_line();
4090 fprintf(stderr,
4091 _("Stopped at %s... %.*s\n"),
4092 short_commit_name(commit),
4093 item->arg_len, arg);
4095 return error_with_patch(r, commit,
4096 arg, item->arg_len, opts, res, !res);
4098 if (is_rebase_i(opts) && !res)
4099 record_in_rewritten(&item->commit->object.oid,
4100 peek_command(todo_list, 1));
4101 if (res && is_fixup(item->command)) {
4102 if (res == 1)
4103 intend_to_amend();
4104 return error_failed_squash(r, item->commit, opts,
4105 item->arg_len, arg);
4106 } else if (res && is_rebase_i(opts) && item->commit) {
4107 int to_amend = 0;
4108 struct object_id oid;
4111 * If we are rewording and have either
4112 * fast-forwarded already, or are about to
4113 * create a new root commit, we want to amend,
4114 * otherwise we do not.
4116 if (item->command == TODO_REWORD &&
4117 !get_oid("HEAD", &oid) &&
4118 (oideq(&item->commit->object.oid, &oid) ||
4119 (opts->have_squash_onto &&
4120 oideq(&opts->squash_onto, &oid))))
4121 to_amend = 1;
4123 return res | error_with_patch(r, item->commit,
4124 arg, item->arg_len, opts,
4125 res, to_amend);
4127 } else if (item->command == TODO_EXEC) {
4128 char *end_of_arg = (char *)(arg + item->arg_len);
4129 int saved = *end_of_arg;
4131 if (!opts->verbose)
4132 term_clear_line();
4133 *end_of_arg = '\0';
4134 res = do_exec(r, arg);
4135 *end_of_arg = saved;
4137 if (res) {
4138 if (opts->reschedule_failed_exec)
4139 reschedule = 1;
4141 check_todo = 1;
4142 } else if (item->command == TODO_LABEL) {
4143 if ((res = do_label(r, arg, item->arg_len)))
4144 reschedule = 1;
4145 } else if (item->command == TODO_RESET) {
4146 if ((res = do_reset(r, arg, item->arg_len, opts)))
4147 reschedule = 1;
4148 } else if (item->command == TODO_MERGE) {
4149 if ((res = do_merge(r, item->commit,
4150 arg, item->arg_len,
4151 item->flags, opts)) < 0)
4152 reschedule = 1;
4153 else if (item->commit)
4154 record_in_rewritten(&item->commit->object.oid,
4155 peek_command(todo_list, 1));
4156 if (res > 0)
4157 /* failed with merge conflicts */
4158 return error_with_patch(r, item->commit,
4159 arg, item->arg_len,
4160 opts, res, 0);
4161 } else if (!is_noop(item->command))
4162 return error(_("unknown command %d"), item->command);
4164 if (reschedule) {
4165 advise(_(rescheduled_advice),
4166 get_item_line_length(todo_list,
4167 todo_list->current),
4168 get_item_line(todo_list, todo_list->current));
4169 todo_list->current--;
4170 if (save_todo(todo_list, opts))
4171 return -1;
4172 if (item->commit)
4173 return error_with_patch(r,
4174 item->commit,
4175 arg, item->arg_len,
4176 opts, res, 0);
4177 } else if (is_rebase_i(opts) && check_todo && !res) {
4178 struct stat st;
4180 if (stat(get_todo_path(opts), &st)) {
4181 res = error_errno(_("could not stat '%s'"),
4182 get_todo_path(opts));
4183 } else if (match_stat_data(&todo_list->stat, &st)) {
4184 /* Reread the todo file if it has changed. */
4185 todo_list_release(todo_list);
4186 if (read_populate_todo(r, todo_list, opts))
4187 res = -1; /* message was printed */
4188 /* `current` will be incremented below */
4189 todo_list->current = -1;
4193 todo_list->current++;
4194 if (res)
4195 return res;
4198 if (is_rebase_i(opts)) {
4199 struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
4200 struct stat st;
4202 /* Stopped in the middle, as planned? */
4203 if (todo_list->current < todo_list->nr)
4204 return 0;
4206 if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
4207 starts_with(head_ref.buf, "refs/")) {
4208 const char *msg;
4209 struct object_id head, orig;
4210 int res;
4212 if (get_oid("HEAD", &head)) {
4213 res = error(_("cannot read HEAD"));
4214 cleanup_head_ref:
4215 strbuf_release(&head_ref);
4216 strbuf_release(&buf);
4217 return res;
4219 if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
4220 get_oid_hex(buf.buf, &orig)) {
4221 res = error(_("could not read orig-head"));
4222 goto cleanup_head_ref;
4224 strbuf_reset(&buf);
4225 if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
4226 res = error(_("could not read 'onto'"));
4227 goto cleanup_head_ref;
4229 msg = reflog_message(opts, "finish", "%s onto %s",
4230 head_ref.buf, buf.buf);
4231 if (update_ref(msg, head_ref.buf, &head, &orig,
4232 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
4233 res = error(_("could not update %s"),
4234 head_ref.buf);
4235 goto cleanup_head_ref;
4237 msg = reflog_message(opts, "finish", "returning to %s",
4238 head_ref.buf);
4239 if (create_symref("HEAD", head_ref.buf, msg)) {
4240 res = error(_("could not update HEAD to %s"),
4241 head_ref.buf);
4242 goto cleanup_head_ref;
4244 strbuf_reset(&buf);
4247 if (opts->verbose) {
4248 struct rev_info log_tree_opt;
4249 struct object_id orig, head;
4251 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
4252 repo_init_revisions(r, &log_tree_opt, NULL);
4253 log_tree_opt.diff = 1;
4254 log_tree_opt.diffopt.output_format =
4255 DIFF_FORMAT_DIFFSTAT;
4256 log_tree_opt.disable_stdin = 1;
4258 if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
4259 !get_oid(buf.buf, &orig) &&
4260 !get_oid("HEAD", &head)) {
4261 diff_tree_oid(&orig, &head, "",
4262 &log_tree_opt.diffopt);
4263 log_tree_diff_flush(&log_tree_opt);
4266 flush_rewritten_pending();
4267 if (!stat(rebase_path_rewritten_list(), &st) &&
4268 st.st_size > 0) {
4269 struct child_process child = CHILD_PROCESS_INIT;
4270 const char *post_rewrite_hook =
4271 find_hook("post-rewrite");
4273 child.in = open(rebase_path_rewritten_list(), O_RDONLY);
4274 child.git_cmd = 1;
4275 strvec_push(&child.args, "notes");
4276 strvec_push(&child.args, "copy");
4277 strvec_push(&child.args, "--for-rewrite=rebase");
4278 /* we don't care if this copying failed */
4279 run_command(&child);
4281 if (post_rewrite_hook) {
4282 struct child_process hook = CHILD_PROCESS_INIT;
4284 hook.in = open(rebase_path_rewritten_list(),
4285 O_RDONLY);
4286 hook.stdout_to_stderr = 1;
4287 hook.trace2_hook_name = "post-rewrite";
4288 strvec_push(&hook.args, post_rewrite_hook);
4289 strvec_push(&hook.args, "rebase");
4290 /* we don't care if this hook failed */
4291 run_command(&hook);
4294 apply_autostash(rebase_path_autostash());
4296 if (!opts->quiet) {
4297 if (!opts->verbose)
4298 term_clear_line();
4299 fprintf(stderr,
4300 _("Successfully rebased and updated %s.\n"),
4301 head_ref.buf);
4304 strbuf_release(&buf);
4305 strbuf_release(&head_ref);
4309 * Sequence of picks finished successfully; cleanup by
4310 * removing the .git/sequencer directory
4312 return sequencer_remove_state(opts);
4315 static int continue_single_pick(struct repository *r)
4317 const char *argv[] = { "commit", NULL };
4319 if (!refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD") &&
4320 !refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD"))
4321 return error(_("no cherry-pick or revert in progress"));
4322 return run_command_v_opt(argv, RUN_GIT_CMD);
4325 static int commit_staged_changes(struct repository *r,
4326 struct replay_opts *opts,
4327 struct todo_list *todo_list)
4329 unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
4330 unsigned int final_fixup = 0, is_clean;
4332 if (has_unstaged_changes(r, 1))
4333 return error(_("cannot rebase: You have unstaged changes."));
4335 is_clean = !has_uncommitted_changes(r, 0);
4337 if (file_exists(rebase_path_amend())) {
4338 struct strbuf rev = STRBUF_INIT;
4339 struct object_id head, to_amend;
4341 if (get_oid("HEAD", &head))
4342 return error(_("cannot amend non-existing commit"));
4343 if (!read_oneliner(&rev, rebase_path_amend(), 0))
4344 return error(_("invalid file: '%s'"), rebase_path_amend());
4345 if (get_oid_hex(rev.buf, &to_amend))
4346 return error(_("invalid contents: '%s'"),
4347 rebase_path_amend());
4348 if (!is_clean && !oideq(&head, &to_amend))
4349 return error(_("\nYou have uncommitted changes in your "
4350 "working tree. Please, commit them\n"
4351 "first and then run 'git rebase "
4352 "--continue' again."));
4354 * When skipping a failed fixup/squash, we need to edit the
4355 * commit message, the current fixup list and count, and if it
4356 * was the last fixup/squash in the chain, we need to clean up
4357 * the commit message and if there was a squash, let the user
4358 * edit it.
4360 if (!is_clean || !opts->current_fixup_count)
4361 ; /* this is not the final fixup */
4362 else if (!oideq(&head, &to_amend) ||
4363 !file_exists(rebase_path_stopped_sha())) {
4364 /* was a final fixup or squash done manually? */
4365 if (!is_fixup(peek_command(todo_list, 0))) {
4366 unlink(rebase_path_fixup_msg());
4367 unlink(rebase_path_squash_msg());
4368 unlink(rebase_path_current_fixups());
4369 strbuf_reset(&opts->current_fixups);
4370 opts->current_fixup_count = 0;
4372 } else {
4373 /* we are in a fixup/squash chain */
4374 const char *p = opts->current_fixups.buf;
4375 int len = opts->current_fixups.len;
4377 opts->current_fixup_count--;
4378 if (!len)
4379 BUG("Incorrect current_fixups:\n%s", p);
4380 while (len && p[len - 1] != '\n')
4381 len--;
4382 strbuf_setlen(&opts->current_fixups, len);
4383 if (write_message(p, len, rebase_path_current_fixups(),
4384 0) < 0)
4385 return error(_("could not write file: '%s'"),
4386 rebase_path_current_fixups());
4389 * If a fixup/squash in a fixup/squash chain failed, the
4390 * commit message is already correct, no need to commit
4391 * it again.
4393 * Only if it is the final command in the fixup/squash
4394 * chain, and only if the chain is longer than a single
4395 * fixup/squash command (which was just skipped), do we
4396 * actually need to re-commit with a cleaned up commit
4397 * message.
4399 if (opts->current_fixup_count > 0 &&
4400 !is_fixup(peek_command(todo_list, 0))) {
4401 final_fixup = 1;
4403 * If there was not a single "squash" in the
4404 * chain, we only need to clean up the commit
4405 * message, no need to bother the user with
4406 * opening the commit message in the editor.
4408 if (!starts_with(p, "squash ") &&
4409 !strstr(p, "\nsquash "))
4410 flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;
4411 } else if (is_fixup(peek_command(todo_list, 0))) {
4413 * We need to update the squash message to skip
4414 * the latest commit message.
4416 struct commit *commit;
4417 const char *path = rebase_path_squash_msg();
4418 const char *encoding = get_commit_output_encoding();
4420 if (parse_head(r, &commit) ||
4421 !(p = logmsg_reencode(commit, NULL, encoding)) ||
4422 write_message(p, strlen(p), path, 0)) {
4423 unuse_commit_buffer(commit, p);
4424 return error(_("could not write file: "
4425 "'%s'"), path);
4427 unuse_commit_buffer(commit, p);
4431 strbuf_release(&rev);
4432 flags |= AMEND_MSG;
4435 if (is_clean) {
4436 if (refs_ref_exists(get_main_ref_store(r),
4437 "CHERRY_PICK_HEAD") &&
4438 refs_delete_ref(get_main_ref_store(r), "",
4439 "CHERRY_PICK_HEAD", NULL, 0))
4440 return error(_("could not remove CHERRY_PICK_HEAD"));
4441 if (!final_fixup)
4442 return 0;
4445 if (run_git_commit(final_fixup ? NULL : rebase_path_message(),
4446 opts, flags))
4447 return error(_("could not commit staged changes."));
4448 unlink(rebase_path_amend());
4449 unlink(git_path_merge_head(r));
4450 if (final_fixup) {
4451 unlink(rebase_path_fixup_msg());
4452 unlink(rebase_path_squash_msg());
4454 if (opts->current_fixup_count > 0) {
4456 * Whether final fixup or not, we just cleaned up the commit
4457 * message...
4459 unlink(rebase_path_current_fixups());
4460 strbuf_reset(&opts->current_fixups);
4461 opts->current_fixup_count = 0;
4463 return 0;
4466 static int init_committer(struct replay_opts *opts)
4468 struct ident_split id;
4469 const char *committer;
4471 committer = git_committer_info(IDENT_STRICT);
4472 if (split_ident_line(&id, committer, strlen(committer)) < 0)
4473 return error(_("invalid committer '%s'"), committer);
4474 opts->committer_name =
4475 xmemdupz(id.name_begin, id.name_end - id.name_begin);
4476 opts->committer_email =
4477 xmemdupz(id.mail_begin, id.mail_end - id.mail_end);
4479 return 0;
4482 int sequencer_continue(struct repository *r, struct replay_opts *opts)
4484 struct todo_list todo_list = TODO_LIST_INIT;
4485 int res;
4487 if (read_and_refresh_cache(r, opts))
4488 return -1;
4490 if (read_populate_opts(opts))
4491 return -1;
4492 if (is_rebase_i(opts)) {
4493 if (opts->committer_date_is_author_date && init_committer(opts))
4494 return -1;
4496 if ((res = read_populate_todo(r, &todo_list, opts)))
4497 goto release_todo_list;
4499 if (file_exists(rebase_path_dropped())) {
4500 if ((res = todo_list_check_against_backup(r, &todo_list)))
4501 goto release_todo_list;
4503 unlink(rebase_path_dropped());
4506 if (commit_staged_changes(r, opts, &todo_list)) {
4507 res = -1;
4508 goto release_todo_list;
4510 } else if (!file_exists(get_todo_path(opts)))
4511 return continue_single_pick(r);
4512 else if ((res = read_populate_todo(r, &todo_list, opts)))
4513 goto release_todo_list;
4515 if (!is_rebase_i(opts)) {
4516 /* Verify that the conflict has been resolved */
4517 if (refs_ref_exists(get_main_ref_store(r),
4518 "CHERRY_PICK_HEAD") ||
4519 refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD")) {
4520 res = continue_single_pick(r);
4521 if (res)
4522 goto release_todo_list;
4524 if (index_differs_from(r, "HEAD", NULL, 0)) {
4525 res = error_dirty_index(r, opts);
4526 goto release_todo_list;
4528 todo_list.current++;
4529 } else if (file_exists(rebase_path_stopped_sha())) {
4530 struct strbuf buf = STRBUF_INIT;
4531 struct object_id oid;
4533 if (read_oneliner(&buf, rebase_path_stopped_sha(),
4534 READ_ONELINER_SKIP_IF_EMPTY) &&
4535 !get_oid_hex(buf.buf, &oid))
4536 record_in_rewritten(&oid, peek_command(&todo_list, 0));
4537 strbuf_release(&buf);
4540 res = pick_commits(r, &todo_list, opts);
4541 release_todo_list:
4542 todo_list_release(&todo_list);
4543 return res;
4546 static int single_pick(struct repository *r,
4547 struct commit *cmit,
4548 struct replay_opts *opts)
4550 int check_todo;
4552 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
4553 return do_pick_commit(r, opts->action == REPLAY_PICK ?
4554 TODO_PICK : TODO_REVERT, cmit, opts, 0,
4555 &check_todo);
4558 int sequencer_pick_revisions(struct repository *r,
4559 struct replay_opts *opts)
4561 struct todo_list todo_list = TODO_LIST_INIT;
4562 struct object_id oid;
4563 int i, res;
4565 assert(opts->revs);
4566 if (read_and_refresh_cache(r, opts))
4567 return -1;
4569 for (i = 0; i < opts->revs->pending.nr; i++) {
4570 struct object_id oid;
4571 const char *name = opts->revs->pending.objects[i].name;
4573 /* This happens when using --stdin. */
4574 if (!strlen(name))
4575 continue;
4577 if (!get_oid(name, &oid)) {
4578 if (!lookup_commit_reference_gently(r, &oid, 1)) {
4579 enum object_type type = oid_object_info(r,
4580 &oid,
4581 NULL);
4582 return error(_("%s: can't cherry-pick a %s"),
4583 name, type_name(type));
4585 } else
4586 return error(_("%s: bad revision"), name);
4590 * If we were called as "git cherry-pick <commit>", just
4591 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4592 * REVERT_HEAD, and don't touch the sequencer state.
4593 * This means it is possible to cherry-pick in the middle
4594 * of a cherry-pick sequence.
4596 if (opts->revs->cmdline.nr == 1 &&
4597 opts->revs->cmdline.rev->whence == REV_CMD_REV &&
4598 opts->revs->no_walk &&
4599 !opts->revs->cmdline.rev->flags) {
4600 struct commit *cmit;
4601 if (prepare_revision_walk(opts->revs))
4602 return error(_("revision walk setup failed"));
4603 cmit = get_revision(opts->revs);
4604 if (!cmit)
4605 return error(_("empty commit set passed"));
4606 if (get_revision(opts->revs))
4607 BUG("unexpected extra commit from walk");
4608 return single_pick(r, cmit, opts);
4612 * Start a new cherry-pick/ revert sequence; but
4613 * first, make sure that an existing one isn't in
4614 * progress
4617 if (walk_revs_populate_todo(&todo_list, opts) ||
4618 create_seq_dir(r) < 0)
4619 return -1;
4620 if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
4621 return error(_("can't revert as initial commit"));
4622 if (save_head(oid_to_hex(&oid)))
4623 return -1;
4624 if (save_opts(opts))
4625 return -1;
4626 update_abort_safety_file();
4627 res = pick_commits(r, &todo_list, opts);
4628 todo_list_release(&todo_list);
4629 return res;
4632 void append_signoff(struct strbuf *msgbuf, size_t ignore_footer, unsigned flag)
4634 unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
4635 struct strbuf sob = STRBUF_INIT;
4636 int has_footer;
4638 strbuf_addstr(&sob, sign_off_header);
4639 strbuf_addstr(&sob, fmt_name(WANT_COMMITTER_IDENT));
4640 strbuf_addch(&sob, '\n');
4642 if (!ignore_footer)
4643 strbuf_complete_line(msgbuf);
4646 * If the whole message buffer is equal to the sob, pretend that we
4647 * found a conforming footer with a matching sob
4649 if (msgbuf->len - ignore_footer == sob.len &&
4650 !strncmp(msgbuf->buf, sob.buf, sob.len))
4651 has_footer = 3;
4652 else
4653 has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
4655 if (!has_footer) {
4656 const char *append_newlines = NULL;
4657 size_t len = msgbuf->len - ignore_footer;
4659 if (!len) {
4661 * The buffer is completely empty. Leave foom for
4662 * the title and body to be filled in by the user.
4664 append_newlines = "\n\n";
4665 } else if (len == 1) {
4667 * Buffer contains a single newline. Add another
4668 * so that we leave room for the title and body.
4670 append_newlines = "\n";
4671 } else if (msgbuf->buf[len - 2] != '\n') {
4673 * Buffer ends with a single newline. Add another
4674 * so that there is an empty line between the message
4675 * body and the sob.
4677 append_newlines = "\n";
4678 } /* else, the buffer already ends with two newlines. */
4680 if (append_newlines)
4681 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4682 append_newlines, strlen(append_newlines));
4685 if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
4686 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4687 sob.buf, sob.len);
4689 strbuf_release(&sob);
4692 struct labels_entry {
4693 struct hashmap_entry entry;
4694 char label[FLEX_ARRAY];
4697 static int labels_cmp(const void *fndata, const struct hashmap_entry *eptr,
4698 const struct hashmap_entry *entry_or_key, const void *key)
4700 const struct labels_entry *a, *b;
4702 a = container_of(eptr, const struct labels_entry, entry);
4703 b = container_of(entry_or_key, const struct labels_entry, entry);
4705 return key ? strcmp(a->label, key) : strcmp(a->label, b->label);
4708 struct string_entry {
4709 struct oidmap_entry entry;
4710 char string[FLEX_ARRAY];
4713 struct label_state {
4714 struct oidmap commit2label;
4715 struct hashmap labels;
4716 struct strbuf buf;
4719 static const char *label_oid(struct object_id *oid, const char *label,
4720 struct label_state *state)
4722 struct labels_entry *labels_entry;
4723 struct string_entry *string_entry;
4724 struct object_id dummy;
4725 int i;
4727 string_entry = oidmap_get(&state->commit2label, oid);
4728 if (string_entry)
4729 return string_entry->string;
4732 * For "uninteresting" commits, i.e. commits that are not to be
4733 * rebased, and which can therefore not be labeled, we use a unique
4734 * abbreviation of the commit name. This is slightly more complicated
4735 * than calling find_unique_abbrev() because we also need to make
4736 * sure that the abbreviation does not conflict with any other
4737 * label.
4739 * We disallow "interesting" commits to be labeled by a string that
4740 * is a valid full-length hash, to ensure that we always can find an
4741 * abbreviation for any uninteresting commit's names that does not
4742 * clash with any other label.
4744 strbuf_reset(&state->buf);
4745 if (!label) {
4746 char *p;
4748 strbuf_grow(&state->buf, GIT_MAX_HEXSZ);
4749 label = p = state->buf.buf;
4751 find_unique_abbrev_r(p, oid, default_abbrev);
4754 * We may need to extend the abbreviated hash so that there is
4755 * no conflicting label.
4757 if (hashmap_get_from_hash(&state->labels, strihash(p), p)) {
4758 size_t i = strlen(p) + 1;
4760 oid_to_hex_r(p, oid);
4761 for (; i < the_hash_algo->hexsz; i++) {
4762 char save = p[i];
4763 p[i] = '\0';
4764 if (!hashmap_get_from_hash(&state->labels,
4765 strihash(p), p))
4766 break;
4767 p[i] = save;
4770 } else {
4771 struct strbuf *buf = &state->buf;
4774 * Sanitize labels by replacing non-alpha-numeric characters
4775 * (including white-space ones) by dashes, as they might be
4776 * illegal in file names (and hence in ref names).
4778 * Note that we retain non-ASCII UTF-8 characters (identified
4779 * via the most significant bit). They should be all acceptable
4780 * in file names. We do not validate the UTF-8 here, that's not
4781 * the job of this function.
4783 for (; *label; label++)
4784 if ((*label & 0x80) || isalnum(*label))
4785 strbuf_addch(buf, *label);
4786 /* avoid leading dash and double-dashes */
4787 else if (buf->len && buf->buf[buf->len - 1] != '-')
4788 strbuf_addch(buf, '-');
4789 if (!buf->len) {
4790 strbuf_addstr(buf, "rev-");
4791 strbuf_add_unique_abbrev(buf, oid, default_abbrev);
4793 label = buf->buf;
4795 if ((buf->len == the_hash_algo->hexsz &&
4796 !get_oid_hex(label, &dummy)) ||
4797 (buf->len == 1 && *label == '#') ||
4798 hashmap_get_from_hash(&state->labels,
4799 strihash(label), label)) {
4801 * If the label already exists, or if the label is a
4802 * valid full OID, or the label is a '#' (which we use
4803 * as a separator between merge heads and oneline), we
4804 * append a dash and a number to make it unique.
4806 size_t len = buf->len;
4808 for (i = 2; ; i++) {
4809 strbuf_setlen(buf, len);
4810 strbuf_addf(buf, "-%d", i);
4811 if (!hashmap_get_from_hash(&state->labels,
4812 strihash(buf->buf),
4813 buf->buf))
4814 break;
4817 label = buf->buf;
4821 FLEX_ALLOC_STR(labels_entry, label, label);
4822 hashmap_entry_init(&labels_entry->entry, strihash(label));
4823 hashmap_add(&state->labels, &labels_entry->entry);
4825 FLEX_ALLOC_STR(string_entry, string, label);
4826 oidcpy(&string_entry->entry.oid, oid);
4827 oidmap_put(&state->commit2label, string_entry);
4829 return string_entry->string;
4832 static int make_script_with_merges(struct pretty_print_context *pp,
4833 struct rev_info *revs, struct strbuf *out,
4834 unsigned flags)
4836 int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4837 int rebase_cousins = flags & TODO_LIST_REBASE_COUSINS;
4838 int root_with_onto = flags & TODO_LIST_ROOT_WITH_ONTO;
4839 struct strbuf buf = STRBUF_INIT, oneline = STRBUF_INIT;
4840 struct strbuf label = STRBUF_INIT;
4841 struct commit_list *commits = NULL, **tail = &commits, *iter;
4842 struct commit_list *tips = NULL, **tips_tail = &tips;
4843 struct commit *commit;
4844 struct oidmap commit2todo = OIDMAP_INIT;
4845 struct string_entry *entry;
4846 struct oidset interesting = OIDSET_INIT, child_seen = OIDSET_INIT,
4847 shown = OIDSET_INIT;
4848 struct label_state state = { OIDMAP_INIT, { NULL }, STRBUF_INIT };
4850 int abbr = flags & TODO_LIST_ABBREVIATE_CMDS;
4851 const char *cmd_pick = abbr ? "p" : "pick",
4852 *cmd_label = abbr ? "l" : "label",
4853 *cmd_reset = abbr ? "t" : "reset",
4854 *cmd_merge = abbr ? "m" : "merge";
4856 oidmap_init(&commit2todo, 0);
4857 oidmap_init(&state.commit2label, 0);
4858 hashmap_init(&state.labels, labels_cmp, NULL, 0);
4859 strbuf_init(&state.buf, 32);
4861 if (revs->cmdline.nr && (revs->cmdline.rev[0].flags & BOTTOM)) {
4862 struct labels_entry *onto_label_entry;
4863 struct object_id *oid = &revs->cmdline.rev[0].item->oid;
4864 FLEX_ALLOC_STR(entry, string, "onto");
4865 oidcpy(&entry->entry.oid, oid);
4866 oidmap_put(&state.commit2label, entry);
4868 FLEX_ALLOC_STR(onto_label_entry, label, "onto");
4869 hashmap_entry_init(&onto_label_entry->entry, strihash("onto"));
4870 hashmap_add(&state.labels, &onto_label_entry->entry);
4874 * First phase:
4875 * - get onelines for all commits
4876 * - gather all branch tips (i.e. 2nd or later parents of merges)
4877 * - label all branch tips
4879 while ((commit = get_revision(revs))) {
4880 struct commit_list *to_merge;
4881 const char *p1, *p2;
4882 struct object_id *oid;
4883 int is_empty;
4885 tail = &commit_list_insert(commit, tail)->next;
4886 oidset_insert(&interesting, &commit->object.oid);
4888 is_empty = is_original_commit_empty(commit);
4889 if (!is_empty && (commit->object.flags & PATCHSAME))
4890 continue;
4891 if (is_empty && !keep_empty)
4892 continue;
4894 strbuf_reset(&oneline);
4895 pretty_print_commit(pp, commit, &oneline);
4897 to_merge = commit->parents ? commit->parents->next : NULL;
4898 if (!to_merge) {
4899 /* non-merge commit: easy case */
4900 strbuf_reset(&buf);
4901 strbuf_addf(&buf, "%s %s %s", cmd_pick,
4902 oid_to_hex(&commit->object.oid),
4903 oneline.buf);
4904 if (is_empty)
4905 strbuf_addf(&buf, " %c empty",
4906 comment_line_char);
4908 FLEX_ALLOC_STR(entry, string, buf.buf);
4909 oidcpy(&entry->entry.oid, &commit->object.oid);
4910 oidmap_put(&commit2todo, entry);
4912 continue;
4915 /* Create a label */
4916 strbuf_reset(&label);
4917 if (skip_prefix(oneline.buf, "Merge ", &p1) &&
4918 (p1 = strchr(p1, '\'')) &&
4919 (p2 = strchr(++p1, '\'')))
4920 strbuf_add(&label, p1, p2 - p1);
4921 else if (skip_prefix(oneline.buf, "Merge pull request ",
4922 &p1) &&
4923 (p1 = strstr(p1, " from ")))
4924 strbuf_addstr(&label, p1 + strlen(" from "));
4925 else
4926 strbuf_addbuf(&label, &oneline);
4928 strbuf_reset(&buf);
4929 strbuf_addf(&buf, "%s -C %s",
4930 cmd_merge, oid_to_hex(&commit->object.oid));
4932 /* label the tips of merged branches */
4933 for (; to_merge; to_merge = to_merge->next) {
4934 oid = &to_merge->item->object.oid;
4935 strbuf_addch(&buf, ' ');
4937 if (!oidset_contains(&interesting, oid)) {
4938 strbuf_addstr(&buf, label_oid(oid, NULL,
4939 &state));
4940 continue;
4943 tips_tail = &commit_list_insert(to_merge->item,
4944 tips_tail)->next;
4946 strbuf_addstr(&buf, label_oid(oid, label.buf, &state));
4948 strbuf_addf(&buf, " # %s", oneline.buf);
4950 FLEX_ALLOC_STR(entry, string, buf.buf);
4951 oidcpy(&entry->entry.oid, &commit->object.oid);
4952 oidmap_put(&commit2todo, entry);
4956 * Second phase:
4957 * - label branch points
4958 * - add HEAD to the branch tips
4960 for (iter = commits; iter; iter = iter->next) {
4961 struct commit_list *parent = iter->item->parents;
4962 for (; parent; parent = parent->next) {
4963 struct object_id *oid = &parent->item->object.oid;
4964 if (!oidset_contains(&interesting, oid))
4965 continue;
4966 if (oidset_insert(&child_seen, oid))
4967 label_oid(oid, "branch-point", &state);
4970 /* Add HEAD as implicit "tip of branch" */
4971 if (!iter->next)
4972 tips_tail = &commit_list_insert(iter->item,
4973 tips_tail)->next;
4977 * Third phase: output the todo list. This is a bit tricky, as we
4978 * want to avoid jumping back and forth between revisions. To
4979 * accomplish that goal, we walk backwards from the branch tips,
4980 * gathering commits not yet shown, reversing the list on the fly,
4981 * then outputting that list (labeling revisions as needed).
4983 strbuf_addf(out, "%s onto\n", cmd_label);
4984 for (iter = tips; iter; iter = iter->next) {
4985 struct commit_list *list = NULL, *iter2;
4987 commit = iter->item;
4988 if (oidset_contains(&shown, &commit->object.oid))
4989 continue;
4990 entry = oidmap_get(&state.commit2label, &commit->object.oid);
4992 if (entry)
4993 strbuf_addf(out, "\n%c Branch %s\n", comment_line_char, entry->string);
4994 else
4995 strbuf_addch(out, '\n');
4997 while (oidset_contains(&interesting, &commit->object.oid) &&
4998 !oidset_contains(&shown, &commit->object.oid)) {
4999 commit_list_insert(commit, &list);
5000 if (!commit->parents) {
5001 commit = NULL;
5002 break;
5004 commit = commit->parents->item;
5007 if (!commit)
5008 strbuf_addf(out, "%s %s\n", cmd_reset,
5009 rebase_cousins || root_with_onto ?
5010 "onto" : "[new root]");
5011 else {
5012 const char *to = NULL;
5014 entry = oidmap_get(&state.commit2label,
5015 &commit->object.oid);
5016 if (entry)
5017 to = entry->string;
5018 else if (!rebase_cousins)
5019 to = label_oid(&commit->object.oid, NULL,
5020 &state);
5022 if (!to || !strcmp(to, "onto"))
5023 strbuf_addf(out, "%s onto\n", cmd_reset);
5024 else {
5025 strbuf_reset(&oneline);
5026 pretty_print_commit(pp, commit, &oneline);
5027 strbuf_addf(out, "%s %s # %s\n",
5028 cmd_reset, to, oneline.buf);
5032 for (iter2 = list; iter2; iter2 = iter2->next) {
5033 struct object_id *oid = &iter2->item->object.oid;
5034 entry = oidmap_get(&commit2todo, oid);
5035 /* only show if not already upstream */
5036 if (entry)
5037 strbuf_addf(out, "%s\n", entry->string);
5038 entry = oidmap_get(&state.commit2label, oid);
5039 if (entry)
5040 strbuf_addf(out, "%s %s\n",
5041 cmd_label, entry->string);
5042 oidset_insert(&shown, oid);
5045 free_commit_list(list);
5048 free_commit_list(commits);
5049 free_commit_list(tips);
5051 strbuf_release(&label);
5052 strbuf_release(&oneline);
5053 strbuf_release(&buf);
5055 oidmap_free(&commit2todo, 1);
5056 oidmap_free(&state.commit2label, 1);
5057 hashmap_free_entries(&state.labels, struct labels_entry, entry);
5058 strbuf_release(&state.buf);
5060 return 0;
5063 int sequencer_make_script(struct repository *r, struct strbuf *out, int argc,
5064 const char **argv, unsigned flags)
5066 char *format = NULL;
5067 struct pretty_print_context pp = {0};
5068 struct rev_info revs;
5069 struct commit *commit;
5070 int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
5071 const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";
5072 int rebase_merges = flags & TODO_LIST_REBASE_MERGES;
5073 int reapply_cherry_picks = flags & TODO_LIST_REAPPLY_CHERRY_PICKS;
5075 repo_init_revisions(r, &revs, NULL);
5076 revs.verbose_header = 1;
5077 if (!rebase_merges)
5078 revs.max_parents = 1;
5079 revs.cherry_mark = !reapply_cherry_picks;
5080 revs.limited = 1;
5081 revs.reverse = 1;
5082 revs.right_only = 1;
5083 revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
5084 revs.topo_order = 1;
5086 revs.pretty_given = 1;
5087 git_config_get_string("rebase.instructionFormat", &format);
5088 if (!format || !*format) {
5089 free(format);
5090 format = xstrdup("%s");
5092 get_commit_format(format, &revs);
5093 free(format);
5094 pp.fmt = revs.commit_format;
5095 pp.output_encoding = get_log_output_encoding();
5097 if (setup_revisions(argc, argv, &revs, NULL) > 1)
5098 return error(_("make_script: unhandled options"));
5100 if (prepare_revision_walk(&revs) < 0)
5101 return error(_("make_script: error preparing revisions"));
5103 if (rebase_merges)
5104 return make_script_with_merges(&pp, &revs, out, flags);
5106 while ((commit = get_revision(&revs))) {
5107 int is_empty = is_original_commit_empty(commit);
5109 if (!is_empty && (commit->object.flags & PATCHSAME))
5110 continue;
5111 if (is_empty && !keep_empty)
5112 continue;
5113 strbuf_addf(out, "%s %s ", insn,
5114 oid_to_hex(&commit->object.oid));
5115 pretty_print_commit(&pp, commit, out);
5116 if (is_empty)
5117 strbuf_addf(out, " %c empty", comment_line_char);
5118 strbuf_addch(out, '\n');
5120 return 0;
5124 * Add commands after pick and (series of) squash/fixup commands
5125 * in the todo list.
5127 void todo_list_add_exec_commands(struct todo_list *todo_list,
5128 struct string_list *commands)
5130 struct strbuf *buf = &todo_list->buf;
5131 size_t base_offset = buf->len;
5132 int i, insert, nr = 0, alloc = 0;
5133 struct todo_item *items = NULL, *base_items = NULL;
5135 base_items = xcalloc(commands->nr, sizeof(struct todo_item));
5136 for (i = 0; i < commands->nr; i++) {
5137 size_t command_len = strlen(commands->items[i].string);
5139 strbuf_addstr(buf, commands->items[i].string);
5140 strbuf_addch(buf, '\n');
5142 base_items[i].command = TODO_EXEC;
5143 base_items[i].offset_in_buf = base_offset;
5144 base_items[i].arg_offset = base_offset + strlen("exec ");
5145 base_items[i].arg_len = command_len - strlen("exec ");
5147 base_offset += command_len + 1;
5151 * Insert <commands> after every pick. Here, fixup/squash chains
5152 * are considered part of the pick, so we insert the commands *after*
5153 * those chains if there are any.
5155 * As we insert the exec commands immediately after rearranging
5156 * any fixups and before the user edits the list, a fixup chain
5157 * can never contain comments (any comments are empty picks that
5158 * have been commented out because the user did not specify
5159 * --keep-empty). So, it is safe to insert an exec command
5160 * without looking at the command following a comment.
5162 insert = 0;
5163 for (i = 0; i < todo_list->nr; i++) {
5164 enum todo_command command = todo_list->items[i].command;
5165 if (insert && !is_fixup(command)) {
5166 ALLOC_GROW(items, nr + commands->nr, alloc);
5167 COPY_ARRAY(items + nr, base_items, commands->nr);
5168 nr += commands->nr;
5170 insert = 0;
5173 ALLOC_GROW(items, nr + 1, alloc);
5174 items[nr++] = todo_list->items[i];
5176 if (command == TODO_PICK || command == TODO_MERGE)
5177 insert = 1;
5180 /* insert or append final <commands> */
5181 if (insert || nr == todo_list->nr) {
5182 ALLOC_GROW(items, nr + commands->nr, alloc);
5183 COPY_ARRAY(items + nr, base_items, commands->nr);
5184 nr += commands->nr;
5187 free(base_items);
5188 FREE_AND_NULL(todo_list->items);
5189 todo_list->items = items;
5190 todo_list->nr = nr;
5191 todo_list->alloc = alloc;
5194 static void todo_list_to_strbuf(struct repository *r, struct todo_list *todo_list,
5195 struct strbuf *buf, int num, unsigned flags)
5197 struct todo_item *item;
5198 int i, max = todo_list->nr;
5200 if (num > 0 && num < max)
5201 max = num;
5203 for (item = todo_list->items, i = 0; i < max; i++, item++) {
5204 char cmd;
5206 /* if the item is not a command write it and continue */
5207 if (item->command >= TODO_COMMENT) {
5208 strbuf_addf(buf, "%.*s\n", item->arg_len,
5209 todo_item_get_arg(todo_list, item));
5210 continue;
5213 /* add command to the buffer */
5214 cmd = command_to_char(item->command);
5215 if ((flags & TODO_LIST_ABBREVIATE_CMDS) && cmd)
5216 strbuf_addch(buf, cmd);
5217 else
5218 strbuf_addstr(buf, command_to_string(item->command));
5220 /* add commit id */
5221 if (item->commit) {
5222 const char *oid = flags & TODO_LIST_SHORTEN_IDS ?
5223 short_commit_name(item->commit) :
5224 oid_to_hex(&item->commit->object.oid);
5226 if (item->command == TODO_MERGE) {
5227 if (item->flags & TODO_EDIT_MERGE_MSG)
5228 strbuf_addstr(buf, " -c");
5229 else
5230 strbuf_addstr(buf, " -C");
5233 strbuf_addf(buf, " %s", oid);
5236 /* add all the rest */
5237 if (!item->arg_len)
5238 strbuf_addch(buf, '\n');
5239 else
5240 strbuf_addf(buf, " %.*s\n", item->arg_len,
5241 todo_item_get_arg(todo_list, item));
5245 int todo_list_write_to_file(struct repository *r, struct todo_list *todo_list,
5246 const char *file, const char *shortrevisions,
5247 const char *shortonto, int num, unsigned flags)
5249 int res;
5250 struct strbuf buf = STRBUF_INIT;
5252 todo_list_to_strbuf(r, todo_list, &buf, num, flags);
5253 if (flags & TODO_LIST_APPEND_TODO_HELP)
5254 append_todo_help(count_commands(todo_list),
5255 shortrevisions, shortonto, &buf);
5257 res = write_message(buf.buf, buf.len, file, 0);
5258 strbuf_release(&buf);
5260 return res;
5263 /* skip picking commits whose parents are unchanged */
5264 static int skip_unnecessary_picks(struct repository *r,
5265 struct todo_list *todo_list,
5266 struct object_id *base_oid)
5268 struct object_id *parent_oid;
5269 int i;
5271 for (i = 0; i < todo_list->nr; i++) {
5272 struct todo_item *item = todo_list->items + i;
5274 if (item->command >= TODO_NOOP)
5275 continue;
5276 if (item->command != TODO_PICK)
5277 break;
5278 if (parse_commit(item->commit)) {
5279 return error(_("could not parse commit '%s'"),
5280 oid_to_hex(&item->commit->object.oid));
5282 if (!item->commit->parents)
5283 break; /* root commit */
5284 if (item->commit->parents->next)
5285 break; /* merge commit */
5286 parent_oid = &item->commit->parents->item->object.oid;
5287 if (!oideq(parent_oid, base_oid))
5288 break;
5289 oidcpy(base_oid, &item->commit->object.oid);
5291 if (i > 0) {
5292 const char *done_path = rebase_path_done();
5294 if (todo_list_write_to_file(r, todo_list, done_path, NULL, NULL, i, 0)) {
5295 error_errno(_("could not write to '%s'"), done_path);
5296 return -1;
5299 MOVE_ARRAY(todo_list->items, todo_list->items + i, todo_list->nr - i);
5300 todo_list->nr -= i;
5301 todo_list->current = 0;
5302 todo_list->done_nr += i;
5304 if (is_fixup(peek_command(todo_list, 0)))
5305 record_in_rewritten(base_oid, peek_command(todo_list, 0));
5308 return 0;
5311 int complete_action(struct repository *r, struct replay_opts *opts, unsigned flags,
5312 const char *shortrevisions, const char *onto_name,
5313 struct commit *onto, const struct object_id *orig_head,
5314 struct string_list *commands, unsigned autosquash,
5315 struct todo_list *todo_list)
5317 char shortonto[GIT_MAX_HEXSZ + 1];
5318 const char *todo_file = rebase_path_todo();
5319 struct todo_list new_todo = TODO_LIST_INIT;
5320 struct strbuf *buf = &todo_list->buf, buf2 = STRBUF_INIT;
5321 struct object_id oid = onto->object.oid;
5322 int res;
5324 find_unique_abbrev_r(shortonto, &oid, DEFAULT_ABBREV);
5326 if (buf->len == 0) {
5327 struct todo_item *item = append_new_todo(todo_list);
5328 item->command = TODO_NOOP;
5329 item->commit = NULL;
5330 item->arg_len = item->arg_offset = item->flags = item->offset_in_buf = 0;
5333 if (autosquash && todo_list_rearrange_squash(todo_list))
5334 return -1;
5336 if (commands->nr)
5337 todo_list_add_exec_commands(todo_list, commands);
5339 if (count_commands(todo_list) == 0) {
5340 apply_autostash(rebase_path_autostash());
5341 sequencer_remove_state(opts);
5343 return error(_("nothing to do"));
5346 res = edit_todo_list(r, todo_list, &new_todo, shortrevisions,
5347 shortonto, flags);
5348 if (res == -1)
5349 return -1;
5350 else if (res == -2) {
5351 apply_autostash(rebase_path_autostash());
5352 sequencer_remove_state(opts);
5354 return -1;
5355 } else if (res == -3) {
5356 apply_autostash(rebase_path_autostash());
5357 sequencer_remove_state(opts);
5358 todo_list_release(&new_todo);
5360 return error(_("nothing to do"));
5361 } else if (res == -4) {
5362 checkout_onto(r, opts, onto_name, &onto->object.oid, orig_head);
5363 todo_list_release(&new_todo);
5365 return -1;
5368 /* Expand the commit IDs */
5369 todo_list_to_strbuf(r, &new_todo, &buf2, -1, 0);
5370 strbuf_swap(&new_todo.buf, &buf2);
5371 strbuf_release(&buf2);
5372 new_todo.total_nr -= new_todo.nr;
5373 if (todo_list_parse_insn_buffer(r, new_todo.buf.buf, &new_todo) < 0)
5374 BUG("invalid todo list after expanding IDs:\n%s",
5375 new_todo.buf.buf);
5377 if (opts->allow_ff && skip_unnecessary_picks(r, &new_todo, &oid)) {
5378 todo_list_release(&new_todo);
5379 return error(_("could not skip unnecessary pick commands"));
5382 if (todo_list_write_to_file(r, &new_todo, todo_file, NULL, NULL, -1,
5383 flags & ~(TODO_LIST_SHORTEN_IDS))) {
5384 todo_list_release(&new_todo);
5385 return error_errno(_("could not write '%s'"), todo_file);
5388 res = -1;
5390 if (opts->committer_date_is_author_date && init_committer(opts))
5391 goto cleanup;
5393 if (checkout_onto(r, opts, onto_name, &oid, orig_head))
5394 goto cleanup;
5396 if (require_clean_work_tree(r, "rebase", "", 1, 1))
5397 goto cleanup;
5399 todo_list_write_total_nr(&new_todo);
5400 res = pick_commits(r, &new_todo, opts);
5402 cleanup:
5403 todo_list_release(&new_todo);
5405 return res;
5408 struct subject2item_entry {
5409 struct hashmap_entry entry;
5410 int i;
5411 char subject[FLEX_ARRAY];
5414 static int subject2item_cmp(const void *fndata,
5415 const struct hashmap_entry *eptr,
5416 const struct hashmap_entry *entry_or_key,
5417 const void *key)
5419 const struct subject2item_entry *a, *b;
5421 a = container_of(eptr, const struct subject2item_entry, entry);
5422 b = container_of(entry_or_key, const struct subject2item_entry, entry);
5424 return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
5427 define_commit_slab(commit_todo_item, struct todo_item *);
5430 * Rearrange the todo list that has both "pick commit-id msg" and "pick
5431 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
5432 * after the former, and change "pick" to "fixup"/"squash".
5434 * Note that if the config has specified a custom instruction format, each log
5435 * message will have to be retrieved from the commit (as the oneline in the
5436 * script cannot be trusted) in order to normalize the autosquash arrangement.
5438 int todo_list_rearrange_squash(struct todo_list *todo_list)
5440 struct hashmap subject2item;
5441 int rearranged = 0, *next, *tail, i, nr = 0, alloc = 0;
5442 char **subjects;
5443 struct commit_todo_item commit_todo;
5444 struct todo_item *items = NULL;
5446 init_commit_todo_item(&commit_todo);
5448 * The hashmap maps onelines to the respective todo list index.
5450 * If any items need to be rearranged, the next[i] value will indicate
5451 * which item was moved directly after the i'th.
5453 * In that case, last[i] will indicate the index of the latest item to
5454 * be moved to appear after the i'th.
5456 hashmap_init(&subject2item, subject2item_cmp, NULL, todo_list->nr);
5457 ALLOC_ARRAY(next, todo_list->nr);
5458 ALLOC_ARRAY(tail, todo_list->nr);
5459 ALLOC_ARRAY(subjects, todo_list->nr);
5460 for (i = 0; i < todo_list->nr; i++) {
5461 struct strbuf buf = STRBUF_INIT;
5462 struct todo_item *item = todo_list->items + i;
5463 const char *commit_buffer, *subject, *p;
5464 size_t subject_len;
5465 int i2 = -1;
5466 struct subject2item_entry *entry;
5468 next[i] = tail[i] = -1;
5469 if (!item->commit || item->command == TODO_DROP) {
5470 subjects[i] = NULL;
5471 continue;
5474 if (is_fixup(item->command)) {
5475 clear_commit_todo_item(&commit_todo);
5476 return error(_("the script was already rearranged."));
5479 *commit_todo_item_at(&commit_todo, item->commit) = item;
5481 parse_commit(item->commit);
5482 commit_buffer = logmsg_reencode(item->commit, NULL, "UTF-8");
5483 find_commit_subject(commit_buffer, &subject);
5484 format_subject(&buf, subject, " ");
5485 subject = subjects[i] = strbuf_detach(&buf, &subject_len);
5486 unuse_commit_buffer(item->commit, commit_buffer);
5487 if ((skip_prefix(subject, "fixup! ", &p) ||
5488 skip_prefix(subject, "squash! ", &p))) {
5489 struct commit *commit2;
5491 for (;;) {
5492 while (isspace(*p))
5493 p++;
5494 if (!skip_prefix(p, "fixup! ", &p) &&
5495 !skip_prefix(p, "squash! ", &p))
5496 break;
5499 entry = hashmap_get_entry_from_hash(&subject2item,
5500 strhash(p), p,
5501 struct subject2item_entry,
5502 entry);
5503 if (entry)
5504 /* found by title */
5505 i2 = entry->i;
5506 else if (!strchr(p, ' ') &&
5507 (commit2 =
5508 lookup_commit_reference_by_name(p)) &&
5509 *commit_todo_item_at(&commit_todo, commit2))
5510 /* found by commit name */
5511 i2 = *commit_todo_item_at(&commit_todo, commit2)
5512 - todo_list->items;
5513 else {
5514 /* copy can be a prefix of the commit subject */
5515 for (i2 = 0; i2 < i; i2++)
5516 if (subjects[i2] &&
5517 starts_with(subjects[i2], p))
5518 break;
5519 if (i2 == i)
5520 i2 = -1;
5523 if (i2 >= 0) {
5524 rearranged = 1;
5525 todo_list->items[i].command =
5526 starts_with(subject, "fixup!") ?
5527 TODO_FIXUP : TODO_SQUASH;
5528 if (tail[i2] < 0) {
5529 next[i] = next[i2];
5530 next[i2] = i;
5531 } else {
5532 next[i] = next[tail[i2]];
5533 next[tail[i2]] = i;
5535 tail[i2] = i;
5536 } else if (!hashmap_get_from_hash(&subject2item,
5537 strhash(subject), subject)) {
5538 FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
5539 entry->i = i;
5540 hashmap_entry_init(&entry->entry,
5541 strhash(entry->subject));
5542 hashmap_put(&subject2item, &entry->entry);
5546 if (rearranged) {
5547 for (i = 0; i < todo_list->nr; i++) {
5548 enum todo_command command = todo_list->items[i].command;
5549 int cur = i;
5552 * Initially, all commands are 'pick's. If it is a
5553 * fixup or a squash now, we have rearranged it.
5555 if (is_fixup(command))
5556 continue;
5558 while (cur >= 0) {
5559 ALLOC_GROW(items, nr + 1, alloc);
5560 items[nr++] = todo_list->items[cur];
5561 cur = next[cur];
5565 FREE_AND_NULL(todo_list->items);
5566 todo_list->items = items;
5567 todo_list->nr = nr;
5568 todo_list->alloc = alloc;
5571 free(next);
5572 free(tail);
5573 for (i = 0; i < todo_list->nr; i++)
5574 free(subjects[i]);
5575 free(subjects);
5576 hashmap_free_entries(&subject2item, struct subject2item_entry, entry);
5578 clear_commit_todo_item(&commit_todo);
5580 return 0;
5583 int sequencer_determine_whence(struct repository *r, enum commit_whence *whence)
5585 if (refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD")) {
5586 struct object_id cherry_pick_head, rebase_head;
5588 if (file_exists(git_path_seq_dir()))
5589 *whence = FROM_CHERRY_PICK_MULTI;
5590 if (file_exists(rebase_path()) &&
5591 !get_oid("REBASE_HEAD", &rebase_head) &&
5592 !get_oid("CHERRY_PICK_HEAD", &cherry_pick_head) &&
5593 oideq(&rebase_head, &cherry_pick_head))
5594 *whence = FROM_REBASE_PICK;
5595 else
5596 *whence = FROM_CHERRY_PICK_SINGLE;
5598 return 1;
5601 return 0;