t6018-rev-list-glob: fix 'empty stdin' test
[git/debian.git] / sequencer.c
blob16c1411054ab16a677b323bee035ef27a9005d18
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 "argv-array.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"
34 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
36 const char sign_off_header[] = "Signed-off-by: ";
37 static const char cherry_picked_prefix[] = "(cherry picked from commit ";
39 GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
41 GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
43 static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
44 static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
45 static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
46 static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
48 static GIT_PATH_FUNC(rebase_path, "rebase-merge")
50 * The file containing rebase commands, comments, and empty lines.
51 * This file is created by "git rebase -i" then edited by the user. As
52 * the lines are processed, they are removed from the front of this
53 * file and written to the tail of 'done'.
55 static GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
57 * The rebase command lines that have already been processed. A line
58 * is moved here when it is first handled, before any associated user
59 * actions.
61 static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
63 * The file to keep track of how many commands were already processed (e.g.
64 * for the prompt).
66 static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum")
68 * The file to keep track of how many commands are to be processed in total
69 * (e.g. for the prompt).
71 static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end")
73 * The commit message that is planned to be used for any changes that
74 * need to be committed following a user interaction.
76 static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
78 * The file into which is accumulated the suggested commit message for
79 * squash/fixup commands. When the first of a series of squash/fixups
80 * is seen, the file is created and the commit message from the
81 * previous commit and from the first squash/fixup commit are written
82 * to it. The commit message for each subsequent squash/fixup commit
83 * is appended to the file as it is processed.
85 static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
87 * If the current series of squash/fixups has not yet included a squash
88 * command, then this file exists and holds the commit message of the
89 * original "pick" commit. (If the series ends without a "squash"
90 * command, then this can be used as the commit message of the combined
91 * commit without opening the editor.)
93 static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
95 * This file contains the list fixup/squash commands that have been
96 * accumulated into message-fixup or message-squash so far.
98 static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")
100 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
101 * GIT_AUTHOR_DATE that will be used for the commit that is currently
102 * being rebased.
104 static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
106 * When an "edit" rebase command is being processed, the SHA1 of the
107 * commit to be edited is recorded in this file. When "git rebase
108 * --continue" is executed, if there are any staged changes then they
109 * will be amended to the HEAD commit, but only provided the HEAD
110 * commit is still the commit to be edited. When any other rebase
111 * command is processed, this file is deleted.
113 static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
115 * When we stop at a given patch via the "edit" command, this file contains
116 * the abbreviated commit name of the corresponding patch.
118 static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
120 * For the post-rewrite hook, we make a list of rewritten commits and
121 * their new sha1s. The rewritten-pending list keeps the sha1s of
122 * commits that have been processed, but not committed yet,
123 * e.g. because they are waiting for a 'squash' command.
125 static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
126 static GIT_PATH_FUNC(rebase_path_rewritten_pending,
127 "rebase-merge/rewritten-pending")
130 * The path of the file containig the OID of the "squash onto" commit, i.e.
131 * the dummy commit used for `reset [new root]`.
133 static GIT_PATH_FUNC(rebase_path_squash_onto, "rebase-merge/squash-onto")
136 * The path of the file listing refs that need to be deleted after the rebase
137 * finishes. This is used by the `label` command to record the need for cleanup.
139 static GIT_PATH_FUNC(rebase_path_refs_to_delete, "rebase-merge/refs-to-delete")
142 * The following files are written by git-rebase just after parsing the
143 * command-line (and are only consumed, not modified, by the sequencer).
145 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
146 static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
147 static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
148 static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")
149 static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
150 static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
151 static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
152 static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
153 static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
154 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
156 static int git_sequencer_config(const char *k, const char *v, void *cb)
158 struct replay_opts *opts = cb;
159 int status;
161 if (!strcmp(k, "commit.cleanup")) {
162 const char *s;
164 status = git_config_string(&s, k, v);
165 if (status)
166 return status;
168 if (!strcmp(s, "verbatim"))
169 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
170 else if (!strcmp(s, "whitespace"))
171 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
172 else if (!strcmp(s, "strip"))
173 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
174 else if (!strcmp(s, "scissors"))
175 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
176 else
177 warning(_("invalid commit message cleanup mode '%s'"),
180 free((char *)s);
181 return status;
184 if (!strcmp(k, "commit.gpgsign")) {
185 opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
186 return 0;
189 status = git_gpg_config(k, v, NULL);
190 if (status)
191 return status;
193 return git_diff_basic_config(k, v, NULL);
196 void sequencer_init_config(struct replay_opts *opts)
198 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
199 git_config(git_sequencer_config, opts);
202 static inline int is_rebase_i(const struct replay_opts *opts)
204 return opts->action == REPLAY_INTERACTIVE_REBASE;
207 static const char *get_dir(const struct replay_opts *opts)
209 if (is_rebase_i(opts))
210 return rebase_path();
211 return git_path_seq_dir();
214 static const char *get_todo_path(const struct replay_opts *opts)
216 if (is_rebase_i(opts))
217 return rebase_path_todo();
218 return git_path_todo_file();
222 * Returns 0 for non-conforming footer
223 * Returns 1 for conforming footer
224 * Returns 2 when sob exists within conforming footer
225 * Returns 3 when sob exists within conforming footer as last entry
227 static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
228 int ignore_footer)
230 struct trailer_info info;
231 int i;
232 int found_sob = 0, found_sob_last = 0;
234 trailer_info_get(&info, sb->buf);
236 if (info.trailer_start == info.trailer_end)
237 return 0;
239 for (i = 0; i < info.trailer_nr; i++)
240 if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
241 found_sob = 1;
242 if (i == info.trailer_nr - 1)
243 found_sob_last = 1;
246 trailer_info_release(&info);
248 if (found_sob_last)
249 return 3;
250 if (found_sob)
251 return 2;
252 return 1;
255 static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
257 static struct strbuf buf = STRBUF_INIT;
259 strbuf_reset(&buf);
260 if (opts->gpg_sign)
261 sq_quotef(&buf, "-S%s", opts->gpg_sign);
262 return buf.buf;
265 int sequencer_remove_state(struct replay_opts *opts)
267 struct strbuf buf = STRBUF_INIT;
268 int i;
270 if (is_rebase_i(opts) &&
271 strbuf_read_file(&buf, rebase_path_refs_to_delete(), 0) > 0) {
272 char *p = buf.buf;
273 while (*p) {
274 char *eol = strchr(p, '\n');
275 if (eol)
276 *eol = '\0';
277 if (delete_ref("(rebase -i) cleanup", p, NULL, 0) < 0)
278 warning(_("could not delete '%s'"), p);
279 if (!eol)
280 break;
281 p = eol + 1;
285 free(opts->gpg_sign);
286 free(opts->strategy);
287 for (i = 0; i < opts->xopts_nr; i++)
288 free(opts->xopts[i]);
289 free(opts->xopts);
290 strbuf_release(&opts->current_fixups);
292 strbuf_reset(&buf);
293 strbuf_addstr(&buf, get_dir(opts));
294 remove_dir_recursively(&buf, 0);
295 strbuf_release(&buf);
297 return 0;
300 static const char *action_name(const struct replay_opts *opts)
302 switch (opts->action) {
303 case REPLAY_REVERT:
304 return N_("revert");
305 case REPLAY_PICK:
306 return N_("cherry-pick");
307 case REPLAY_INTERACTIVE_REBASE:
308 return N_("rebase -i");
310 die(_("Unknown action: %d"), opts->action);
313 struct commit_message {
314 char *parent_label;
315 char *label;
316 char *subject;
317 const char *message;
320 static const char *short_commit_name(struct commit *commit)
322 return find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV);
325 static int get_message(struct commit *commit, struct commit_message *out)
327 const char *abbrev, *subject;
328 int subject_len;
330 out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
331 abbrev = short_commit_name(commit);
333 subject_len = find_commit_subject(out->message, &subject);
335 out->subject = xmemdupz(subject, subject_len);
336 out->label = xstrfmt("%s... %s", abbrev, out->subject);
337 out->parent_label = xstrfmt("parent of %s", out->label);
339 return 0;
342 static void free_message(struct commit *commit, struct commit_message *msg)
344 free(msg->parent_label);
345 free(msg->label);
346 free(msg->subject);
347 unuse_commit_buffer(commit, msg->message);
350 static void print_advice(int show_hint, struct replay_opts *opts)
352 char *msg = getenv("GIT_CHERRY_PICK_HELP");
354 if (msg) {
355 fprintf(stderr, "%s\n", msg);
357 * A conflict has occurred but the porcelain
358 * (typically rebase --interactive) wants to take care
359 * of the commit itself so remove CHERRY_PICK_HEAD
361 unlink(git_path_cherry_pick_head(the_repository));
362 return;
365 if (show_hint) {
366 if (opts->no_commit)
367 advise(_("after resolving the conflicts, mark the corrected paths\n"
368 "with 'git add <paths>' or 'git rm <paths>'"));
369 else
370 advise(_("after resolving the conflicts, mark the corrected paths\n"
371 "with 'git add <paths>' or 'git rm <paths>'\n"
372 "and commit the result with 'git commit'"));
376 static int write_message(const void *buf, size_t len, const char *filename,
377 int append_eol)
379 struct lock_file msg_file = LOCK_INIT;
381 int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
382 if (msg_fd < 0)
383 return error_errno(_("could not lock '%s'"), filename);
384 if (write_in_full(msg_fd, buf, len) < 0) {
385 error_errno(_("could not write to '%s'"), filename);
386 rollback_lock_file(&msg_file);
387 return -1;
389 if (append_eol && write(msg_fd, "\n", 1) < 0) {
390 error_errno(_("could not write eol to '%s'"), filename);
391 rollback_lock_file(&msg_file);
392 return -1;
394 if (commit_lock_file(&msg_file) < 0)
395 return error(_("failed to finalize '%s'"), filename);
397 return 0;
401 * Reads a file that was presumably written by a shell script, i.e. with an
402 * end-of-line marker that needs to be stripped.
404 * Note that only the last end-of-line marker is stripped, consistent with the
405 * behavior of "$(cat path)" in a shell script.
407 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
409 static int read_oneliner(struct strbuf *buf,
410 const char *path, int skip_if_empty)
412 int orig_len = buf->len;
414 if (!file_exists(path))
415 return 0;
417 if (strbuf_read_file(buf, path, 0) < 0) {
418 warning_errno(_("could not read '%s'"), path);
419 return 0;
422 if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
423 if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
424 --buf->len;
425 buf->buf[buf->len] = '\0';
428 if (skip_if_empty && buf->len == orig_len)
429 return 0;
431 return 1;
434 static struct tree *empty_tree(void)
436 return lookup_tree(the_hash_algo->empty_tree);
439 static int error_dirty_index(struct replay_opts *opts)
441 if (read_cache_unmerged())
442 return error_resolve_conflict(_(action_name(opts)));
444 error(_("your local changes would be overwritten by %s."),
445 _(action_name(opts)));
447 if (advice_commit_before_merge)
448 advise(_("commit your changes or stash them to proceed."));
449 return -1;
452 static void update_abort_safety_file(void)
454 struct object_id head;
456 /* Do nothing on a single-pick */
457 if (!file_exists(git_path_seq_dir()))
458 return;
460 if (!get_oid("HEAD", &head))
461 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
462 else
463 write_file(git_path_abort_safety_file(), "%s", "");
466 static int fast_forward_to(const struct object_id *to, const struct object_id *from,
467 int unborn, struct replay_opts *opts)
469 struct ref_transaction *transaction;
470 struct strbuf sb = STRBUF_INIT;
471 struct strbuf err = STRBUF_INIT;
473 read_cache();
474 if (checkout_fast_forward(from, to, 1))
475 return -1; /* the callee should have complained already */
477 strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
479 transaction = ref_transaction_begin(&err);
480 if (!transaction ||
481 ref_transaction_update(transaction, "HEAD",
482 to, unborn && !is_rebase_i(opts) ?
483 &null_oid : from,
484 0, sb.buf, &err) ||
485 ref_transaction_commit(transaction, &err)) {
486 ref_transaction_free(transaction);
487 error("%s", err.buf);
488 strbuf_release(&sb);
489 strbuf_release(&err);
490 return -1;
493 strbuf_release(&sb);
494 strbuf_release(&err);
495 ref_transaction_free(transaction);
496 update_abort_safety_file();
497 return 0;
500 void append_conflicts_hint(struct strbuf *msgbuf)
502 int i;
504 strbuf_addch(msgbuf, '\n');
505 strbuf_commented_addf(msgbuf, "Conflicts:\n");
506 for (i = 0; i < active_nr;) {
507 const struct cache_entry *ce = active_cache[i++];
508 if (ce_stage(ce)) {
509 strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
510 while (i < active_nr && !strcmp(ce->name,
511 active_cache[i]->name))
512 i++;
517 static int do_recursive_merge(struct commit *base, struct commit *next,
518 const char *base_label, const char *next_label,
519 struct object_id *head, struct strbuf *msgbuf,
520 struct replay_opts *opts)
522 struct merge_options o;
523 struct tree *result, *next_tree, *base_tree, *head_tree;
524 int clean;
525 char **xopt;
526 struct lock_file index_lock = LOCK_INIT;
528 if (hold_locked_index(&index_lock, LOCK_REPORT_ON_ERROR) < 0)
529 return -1;
531 read_cache();
533 init_merge_options(&o);
534 o.ancestor = base ? base_label : "(empty tree)";
535 o.branch1 = "HEAD";
536 o.branch2 = next ? next_label : "(empty tree)";
537 if (is_rebase_i(opts))
538 o.buffer_output = 2;
539 o.show_rename_progress = 1;
541 head_tree = parse_tree_indirect(head);
542 next_tree = next ? get_commit_tree(next) : empty_tree();
543 base_tree = base ? get_commit_tree(base) : empty_tree();
545 for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)
546 parse_merge_opt(&o, *xopt);
548 clean = merge_trees(&o,
549 head_tree,
550 next_tree, base_tree, &result);
551 if (is_rebase_i(opts) && clean <= 0)
552 fputs(o.obuf.buf, stdout);
553 strbuf_release(&o.obuf);
554 diff_warn_rename_limit("merge.renamelimit", o.needed_rename_limit, 0);
555 if (clean < 0) {
556 rollback_lock_file(&index_lock);
557 return clean;
560 if (write_locked_index(&the_index, &index_lock,
561 COMMIT_LOCK | SKIP_IF_UNCHANGED))
563 * TRANSLATORS: %s will be "revert", "cherry-pick" or
564 * "rebase -i".
566 return error(_("%s: Unable to write new index file"),
567 _(action_name(opts)));
569 if (!clean)
570 append_conflicts_hint(msgbuf);
572 return !clean;
575 static struct object_id *get_cache_tree_oid(void)
577 if (!active_cache_tree)
578 active_cache_tree = cache_tree();
580 if (!cache_tree_fully_valid(active_cache_tree))
581 if (cache_tree_update(&the_index, 0)) {
582 error(_("unable to update cache tree"));
583 return NULL;
586 return &active_cache_tree->oid;
589 static int is_index_unchanged(void)
591 struct object_id head_oid, *cache_tree_oid;
592 struct commit *head_commit;
594 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
595 return error(_("could not resolve HEAD commit"));
597 head_commit = lookup_commit(&head_oid);
600 * If head_commit is NULL, check_commit, called from
601 * lookup_commit, would have indicated that head_commit is not
602 * a commit object already. parse_commit() will return failure
603 * without further complaints in such a case. Otherwise, if
604 * the commit is invalid, parse_commit() will complain. So
605 * there is nothing for us to say here. Just return failure.
607 if (parse_commit(head_commit))
608 return -1;
610 if (!(cache_tree_oid = get_cache_tree_oid()))
611 return -1;
613 return !oidcmp(cache_tree_oid, get_commit_tree_oid(head_commit));
616 static int write_author_script(const char *message)
618 struct strbuf buf = STRBUF_INIT;
619 const char *eol;
620 int res;
622 for (;;)
623 if (!*message || starts_with(message, "\n")) {
624 missing_author:
625 /* Missing 'author' line? */
626 unlink(rebase_path_author_script());
627 return 0;
628 } else if (skip_prefix(message, "author ", &message))
629 break;
630 else if ((eol = strchr(message, '\n')))
631 message = eol + 1;
632 else
633 goto missing_author;
635 strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
636 while (*message && *message != '\n' && *message != '\r')
637 if (skip_prefix(message, " <", &message))
638 break;
639 else if (*message != '\'')
640 strbuf_addch(&buf, *(message++));
641 else
642 strbuf_addf(&buf, "'\\\\%c'", *(message++));
643 strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
644 while (*message && *message != '\n' && *message != '\r')
645 if (skip_prefix(message, "> ", &message))
646 break;
647 else if (*message != '\'')
648 strbuf_addch(&buf, *(message++));
649 else
650 strbuf_addf(&buf, "'\\\\%c'", *(message++));
651 strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
652 while (*message && *message != '\n' && *message != '\r')
653 if (*message != '\'')
654 strbuf_addch(&buf, *(message++));
655 else
656 strbuf_addf(&buf, "'\\\\%c'", *(message++));
657 res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
658 strbuf_release(&buf);
659 return res;
663 * Read a list of environment variable assignments (such as the author-script
664 * file) into an environment block. Returns -1 on error, 0 otherwise.
666 static int read_env_script(struct argv_array *env)
668 struct strbuf script = STRBUF_INIT;
669 int i, count = 0;
670 char *p, *p2;
672 if (strbuf_read_file(&script, rebase_path_author_script(), 256) <= 0)
673 return -1;
675 for (p = script.buf; *p; p++)
676 if (skip_prefix(p, "'\\\\''", (const char **)&p2))
677 strbuf_splice(&script, p - script.buf, p2 - p, "'", 1);
678 else if (*p == '\'')
679 strbuf_splice(&script, p-- - script.buf, 1, "", 0);
680 else if (*p == '\n') {
681 *p = '\0';
682 count++;
685 for (i = 0, p = script.buf; i < count; i++) {
686 argv_array_push(env, p);
687 p += strlen(p) + 1;
690 return 0;
693 static char *get_author(const char *message)
695 size_t len;
696 const char *a;
698 a = find_commit_header(message, "author", &len);
699 if (a)
700 return xmemdupz(a, len);
702 return NULL;
705 /* Read author-script and return an ident line (author <email> timestamp) */
706 static const char *read_author_ident(struct strbuf *buf)
708 const char *keys[] = {
709 "GIT_AUTHOR_NAME=", "GIT_AUTHOR_EMAIL=", "GIT_AUTHOR_DATE="
711 char *in, *out, *eol;
712 int i = 0, len;
714 if (strbuf_read_file(buf, rebase_path_author_script(), 256) <= 0)
715 return NULL;
717 /* dequote values and construct ident line in-place */
718 for (in = out = buf->buf; i < 3 && in - buf->buf < buf->len; i++) {
719 if (!skip_prefix(in, keys[i], (const char **)&in)) {
720 warning("could not parse '%s' (looking for '%s'",
721 rebase_path_author_script(), keys[i]);
722 return NULL;
725 eol = strchrnul(in, '\n');
726 *eol = '\0';
727 sq_dequote(in);
728 len = strlen(in);
730 if (i > 0) /* separate values by spaces */
731 *(out++) = ' ';
732 if (i == 1) /* email needs to be surrounded by <...> */
733 *(out++) = '<';
734 memmove(out, in, len);
735 out += len;
736 if (i == 1) /* email needs to be surrounded by <...> */
737 *(out++) = '>';
738 in = eol + 1;
741 if (i < 3) {
742 warning("could not parse '%s' (looking for '%s')",
743 rebase_path_author_script(), keys[i]);
744 return NULL;
747 buf->len = out - buf->buf;
748 return buf->buf;
751 static const char staged_changes_advice[] =
752 N_("you have staged changes in your working tree\n"
753 "If these changes are meant to be squashed into the previous commit, run:\n"
754 "\n"
755 " git commit --amend %s\n"
756 "\n"
757 "If they are meant to go into a new commit, run:\n"
758 "\n"
759 " git commit %s\n"
760 "\n"
761 "In both cases, once you're done, continue with:\n"
762 "\n"
763 " git rebase --continue\n");
765 #define ALLOW_EMPTY (1<<0)
766 #define EDIT_MSG (1<<1)
767 #define AMEND_MSG (1<<2)
768 #define CLEANUP_MSG (1<<3)
769 #define VERIFY_MSG (1<<4)
770 #define CREATE_ROOT_COMMIT (1<<5)
773 * If we are cherry-pick, and if the merge did not result in
774 * hand-editing, we will hit this commit and inherit the original
775 * author date and name.
777 * If we are revert, or if our cherry-pick results in a hand merge,
778 * we had better say that the current user is responsible for that.
780 * An exception is when run_git_commit() is called during an
781 * interactive rebase: in that case, we will want to retain the
782 * author metadata.
784 static int run_git_commit(const char *defmsg, struct replay_opts *opts,
785 unsigned int flags)
787 struct child_process cmd = CHILD_PROCESS_INIT;
788 const char *value;
790 if ((flags & CREATE_ROOT_COMMIT) && !(flags & AMEND_MSG)) {
791 struct strbuf msg = STRBUF_INIT, script = STRBUF_INIT;
792 const char *author = is_rebase_i(opts) ?
793 read_author_ident(&script) : NULL;
794 struct object_id root_commit, *cache_tree_oid;
795 int res = 0;
797 if (!defmsg)
798 BUG("root commit without message");
800 if (!(cache_tree_oid = get_cache_tree_oid()))
801 res = -1;
803 if (!res)
804 res = strbuf_read_file(&msg, defmsg, 0);
806 if (res <= 0)
807 res = error_errno(_("could not read '%s'"), defmsg);
808 else
809 res = commit_tree(msg.buf, msg.len, cache_tree_oid,
810 NULL, &root_commit, author,
811 opts->gpg_sign);
813 strbuf_release(&msg);
814 strbuf_release(&script);
815 if (!res) {
816 update_ref(NULL, "CHERRY_PICK_HEAD", &root_commit, NULL,
817 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR);
818 res = update_ref(NULL, "HEAD", &root_commit, NULL, 0,
819 UPDATE_REFS_MSG_ON_ERR);
821 return res < 0 ? error(_("writing root commit")) : 0;
824 cmd.git_cmd = 1;
826 if (is_rebase_i(opts)) {
827 if (!(flags & EDIT_MSG)) {
828 cmd.stdout_to_stderr = 1;
829 cmd.err = -1;
832 if (read_env_script(&cmd.env_array)) {
833 const char *gpg_opt = gpg_sign_opt_quoted(opts);
835 return error(_(staged_changes_advice),
836 gpg_opt, gpg_opt);
840 argv_array_push(&cmd.args, "commit");
842 if (!(flags & VERIFY_MSG))
843 argv_array_push(&cmd.args, "-n");
844 if ((flags & AMEND_MSG))
845 argv_array_push(&cmd.args, "--amend");
846 if (opts->gpg_sign)
847 argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
848 if (defmsg)
849 argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
850 else if (!(flags & EDIT_MSG))
851 argv_array_pushl(&cmd.args, "-C", "HEAD", NULL);
852 if ((flags & CLEANUP_MSG))
853 argv_array_push(&cmd.args, "--cleanup=strip");
854 if ((flags & EDIT_MSG))
855 argv_array_push(&cmd.args, "-e");
856 else if (!(flags & CLEANUP_MSG) &&
857 !opts->signoff && !opts->record_origin &&
858 git_config_get_value("commit.cleanup", &value))
859 argv_array_push(&cmd.args, "--cleanup=verbatim");
861 if ((flags & ALLOW_EMPTY))
862 argv_array_push(&cmd.args, "--allow-empty");
864 if (opts->allow_empty_message)
865 argv_array_push(&cmd.args, "--allow-empty-message");
867 if (cmd.err == -1) {
868 /* hide stderr on success */
869 struct strbuf buf = STRBUF_INIT;
870 int rc = pipe_command(&cmd,
871 NULL, 0,
872 /* stdout is already redirected */
873 NULL, 0,
874 &buf, 0);
875 if (rc)
876 fputs(buf.buf, stderr);
877 strbuf_release(&buf);
878 return rc;
881 return run_command(&cmd);
884 static int rest_is_empty(const struct strbuf *sb, int start)
886 int i, eol;
887 const char *nl;
889 /* Check if the rest is just whitespace and Signed-off-by's. */
890 for (i = start; i < sb->len; i++) {
891 nl = memchr(sb->buf + i, '\n', sb->len - i);
892 if (nl)
893 eol = nl - sb->buf;
894 else
895 eol = sb->len;
897 if (strlen(sign_off_header) <= eol - i &&
898 starts_with(sb->buf + i, sign_off_header)) {
899 i = eol;
900 continue;
902 while (i < eol)
903 if (!isspace(sb->buf[i++]))
904 return 0;
907 return 1;
911 * Find out if the message in the strbuf contains only whitespace and
912 * Signed-off-by lines.
914 int message_is_empty(const struct strbuf *sb,
915 enum commit_msg_cleanup_mode cleanup_mode)
917 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
918 return 0;
919 return rest_is_empty(sb, 0);
923 * See if the user edited the message in the editor or left what
924 * was in the template intact
926 int template_untouched(const struct strbuf *sb, const char *template_file,
927 enum commit_msg_cleanup_mode cleanup_mode)
929 struct strbuf tmpl = STRBUF_INIT;
930 const char *start;
932 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
933 return 0;
935 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
936 return 0;
938 strbuf_stripspace(&tmpl, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
939 if (!skip_prefix(sb->buf, tmpl.buf, &start))
940 start = sb->buf;
941 strbuf_release(&tmpl);
942 return rest_is_empty(sb, start - sb->buf);
945 int update_head_with_reflog(const struct commit *old_head,
946 const struct object_id *new_head,
947 const char *action, const struct strbuf *msg,
948 struct strbuf *err)
950 struct ref_transaction *transaction;
951 struct strbuf sb = STRBUF_INIT;
952 const char *nl;
953 int ret = 0;
955 if (action) {
956 strbuf_addstr(&sb, action);
957 strbuf_addstr(&sb, ": ");
960 nl = strchr(msg->buf, '\n');
961 if (nl) {
962 strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
963 } else {
964 strbuf_addbuf(&sb, msg);
965 strbuf_addch(&sb, '\n');
968 transaction = ref_transaction_begin(err);
969 if (!transaction ||
970 ref_transaction_update(transaction, "HEAD", new_head,
971 old_head ? &old_head->object.oid : &null_oid,
972 0, sb.buf, err) ||
973 ref_transaction_commit(transaction, err)) {
974 ret = -1;
976 ref_transaction_free(transaction);
977 strbuf_release(&sb);
979 return ret;
982 static int run_rewrite_hook(const struct object_id *oldoid,
983 const struct object_id *newoid)
985 struct child_process proc = CHILD_PROCESS_INIT;
986 const char *argv[3];
987 int code;
988 struct strbuf sb = STRBUF_INIT;
990 argv[0] = find_hook("post-rewrite");
991 if (!argv[0])
992 return 0;
994 argv[1] = "amend";
995 argv[2] = NULL;
997 proc.argv = argv;
998 proc.in = -1;
999 proc.stdout_to_stderr = 1;
1001 code = start_command(&proc);
1002 if (code)
1003 return code;
1004 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1005 sigchain_push(SIGPIPE, SIG_IGN);
1006 write_in_full(proc.in, sb.buf, sb.len);
1007 close(proc.in);
1008 strbuf_release(&sb);
1009 sigchain_pop(SIGPIPE);
1010 return finish_command(&proc);
1013 void commit_post_rewrite(const struct commit *old_head,
1014 const struct object_id *new_head)
1016 struct notes_rewrite_cfg *cfg;
1018 cfg = init_copy_notes_for_rewrite("amend");
1019 if (cfg) {
1020 /* we are amending, so old_head is not NULL */
1021 copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
1022 finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
1024 run_rewrite_hook(&old_head->object.oid, new_head);
1027 static int run_prepare_commit_msg_hook(struct strbuf *msg, const char *commit)
1029 struct argv_array hook_env = ARGV_ARRAY_INIT;
1030 int ret;
1031 const char *name;
1033 name = git_path_commit_editmsg();
1034 if (write_message(msg->buf, msg->len, name, 0))
1035 return -1;
1037 argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", get_index_file());
1038 argv_array_push(&hook_env, "GIT_EDITOR=:");
1039 if (commit)
1040 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1041 "commit", commit, NULL);
1042 else
1043 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1044 "message", NULL);
1045 if (ret)
1046 ret = error(_("'prepare-commit-msg' hook failed"));
1047 argv_array_clear(&hook_env);
1049 return ret;
1052 static const char implicit_ident_advice_noconfig[] =
1053 N_("Your name and email address were configured automatically based\n"
1054 "on your username and hostname. Please check that they are accurate.\n"
1055 "You can suppress this message by setting them explicitly. Run the\n"
1056 "following command and follow the instructions in your editor to edit\n"
1057 "your configuration file:\n"
1058 "\n"
1059 " git config --global --edit\n"
1060 "\n"
1061 "After doing this, you may fix the identity used for this commit with:\n"
1062 "\n"
1063 " git commit --amend --reset-author\n");
1065 static const char implicit_ident_advice_config[] =
1066 N_("Your name and email address were configured automatically based\n"
1067 "on your username and hostname. Please check that they are accurate.\n"
1068 "You can suppress this message by setting them explicitly:\n"
1069 "\n"
1070 " git config --global user.name \"Your Name\"\n"
1071 " git config --global user.email you@example.com\n"
1072 "\n"
1073 "After doing this, you may fix the identity used for this commit with:\n"
1074 "\n"
1075 " git commit --amend --reset-author\n");
1077 static const char *implicit_ident_advice(void)
1079 char *user_config = expand_user_path("~/.gitconfig", 0);
1080 char *xdg_config = xdg_config_home("config");
1081 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1083 free(user_config);
1084 free(xdg_config);
1086 if (config_exists)
1087 return _(implicit_ident_advice_config);
1088 else
1089 return _(implicit_ident_advice_noconfig);
1093 void print_commit_summary(const char *prefix, const struct object_id *oid,
1094 unsigned int flags)
1096 struct rev_info rev;
1097 struct commit *commit;
1098 struct strbuf format = STRBUF_INIT;
1099 const char *head;
1100 struct pretty_print_context pctx = {0};
1101 struct strbuf author_ident = STRBUF_INIT;
1102 struct strbuf committer_ident = STRBUF_INIT;
1104 commit = lookup_commit(oid);
1105 if (!commit)
1106 die(_("couldn't look up newly created commit"));
1107 if (parse_commit(commit))
1108 die(_("could not parse newly created commit"));
1110 strbuf_addstr(&format, "format:%h] %s");
1112 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1113 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1114 if (strbuf_cmp(&author_ident, &committer_ident)) {
1115 strbuf_addstr(&format, "\n Author: ");
1116 strbuf_addbuf_percentquote(&format, &author_ident);
1118 if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
1119 struct strbuf date = STRBUF_INIT;
1121 format_commit_message(commit, "%ad", &date, &pctx);
1122 strbuf_addstr(&format, "\n Date: ");
1123 strbuf_addbuf_percentquote(&format, &date);
1124 strbuf_release(&date);
1126 if (!committer_ident_sufficiently_given()) {
1127 strbuf_addstr(&format, "\n Committer: ");
1128 strbuf_addbuf_percentquote(&format, &committer_ident);
1129 if (advice_implicit_identity) {
1130 strbuf_addch(&format, '\n');
1131 strbuf_addstr(&format, implicit_ident_advice());
1134 strbuf_release(&author_ident);
1135 strbuf_release(&committer_ident);
1137 init_revisions(&rev, prefix);
1138 setup_revisions(0, NULL, &rev, NULL);
1140 rev.diff = 1;
1141 rev.diffopt.output_format =
1142 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1144 rev.verbose_header = 1;
1145 rev.show_root_diff = 1;
1146 get_commit_format(format.buf, &rev);
1147 rev.always_show_header = 0;
1148 rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1149 rev.diffopt.break_opt = 0;
1150 diff_setup_done(&rev.diffopt);
1152 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1153 if (!head)
1154 die_errno(_("unable to resolve HEAD after creating commit"));
1155 if (!strcmp(head, "HEAD"))
1156 head = _("detached HEAD");
1157 else
1158 skip_prefix(head, "refs/heads/", &head);
1159 printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1160 _(" (root-commit)") : "");
1162 if (!log_tree_commit(&rev, commit)) {
1163 rev.always_show_header = 1;
1164 rev.use_terminator = 1;
1165 log_tree_commit(&rev, commit);
1168 strbuf_release(&format);
1171 static int parse_head(struct commit **head)
1173 struct commit *current_head;
1174 struct object_id oid;
1176 if (get_oid("HEAD", &oid)) {
1177 current_head = NULL;
1178 } else {
1179 current_head = lookup_commit_reference(&oid);
1180 if (!current_head)
1181 return error(_("could not parse HEAD"));
1182 if (oidcmp(&oid, &current_head->object.oid)) {
1183 warning(_("HEAD %s is not a commit!"),
1184 oid_to_hex(&oid));
1186 if (parse_commit(current_head))
1187 return error(_("could not parse HEAD commit"));
1189 *head = current_head;
1191 return 0;
1195 * Try to commit without forking 'git commit'. In some cases we need
1196 * to run 'git commit' to display an error message
1198 * Returns:
1199 * -1 - error unable to commit
1200 * 0 - success
1201 * 1 - run 'git commit'
1203 static int try_to_commit(struct strbuf *msg, const char *author,
1204 struct replay_opts *opts, unsigned int flags,
1205 struct object_id *oid)
1207 struct object_id tree;
1208 struct commit *current_head;
1209 struct commit_list *parents = NULL;
1210 struct commit_extra_header *extra = NULL;
1211 struct strbuf err = STRBUF_INIT;
1212 struct strbuf commit_msg = STRBUF_INIT;
1213 char *amend_author = NULL;
1214 const char *hook_commit = NULL;
1215 enum commit_msg_cleanup_mode cleanup;
1216 int res = 0;
1218 if (parse_head(&current_head))
1219 return -1;
1221 if (flags & AMEND_MSG) {
1222 const char *exclude_gpgsig[] = { "gpgsig", NULL };
1223 const char *out_enc = get_commit_output_encoding();
1224 const char *message = logmsg_reencode(current_head, NULL,
1225 out_enc);
1227 if (!msg) {
1228 const char *orig_message = NULL;
1230 find_commit_subject(message, &orig_message);
1231 msg = &commit_msg;
1232 strbuf_addstr(msg, orig_message);
1233 hook_commit = "HEAD";
1235 author = amend_author = get_author(message);
1236 unuse_commit_buffer(current_head, message);
1237 if (!author) {
1238 res = error(_("unable to parse commit author"));
1239 goto out;
1241 parents = copy_commit_list(current_head->parents);
1242 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1243 } else if (current_head) {
1244 commit_list_insert(current_head, &parents);
1247 if (write_cache_as_tree(&tree, 0, NULL)) {
1248 res = error(_("git write-tree failed to write a tree"));
1249 goto out;
1252 if (!(flags & ALLOW_EMPTY) && !oidcmp(current_head ?
1253 get_commit_tree_oid(current_head) :
1254 the_hash_algo->empty_tree, &tree)) {
1255 res = 1; /* run 'git commit' to display error message */
1256 goto out;
1259 if (find_hook("prepare-commit-msg")) {
1260 res = run_prepare_commit_msg_hook(msg, hook_commit);
1261 if (res)
1262 goto out;
1263 if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1264 2048) < 0) {
1265 res = error_errno(_("unable to read commit message "
1266 "from '%s'"),
1267 git_path_commit_editmsg());
1268 goto out;
1270 msg = &commit_msg;
1273 cleanup = (flags & CLEANUP_MSG) ? COMMIT_MSG_CLEANUP_ALL :
1274 opts->default_msg_cleanup;
1276 if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1277 strbuf_stripspace(msg, cleanup == COMMIT_MSG_CLEANUP_ALL);
1278 if (!opts->allow_empty_message && message_is_empty(msg, cleanup)) {
1279 res = 1; /* run 'git commit' to display error message */
1280 goto out;
1283 reset_ident_date();
1285 if (commit_tree_extended(msg->buf, msg->len, &tree, parents,
1286 oid, author, opts->gpg_sign, extra)) {
1287 res = error(_("failed to write commit object"));
1288 goto out;
1291 if (update_head_with_reflog(current_head, oid,
1292 getenv("GIT_REFLOG_ACTION"), msg, &err)) {
1293 res = error("%s", err.buf);
1294 goto out;
1297 if (flags & AMEND_MSG)
1298 commit_post_rewrite(current_head, oid);
1300 out:
1301 free_commit_extra_headers(extra);
1302 strbuf_release(&err);
1303 strbuf_release(&commit_msg);
1304 free(amend_author);
1306 return res;
1309 static int do_commit(const char *msg_file, const char *author,
1310 struct replay_opts *opts, unsigned int flags)
1312 int res = 1;
1314 if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG) &&
1315 !(flags & CREATE_ROOT_COMMIT)) {
1316 struct object_id oid;
1317 struct strbuf sb = STRBUF_INIT;
1319 if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1320 return error_errno(_("unable to read commit message "
1321 "from '%s'"),
1322 msg_file);
1324 res = try_to_commit(msg_file ? &sb : NULL, author, opts, flags,
1325 &oid);
1326 strbuf_release(&sb);
1327 if (!res) {
1328 unlink(git_path_cherry_pick_head(the_repository));
1329 unlink(git_path_merge_msg(the_repository));
1330 if (!is_rebase_i(opts))
1331 print_commit_summary(NULL, &oid,
1332 SUMMARY_SHOW_AUTHOR_DATE);
1333 return res;
1336 if (res == 1)
1337 return run_git_commit(msg_file, opts, flags);
1339 return res;
1342 static int is_original_commit_empty(struct commit *commit)
1344 const struct object_id *ptree_oid;
1346 if (parse_commit(commit))
1347 return error(_("could not parse commit %s"),
1348 oid_to_hex(&commit->object.oid));
1349 if (commit->parents) {
1350 struct commit *parent = commit->parents->item;
1351 if (parse_commit(parent))
1352 return error(_("could not parse parent commit %s"),
1353 oid_to_hex(&parent->object.oid));
1354 ptree_oid = get_commit_tree_oid(parent);
1355 } else {
1356 ptree_oid = the_hash_algo->empty_tree; /* commit is root */
1359 return !oidcmp(ptree_oid, get_commit_tree_oid(commit));
1363 * Do we run "git commit" with "--allow-empty"?
1365 static int allow_empty(struct replay_opts *opts, struct commit *commit)
1367 int index_unchanged, empty_commit;
1370 * Three cases:
1372 * (1) we do not allow empty at all and error out.
1374 * (2) we allow ones that were initially empty, but
1375 * forbid the ones that become empty;
1377 * (3) we allow both.
1379 if (!opts->allow_empty)
1380 return 0; /* let "git commit" barf as necessary */
1382 index_unchanged = is_index_unchanged();
1383 if (index_unchanged < 0)
1384 return index_unchanged;
1385 if (!index_unchanged)
1386 return 0; /* we do not have to say --allow-empty */
1388 if (opts->keep_redundant_commits)
1389 return 1;
1391 empty_commit = is_original_commit_empty(commit);
1392 if (empty_commit < 0)
1393 return empty_commit;
1394 if (!empty_commit)
1395 return 0;
1396 else
1397 return 1;
1401 * Note that ordering matters in this enum. Not only must it match the mapping
1402 * below, it is also divided into several sections that matter. When adding
1403 * new commands, make sure you add it in the right section.
1405 enum todo_command {
1406 /* commands that handle commits */
1407 TODO_PICK = 0,
1408 TODO_REVERT,
1409 TODO_EDIT,
1410 TODO_REWORD,
1411 TODO_FIXUP,
1412 TODO_SQUASH,
1413 /* commands that do something else than handling a single commit */
1414 TODO_EXEC,
1415 TODO_LABEL,
1416 TODO_RESET,
1417 TODO_MERGE,
1418 /* commands that do nothing but are counted for reporting progress */
1419 TODO_NOOP,
1420 TODO_DROP,
1421 /* comments (not counted for reporting progress) */
1422 TODO_COMMENT
1425 static struct {
1426 char c;
1427 const char *str;
1428 } todo_command_info[] = {
1429 { 'p', "pick" },
1430 { 0, "revert" },
1431 { 'e', "edit" },
1432 { 'r', "reword" },
1433 { 'f', "fixup" },
1434 { 's', "squash" },
1435 { 'x', "exec" },
1436 { 'l', "label" },
1437 { 't', "reset" },
1438 { 'm', "merge" },
1439 { 0, "noop" },
1440 { 'd', "drop" },
1441 { 0, NULL }
1444 static const char *command_to_string(const enum todo_command command)
1446 if (command < TODO_COMMENT)
1447 return todo_command_info[command].str;
1448 die("Unknown command: %d", command);
1451 static char command_to_char(const enum todo_command command)
1453 if (command < TODO_COMMENT && todo_command_info[command].c)
1454 return todo_command_info[command].c;
1455 return comment_line_char;
1458 static int is_noop(const enum todo_command command)
1460 return TODO_NOOP <= command;
1463 static int is_fixup(enum todo_command command)
1465 return command == TODO_FIXUP || command == TODO_SQUASH;
1468 /* Does this command create a (non-merge) commit? */
1469 static int is_pick_or_similar(enum todo_command command)
1471 switch (command) {
1472 case TODO_PICK:
1473 case TODO_REVERT:
1474 case TODO_EDIT:
1475 case TODO_REWORD:
1476 case TODO_FIXUP:
1477 case TODO_SQUASH:
1478 return 1;
1479 default:
1480 return 0;
1484 static int update_squash_messages(enum todo_command command,
1485 struct commit *commit, struct replay_opts *opts)
1487 struct strbuf buf = STRBUF_INIT;
1488 int res;
1489 const char *message, *body;
1491 if (opts->current_fixup_count > 0) {
1492 struct strbuf header = STRBUF_INIT;
1493 char *eol;
1495 if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
1496 return error(_("could not read '%s'"),
1497 rebase_path_squash_msg());
1499 eol = buf.buf[0] != comment_line_char ?
1500 buf.buf : strchrnul(buf.buf, '\n');
1502 strbuf_addf(&header, "%c ", comment_line_char);
1503 strbuf_addf(&header, _("This is a combination of %d commits."),
1504 opts->current_fixup_count + 2);
1505 strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
1506 strbuf_release(&header);
1507 } else {
1508 struct object_id head;
1509 struct commit *head_commit;
1510 const char *head_message, *body;
1512 if (get_oid("HEAD", &head))
1513 return error(_("need a HEAD to fixup"));
1514 if (!(head_commit = lookup_commit_reference(&head)))
1515 return error(_("could not read HEAD"));
1516 if (!(head_message = get_commit_buffer(head_commit, NULL)))
1517 return error(_("could not read HEAD's commit message"));
1519 find_commit_subject(head_message, &body);
1520 if (write_message(body, strlen(body),
1521 rebase_path_fixup_msg(), 0)) {
1522 unuse_commit_buffer(head_commit, head_message);
1523 return error(_("cannot write '%s'"),
1524 rebase_path_fixup_msg());
1527 strbuf_addf(&buf, "%c ", comment_line_char);
1528 strbuf_addf(&buf, _("This is a combination of %d commits."), 2);
1529 strbuf_addf(&buf, "\n%c ", comment_line_char);
1530 strbuf_addstr(&buf, _("This is the 1st commit message:"));
1531 strbuf_addstr(&buf, "\n\n");
1532 strbuf_addstr(&buf, body);
1534 unuse_commit_buffer(head_commit, head_message);
1537 if (!(message = get_commit_buffer(commit, NULL)))
1538 return error(_("could not read commit message of %s"),
1539 oid_to_hex(&commit->object.oid));
1540 find_commit_subject(message, &body);
1542 if (command == TODO_SQUASH) {
1543 unlink(rebase_path_fixup_msg());
1544 strbuf_addf(&buf, "\n%c ", comment_line_char);
1545 strbuf_addf(&buf, _("This is the commit message #%d:"),
1546 ++opts->current_fixup_count);
1547 strbuf_addstr(&buf, "\n\n");
1548 strbuf_addstr(&buf, body);
1549 } else if (command == TODO_FIXUP) {
1550 strbuf_addf(&buf, "\n%c ", comment_line_char);
1551 strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
1552 ++opts->current_fixup_count);
1553 strbuf_addstr(&buf, "\n\n");
1554 strbuf_add_commented_lines(&buf, body, strlen(body));
1555 } else
1556 return error(_("unknown command: %d"), command);
1557 unuse_commit_buffer(commit, message);
1559 res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
1560 strbuf_release(&buf);
1562 if (!res) {
1563 strbuf_addf(&opts->current_fixups, "%s%s %s",
1564 opts->current_fixups.len ? "\n" : "",
1565 command_to_string(command),
1566 oid_to_hex(&commit->object.oid));
1567 res = write_message(opts->current_fixups.buf,
1568 opts->current_fixups.len,
1569 rebase_path_current_fixups(), 0);
1572 return res;
1575 static void flush_rewritten_pending(void) {
1576 struct strbuf buf = STRBUF_INIT;
1577 struct object_id newoid;
1578 FILE *out;
1580 if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
1581 !get_oid("HEAD", &newoid) &&
1582 (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1583 char *bol = buf.buf, *eol;
1585 while (*bol) {
1586 eol = strchrnul(bol, '\n');
1587 fprintf(out, "%.*s %s\n", (int)(eol - bol),
1588 bol, oid_to_hex(&newoid));
1589 if (!*eol)
1590 break;
1591 bol = eol + 1;
1593 fclose(out);
1594 unlink(rebase_path_rewritten_pending());
1596 strbuf_release(&buf);
1599 static void record_in_rewritten(struct object_id *oid,
1600 enum todo_command next_command) {
1601 FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
1603 if (!out)
1604 return;
1606 fprintf(out, "%s\n", oid_to_hex(oid));
1607 fclose(out);
1609 if (!is_fixup(next_command))
1610 flush_rewritten_pending();
1613 static int do_pick_commit(enum todo_command command, struct commit *commit,
1614 struct replay_opts *opts, int final_fixup)
1616 unsigned int flags = opts->edit ? EDIT_MSG : 0;
1617 const char *msg_file = opts->edit ? NULL : git_path_merge_msg(the_repository);
1618 struct object_id head;
1619 struct commit *base, *next, *parent;
1620 const char *base_label, *next_label;
1621 char *author = NULL;
1622 struct commit_message msg = { NULL, NULL, NULL, NULL };
1623 struct strbuf msgbuf = STRBUF_INIT;
1624 int res, unborn = 0, allow;
1626 if (opts->no_commit) {
1628 * We do not intend to commit immediately. We just want to
1629 * merge the differences in, so let's compute the tree
1630 * that represents the "current" state for merge-recursive
1631 * to work on.
1633 if (write_cache_as_tree(&head, 0, NULL))
1634 return error(_("your index file is unmerged."));
1635 } else {
1636 unborn = get_oid("HEAD", &head);
1637 /* Do we want to generate a root commit? */
1638 if (is_pick_or_similar(command) && opts->have_squash_onto &&
1639 !oidcmp(&head, &opts->squash_onto)) {
1640 if (is_fixup(command))
1641 return error(_("cannot fixup root commit"));
1642 flags |= CREATE_ROOT_COMMIT;
1643 unborn = 1;
1644 } else if (unborn)
1645 oidcpy(&head, the_hash_algo->empty_tree);
1646 if (index_differs_from(unborn ? empty_tree_oid_hex() : "HEAD",
1647 NULL, 0))
1648 return error_dirty_index(opts);
1650 discard_cache();
1652 if (!commit->parents)
1653 parent = NULL;
1654 else if (commit->parents->next) {
1655 /* Reverting or cherry-picking a merge commit */
1656 int cnt;
1657 struct commit_list *p;
1659 if (!opts->mainline)
1660 return error(_("commit %s is a merge but no -m option was given."),
1661 oid_to_hex(&commit->object.oid));
1663 for (cnt = 1, p = commit->parents;
1664 cnt != opts->mainline && p;
1665 cnt++)
1666 p = p->next;
1667 if (cnt != opts->mainline || !p)
1668 return error(_("commit %s does not have parent %d"),
1669 oid_to_hex(&commit->object.oid), opts->mainline);
1670 parent = p->item;
1671 } else if (0 < opts->mainline)
1672 return error(_("mainline was specified but commit %s is not a merge."),
1673 oid_to_hex(&commit->object.oid));
1674 else
1675 parent = commit->parents->item;
1677 if (get_message(commit, &msg) != 0)
1678 return error(_("cannot get commit message for %s"),
1679 oid_to_hex(&commit->object.oid));
1681 if (opts->allow_ff && !is_fixup(command) &&
1682 ((parent && !oidcmp(&parent->object.oid, &head)) ||
1683 (!parent && unborn))) {
1684 if (is_rebase_i(opts))
1685 write_author_script(msg.message);
1686 res = fast_forward_to(&commit->object.oid, &head, unborn,
1687 opts);
1688 if (res || command != TODO_REWORD)
1689 goto leave;
1690 flags |= EDIT_MSG | AMEND_MSG | VERIFY_MSG;
1691 msg_file = NULL;
1692 goto fast_forward_edit;
1694 if (parent && parse_commit(parent) < 0)
1695 /* TRANSLATORS: The first %s will be a "todo" command like
1696 "revert" or "pick", the second %s a SHA1. */
1697 return error(_("%s: cannot parse parent commit %s"),
1698 command_to_string(command),
1699 oid_to_hex(&parent->object.oid));
1702 * "commit" is an existing commit. We would want to apply
1703 * the difference it introduces since its first parent "prev"
1704 * on top of the current HEAD if we are cherry-pick. Or the
1705 * reverse of it if we are revert.
1708 if (command == TODO_REVERT) {
1709 base = commit;
1710 base_label = msg.label;
1711 next = parent;
1712 next_label = msg.parent_label;
1713 strbuf_addstr(&msgbuf, "Revert \"");
1714 strbuf_addstr(&msgbuf, msg.subject);
1715 strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
1716 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1718 if (commit->parents && commit->parents->next) {
1719 strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
1720 strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
1722 strbuf_addstr(&msgbuf, ".\n");
1723 } else {
1724 const char *p;
1726 base = parent;
1727 base_label = msg.parent_label;
1728 next = commit;
1729 next_label = msg.label;
1731 /* Append the commit log message to msgbuf. */
1732 if (find_commit_subject(msg.message, &p))
1733 strbuf_addstr(&msgbuf, p);
1735 if (opts->record_origin) {
1736 strbuf_complete_line(&msgbuf);
1737 if (!has_conforming_footer(&msgbuf, NULL, 0))
1738 strbuf_addch(&msgbuf, '\n');
1739 strbuf_addstr(&msgbuf, cherry_picked_prefix);
1740 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1741 strbuf_addstr(&msgbuf, ")\n");
1743 if (!is_fixup(command))
1744 author = get_author(msg.message);
1747 if (command == TODO_REWORD)
1748 flags |= EDIT_MSG | VERIFY_MSG;
1749 else if (is_fixup(command)) {
1750 if (update_squash_messages(command, commit, opts))
1751 return -1;
1752 flags |= AMEND_MSG;
1753 if (!final_fixup)
1754 msg_file = rebase_path_squash_msg();
1755 else if (file_exists(rebase_path_fixup_msg())) {
1756 flags |= CLEANUP_MSG;
1757 msg_file = rebase_path_fixup_msg();
1758 } else {
1759 const char *dest = git_path_squash_msg(the_repository);
1760 unlink(dest);
1761 if (copy_file(dest, rebase_path_squash_msg(), 0666))
1762 return error(_("could not rename '%s' to '%s'"),
1763 rebase_path_squash_msg(), dest);
1764 unlink(git_path_merge_msg(the_repository));
1765 msg_file = dest;
1766 flags |= EDIT_MSG;
1770 if (opts->signoff && !is_fixup(command))
1771 append_signoff(&msgbuf, 0, 0);
1773 if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1774 res = -1;
1775 else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
1776 res = do_recursive_merge(base, next, base_label, next_label,
1777 &head, &msgbuf, opts);
1778 if (res < 0)
1779 goto leave;
1781 res |= write_message(msgbuf.buf, msgbuf.len,
1782 git_path_merge_msg(the_repository), 0);
1783 } else {
1784 struct commit_list *common = NULL;
1785 struct commit_list *remotes = NULL;
1787 res = write_message(msgbuf.buf, msgbuf.len,
1788 git_path_merge_msg(the_repository), 0);
1790 commit_list_insert(base, &common);
1791 commit_list_insert(next, &remotes);
1792 res |= try_merge_command(opts->strategy,
1793 opts->xopts_nr, (const char **)opts->xopts,
1794 common, oid_to_hex(&head), remotes);
1795 free_commit_list(common);
1796 free_commit_list(remotes);
1798 strbuf_release(&msgbuf);
1801 * If the merge was clean or if it failed due to conflict, we write
1802 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1803 * However, if the merge did not even start, then we don't want to
1804 * write it at all.
1806 if (command == TODO_PICK && !opts->no_commit && (res == 0 || res == 1) &&
1807 update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
1808 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1809 res = -1;
1810 if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
1811 update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
1812 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1813 res = -1;
1815 if (res) {
1816 error(command == TODO_REVERT
1817 ? _("could not revert %s... %s")
1818 : _("could not apply %s... %s"),
1819 short_commit_name(commit), msg.subject);
1820 print_advice(res == 1, opts);
1821 rerere(opts->allow_rerere_auto);
1822 goto leave;
1825 allow = allow_empty(opts, commit);
1826 if (allow < 0) {
1827 res = allow;
1828 goto leave;
1829 } else if (allow)
1830 flags |= ALLOW_EMPTY;
1831 if (!opts->no_commit) {
1832 fast_forward_edit:
1833 if (author || command == TODO_REVERT || (flags & AMEND_MSG))
1834 res = do_commit(msg_file, author, opts, flags);
1835 else
1836 res = error(_("unable to parse commit author"));
1839 if (!res && final_fixup) {
1840 unlink(rebase_path_fixup_msg());
1841 unlink(rebase_path_squash_msg());
1842 unlink(rebase_path_current_fixups());
1843 strbuf_reset(&opts->current_fixups);
1844 opts->current_fixup_count = 0;
1847 leave:
1848 free_message(commit, &msg);
1849 free(author);
1850 update_abort_safety_file();
1852 return res;
1855 static int prepare_revs(struct replay_opts *opts)
1858 * picking (but not reverting) ranges (but not individual revisions)
1859 * should be done in reverse
1861 if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
1862 opts->revs->reverse ^= 1;
1864 if (prepare_revision_walk(opts->revs))
1865 return error(_("revision walk setup failed"));
1867 return 0;
1870 static int read_and_refresh_cache(struct replay_opts *opts)
1872 struct lock_file index_lock = LOCK_INIT;
1873 int index_fd = hold_locked_index(&index_lock, 0);
1874 if (read_index_preload(&the_index, NULL) < 0) {
1875 rollback_lock_file(&index_lock);
1876 return error(_("git %s: failed to read the index"),
1877 _(action_name(opts)));
1879 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
1880 if (index_fd >= 0) {
1881 if (write_locked_index(&the_index, &index_lock,
1882 COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
1883 return error(_("git %s: failed to refresh the index"),
1884 _(action_name(opts)));
1887 return 0;
1890 enum todo_item_flags {
1891 TODO_EDIT_MERGE_MSG = 1
1894 struct todo_item {
1895 enum todo_command command;
1896 struct commit *commit;
1897 unsigned int flags;
1898 const char *arg;
1899 int arg_len;
1900 size_t offset_in_buf;
1903 struct todo_list {
1904 struct strbuf buf;
1905 struct todo_item *items;
1906 int nr, alloc, current;
1907 int done_nr, total_nr;
1908 struct stat_data stat;
1911 #define TODO_LIST_INIT { STRBUF_INIT }
1913 static void todo_list_release(struct todo_list *todo_list)
1915 strbuf_release(&todo_list->buf);
1916 FREE_AND_NULL(todo_list->items);
1917 todo_list->nr = todo_list->alloc = 0;
1920 static struct todo_item *append_new_todo(struct todo_list *todo_list)
1922 ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
1923 return todo_list->items + todo_list->nr++;
1926 static int parse_insn_line(struct todo_item *item, const char *bol, char *eol)
1928 struct object_id commit_oid;
1929 char *end_of_object_name;
1930 int i, saved, status, padding;
1932 item->flags = 0;
1934 /* left-trim */
1935 bol += strspn(bol, " \t");
1937 if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
1938 item->command = TODO_COMMENT;
1939 item->commit = NULL;
1940 item->arg = bol;
1941 item->arg_len = eol - bol;
1942 return 0;
1945 for (i = 0; i < TODO_COMMENT; i++)
1946 if (skip_prefix(bol, todo_command_info[i].str, &bol)) {
1947 item->command = i;
1948 break;
1949 } else if (bol[1] == ' ' && *bol == todo_command_info[i].c) {
1950 bol++;
1951 item->command = i;
1952 break;
1954 if (i >= TODO_COMMENT)
1955 return -1;
1957 /* Eat up extra spaces/ tabs before object name */
1958 padding = strspn(bol, " \t");
1959 bol += padding;
1961 if (item->command == TODO_NOOP) {
1962 if (bol != eol)
1963 return error(_("%s does not accept arguments: '%s'"),
1964 command_to_string(item->command), bol);
1965 item->commit = NULL;
1966 item->arg = bol;
1967 item->arg_len = eol - bol;
1968 return 0;
1971 if (!padding)
1972 return error(_("missing arguments for %s"),
1973 command_to_string(item->command));
1975 if (item->command == TODO_EXEC || item->command == TODO_LABEL ||
1976 item->command == TODO_RESET) {
1977 item->commit = NULL;
1978 item->arg = bol;
1979 item->arg_len = (int)(eol - bol);
1980 return 0;
1983 if (item->command == TODO_MERGE) {
1984 if (skip_prefix(bol, "-C", &bol))
1985 bol += strspn(bol, " \t");
1986 else if (skip_prefix(bol, "-c", &bol)) {
1987 bol += strspn(bol, " \t");
1988 item->flags |= TODO_EDIT_MERGE_MSG;
1989 } else {
1990 item->flags |= TODO_EDIT_MERGE_MSG;
1991 item->commit = NULL;
1992 item->arg = bol;
1993 item->arg_len = (int)(eol - bol);
1994 return 0;
1998 end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
1999 saved = *end_of_object_name;
2000 *end_of_object_name = '\0';
2001 status = get_oid(bol, &commit_oid);
2002 *end_of_object_name = saved;
2004 item->arg = end_of_object_name + strspn(end_of_object_name, " \t");
2005 item->arg_len = (int)(eol - item->arg);
2007 if (status < 0)
2008 return -1;
2010 item->commit = lookup_commit_reference(&commit_oid);
2011 return !item->commit;
2014 static int parse_insn_buffer(char *buf, struct todo_list *todo_list)
2016 struct todo_item *item;
2017 char *p = buf, *next_p;
2018 int i, res = 0, fixup_okay = file_exists(rebase_path_done());
2020 for (i = 1; *p; i++, p = next_p) {
2021 char *eol = strchrnul(p, '\n');
2023 next_p = *eol ? eol + 1 /* skip LF */ : eol;
2025 if (p != eol && eol[-1] == '\r')
2026 eol--; /* strip Carriage Return */
2028 item = append_new_todo(todo_list);
2029 item->offset_in_buf = p - todo_list->buf.buf;
2030 if (parse_insn_line(item, p, eol)) {
2031 res = error(_("invalid line %d: %.*s"),
2032 i, (int)(eol - p), p);
2033 item->command = TODO_NOOP;
2036 if (fixup_okay)
2037 ; /* do nothing */
2038 else if (is_fixup(item->command))
2039 return error(_("cannot '%s' without a previous commit"),
2040 command_to_string(item->command));
2041 else if (!is_noop(item->command))
2042 fixup_okay = 1;
2045 return res;
2048 static int count_commands(struct todo_list *todo_list)
2050 int count = 0, i;
2052 for (i = 0; i < todo_list->nr; i++)
2053 if (todo_list->items[i].command != TODO_COMMENT)
2054 count++;
2056 return count;
2059 static int get_item_line_offset(struct todo_list *todo_list, int index)
2061 return index < todo_list->nr ?
2062 todo_list->items[index].offset_in_buf : todo_list->buf.len;
2065 static const char *get_item_line(struct todo_list *todo_list, int index)
2067 return todo_list->buf.buf + get_item_line_offset(todo_list, index);
2070 static int get_item_line_length(struct todo_list *todo_list, int index)
2072 return get_item_line_offset(todo_list, index + 1)
2073 - get_item_line_offset(todo_list, index);
2076 static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
2078 int fd;
2079 ssize_t len;
2081 fd = open(path, O_RDONLY);
2082 if (fd < 0)
2083 return error_errno(_("could not open '%s'"), path);
2084 len = strbuf_read(sb, fd, 0);
2085 close(fd);
2086 if (len < 0)
2087 return error(_("could not read '%s'."), path);
2088 return len;
2091 static int read_populate_todo(struct todo_list *todo_list,
2092 struct replay_opts *opts)
2094 struct stat st;
2095 const char *todo_file = get_todo_path(opts);
2096 int res;
2098 strbuf_reset(&todo_list->buf);
2099 if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
2100 return -1;
2102 res = stat(todo_file, &st);
2103 if (res)
2104 return error(_("could not stat '%s'"), todo_file);
2105 fill_stat_data(&todo_list->stat, &st);
2107 res = parse_insn_buffer(todo_list->buf.buf, todo_list);
2108 if (res) {
2109 if (is_rebase_i(opts))
2110 return error(_("please fix this using "
2111 "'git rebase --edit-todo'."));
2112 return error(_("unusable instruction sheet: '%s'"), todo_file);
2115 if (!todo_list->nr &&
2116 (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
2117 return error(_("no commits parsed."));
2119 if (!is_rebase_i(opts)) {
2120 enum todo_command valid =
2121 opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
2122 int i;
2124 for (i = 0; i < todo_list->nr; i++)
2125 if (valid == todo_list->items[i].command)
2126 continue;
2127 else if (valid == TODO_PICK)
2128 return error(_("cannot cherry-pick during a revert."));
2129 else
2130 return error(_("cannot revert during a cherry-pick."));
2133 if (is_rebase_i(opts)) {
2134 struct todo_list done = TODO_LIST_INIT;
2135 FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
2137 if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
2138 !parse_insn_buffer(done.buf.buf, &done))
2139 todo_list->done_nr = count_commands(&done);
2140 else
2141 todo_list->done_nr = 0;
2143 todo_list->total_nr = todo_list->done_nr
2144 + count_commands(todo_list);
2145 todo_list_release(&done);
2147 if (f) {
2148 fprintf(f, "%d\n", todo_list->total_nr);
2149 fclose(f);
2153 return 0;
2156 static int git_config_string_dup(char **dest,
2157 const char *var, const char *value)
2159 if (!value)
2160 return config_error_nonbool(var);
2161 free(*dest);
2162 *dest = xstrdup(value);
2163 return 0;
2166 static int populate_opts_cb(const char *key, const char *value, void *data)
2168 struct replay_opts *opts = data;
2169 int error_flag = 1;
2171 if (!value)
2172 error_flag = 0;
2173 else if (!strcmp(key, "options.no-commit"))
2174 opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
2175 else if (!strcmp(key, "options.edit"))
2176 opts->edit = git_config_bool_or_int(key, value, &error_flag);
2177 else if (!strcmp(key, "options.signoff"))
2178 opts->signoff = git_config_bool_or_int(key, value, &error_flag);
2179 else if (!strcmp(key, "options.record-origin"))
2180 opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
2181 else if (!strcmp(key, "options.allow-ff"))
2182 opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
2183 else if (!strcmp(key, "options.mainline"))
2184 opts->mainline = git_config_int(key, value);
2185 else if (!strcmp(key, "options.strategy"))
2186 git_config_string_dup(&opts->strategy, key, value);
2187 else if (!strcmp(key, "options.gpg-sign"))
2188 git_config_string_dup(&opts->gpg_sign, key, value);
2189 else if (!strcmp(key, "options.strategy-option")) {
2190 ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
2191 opts->xopts[opts->xopts_nr++] = xstrdup(value);
2192 } else if (!strcmp(key, "options.allow-rerere-auto"))
2193 opts->allow_rerere_auto =
2194 git_config_bool_or_int(key, value, &error_flag) ?
2195 RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
2196 else
2197 return error(_("invalid key: %s"), key);
2199 if (!error_flag)
2200 return error(_("invalid value for %s: %s"), key, value);
2202 return 0;
2205 static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
2207 int i;
2208 char *strategy_opts_string;
2210 strbuf_reset(buf);
2211 if (!read_oneliner(buf, rebase_path_strategy(), 0))
2212 return;
2213 opts->strategy = strbuf_detach(buf, NULL);
2214 if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2215 return;
2217 strategy_opts_string = buf->buf;
2218 if (*strategy_opts_string == ' ')
2219 strategy_opts_string++;
2220 opts->xopts_nr = split_cmdline(strategy_opts_string,
2221 (const char ***)&opts->xopts);
2222 for (i = 0; i < opts->xopts_nr; i++) {
2223 const char *arg = opts->xopts[i];
2225 skip_prefix(arg, "--", &arg);
2226 opts->xopts[i] = xstrdup(arg);
2230 static int read_populate_opts(struct replay_opts *opts)
2232 if (is_rebase_i(opts)) {
2233 struct strbuf buf = STRBUF_INIT;
2235 if (read_oneliner(&buf, rebase_path_gpg_sign_opt(), 1)) {
2236 if (!starts_with(buf.buf, "-S"))
2237 strbuf_reset(&buf);
2238 else {
2239 free(opts->gpg_sign);
2240 opts->gpg_sign = xstrdup(buf.buf + 2);
2242 strbuf_reset(&buf);
2245 if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(), 1)) {
2246 if (!strcmp(buf.buf, "--rerere-autoupdate"))
2247 opts->allow_rerere_auto = RERERE_AUTOUPDATE;
2248 else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
2249 opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
2250 strbuf_reset(&buf);
2253 if (file_exists(rebase_path_verbose()))
2254 opts->verbose = 1;
2256 if (file_exists(rebase_path_signoff())) {
2257 opts->allow_ff = 0;
2258 opts->signoff = 1;
2261 read_strategy_opts(opts, &buf);
2262 strbuf_release(&buf);
2264 if (read_oneliner(&opts->current_fixups,
2265 rebase_path_current_fixups(), 1)) {
2266 const char *p = opts->current_fixups.buf;
2267 opts->current_fixup_count = 1;
2268 while ((p = strchr(p, '\n'))) {
2269 opts->current_fixup_count++;
2270 p++;
2274 if (read_oneliner(&buf, rebase_path_squash_onto(), 0)) {
2275 if (get_oid_hex(buf.buf, &opts->squash_onto) < 0)
2276 return error(_("unusable squash-onto"));
2277 opts->have_squash_onto = 1;
2280 return 0;
2283 if (!file_exists(git_path_opts_file()))
2284 return 0;
2286 * The function git_parse_source(), called from git_config_from_file(),
2287 * may die() in case of a syntactically incorrect file. We do not care
2288 * about this case, though, because we wrote that file ourselves, so we
2289 * are pretty certain that it is syntactically correct.
2291 if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
2292 return error(_("malformed options sheet: '%s'"),
2293 git_path_opts_file());
2294 return 0;
2297 static int walk_revs_populate_todo(struct todo_list *todo_list,
2298 struct replay_opts *opts)
2300 enum todo_command command = opts->action == REPLAY_PICK ?
2301 TODO_PICK : TODO_REVERT;
2302 const char *command_string = todo_command_info[command].str;
2303 struct commit *commit;
2305 if (prepare_revs(opts))
2306 return -1;
2308 while ((commit = get_revision(opts->revs))) {
2309 struct todo_item *item = append_new_todo(todo_list);
2310 const char *commit_buffer = get_commit_buffer(commit, NULL);
2311 const char *subject;
2312 int subject_len;
2314 item->command = command;
2315 item->commit = commit;
2316 item->arg = NULL;
2317 item->arg_len = 0;
2318 item->offset_in_buf = todo_list->buf.len;
2319 subject_len = find_commit_subject(commit_buffer, &subject);
2320 strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
2321 short_commit_name(commit), subject_len, subject);
2322 unuse_commit_buffer(commit, commit_buffer);
2325 if (!todo_list->nr)
2326 return error(_("empty commit set passed"));
2328 return 0;
2331 static int create_seq_dir(void)
2333 if (file_exists(git_path_seq_dir())) {
2334 error(_("a cherry-pick or revert is already in progress"));
2335 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
2336 return -1;
2337 } else if (mkdir(git_path_seq_dir(), 0777) < 0)
2338 return error_errno(_("could not create sequencer directory '%s'"),
2339 git_path_seq_dir());
2340 return 0;
2343 static int save_head(const char *head)
2345 struct lock_file head_lock = LOCK_INIT;
2346 struct strbuf buf = STRBUF_INIT;
2347 int fd;
2348 ssize_t written;
2350 fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
2351 if (fd < 0)
2352 return error_errno(_("could not lock HEAD"));
2353 strbuf_addf(&buf, "%s\n", head);
2354 written = write_in_full(fd, buf.buf, buf.len);
2355 strbuf_release(&buf);
2356 if (written < 0) {
2357 error_errno(_("could not write to '%s'"), git_path_head_file());
2358 rollback_lock_file(&head_lock);
2359 return -1;
2361 if (commit_lock_file(&head_lock) < 0)
2362 return error(_("failed to finalize '%s'"), git_path_head_file());
2363 return 0;
2366 static int rollback_is_safe(void)
2368 struct strbuf sb = STRBUF_INIT;
2369 struct object_id expected_head, actual_head;
2371 if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2372 strbuf_trim(&sb);
2373 if (get_oid_hex(sb.buf, &expected_head)) {
2374 strbuf_release(&sb);
2375 die(_("could not parse %s"), git_path_abort_safety_file());
2377 strbuf_release(&sb);
2379 else if (errno == ENOENT)
2380 oidclr(&expected_head);
2381 else
2382 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2384 if (get_oid("HEAD", &actual_head))
2385 oidclr(&actual_head);
2387 return !oidcmp(&actual_head, &expected_head);
2390 static int reset_for_rollback(const struct object_id *oid)
2392 const char *argv[4]; /* reset --merge <arg> + NULL */
2394 argv[0] = "reset";
2395 argv[1] = "--merge";
2396 argv[2] = oid_to_hex(oid);
2397 argv[3] = NULL;
2398 return run_command_v_opt(argv, RUN_GIT_CMD);
2401 static int rollback_single_pick(void)
2403 struct object_id head_oid;
2405 if (!file_exists(git_path_cherry_pick_head(the_repository)) &&
2406 !file_exists(git_path_revert_head(the_repository)))
2407 return error(_("no cherry-pick or revert in progress"));
2408 if (read_ref_full("HEAD", 0, &head_oid, NULL))
2409 return error(_("cannot resolve HEAD"));
2410 if (is_null_oid(&head_oid))
2411 return error(_("cannot abort from a branch yet to be born"));
2412 return reset_for_rollback(&head_oid);
2415 int sequencer_rollback(struct replay_opts *opts)
2417 FILE *f;
2418 struct object_id oid;
2419 struct strbuf buf = STRBUF_INIT;
2420 const char *p;
2422 f = fopen(git_path_head_file(), "r");
2423 if (!f && errno == ENOENT) {
2425 * There is no multiple-cherry-pick in progress.
2426 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2427 * a single-cherry-pick in progress, abort that.
2429 return rollback_single_pick();
2431 if (!f)
2432 return error_errno(_("cannot open '%s'"), git_path_head_file());
2433 if (strbuf_getline_lf(&buf, f)) {
2434 error(_("cannot read '%s': %s"), git_path_head_file(),
2435 ferror(f) ? strerror(errno) : _("unexpected end of file"));
2436 fclose(f);
2437 goto fail;
2439 fclose(f);
2440 if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
2441 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2442 git_path_head_file());
2443 goto fail;
2445 if (is_null_oid(&oid)) {
2446 error(_("cannot abort from a branch yet to be born"));
2447 goto fail;
2450 if (!rollback_is_safe()) {
2451 /* Do not error, just do not rollback */
2452 warning(_("You seem to have moved HEAD. "
2453 "Not rewinding, check your HEAD!"));
2454 } else
2455 if (reset_for_rollback(&oid))
2456 goto fail;
2457 strbuf_release(&buf);
2458 return sequencer_remove_state(opts);
2459 fail:
2460 strbuf_release(&buf);
2461 return -1;
2464 static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
2466 struct lock_file todo_lock = LOCK_INIT;
2467 const char *todo_path = get_todo_path(opts);
2468 int next = todo_list->current, offset, fd;
2471 * rebase -i writes "git-rebase-todo" without the currently executing
2472 * command, appending it to "done" instead.
2474 if (is_rebase_i(opts))
2475 next++;
2477 fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
2478 if (fd < 0)
2479 return error_errno(_("could not lock '%s'"), todo_path);
2480 offset = get_item_line_offset(todo_list, next);
2481 if (write_in_full(fd, todo_list->buf.buf + offset,
2482 todo_list->buf.len - offset) < 0)
2483 return error_errno(_("could not write to '%s'"), todo_path);
2484 if (commit_lock_file(&todo_lock) < 0)
2485 return error(_("failed to finalize '%s'"), todo_path);
2487 if (is_rebase_i(opts) && next > 0) {
2488 const char *done = rebase_path_done();
2489 int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
2490 int ret = 0;
2492 if (fd < 0)
2493 return 0;
2494 if (write_in_full(fd, get_item_line(todo_list, next - 1),
2495 get_item_line_length(todo_list, next - 1))
2496 < 0)
2497 ret = error_errno(_("could not write to '%s'"), done);
2498 if (close(fd) < 0)
2499 ret = error_errno(_("failed to finalize '%s'"), done);
2500 return ret;
2502 return 0;
2505 static int save_opts(struct replay_opts *opts)
2507 const char *opts_file = git_path_opts_file();
2508 int res = 0;
2510 if (opts->no_commit)
2511 res |= git_config_set_in_file_gently(opts_file, "options.no-commit", "true");
2512 if (opts->edit)
2513 res |= git_config_set_in_file_gently(opts_file, "options.edit", "true");
2514 if (opts->signoff)
2515 res |= git_config_set_in_file_gently(opts_file, "options.signoff", "true");
2516 if (opts->record_origin)
2517 res |= git_config_set_in_file_gently(opts_file, "options.record-origin", "true");
2518 if (opts->allow_ff)
2519 res |= git_config_set_in_file_gently(opts_file, "options.allow-ff", "true");
2520 if (opts->mainline) {
2521 struct strbuf buf = STRBUF_INIT;
2522 strbuf_addf(&buf, "%d", opts->mainline);
2523 res |= git_config_set_in_file_gently(opts_file, "options.mainline", buf.buf);
2524 strbuf_release(&buf);
2526 if (opts->strategy)
2527 res |= git_config_set_in_file_gently(opts_file, "options.strategy", opts->strategy);
2528 if (opts->gpg_sign)
2529 res |= git_config_set_in_file_gently(opts_file, "options.gpg-sign", opts->gpg_sign);
2530 if (opts->xopts) {
2531 int i;
2532 for (i = 0; i < opts->xopts_nr; i++)
2533 res |= git_config_set_multivar_in_file_gently(opts_file,
2534 "options.strategy-option",
2535 opts->xopts[i], "^$", 0);
2537 if (opts->allow_rerere_auto)
2538 res |= git_config_set_in_file_gently(opts_file, "options.allow-rerere-auto",
2539 opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
2540 "true" : "false");
2541 return res;
2544 static int make_patch(struct commit *commit, struct replay_opts *opts)
2546 struct strbuf buf = STRBUF_INIT;
2547 struct rev_info log_tree_opt;
2548 const char *subject, *p;
2549 int res = 0;
2551 p = short_commit_name(commit);
2552 if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
2553 return -1;
2554 if (update_ref("rebase", "REBASE_HEAD", &commit->object.oid,
2555 NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2556 res |= error(_("could not update %s"), "REBASE_HEAD");
2558 strbuf_addf(&buf, "%s/patch", get_dir(opts));
2559 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
2560 init_revisions(&log_tree_opt, NULL);
2561 log_tree_opt.abbrev = 0;
2562 log_tree_opt.diff = 1;
2563 log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
2564 log_tree_opt.disable_stdin = 1;
2565 log_tree_opt.no_commit_id = 1;
2566 log_tree_opt.diffopt.file = fopen(buf.buf, "w");
2567 log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
2568 if (!log_tree_opt.diffopt.file)
2569 res |= error_errno(_("could not open '%s'"), buf.buf);
2570 else {
2571 res |= log_tree_commit(&log_tree_opt, commit);
2572 fclose(log_tree_opt.diffopt.file);
2574 strbuf_reset(&buf);
2576 strbuf_addf(&buf, "%s/message", get_dir(opts));
2577 if (!file_exists(buf.buf)) {
2578 const char *commit_buffer = get_commit_buffer(commit, NULL);
2579 find_commit_subject(commit_buffer, &subject);
2580 res |= write_message(subject, strlen(subject), buf.buf, 1);
2581 unuse_commit_buffer(commit, commit_buffer);
2583 strbuf_release(&buf);
2585 return res;
2588 static int intend_to_amend(void)
2590 struct object_id head;
2591 char *p;
2593 if (get_oid("HEAD", &head))
2594 return error(_("cannot read HEAD"));
2596 p = oid_to_hex(&head);
2597 return write_message(p, strlen(p), rebase_path_amend(), 1);
2600 static int error_with_patch(struct commit *commit,
2601 const char *subject, int subject_len,
2602 struct replay_opts *opts, int exit_code, int to_amend)
2604 if (make_patch(commit, opts))
2605 return -1;
2607 if (to_amend) {
2608 if (intend_to_amend())
2609 return -1;
2611 fprintf(stderr, "You can amend the commit now, with\n"
2612 "\n"
2613 " git commit --amend %s\n"
2614 "\n"
2615 "Once you are satisfied with your changes, run\n"
2616 "\n"
2617 " git rebase --continue\n", gpg_sign_opt_quoted(opts));
2618 } else if (exit_code)
2619 fprintf(stderr, "Could not apply %s... %.*s\n",
2620 short_commit_name(commit), subject_len, subject);
2622 return exit_code;
2625 static int error_failed_squash(struct commit *commit,
2626 struct replay_opts *opts, int subject_len, const char *subject)
2628 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
2629 return error(_("could not copy '%s' to '%s'"),
2630 rebase_path_squash_msg(), rebase_path_message());
2631 unlink(git_path_merge_msg(the_repository));
2632 if (copy_file(git_path_merge_msg(the_repository), rebase_path_message(), 0666))
2633 return error(_("could not copy '%s' to '%s'"),
2634 rebase_path_message(),
2635 git_path_merge_msg(the_repository));
2636 return error_with_patch(commit, subject, subject_len, opts, 1, 0);
2639 static int do_exec(const char *command_line)
2641 struct argv_array child_env = ARGV_ARRAY_INIT;
2642 const char *child_argv[] = { NULL, NULL };
2643 int dirty, status;
2645 fprintf(stderr, "Executing: %s\n", command_line);
2646 child_argv[0] = command_line;
2647 argv_array_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
2648 status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
2649 child_env.argv);
2651 /* force re-reading of the cache */
2652 if (discard_cache() < 0 || read_cache() < 0)
2653 return error(_("could not read index"));
2655 dirty = require_clean_work_tree("rebase", NULL, 1, 1);
2657 if (status) {
2658 warning(_("execution failed: %s\n%s"
2659 "You can fix the problem, and then run\n"
2660 "\n"
2661 " git rebase --continue\n"
2662 "\n"),
2663 command_line,
2664 dirty ? N_("and made changes to the index and/or the "
2665 "working tree\n") : "");
2666 if (status == 127)
2667 /* command not found */
2668 status = 1;
2669 } else if (dirty) {
2670 warning(_("execution succeeded: %s\nbut "
2671 "left changes to the index and/or the working tree\n"
2672 "Commit or stash your changes, and then run\n"
2673 "\n"
2674 " git rebase --continue\n"
2675 "\n"), command_line);
2676 status = 1;
2679 argv_array_clear(&child_env);
2681 return status;
2684 static int safe_append(const char *filename, const char *fmt, ...)
2686 va_list ap;
2687 struct lock_file lock = LOCK_INIT;
2688 int fd = hold_lock_file_for_update(&lock, filename,
2689 LOCK_REPORT_ON_ERROR);
2690 struct strbuf buf = STRBUF_INIT;
2692 if (fd < 0)
2693 return -1;
2695 if (strbuf_read_file(&buf, filename, 0) < 0 && errno != ENOENT) {
2696 error_errno(_("could not read '%s'"), filename);
2697 rollback_lock_file(&lock);
2698 return -1;
2700 strbuf_complete(&buf, '\n');
2701 va_start(ap, fmt);
2702 strbuf_vaddf(&buf, fmt, ap);
2703 va_end(ap);
2705 if (write_in_full(fd, buf.buf, buf.len) < 0) {
2706 error_errno(_("could not write to '%s'"), filename);
2707 strbuf_release(&buf);
2708 rollback_lock_file(&lock);
2709 return -1;
2711 if (commit_lock_file(&lock) < 0) {
2712 strbuf_release(&buf);
2713 rollback_lock_file(&lock);
2714 return error(_("failed to finalize '%s'"), filename);
2717 strbuf_release(&buf);
2718 return 0;
2721 static int do_label(const char *name, int len)
2723 struct ref_store *refs = get_main_ref_store(the_repository);
2724 struct ref_transaction *transaction;
2725 struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
2726 struct strbuf msg = STRBUF_INIT;
2727 int ret = 0;
2728 struct object_id head_oid;
2730 if (len == 1 && *name == '#')
2731 return error("Illegal label name: '%.*s'", len, name);
2733 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
2734 strbuf_addf(&msg, "rebase -i (label) '%.*s'", len, name);
2736 transaction = ref_store_transaction_begin(refs, &err);
2737 if (!transaction) {
2738 error("%s", err.buf);
2739 ret = -1;
2740 } else if (get_oid("HEAD", &head_oid)) {
2741 error(_("could not read HEAD"));
2742 ret = -1;
2743 } else if (ref_transaction_update(transaction, ref_name.buf, &head_oid,
2744 NULL, 0, msg.buf, &err) < 0 ||
2745 ref_transaction_commit(transaction, &err)) {
2746 error("%s", err.buf);
2747 ret = -1;
2749 ref_transaction_free(transaction);
2750 strbuf_release(&err);
2751 strbuf_release(&msg);
2753 if (!ret)
2754 ret = safe_append(rebase_path_refs_to_delete(),
2755 "%s\n", ref_name.buf);
2756 strbuf_release(&ref_name);
2758 return ret;
2761 static const char *reflog_message(struct replay_opts *opts,
2762 const char *sub_action, const char *fmt, ...);
2764 static int do_reset(const char *name, int len, struct replay_opts *opts)
2766 struct strbuf ref_name = STRBUF_INIT;
2767 struct object_id oid;
2768 struct lock_file lock = LOCK_INIT;
2769 struct tree_desc desc;
2770 struct tree *tree;
2771 struct unpack_trees_options unpack_tree_opts;
2772 int ret = 0, i;
2774 if (hold_locked_index(&lock, LOCK_REPORT_ON_ERROR) < 0)
2775 return -1;
2777 if (len == 10 && !strncmp("[new root]", name, len)) {
2778 if (!opts->have_squash_onto) {
2779 const char *hex;
2780 if (commit_tree("", 0, the_hash_algo->empty_tree,
2781 NULL, &opts->squash_onto,
2782 NULL, NULL))
2783 return error(_("writing fake root commit"));
2784 opts->have_squash_onto = 1;
2785 hex = oid_to_hex(&opts->squash_onto);
2786 if (write_message(hex, strlen(hex),
2787 rebase_path_squash_onto(), 0))
2788 return error(_("writing squash-onto"));
2790 oidcpy(&oid, &opts->squash_onto);
2791 } else {
2792 /* Determine the length of the label */
2793 for (i = 0; i < len; i++)
2794 if (isspace(name[i]))
2795 len = i;
2797 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
2798 if (get_oid(ref_name.buf, &oid) &&
2799 get_oid(ref_name.buf + strlen("refs/rewritten/"), &oid)) {
2800 error(_("could not read '%s'"), ref_name.buf);
2801 rollback_lock_file(&lock);
2802 strbuf_release(&ref_name);
2803 return -1;
2807 memset(&unpack_tree_opts, 0, sizeof(unpack_tree_opts));
2808 setup_unpack_trees_porcelain(&unpack_tree_opts, "reset");
2809 unpack_tree_opts.head_idx = 1;
2810 unpack_tree_opts.src_index = &the_index;
2811 unpack_tree_opts.dst_index = &the_index;
2812 unpack_tree_opts.fn = oneway_merge;
2813 unpack_tree_opts.merge = 1;
2814 unpack_tree_opts.update = 1;
2816 if (read_cache_unmerged()) {
2817 rollback_lock_file(&lock);
2818 strbuf_release(&ref_name);
2819 return error_resolve_conflict(_(action_name(opts)));
2822 if (!fill_tree_descriptor(&desc, &oid)) {
2823 error(_("failed to find tree of %s"), oid_to_hex(&oid));
2824 rollback_lock_file(&lock);
2825 free((void *)desc.buffer);
2826 strbuf_release(&ref_name);
2827 return -1;
2830 if (unpack_trees(1, &desc, &unpack_tree_opts)) {
2831 rollback_lock_file(&lock);
2832 free((void *)desc.buffer);
2833 strbuf_release(&ref_name);
2834 return -1;
2837 tree = parse_tree_indirect(&oid);
2838 prime_cache_tree(&the_index, tree);
2840 if (write_locked_index(&the_index, &lock, COMMIT_LOCK) < 0)
2841 ret = error(_("could not write index"));
2842 free((void *)desc.buffer);
2844 if (!ret)
2845 ret = update_ref(reflog_message(opts, "reset", "'%.*s'",
2846 len, name), "HEAD", &oid,
2847 NULL, 0, UPDATE_REFS_MSG_ON_ERR);
2849 strbuf_release(&ref_name);
2850 return ret;
2853 static int do_merge(struct commit *commit, const char *arg, int arg_len,
2854 int flags, struct replay_opts *opts)
2856 int run_commit_flags = (flags & TODO_EDIT_MERGE_MSG) ?
2857 EDIT_MSG | VERIFY_MSG : 0;
2858 struct strbuf ref_name = STRBUF_INIT;
2859 struct commit *head_commit, *merge_commit, *i;
2860 struct commit_list *bases, *j, *reversed = NULL;
2861 struct merge_options o;
2862 int merge_arg_len, oneline_offset, can_fast_forward, ret;
2863 static struct lock_file lock;
2864 const char *p;
2866 if (hold_locked_index(&lock, LOCK_REPORT_ON_ERROR) < 0) {
2867 ret = -1;
2868 goto leave_merge;
2871 head_commit = lookup_commit_reference_by_name("HEAD");
2872 if (!head_commit) {
2873 ret = error(_("cannot merge without a current revision"));
2874 goto leave_merge;
2877 oneline_offset = arg_len;
2878 merge_arg_len = strcspn(arg, " \t\n");
2879 p = arg + merge_arg_len;
2880 p += strspn(p, " \t\n");
2881 if (*p == '#' && (!p[1] || isspace(p[1]))) {
2882 p += 1 + strspn(p + 1, " \t\n");
2883 oneline_offset = p - arg;
2884 } else if (p - arg < arg_len)
2885 BUG("octopus merges are not supported yet: '%s'", p);
2887 strbuf_addf(&ref_name, "refs/rewritten/%.*s", merge_arg_len, arg);
2888 merge_commit = lookup_commit_reference_by_name(ref_name.buf);
2889 if (!merge_commit) {
2890 /* fall back to non-rewritten ref or commit */
2891 strbuf_splice(&ref_name, 0, strlen("refs/rewritten/"), "", 0);
2892 merge_commit = lookup_commit_reference_by_name(ref_name.buf);
2895 if (!merge_commit) {
2896 ret = error(_("could not resolve '%s'"), ref_name.buf);
2897 goto leave_merge;
2900 if (opts->have_squash_onto &&
2901 !oidcmp(&head_commit->object.oid, &opts->squash_onto)) {
2903 * When the user tells us to "merge" something into a
2904 * "[new root]", let's simply fast-forward to the merge head.
2906 rollback_lock_file(&lock);
2907 ret = fast_forward_to(&merge_commit->object.oid,
2908 &head_commit->object.oid, 0, opts);
2909 goto leave_merge;
2912 if (commit) {
2913 const char *message = get_commit_buffer(commit, NULL);
2914 const char *body;
2915 int len;
2917 if (!message) {
2918 ret = error(_("could not get commit message of '%s'"),
2919 oid_to_hex(&commit->object.oid));
2920 goto leave_merge;
2922 write_author_script(message);
2923 find_commit_subject(message, &body);
2924 len = strlen(body);
2925 ret = write_message(body, len, git_path_merge_msg(the_repository), 0);
2926 unuse_commit_buffer(commit, message);
2927 if (ret) {
2928 error_errno(_("could not write '%s'"),
2929 git_path_merge_msg(the_repository));
2930 goto leave_merge;
2932 } else {
2933 struct strbuf buf = STRBUF_INIT;
2934 int len;
2936 strbuf_addf(&buf, "author %s", git_author_info(0));
2937 write_author_script(buf.buf);
2938 strbuf_reset(&buf);
2940 if (oneline_offset < arg_len) {
2941 p = arg + oneline_offset;
2942 len = arg_len - oneline_offset;
2943 } else {
2944 strbuf_addf(&buf, "Merge branch '%.*s'",
2945 merge_arg_len, arg);
2946 p = buf.buf;
2947 len = buf.len;
2950 ret = write_message(p, len, git_path_merge_msg(the_repository), 0);
2951 strbuf_release(&buf);
2952 if (ret) {
2953 error_errno(_("could not write '%s'"),
2954 git_path_merge_msg(the_repository));
2955 goto leave_merge;
2960 * If HEAD is not identical to the first parent of the original merge
2961 * commit, we cannot fast-forward.
2963 can_fast_forward = opts->allow_ff && commit && commit->parents &&
2964 !oidcmp(&commit->parents->item->object.oid,
2965 &head_commit->object.oid);
2968 * If the merge head is different from the original one, we cannot
2969 * fast-forward.
2971 if (can_fast_forward) {
2972 struct commit_list *second_parent = commit->parents->next;
2974 if (second_parent && !second_parent->next &&
2975 oidcmp(&merge_commit->object.oid,
2976 &second_parent->item->object.oid))
2977 can_fast_forward = 0;
2980 if (can_fast_forward && commit->parents->next &&
2981 !commit->parents->next->next &&
2982 !oidcmp(&commit->parents->next->item->object.oid,
2983 &merge_commit->object.oid)) {
2984 rollback_lock_file(&lock);
2985 ret = fast_forward_to(&commit->object.oid,
2986 &head_commit->object.oid, 0, opts);
2987 goto leave_merge;
2990 write_message(oid_to_hex(&merge_commit->object.oid), GIT_SHA1_HEXSZ,
2991 git_path_merge_head(the_repository), 0);
2992 write_message("no-ff", 5, git_path_merge_mode(the_repository), 0);
2994 bases = get_merge_bases(head_commit, merge_commit);
2995 if (bases && !oidcmp(&merge_commit->object.oid,
2996 &bases->item->object.oid)) {
2997 ret = 0;
2998 /* skip merging an ancestor of HEAD */
2999 goto leave_merge;
3002 for (j = bases; j; j = j->next)
3003 commit_list_insert(j->item, &reversed);
3004 free_commit_list(bases);
3006 read_cache();
3007 init_merge_options(&o);
3008 o.branch1 = "HEAD";
3009 o.branch2 = ref_name.buf;
3010 o.buffer_output = 2;
3012 ret = merge_recursive(&o, head_commit, merge_commit, reversed, &i);
3013 if (ret <= 0)
3014 fputs(o.obuf.buf, stdout);
3015 strbuf_release(&o.obuf);
3016 if (ret < 0) {
3017 error(_("could not even attempt to merge '%.*s'"),
3018 merge_arg_len, arg);
3019 goto leave_merge;
3022 * The return value of merge_recursive() is 1 on clean, and 0 on
3023 * unclean merge.
3025 * Let's reverse that, so that do_merge() returns 0 upon success and
3026 * 1 upon failed merge (keeping the return value -1 for the cases where
3027 * we will want to reschedule the `merge` command).
3029 ret = !ret;
3031 if (active_cache_changed &&
3032 write_locked_index(&the_index, &lock, COMMIT_LOCK)) {
3033 ret = error(_("merge: Unable to write new index file"));
3034 goto leave_merge;
3037 rollback_lock_file(&lock);
3038 if (ret)
3039 rerere(opts->allow_rerere_auto);
3040 else
3042 * In case of problems, we now want to return a positive
3043 * value (a negative one would indicate that the `merge`
3044 * command needs to be rescheduled).
3046 ret = !!run_git_commit(git_path_merge_msg(the_repository), opts,
3047 run_commit_flags);
3049 leave_merge:
3050 strbuf_release(&ref_name);
3051 rollback_lock_file(&lock);
3052 return ret;
3055 static int is_final_fixup(struct todo_list *todo_list)
3057 int i = todo_list->current;
3059 if (!is_fixup(todo_list->items[i].command))
3060 return 0;
3062 while (++i < todo_list->nr)
3063 if (is_fixup(todo_list->items[i].command))
3064 return 0;
3065 else if (!is_noop(todo_list->items[i].command))
3066 break;
3067 return 1;
3070 static enum todo_command peek_command(struct todo_list *todo_list, int offset)
3072 int i;
3074 for (i = todo_list->current + offset; i < todo_list->nr; i++)
3075 if (!is_noop(todo_list->items[i].command))
3076 return todo_list->items[i].command;
3078 return -1;
3081 static int apply_autostash(struct replay_opts *opts)
3083 struct strbuf stash_sha1 = STRBUF_INIT;
3084 struct child_process child = CHILD_PROCESS_INIT;
3085 int ret = 0;
3087 if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
3088 strbuf_release(&stash_sha1);
3089 return 0;
3091 strbuf_trim(&stash_sha1);
3093 child.git_cmd = 1;
3094 child.no_stdout = 1;
3095 child.no_stderr = 1;
3096 argv_array_push(&child.args, "stash");
3097 argv_array_push(&child.args, "apply");
3098 argv_array_push(&child.args, stash_sha1.buf);
3099 if (!run_command(&child))
3100 fprintf(stderr, _("Applied autostash.\n"));
3101 else {
3102 struct child_process store = CHILD_PROCESS_INIT;
3104 store.git_cmd = 1;
3105 argv_array_push(&store.args, "stash");
3106 argv_array_push(&store.args, "store");
3107 argv_array_push(&store.args, "-m");
3108 argv_array_push(&store.args, "autostash");
3109 argv_array_push(&store.args, "-q");
3110 argv_array_push(&store.args, stash_sha1.buf);
3111 if (run_command(&store))
3112 ret = error(_("cannot store %s"), stash_sha1.buf);
3113 else
3114 fprintf(stderr,
3115 _("Applying autostash resulted in conflicts.\n"
3116 "Your changes are safe in the stash.\n"
3117 "You can run \"git stash pop\" or"
3118 " \"git stash drop\" at any time.\n"));
3121 strbuf_release(&stash_sha1);
3122 return ret;
3125 static const char *reflog_message(struct replay_opts *opts,
3126 const char *sub_action, const char *fmt, ...)
3128 va_list ap;
3129 static struct strbuf buf = STRBUF_INIT;
3131 va_start(ap, fmt);
3132 strbuf_reset(&buf);
3133 strbuf_addstr(&buf, action_name(opts));
3134 if (sub_action)
3135 strbuf_addf(&buf, " (%s)", sub_action);
3136 if (fmt) {
3137 strbuf_addstr(&buf, ": ");
3138 strbuf_vaddf(&buf, fmt, ap);
3140 va_end(ap);
3142 return buf.buf;
3145 static const char rescheduled_advice[] =
3146 N_("Could not execute the todo command\n"
3147 "\n"
3148 " %.*s"
3149 "\n"
3150 "It has been rescheduled; To edit the command before continuing, please\n"
3151 "edit the todo list first:\n"
3152 "\n"
3153 " git rebase --edit-todo\n"
3154 " git rebase --continue\n");
3156 static int pick_commits(struct todo_list *todo_list, struct replay_opts *opts)
3158 int res = 0, reschedule = 0;
3160 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
3161 if (opts->allow_ff)
3162 assert(!(opts->signoff || opts->no_commit ||
3163 opts->record_origin || opts->edit));
3164 if (read_and_refresh_cache(opts))
3165 return -1;
3167 while (todo_list->current < todo_list->nr) {
3168 struct todo_item *item = todo_list->items + todo_list->current;
3169 if (save_todo(todo_list, opts))
3170 return -1;
3171 if (is_rebase_i(opts)) {
3172 if (item->command != TODO_COMMENT) {
3173 FILE *f = fopen(rebase_path_msgnum(), "w");
3175 todo_list->done_nr++;
3177 if (f) {
3178 fprintf(f, "%d\n", todo_list->done_nr);
3179 fclose(f);
3181 fprintf(stderr, "Rebasing (%d/%d)%s",
3182 todo_list->done_nr,
3183 todo_list->total_nr,
3184 opts->verbose ? "\n" : "\r");
3186 unlink(rebase_path_message());
3187 unlink(rebase_path_author_script());
3188 unlink(rebase_path_stopped_sha());
3189 unlink(rebase_path_amend());
3190 delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
3192 if (item->command <= TODO_SQUASH) {
3193 if (is_rebase_i(opts))
3194 setenv("GIT_REFLOG_ACTION", reflog_message(opts,
3195 command_to_string(item->command), NULL),
3197 res = do_pick_commit(item->command, item->commit,
3198 opts, is_final_fixup(todo_list));
3199 if (is_rebase_i(opts) && res < 0) {
3200 /* Reschedule */
3201 advise(_(rescheduled_advice),
3202 get_item_line_length(todo_list,
3203 todo_list->current),
3204 get_item_line(todo_list,
3205 todo_list->current));
3206 todo_list->current--;
3207 if (save_todo(todo_list, opts))
3208 return -1;
3210 if (item->command == TODO_EDIT) {
3211 struct commit *commit = item->commit;
3212 if (!res)
3213 fprintf(stderr,
3214 _("Stopped at %s... %.*s\n"),
3215 short_commit_name(commit),
3216 item->arg_len, item->arg);
3217 return error_with_patch(commit,
3218 item->arg, item->arg_len, opts, res,
3219 !res);
3221 if (is_rebase_i(opts) && !res)
3222 record_in_rewritten(&item->commit->object.oid,
3223 peek_command(todo_list, 1));
3224 if (res && is_fixup(item->command)) {
3225 if (res == 1)
3226 intend_to_amend();
3227 return error_failed_squash(item->commit, opts,
3228 item->arg_len, item->arg);
3229 } else if (res && is_rebase_i(opts) && item->commit) {
3230 int to_amend = 0;
3231 struct object_id oid;
3234 * If we are rewording and have either
3235 * fast-forwarded already, or are about to
3236 * create a new root commit, we want to amend,
3237 * otherwise we do not.
3239 if (item->command == TODO_REWORD &&
3240 !get_oid("HEAD", &oid) &&
3241 (!oidcmp(&item->commit->object.oid, &oid) ||
3242 (opts->have_squash_onto &&
3243 !oidcmp(&opts->squash_onto, &oid))))
3244 to_amend = 1;
3246 return res | error_with_patch(item->commit,
3247 item->arg, item->arg_len, opts,
3248 res, to_amend);
3250 } else if (item->command == TODO_EXEC) {
3251 char *end_of_arg = (char *)(item->arg + item->arg_len);
3252 int saved = *end_of_arg;
3253 struct stat st;
3255 *end_of_arg = '\0';
3256 res = do_exec(item->arg);
3257 *end_of_arg = saved;
3259 /* Reread the todo file if it has changed. */
3260 if (res)
3261 ; /* fall through */
3262 else if (stat(get_todo_path(opts), &st))
3263 res = error_errno(_("could not stat '%s'"),
3264 get_todo_path(opts));
3265 else if (match_stat_data(&todo_list->stat, &st)) {
3266 todo_list_release(todo_list);
3267 if (read_populate_todo(todo_list, opts))
3268 res = -1; /* message was printed */
3269 /* `current` will be incremented below */
3270 todo_list->current = -1;
3272 } else if (item->command == TODO_LABEL) {
3273 if ((res = do_label(item->arg, item->arg_len)))
3274 reschedule = 1;
3275 } else if (item->command == TODO_RESET) {
3276 if ((res = do_reset(item->arg, item->arg_len, opts)))
3277 reschedule = 1;
3278 } else if (item->command == TODO_MERGE) {
3279 if ((res = do_merge(item->commit,
3280 item->arg, item->arg_len,
3281 item->flags, opts)) < 0)
3282 reschedule = 1;
3283 else if (item->commit)
3284 record_in_rewritten(&item->commit->object.oid,
3285 peek_command(todo_list, 1));
3286 if (res > 0)
3287 /* failed with merge conflicts */
3288 return error_with_patch(item->commit,
3289 item->arg,
3290 item->arg_len, opts,
3291 res, 0);
3292 } else if (!is_noop(item->command))
3293 return error(_("unknown command %d"), item->command);
3295 if (reschedule) {
3296 advise(_(rescheduled_advice),
3297 get_item_line_length(todo_list,
3298 todo_list->current),
3299 get_item_line(todo_list, todo_list->current));
3300 todo_list->current--;
3301 if (save_todo(todo_list, opts))
3302 return -1;
3303 if (item->commit)
3304 return error_with_patch(item->commit,
3305 item->arg,
3306 item->arg_len, opts,
3307 res, 0);
3310 todo_list->current++;
3311 if (res)
3312 return res;
3315 if (is_rebase_i(opts)) {
3316 struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
3317 struct stat st;
3319 /* Stopped in the middle, as planned? */
3320 if (todo_list->current < todo_list->nr)
3321 return 0;
3323 if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
3324 starts_with(head_ref.buf, "refs/")) {
3325 const char *msg;
3326 struct object_id head, orig;
3327 int res;
3329 if (get_oid("HEAD", &head)) {
3330 res = error(_("cannot read HEAD"));
3331 cleanup_head_ref:
3332 strbuf_release(&head_ref);
3333 strbuf_release(&buf);
3334 return res;
3336 if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
3337 get_oid_hex(buf.buf, &orig)) {
3338 res = error(_("could not read orig-head"));
3339 goto cleanup_head_ref;
3341 strbuf_reset(&buf);
3342 if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
3343 res = error(_("could not read 'onto'"));
3344 goto cleanup_head_ref;
3346 msg = reflog_message(opts, "finish", "%s onto %s",
3347 head_ref.buf, buf.buf);
3348 if (update_ref(msg, head_ref.buf, &head, &orig,
3349 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
3350 res = error(_("could not update %s"),
3351 head_ref.buf);
3352 goto cleanup_head_ref;
3354 msg = reflog_message(opts, "finish", "returning to %s",
3355 head_ref.buf);
3356 if (create_symref("HEAD", head_ref.buf, msg)) {
3357 res = error(_("could not update HEAD to %s"),
3358 head_ref.buf);
3359 goto cleanup_head_ref;
3361 strbuf_reset(&buf);
3364 if (opts->verbose) {
3365 struct rev_info log_tree_opt;
3366 struct object_id orig, head;
3368 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
3369 init_revisions(&log_tree_opt, NULL);
3370 log_tree_opt.diff = 1;
3371 log_tree_opt.diffopt.output_format =
3372 DIFF_FORMAT_DIFFSTAT;
3373 log_tree_opt.disable_stdin = 1;
3375 if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
3376 !get_oid(buf.buf, &orig) &&
3377 !get_oid("HEAD", &head)) {
3378 diff_tree_oid(&orig, &head, "",
3379 &log_tree_opt.diffopt);
3380 log_tree_diff_flush(&log_tree_opt);
3383 flush_rewritten_pending();
3384 if (!stat(rebase_path_rewritten_list(), &st) &&
3385 st.st_size > 0) {
3386 struct child_process child = CHILD_PROCESS_INIT;
3387 const char *post_rewrite_hook =
3388 find_hook("post-rewrite");
3390 child.in = open(rebase_path_rewritten_list(), O_RDONLY);
3391 child.git_cmd = 1;
3392 argv_array_push(&child.args, "notes");
3393 argv_array_push(&child.args, "copy");
3394 argv_array_push(&child.args, "--for-rewrite=rebase");
3395 /* we don't care if this copying failed */
3396 run_command(&child);
3398 if (post_rewrite_hook) {
3399 struct child_process hook = CHILD_PROCESS_INIT;
3401 hook.in = open(rebase_path_rewritten_list(),
3402 O_RDONLY);
3403 hook.stdout_to_stderr = 1;
3404 argv_array_push(&hook.args, post_rewrite_hook);
3405 argv_array_push(&hook.args, "rebase");
3406 /* we don't care if this hook failed */
3407 run_command(&hook);
3410 apply_autostash(opts);
3412 fprintf(stderr, "Successfully rebased and updated %s.\n",
3413 head_ref.buf);
3415 strbuf_release(&buf);
3416 strbuf_release(&head_ref);
3420 * Sequence of picks finished successfully; cleanup by
3421 * removing the .git/sequencer directory
3423 return sequencer_remove_state(opts);
3426 static int continue_single_pick(void)
3428 const char *argv[] = { "commit", NULL };
3430 if (!file_exists(git_path_cherry_pick_head(the_repository)) &&
3431 !file_exists(git_path_revert_head(the_repository)))
3432 return error(_("no cherry-pick or revert in progress"));
3433 return run_command_v_opt(argv, RUN_GIT_CMD);
3436 static int commit_staged_changes(struct replay_opts *opts,
3437 struct todo_list *todo_list)
3439 unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
3440 unsigned int final_fixup = 0, is_clean;
3442 if (has_unstaged_changes(1))
3443 return error(_("cannot rebase: You have unstaged changes."));
3445 is_clean = !has_uncommitted_changes(0);
3447 if (file_exists(rebase_path_amend())) {
3448 struct strbuf rev = STRBUF_INIT;
3449 struct object_id head, to_amend;
3451 if (get_oid("HEAD", &head))
3452 return error(_("cannot amend non-existing commit"));
3453 if (!read_oneliner(&rev, rebase_path_amend(), 0))
3454 return error(_("invalid file: '%s'"), rebase_path_amend());
3455 if (get_oid_hex(rev.buf, &to_amend))
3456 return error(_("invalid contents: '%s'"),
3457 rebase_path_amend());
3458 if (!is_clean && oidcmp(&head, &to_amend))
3459 return error(_("\nYou have uncommitted changes in your "
3460 "working tree. Please, commit them\n"
3461 "first and then run 'git rebase "
3462 "--continue' again."));
3464 * When skipping a failed fixup/squash, we need to edit the
3465 * commit message, the current fixup list and count, and if it
3466 * was the last fixup/squash in the chain, we need to clean up
3467 * the commit message and if there was a squash, let the user
3468 * edit it.
3470 if (is_clean && !oidcmp(&head, &to_amend) &&
3471 opts->current_fixup_count > 0 &&
3472 file_exists(rebase_path_stopped_sha())) {
3473 const char *p = opts->current_fixups.buf;
3474 int len = opts->current_fixups.len;
3476 opts->current_fixup_count--;
3477 if (!len)
3478 BUG("Incorrect current_fixups:\n%s", p);
3479 while (len && p[len - 1] != '\n')
3480 len--;
3481 strbuf_setlen(&opts->current_fixups, len);
3482 if (write_message(p, len, rebase_path_current_fixups(),
3483 0) < 0)
3484 return error(_("could not write file: '%s'"),
3485 rebase_path_current_fixups());
3488 * If a fixup/squash in a fixup/squash chain failed, the
3489 * commit message is already correct, no need to commit
3490 * it again.
3492 * Only if it is the final command in the fixup/squash
3493 * chain, and only if the chain is longer than a single
3494 * fixup/squash command (which was just skipped), do we
3495 * actually need to re-commit with a cleaned up commit
3496 * message.
3498 if (opts->current_fixup_count > 0 &&
3499 !is_fixup(peek_command(todo_list, 0))) {
3500 final_fixup = 1;
3502 * If there was not a single "squash" in the
3503 * chain, we only need to clean up the commit
3504 * message, no need to bother the user with
3505 * opening the commit message in the editor.
3507 if (!starts_with(p, "squash ") &&
3508 !strstr(p, "\nsquash "))
3509 flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;
3510 } else if (is_fixup(peek_command(todo_list, 0))) {
3512 * We need to update the squash message to skip
3513 * the latest commit message.
3515 struct commit *commit;
3516 const char *path = rebase_path_squash_msg();
3518 if (parse_head(&commit) ||
3519 !(p = get_commit_buffer(commit, NULL)) ||
3520 write_message(p, strlen(p), path, 0)) {
3521 unuse_commit_buffer(commit, p);
3522 return error(_("could not write file: "
3523 "'%s'"), path);
3525 unuse_commit_buffer(commit, p);
3529 strbuf_release(&rev);
3530 flags |= AMEND_MSG;
3533 if (is_clean) {
3534 const char *cherry_pick_head = git_path_cherry_pick_head(the_repository);
3536 if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
3537 return error(_("could not remove CHERRY_PICK_HEAD"));
3538 if (!final_fixup)
3539 return 0;
3542 if (run_git_commit(final_fixup ? NULL : rebase_path_message(),
3543 opts, flags))
3544 return error(_("could not commit staged changes."));
3545 unlink(rebase_path_amend());
3546 if (final_fixup) {
3547 unlink(rebase_path_fixup_msg());
3548 unlink(rebase_path_squash_msg());
3550 if (opts->current_fixup_count > 0) {
3552 * Whether final fixup or not, we just cleaned up the commit
3553 * message...
3555 unlink(rebase_path_current_fixups());
3556 strbuf_reset(&opts->current_fixups);
3557 opts->current_fixup_count = 0;
3559 return 0;
3562 int sequencer_continue(struct replay_opts *opts)
3564 struct todo_list todo_list = TODO_LIST_INIT;
3565 int res;
3567 if (read_and_refresh_cache(opts))
3568 return -1;
3570 if (read_populate_opts(opts))
3571 return -1;
3572 if (is_rebase_i(opts)) {
3573 if ((res = read_populate_todo(&todo_list, opts)))
3574 goto release_todo_list;
3575 if (commit_staged_changes(opts, &todo_list))
3576 return -1;
3577 } else if (!file_exists(get_todo_path(opts)))
3578 return continue_single_pick();
3579 else if ((res = read_populate_todo(&todo_list, opts)))
3580 goto release_todo_list;
3582 if (!is_rebase_i(opts)) {
3583 /* Verify that the conflict has been resolved */
3584 if (file_exists(git_path_cherry_pick_head(the_repository)) ||
3585 file_exists(git_path_revert_head(the_repository))) {
3586 res = continue_single_pick();
3587 if (res)
3588 goto release_todo_list;
3590 if (index_differs_from("HEAD", NULL, 0)) {
3591 res = error_dirty_index(opts);
3592 goto release_todo_list;
3594 todo_list.current++;
3595 } else if (file_exists(rebase_path_stopped_sha())) {
3596 struct strbuf buf = STRBUF_INIT;
3597 struct object_id oid;
3599 if (read_oneliner(&buf, rebase_path_stopped_sha(), 1) &&
3600 !get_oid_committish(buf.buf, &oid))
3601 record_in_rewritten(&oid, peek_command(&todo_list, 0));
3602 strbuf_release(&buf);
3605 res = pick_commits(&todo_list, opts);
3606 release_todo_list:
3607 todo_list_release(&todo_list);
3608 return res;
3611 static int single_pick(struct commit *cmit, struct replay_opts *opts)
3613 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
3614 return do_pick_commit(opts->action == REPLAY_PICK ?
3615 TODO_PICK : TODO_REVERT, cmit, opts, 0);
3618 int sequencer_pick_revisions(struct replay_opts *opts)
3620 struct todo_list todo_list = TODO_LIST_INIT;
3621 struct object_id oid;
3622 int i, res;
3624 assert(opts->revs);
3625 if (read_and_refresh_cache(opts))
3626 return -1;
3628 for (i = 0; i < opts->revs->pending.nr; i++) {
3629 struct object_id oid;
3630 const char *name = opts->revs->pending.objects[i].name;
3632 /* This happens when using --stdin. */
3633 if (!strlen(name))
3634 continue;
3636 if (!get_oid(name, &oid)) {
3637 if (!lookup_commit_reference_gently(&oid, 1)) {
3638 enum object_type type = oid_object_info(the_repository,
3639 &oid,
3640 NULL);
3641 return error(_("%s: can't cherry-pick a %s"),
3642 name, type_name(type));
3644 } else
3645 return error(_("%s: bad revision"), name);
3649 * If we were called as "git cherry-pick <commit>", just
3650 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
3651 * REVERT_HEAD, and don't touch the sequencer state.
3652 * This means it is possible to cherry-pick in the middle
3653 * of a cherry-pick sequence.
3655 if (opts->revs->cmdline.nr == 1 &&
3656 opts->revs->cmdline.rev->whence == REV_CMD_REV &&
3657 opts->revs->no_walk &&
3658 !opts->revs->cmdline.rev->flags) {
3659 struct commit *cmit;
3660 if (prepare_revision_walk(opts->revs))
3661 return error(_("revision walk setup failed"));
3662 cmit = get_revision(opts->revs);
3663 if (!cmit)
3664 return error(_("empty commit set passed"));
3665 if (get_revision(opts->revs))
3666 BUG("unexpected extra commit from walk");
3667 return single_pick(cmit, opts);
3671 * Start a new cherry-pick/ revert sequence; but
3672 * first, make sure that an existing one isn't in
3673 * progress
3676 if (walk_revs_populate_todo(&todo_list, opts) ||
3677 create_seq_dir() < 0)
3678 return -1;
3679 if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
3680 return error(_("can't revert as initial commit"));
3681 if (save_head(oid_to_hex(&oid)))
3682 return -1;
3683 if (save_opts(opts))
3684 return -1;
3685 update_abort_safety_file();
3686 res = pick_commits(&todo_list, opts);
3687 todo_list_release(&todo_list);
3688 return res;
3691 void append_signoff(struct strbuf *msgbuf, int ignore_footer, unsigned flag)
3693 unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
3694 struct strbuf sob = STRBUF_INIT;
3695 int has_footer;
3697 strbuf_addstr(&sob, sign_off_header);
3698 strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
3699 getenv("GIT_COMMITTER_EMAIL")));
3700 strbuf_addch(&sob, '\n');
3702 if (!ignore_footer)
3703 strbuf_complete_line(msgbuf);
3706 * If the whole message buffer is equal to the sob, pretend that we
3707 * found a conforming footer with a matching sob
3709 if (msgbuf->len - ignore_footer == sob.len &&
3710 !strncmp(msgbuf->buf, sob.buf, sob.len))
3711 has_footer = 3;
3712 else
3713 has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
3715 if (!has_footer) {
3716 const char *append_newlines = NULL;
3717 size_t len = msgbuf->len - ignore_footer;
3719 if (!len) {
3721 * The buffer is completely empty. Leave foom for
3722 * the title and body to be filled in by the user.
3724 append_newlines = "\n\n";
3725 } else if (len == 1) {
3727 * Buffer contains a single newline. Add another
3728 * so that we leave room for the title and body.
3730 append_newlines = "\n";
3731 } else if (msgbuf->buf[len - 2] != '\n') {
3733 * Buffer ends with a single newline. Add another
3734 * so that there is an empty line between the message
3735 * body and the sob.
3737 append_newlines = "\n";
3738 } /* else, the buffer already ends with two newlines. */
3740 if (append_newlines)
3741 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
3742 append_newlines, strlen(append_newlines));
3745 if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
3746 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
3747 sob.buf, sob.len);
3749 strbuf_release(&sob);
3752 struct labels_entry {
3753 struct hashmap_entry entry;
3754 char label[FLEX_ARRAY];
3757 static int labels_cmp(const void *fndata, const struct labels_entry *a,
3758 const struct labels_entry *b, const void *key)
3760 return key ? strcmp(a->label, key) : strcmp(a->label, b->label);
3763 struct string_entry {
3764 struct oidmap_entry entry;
3765 char string[FLEX_ARRAY];
3768 struct label_state {
3769 struct oidmap commit2label;
3770 struct hashmap labels;
3771 struct strbuf buf;
3774 static const char *label_oid(struct object_id *oid, const char *label,
3775 struct label_state *state)
3777 struct labels_entry *labels_entry;
3778 struct string_entry *string_entry;
3779 struct object_id dummy;
3780 size_t len;
3781 int i;
3783 string_entry = oidmap_get(&state->commit2label, oid);
3784 if (string_entry)
3785 return string_entry->string;
3788 * For "uninteresting" commits, i.e. commits that are not to be
3789 * rebased, and which can therefore not be labeled, we use a unique
3790 * abbreviation of the commit name. This is slightly more complicated
3791 * than calling find_unique_abbrev() because we also need to make
3792 * sure that the abbreviation does not conflict with any other
3793 * label.
3795 * We disallow "interesting" commits to be labeled by a string that
3796 * is a valid full-length hash, to ensure that we always can find an
3797 * abbreviation for any uninteresting commit's names that does not
3798 * clash with any other label.
3800 if (!label) {
3801 char *p;
3803 strbuf_reset(&state->buf);
3804 strbuf_grow(&state->buf, GIT_SHA1_HEXSZ);
3805 label = p = state->buf.buf;
3807 find_unique_abbrev_r(p, oid, default_abbrev);
3810 * We may need to extend the abbreviated hash so that there is
3811 * no conflicting label.
3813 if (hashmap_get_from_hash(&state->labels, strihash(p), p)) {
3814 size_t i = strlen(p) + 1;
3816 oid_to_hex_r(p, oid);
3817 for (; i < GIT_SHA1_HEXSZ; i++) {
3818 char save = p[i];
3819 p[i] = '\0';
3820 if (!hashmap_get_from_hash(&state->labels,
3821 strihash(p), p))
3822 break;
3823 p[i] = save;
3826 } else if (((len = strlen(label)) == the_hash_algo->hexsz &&
3827 !get_oid_hex(label, &dummy)) ||
3828 (len == 1 && *label == '#') ||
3829 hashmap_get_from_hash(&state->labels,
3830 strihash(label), label)) {
3832 * If the label already exists, or if the label is a valid full
3833 * OID, or the label is a '#' (which we use as a separator
3834 * between merge heads and oneline), we append a dash and a
3835 * number to make it unique.
3837 struct strbuf *buf = &state->buf;
3839 strbuf_reset(buf);
3840 strbuf_add(buf, label, len);
3842 for (i = 2; ; i++) {
3843 strbuf_setlen(buf, len);
3844 strbuf_addf(buf, "-%d", i);
3845 if (!hashmap_get_from_hash(&state->labels,
3846 strihash(buf->buf),
3847 buf->buf))
3848 break;
3851 label = buf->buf;
3854 FLEX_ALLOC_STR(labels_entry, label, label);
3855 hashmap_entry_init(labels_entry, strihash(label));
3856 hashmap_add(&state->labels, labels_entry);
3858 FLEX_ALLOC_STR(string_entry, string, label);
3859 oidcpy(&string_entry->entry.oid, oid);
3860 oidmap_put(&state->commit2label, string_entry);
3862 return string_entry->string;
3865 static int make_script_with_merges(struct pretty_print_context *pp,
3866 struct rev_info *revs, FILE *out,
3867 unsigned flags)
3869 int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
3870 int rebase_cousins = flags & TODO_LIST_REBASE_COUSINS;
3871 struct strbuf buf = STRBUF_INIT, oneline = STRBUF_INIT;
3872 struct strbuf label = STRBUF_INIT;
3873 struct commit_list *commits = NULL, **tail = &commits, *iter;
3874 struct commit_list *tips = NULL, **tips_tail = &tips;
3875 struct commit *commit;
3876 struct oidmap commit2todo = OIDMAP_INIT;
3877 struct string_entry *entry;
3878 struct oidset interesting = OIDSET_INIT, child_seen = OIDSET_INIT,
3879 shown = OIDSET_INIT;
3880 struct label_state state = { OIDMAP_INIT, { NULL }, STRBUF_INIT };
3882 int abbr = flags & TODO_LIST_ABBREVIATE_CMDS;
3883 const char *cmd_pick = abbr ? "p" : "pick",
3884 *cmd_label = abbr ? "l" : "label",
3885 *cmd_reset = abbr ? "t" : "reset",
3886 *cmd_merge = abbr ? "m" : "merge";
3888 oidmap_init(&commit2todo, 0);
3889 oidmap_init(&state.commit2label, 0);
3890 hashmap_init(&state.labels, (hashmap_cmp_fn) labels_cmp, NULL, 0);
3891 strbuf_init(&state.buf, 32);
3893 if (revs->cmdline.nr && (revs->cmdline.rev[0].flags & BOTTOM)) {
3894 struct object_id *oid = &revs->cmdline.rev[0].item->oid;
3895 FLEX_ALLOC_STR(entry, string, "onto");
3896 oidcpy(&entry->entry.oid, oid);
3897 oidmap_put(&state.commit2label, entry);
3901 * First phase:
3902 * - get onelines for all commits
3903 * - gather all branch tips (i.e. 2nd or later parents of merges)
3904 * - label all branch tips
3906 while ((commit = get_revision(revs))) {
3907 struct commit_list *to_merge;
3908 int is_octopus;
3909 const char *p1, *p2;
3910 struct object_id *oid;
3911 int is_empty;
3913 tail = &commit_list_insert(commit, tail)->next;
3914 oidset_insert(&interesting, &commit->object.oid);
3916 is_empty = is_original_commit_empty(commit);
3917 if (!is_empty && (commit->object.flags & PATCHSAME))
3918 continue;
3920 strbuf_reset(&oneline);
3921 pretty_print_commit(pp, commit, &oneline);
3923 to_merge = commit->parents ? commit->parents->next : NULL;
3924 if (!to_merge) {
3925 /* non-merge commit: easy case */
3926 strbuf_reset(&buf);
3927 if (!keep_empty && is_empty)
3928 strbuf_addf(&buf, "%c ", comment_line_char);
3929 strbuf_addf(&buf, "%s %s %s", cmd_pick,
3930 oid_to_hex(&commit->object.oid),
3931 oneline.buf);
3933 FLEX_ALLOC_STR(entry, string, buf.buf);
3934 oidcpy(&entry->entry.oid, &commit->object.oid);
3935 oidmap_put(&commit2todo, entry);
3937 continue;
3940 is_octopus = to_merge && to_merge->next;
3942 if (is_octopus)
3943 BUG("Octopus merges not yet supported");
3945 /* Create a label */
3946 strbuf_reset(&label);
3947 if (skip_prefix(oneline.buf, "Merge ", &p1) &&
3948 (p1 = strchr(p1, '\'')) &&
3949 (p2 = strchr(++p1, '\'')))
3950 strbuf_add(&label, p1, p2 - p1);
3951 else if (skip_prefix(oneline.buf, "Merge pull request ",
3952 &p1) &&
3953 (p1 = strstr(p1, " from ")))
3954 strbuf_addstr(&label, p1 + strlen(" from "));
3955 else
3956 strbuf_addbuf(&label, &oneline);
3958 for (p1 = label.buf; *p1; p1++)
3959 if (isspace(*p1))
3960 *(char *)p1 = '-';
3962 strbuf_reset(&buf);
3963 strbuf_addf(&buf, "%s -C %s",
3964 cmd_merge, oid_to_hex(&commit->object.oid));
3966 /* label the tip of merged branch */
3967 oid = &to_merge->item->object.oid;
3968 strbuf_addch(&buf, ' ');
3970 if (!oidset_contains(&interesting, oid))
3971 strbuf_addstr(&buf, label_oid(oid, NULL, &state));
3972 else {
3973 tips_tail = &commit_list_insert(to_merge->item,
3974 tips_tail)->next;
3976 strbuf_addstr(&buf, label_oid(oid, label.buf, &state));
3978 strbuf_addf(&buf, " # %s", oneline.buf);
3980 FLEX_ALLOC_STR(entry, string, buf.buf);
3981 oidcpy(&entry->entry.oid, &commit->object.oid);
3982 oidmap_put(&commit2todo, entry);
3986 * Second phase:
3987 * - label branch points
3988 * - add HEAD to the branch tips
3990 for (iter = commits; iter; iter = iter->next) {
3991 struct commit_list *parent = iter->item->parents;
3992 for (; parent; parent = parent->next) {
3993 struct object_id *oid = &parent->item->object.oid;
3994 if (!oidset_contains(&interesting, oid))
3995 continue;
3996 if (!oidset_contains(&child_seen, oid))
3997 oidset_insert(&child_seen, oid);
3998 else
3999 label_oid(oid, "branch-point", &state);
4002 /* Add HEAD as implict "tip of branch" */
4003 if (!iter->next)
4004 tips_tail = &commit_list_insert(iter->item,
4005 tips_tail)->next;
4009 * Third phase: output the todo list. This is a bit tricky, as we
4010 * want to avoid jumping back and forth between revisions. To
4011 * accomplish that goal, we walk backwards from the branch tips,
4012 * gathering commits not yet shown, reversing the list on the fly,
4013 * then outputting that list (labeling revisions as needed).
4015 fprintf(out, "%s onto\n", cmd_label);
4016 for (iter = tips; iter; iter = iter->next) {
4017 struct commit_list *list = NULL, *iter2;
4019 commit = iter->item;
4020 if (oidset_contains(&shown, &commit->object.oid))
4021 continue;
4022 entry = oidmap_get(&state.commit2label, &commit->object.oid);
4024 if (entry)
4025 fprintf(out, "\n%c Branch %s\n", comment_line_char, entry->string);
4026 else
4027 fprintf(out, "\n");
4029 while (oidset_contains(&interesting, &commit->object.oid) &&
4030 !oidset_contains(&shown, &commit->object.oid)) {
4031 commit_list_insert(commit, &list);
4032 if (!commit->parents) {
4033 commit = NULL;
4034 break;
4036 commit = commit->parents->item;
4039 if (!commit)
4040 fprintf(out, "%s %s\n", cmd_reset,
4041 rebase_cousins ? "onto" : "[new root]");
4042 else {
4043 const char *to = NULL;
4045 entry = oidmap_get(&state.commit2label,
4046 &commit->object.oid);
4047 if (entry)
4048 to = entry->string;
4049 else if (!rebase_cousins)
4050 to = label_oid(&commit->object.oid, NULL,
4051 &state);
4053 if (!to || !strcmp(to, "onto"))
4054 fprintf(out, "%s onto\n", cmd_reset);
4055 else {
4056 strbuf_reset(&oneline);
4057 pretty_print_commit(pp, commit, &oneline);
4058 fprintf(out, "%s %s # %s\n",
4059 cmd_reset, to, oneline.buf);
4063 for (iter2 = list; iter2; iter2 = iter2->next) {
4064 struct object_id *oid = &iter2->item->object.oid;
4065 entry = oidmap_get(&commit2todo, oid);
4066 /* only show if not already upstream */
4067 if (entry)
4068 fprintf(out, "%s\n", entry->string);
4069 entry = oidmap_get(&state.commit2label, oid);
4070 if (entry)
4071 fprintf(out, "%s %s\n",
4072 cmd_label, entry->string);
4073 oidset_insert(&shown, oid);
4076 free_commit_list(list);
4079 free_commit_list(commits);
4080 free_commit_list(tips);
4082 strbuf_release(&label);
4083 strbuf_release(&oneline);
4084 strbuf_release(&buf);
4086 oidmap_free(&commit2todo, 1);
4087 oidmap_free(&state.commit2label, 1);
4088 hashmap_free(&state.labels, 1);
4089 strbuf_release(&state.buf);
4091 return 0;
4094 int sequencer_make_script(FILE *out, int argc, const char **argv,
4095 unsigned flags)
4097 char *format = NULL;
4098 struct pretty_print_context pp = {0};
4099 struct strbuf buf = STRBUF_INIT;
4100 struct rev_info revs;
4101 struct commit *commit;
4102 int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4103 const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";
4104 int rebase_merges = flags & TODO_LIST_REBASE_MERGES;
4106 init_revisions(&revs, NULL);
4107 revs.verbose_header = 1;
4108 if (!rebase_merges)
4109 revs.max_parents = 1;
4110 revs.cherry_mark = 1;
4111 revs.limited = 1;
4112 revs.reverse = 1;
4113 revs.right_only = 1;
4114 revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
4115 revs.topo_order = 1;
4117 revs.pretty_given = 1;
4118 git_config_get_string("rebase.instructionFormat", &format);
4119 if (!format || !*format) {
4120 free(format);
4121 format = xstrdup("%s");
4123 get_commit_format(format, &revs);
4124 free(format);
4125 pp.fmt = revs.commit_format;
4126 pp.output_encoding = get_log_output_encoding();
4128 if (setup_revisions(argc, argv, &revs, NULL) > 1)
4129 return error(_("make_script: unhandled options"));
4131 if (prepare_revision_walk(&revs) < 0)
4132 return error(_("make_script: error preparing revisions"));
4134 if (rebase_merges)
4135 return make_script_with_merges(&pp, &revs, out, flags);
4137 while ((commit = get_revision(&revs))) {
4138 int is_empty = is_original_commit_empty(commit);
4140 if (!is_empty && (commit->object.flags & PATCHSAME))
4141 continue;
4142 strbuf_reset(&buf);
4143 if (!keep_empty && is_empty)
4144 strbuf_addf(&buf, "%c ", comment_line_char);
4145 strbuf_addf(&buf, "%s %s ", insn,
4146 oid_to_hex(&commit->object.oid));
4147 pretty_print_commit(&pp, commit, &buf);
4148 strbuf_addch(&buf, '\n');
4149 fputs(buf.buf, out);
4151 strbuf_release(&buf);
4152 return 0;
4156 * Add commands after pick and (series of) squash/fixup commands
4157 * in the todo list.
4159 int sequencer_add_exec_commands(const char *commands)
4161 const char *todo_file = rebase_path_todo();
4162 struct todo_list todo_list = TODO_LIST_INIT;
4163 struct todo_item *item;
4164 struct strbuf *buf = &todo_list.buf;
4165 size_t offset = 0, commands_len = strlen(commands);
4166 int i, first;
4168 if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
4169 return error(_("could not read '%s'."), todo_file);
4171 if (parse_insn_buffer(todo_list.buf.buf, &todo_list)) {
4172 todo_list_release(&todo_list);
4173 return error(_("unusable todo list: '%s'"), todo_file);
4176 first = 1;
4177 /* insert <commands> before every pick except the first one */
4178 for (item = todo_list.items, i = 0; i < todo_list.nr; i++, item++) {
4179 if (item->command == TODO_PICK && !first) {
4180 strbuf_insert(buf, item->offset_in_buf + offset,
4181 commands, commands_len);
4182 offset += commands_len;
4184 first = 0;
4187 /* append final <commands> */
4188 strbuf_add(buf, commands, commands_len);
4190 i = write_message(buf->buf, buf->len, todo_file, 0);
4191 todo_list_release(&todo_list);
4192 return i;
4195 int transform_todos(unsigned flags)
4197 const char *todo_file = rebase_path_todo();
4198 struct todo_list todo_list = TODO_LIST_INIT;
4199 struct strbuf buf = STRBUF_INIT;
4200 struct todo_item *item;
4201 int i;
4203 if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
4204 return error(_("could not read '%s'."), todo_file);
4206 if (parse_insn_buffer(todo_list.buf.buf, &todo_list)) {
4207 todo_list_release(&todo_list);
4208 return error(_("unusable todo list: '%s'"), todo_file);
4211 for (item = todo_list.items, i = 0; i < todo_list.nr; i++, item++) {
4212 /* if the item is not a command write it and continue */
4213 if (item->command >= TODO_COMMENT) {
4214 strbuf_addf(&buf, "%.*s\n", item->arg_len, item->arg);
4215 continue;
4218 /* add command to the buffer */
4219 if (flags & TODO_LIST_ABBREVIATE_CMDS)
4220 strbuf_addch(&buf, command_to_char(item->command));
4221 else
4222 strbuf_addstr(&buf, command_to_string(item->command));
4224 /* add commit id */
4225 if (item->commit) {
4226 const char *oid = flags & TODO_LIST_SHORTEN_IDS ?
4227 short_commit_name(item->commit) :
4228 oid_to_hex(&item->commit->object.oid);
4230 if (item->command == TODO_MERGE) {
4231 if (item->flags & TODO_EDIT_MERGE_MSG)
4232 strbuf_addstr(&buf, " -c");
4233 else
4234 strbuf_addstr(&buf, " -C");
4237 strbuf_addf(&buf, " %s", oid);
4240 /* add all the rest */
4241 if (!item->arg_len)
4242 strbuf_addch(&buf, '\n');
4243 else
4244 strbuf_addf(&buf, " %.*s\n", item->arg_len, item->arg);
4247 i = write_message(buf.buf, buf.len, todo_file, 0);
4248 todo_list_release(&todo_list);
4249 return i;
4252 enum check_level {
4253 CHECK_IGNORE = 0, CHECK_WARN, CHECK_ERROR
4256 static enum check_level get_missing_commit_check_level(void)
4258 const char *value;
4260 if (git_config_get_value("rebase.missingcommitscheck", &value) ||
4261 !strcasecmp("ignore", value))
4262 return CHECK_IGNORE;
4263 if (!strcasecmp("warn", value))
4264 return CHECK_WARN;
4265 if (!strcasecmp("error", value))
4266 return CHECK_ERROR;
4267 warning(_("unrecognized setting %s for option "
4268 "rebase.missingCommitsCheck. Ignoring."), value);
4269 return CHECK_IGNORE;
4272 define_commit_slab(commit_seen, unsigned char);
4274 * Check if the user dropped some commits by mistake
4275 * Behaviour determined by rebase.missingCommitsCheck.
4276 * Check if there is an unrecognized command or a
4277 * bad SHA-1 in a command.
4279 int check_todo_list(void)
4281 enum check_level check_level = get_missing_commit_check_level();
4282 struct strbuf todo_file = STRBUF_INIT;
4283 struct todo_list todo_list = TODO_LIST_INIT;
4284 struct strbuf missing = STRBUF_INIT;
4285 int advise_to_edit_todo = 0, res = 0, i;
4286 struct commit_seen commit_seen;
4288 init_commit_seen(&commit_seen);
4290 strbuf_addstr(&todo_file, rebase_path_todo());
4291 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file.buf) < 0) {
4292 res = -1;
4293 goto leave_check;
4295 advise_to_edit_todo = res =
4296 parse_insn_buffer(todo_list.buf.buf, &todo_list);
4298 if (res || check_level == CHECK_IGNORE)
4299 goto leave_check;
4301 /* Mark the commits in git-rebase-todo as seen */
4302 for (i = 0; i < todo_list.nr; i++) {
4303 struct commit *commit = todo_list.items[i].commit;
4304 if (commit)
4305 *commit_seen_at(&commit_seen, commit) = 1;
4308 todo_list_release(&todo_list);
4309 strbuf_addstr(&todo_file, ".backup");
4310 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file.buf) < 0) {
4311 res = -1;
4312 goto leave_check;
4314 strbuf_release(&todo_file);
4315 res = !!parse_insn_buffer(todo_list.buf.buf, &todo_list);
4317 /* Find commits in git-rebase-todo.backup yet unseen */
4318 for (i = todo_list.nr - 1; i >= 0; i--) {
4319 struct todo_item *item = todo_list.items + i;
4320 struct commit *commit = item->commit;
4321 if (commit && !*commit_seen_at(&commit_seen, commit)) {
4322 strbuf_addf(&missing, " - %s %.*s\n",
4323 short_commit_name(commit),
4324 item->arg_len, item->arg);
4325 *commit_seen_at(&commit_seen, commit) = 1;
4329 /* Warn about missing commits */
4330 if (!missing.len)
4331 goto leave_check;
4333 if (check_level == CHECK_ERROR)
4334 advise_to_edit_todo = res = 1;
4336 fprintf(stderr,
4337 _("Warning: some commits may have been dropped accidentally.\n"
4338 "Dropped commits (newer to older):\n"));
4340 /* Make the list user-friendly and display */
4341 fputs(missing.buf, stderr);
4342 strbuf_release(&missing);
4344 fprintf(stderr, _("To avoid this message, use \"drop\" to "
4345 "explicitly remove a commit.\n\n"
4346 "Use 'git config rebase.missingCommitsCheck' to change "
4347 "the level of warnings.\n"
4348 "The possible behaviours are: ignore, warn, error.\n\n"));
4350 leave_check:
4351 clear_commit_seen(&commit_seen);
4352 strbuf_release(&todo_file);
4353 todo_list_release(&todo_list);
4355 if (advise_to_edit_todo)
4356 fprintf(stderr,
4357 _("You can fix this with 'git rebase --edit-todo' "
4358 "and then run 'git rebase --continue'.\n"
4359 "Or you can abort the rebase with 'git rebase"
4360 " --abort'.\n"));
4362 return res;
4365 static int rewrite_file(const char *path, const char *buf, size_t len)
4367 int rc = 0;
4368 int fd = open(path, O_WRONLY | O_TRUNC);
4369 if (fd < 0)
4370 return error_errno(_("could not open '%s' for writing"), path);
4371 if (write_in_full(fd, buf, len) < 0)
4372 rc = error_errno(_("could not write to '%s'"), path);
4373 if (close(fd) && !rc)
4374 rc = error_errno(_("could not close '%s'"), path);
4375 return rc;
4378 /* skip picking commits whose parents are unchanged */
4379 int skip_unnecessary_picks(void)
4381 const char *todo_file = rebase_path_todo();
4382 struct strbuf buf = STRBUF_INIT;
4383 struct todo_list todo_list = TODO_LIST_INIT;
4384 struct object_id onto_oid, *oid = &onto_oid, *parent_oid;
4385 int fd, i;
4387 if (!read_oneliner(&buf, rebase_path_onto(), 0))
4388 return error(_("could not read 'onto'"));
4389 if (get_oid(buf.buf, &onto_oid)) {
4390 strbuf_release(&buf);
4391 return error(_("need a HEAD to fixup"));
4393 strbuf_release(&buf);
4395 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file) < 0)
4396 return -1;
4397 if (parse_insn_buffer(todo_list.buf.buf, &todo_list) < 0) {
4398 todo_list_release(&todo_list);
4399 return -1;
4402 for (i = 0; i < todo_list.nr; i++) {
4403 struct todo_item *item = todo_list.items + i;
4405 if (item->command >= TODO_NOOP)
4406 continue;
4407 if (item->command != TODO_PICK)
4408 break;
4409 if (parse_commit(item->commit)) {
4410 todo_list_release(&todo_list);
4411 return error(_("could not parse commit '%s'"),
4412 oid_to_hex(&item->commit->object.oid));
4414 if (!item->commit->parents)
4415 break; /* root commit */
4416 if (item->commit->parents->next)
4417 break; /* merge commit */
4418 parent_oid = &item->commit->parents->item->object.oid;
4419 if (hashcmp(parent_oid->hash, oid->hash))
4420 break;
4421 oid = &item->commit->object.oid;
4423 if (i > 0) {
4424 int offset = get_item_line_offset(&todo_list, i);
4425 const char *done_path = rebase_path_done();
4427 fd = open(done_path, O_CREAT | O_WRONLY | O_APPEND, 0666);
4428 if (fd < 0) {
4429 error_errno(_("could not open '%s' for writing"),
4430 done_path);
4431 todo_list_release(&todo_list);
4432 return -1;
4434 if (write_in_full(fd, todo_list.buf.buf, offset) < 0) {
4435 error_errno(_("could not write to '%s'"), done_path);
4436 todo_list_release(&todo_list);
4437 close(fd);
4438 return -1;
4440 close(fd);
4442 if (rewrite_file(rebase_path_todo(), todo_list.buf.buf + offset,
4443 todo_list.buf.len - offset) < 0) {
4444 todo_list_release(&todo_list);
4445 return -1;
4448 todo_list.current = i;
4449 if (is_fixup(peek_command(&todo_list, 0)))
4450 record_in_rewritten(oid, peek_command(&todo_list, 0));
4453 todo_list_release(&todo_list);
4454 printf("%s\n", oid_to_hex(oid));
4456 return 0;
4459 struct subject2item_entry {
4460 struct hashmap_entry entry;
4461 int i;
4462 char subject[FLEX_ARRAY];
4465 static int subject2item_cmp(const void *fndata,
4466 const struct subject2item_entry *a,
4467 const struct subject2item_entry *b, const void *key)
4469 return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
4472 define_commit_slab(commit_todo_item, struct todo_item *);
4475 * Rearrange the todo list that has both "pick commit-id msg" and "pick
4476 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
4477 * after the former, and change "pick" to "fixup"/"squash".
4479 * Note that if the config has specified a custom instruction format, each log
4480 * message will have to be retrieved from the commit (as the oneline in the
4481 * script cannot be trusted) in order to normalize the autosquash arrangement.
4483 int rearrange_squash(void)
4485 const char *todo_file = rebase_path_todo();
4486 struct todo_list todo_list = TODO_LIST_INIT;
4487 struct hashmap subject2item;
4488 int res = 0, rearranged = 0, *next, *tail, i;
4489 char **subjects;
4490 struct commit_todo_item commit_todo;
4492 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file) < 0)
4493 return -1;
4494 if (parse_insn_buffer(todo_list.buf.buf, &todo_list) < 0) {
4495 todo_list_release(&todo_list);
4496 return -1;
4499 init_commit_todo_item(&commit_todo);
4501 * The hashmap maps onelines to the respective todo list index.
4503 * If any items need to be rearranged, the next[i] value will indicate
4504 * which item was moved directly after the i'th.
4506 * In that case, last[i] will indicate the index of the latest item to
4507 * be moved to appear after the i'th.
4509 hashmap_init(&subject2item, (hashmap_cmp_fn) subject2item_cmp,
4510 NULL, todo_list.nr);
4511 ALLOC_ARRAY(next, todo_list.nr);
4512 ALLOC_ARRAY(tail, todo_list.nr);
4513 ALLOC_ARRAY(subjects, todo_list.nr);
4514 for (i = 0; i < todo_list.nr; i++) {
4515 struct strbuf buf = STRBUF_INIT;
4516 struct todo_item *item = todo_list.items + i;
4517 const char *commit_buffer, *subject, *p;
4518 size_t subject_len;
4519 int i2 = -1;
4520 struct subject2item_entry *entry;
4522 next[i] = tail[i] = -1;
4523 if (!item->commit || item->command == TODO_DROP) {
4524 subjects[i] = NULL;
4525 continue;
4528 if (is_fixup(item->command)) {
4529 todo_list_release(&todo_list);
4530 clear_commit_todo_item(&commit_todo);
4531 return error(_("the script was already rearranged."));
4534 *commit_todo_item_at(&commit_todo, item->commit) = item;
4536 parse_commit(item->commit);
4537 commit_buffer = get_commit_buffer(item->commit, NULL);
4538 find_commit_subject(commit_buffer, &subject);
4539 format_subject(&buf, subject, " ");
4540 subject = subjects[i] = strbuf_detach(&buf, &subject_len);
4541 unuse_commit_buffer(item->commit, commit_buffer);
4542 if ((skip_prefix(subject, "fixup! ", &p) ||
4543 skip_prefix(subject, "squash! ", &p))) {
4544 struct commit *commit2;
4546 for (;;) {
4547 while (isspace(*p))
4548 p++;
4549 if (!skip_prefix(p, "fixup! ", &p) &&
4550 !skip_prefix(p, "squash! ", &p))
4551 break;
4554 if ((entry = hashmap_get_from_hash(&subject2item,
4555 strhash(p), p)))
4556 /* found by title */
4557 i2 = entry->i;
4558 else if (!strchr(p, ' ') &&
4559 (commit2 =
4560 lookup_commit_reference_by_name(p)) &&
4561 *commit_todo_item_at(&commit_todo, commit2))
4562 /* found by commit name */
4563 i2 = *commit_todo_item_at(&commit_todo, commit2)
4564 - todo_list.items;
4565 else {
4566 /* copy can be a prefix of the commit subject */
4567 for (i2 = 0; i2 < i; i2++)
4568 if (subjects[i2] &&
4569 starts_with(subjects[i2], p))
4570 break;
4571 if (i2 == i)
4572 i2 = -1;
4575 if (i2 >= 0) {
4576 rearranged = 1;
4577 todo_list.items[i].command =
4578 starts_with(subject, "fixup!") ?
4579 TODO_FIXUP : TODO_SQUASH;
4580 if (next[i2] < 0)
4581 next[i2] = i;
4582 else
4583 next[tail[i2]] = i;
4584 tail[i2] = i;
4585 } else if (!hashmap_get_from_hash(&subject2item,
4586 strhash(subject), subject)) {
4587 FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
4588 entry->i = i;
4589 hashmap_entry_init(entry, strhash(entry->subject));
4590 hashmap_put(&subject2item, entry);
4594 if (rearranged) {
4595 struct strbuf buf = STRBUF_INIT;
4597 for (i = 0; i < todo_list.nr; i++) {
4598 enum todo_command command = todo_list.items[i].command;
4599 int cur = i;
4602 * Initially, all commands are 'pick's. If it is a
4603 * fixup or a squash now, we have rearranged it.
4605 if (is_fixup(command))
4606 continue;
4608 while (cur >= 0) {
4609 const char *bol =
4610 get_item_line(&todo_list, cur);
4611 const char *eol =
4612 get_item_line(&todo_list, cur + 1);
4614 /* replace 'pick', by 'fixup' or 'squash' */
4615 command = todo_list.items[cur].command;
4616 if (is_fixup(command)) {
4617 strbuf_addstr(&buf,
4618 todo_command_info[command].str);
4619 bol += strcspn(bol, " \t");
4622 strbuf_add(&buf, bol, eol - bol);
4624 cur = next[cur];
4628 res = rewrite_file(todo_file, buf.buf, buf.len);
4629 strbuf_release(&buf);
4632 free(next);
4633 free(tail);
4634 for (i = 0; i < todo_list.nr; i++)
4635 free(subjects[i]);
4636 free(subjects);
4637 hashmap_free(&subject2item, 1);
4638 todo_list_release(&todo_list);
4640 clear_commit_todo_item(&commit_todo);
4641 return res;