The third batch
[git.git] / sequencer.c
blob95dda23eee450d1d60a70434d254071c6c05146b
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"
33 #include "commit-reach.h"
34 #include "rebase-interactive.h"
36 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
38 static const char sign_off_header[] = "Signed-off-by: ";
39 static const char cherry_picked_prefix[] = "(cherry picked from commit ";
41 GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
43 GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
45 static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
46 static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
47 static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
48 static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
50 static GIT_PATH_FUNC(rebase_path, "rebase-merge")
52 * The file containing rebase commands, comments, and empty lines.
53 * This file is created by "git rebase -i" then edited by the user. As
54 * the lines are processed, they are removed from the front of this
55 * file and written to the tail of 'done'.
57 GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
58 static GIT_PATH_FUNC(rebase_path_todo_backup,
59 "rebase-merge/git-rebase-todo.backup")
62 * The rebase command lines that have already been processed. A line
63 * is moved here when it is first handled, before any associated user
64 * actions.
66 static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
68 * The file to keep track of how many commands were already processed (e.g.
69 * for the prompt).
71 static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum")
73 * The file to keep track of how many commands are to be processed in total
74 * (e.g. for the prompt).
76 static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end")
78 * The commit message that is planned to be used for any changes that
79 * need to be committed following a user interaction.
81 static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
83 * The file into which is accumulated the suggested commit message for
84 * squash/fixup commands. When the first of a series of squash/fixups
85 * is seen, the file is created and the commit message from the
86 * previous commit and from the first squash/fixup commit are written
87 * to it. The commit message for each subsequent squash/fixup commit
88 * is appended to the file as it is processed.
90 static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
92 * If the current series of squash/fixups has not yet included a squash
93 * command, then this file exists and holds the commit message of the
94 * original "pick" commit. (If the series ends without a "squash"
95 * command, then this can be used as the commit message of the combined
96 * commit without opening the editor.)
98 static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
100 * This file contains the list fixup/squash commands that have been
101 * accumulated into message-fixup or message-squash so far.
103 static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")
105 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
106 * GIT_AUTHOR_DATE that will be used for the commit that is currently
107 * being rebased.
109 static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
111 * When an "edit" rebase command is being processed, the SHA1 of the
112 * commit to be edited is recorded in this file. When "git rebase
113 * --continue" is executed, if there are any staged changes then they
114 * will be amended to the HEAD commit, but only provided the HEAD
115 * commit is still the commit to be edited. When any other rebase
116 * command is processed, this file is deleted.
118 static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
120 * When we stop at a given patch via the "edit" command, this file contains
121 * the abbreviated commit name of the corresponding patch.
123 static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
125 * For the post-rewrite hook, we make a list of rewritten commits and
126 * their new sha1s. The rewritten-pending list keeps the sha1s of
127 * commits that have been processed, but not committed yet,
128 * e.g. because they are waiting for a 'squash' command.
130 static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
131 static GIT_PATH_FUNC(rebase_path_rewritten_pending,
132 "rebase-merge/rewritten-pending")
135 * The path of the file containig the OID of the "squash onto" commit, i.e.
136 * the dummy commit used for `reset [new root]`.
138 static GIT_PATH_FUNC(rebase_path_squash_onto, "rebase-merge/squash-onto")
141 * The path of the file listing refs that need to be deleted after the rebase
142 * finishes. This is used by the `label` command to record the need for cleanup.
144 static GIT_PATH_FUNC(rebase_path_refs_to_delete, "rebase-merge/refs-to-delete")
147 * The following files are written by git-rebase just after parsing the
148 * command-line.
150 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
151 static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
152 static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
153 static GIT_PATH_FUNC(rebase_path_quiet, "rebase-merge/quiet")
154 static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")
155 static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
156 static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
157 static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
158 static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
159 static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
160 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
161 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec, "rebase-merge/reschedule-failed-exec")
163 static int git_sequencer_config(const char *k, const char *v, void *cb)
165 struct replay_opts *opts = cb;
166 int status;
168 if (!strcmp(k, "commit.cleanup")) {
169 const char *s;
171 status = git_config_string(&s, k, v);
172 if (status)
173 return status;
175 if (!strcmp(s, "verbatim"))
176 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
177 else if (!strcmp(s, "whitespace"))
178 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
179 else if (!strcmp(s, "strip"))
180 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
181 else if (!strcmp(s, "scissors"))
182 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
183 else
184 warning(_("invalid commit message cleanup mode '%s'"),
187 free((char *)s);
188 return status;
191 if (!strcmp(k, "commit.gpgsign")) {
192 opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
193 return 0;
196 status = git_gpg_config(k, v, NULL);
197 if (status)
198 return status;
200 return git_diff_basic_config(k, v, NULL);
203 void sequencer_init_config(struct replay_opts *opts)
205 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
206 git_config(git_sequencer_config, opts);
209 static inline int is_rebase_i(const struct replay_opts *opts)
211 return opts->action == REPLAY_INTERACTIVE_REBASE;
214 static const char *get_dir(const struct replay_opts *opts)
216 if (is_rebase_i(opts))
217 return rebase_path();
218 return git_path_seq_dir();
221 static const char *get_todo_path(const struct replay_opts *opts)
223 if (is_rebase_i(opts))
224 return rebase_path_todo();
225 return git_path_todo_file();
229 * Returns 0 for non-conforming footer
230 * Returns 1 for conforming footer
231 * Returns 2 when sob exists within conforming footer
232 * Returns 3 when sob exists within conforming footer as last entry
234 static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
235 size_t ignore_footer)
237 struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
238 struct trailer_info info;
239 size_t i;
240 int found_sob = 0, found_sob_last = 0;
242 opts.no_divider = 1;
244 trailer_info_get(&info, sb->buf, &opts);
246 if (info.trailer_start == info.trailer_end)
247 return 0;
249 for (i = 0; i < info.trailer_nr; i++)
250 if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
251 found_sob = 1;
252 if (i == info.trailer_nr - 1)
253 found_sob_last = 1;
256 trailer_info_release(&info);
258 if (found_sob_last)
259 return 3;
260 if (found_sob)
261 return 2;
262 return 1;
265 static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
267 static struct strbuf buf = STRBUF_INIT;
269 strbuf_reset(&buf);
270 if (opts->gpg_sign)
271 sq_quotef(&buf, "-S%s", opts->gpg_sign);
272 return buf.buf;
275 int sequencer_remove_state(struct replay_opts *opts)
277 struct strbuf buf = STRBUF_INIT;
278 int i;
280 if (is_rebase_i(opts) &&
281 strbuf_read_file(&buf, rebase_path_refs_to_delete(), 0) > 0) {
282 char *p = buf.buf;
283 while (*p) {
284 char *eol = strchr(p, '\n');
285 if (eol)
286 *eol = '\0';
287 if (delete_ref("(rebase -i) cleanup", p, NULL, 0) < 0)
288 warning(_("could not delete '%s'"), p);
289 if (!eol)
290 break;
291 p = eol + 1;
295 free(opts->gpg_sign);
296 free(opts->strategy);
297 for (i = 0; i < opts->xopts_nr; i++)
298 free(opts->xopts[i]);
299 free(opts->xopts);
300 strbuf_release(&opts->current_fixups);
302 strbuf_reset(&buf);
303 strbuf_addstr(&buf, get_dir(opts));
304 remove_dir_recursively(&buf, 0);
305 strbuf_release(&buf);
307 return 0;
310 static const char *action_name(const struct replay_opts *opts)
312 switch (opts->action) {
313 case REPLAY_REVERT:
314 return N_("revert");
315 case REPLAY_PICK:
316 return N_("cherry-pick");
317 case REPLAY_INTERACTIVE_REBASE:
318 return N_("rebase -i");
320 die(_("unknown action: %d"), opts->action);
323 struct commit_message {
324 char *parent_label;
325 char *label;
326 char *subject;
327 const char *message;
330 static const char *short_commit_name(struct commit *commit)
332 return find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV);
335 static int get_message(struct commit *commit, struct commit_message *out)
337 const char *abbrev, *subject;
338 int subject_len;
340 out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
341 abbrev = short_commit_name(commit);
343 subject_len = find_commit_subject(out->message, &subject);
345 out->subject = xmemdupz(subject, subject_len);
346 out->label = xstrfmt("%s... %s", abbrev, out->subject);
347 out->parent_label = xstrfmt("parent of %s", out->label);
349 return 0;
352 static void free_message(struct commit *commit, struct commit_message *msg)
354 free(msg->parent_label);
355 free(msg->label);
356 free(msg->subject);
357 unuse_commit_buffer(commit, msg->message);
360 static void print_advice(struct repository *r, int show_hint,
361 struct replay_opts *opts)
363 char *msg = getenv("GIT_CHERRY_PICK_HELP");
365 if (msg) {
366 fprintf(stderr, "%s\n", msg);
368 * A conflict has occurred but the porcelain
369 * (typically rebase --interactive) wants to take care
370 * of the commit itself so remove CHERRY_PICK_HEAD
372 unlink(git_path_cherry_pick_head(r));
373 return;
376 if (show_hint) {
377 if (opts->no_commit)
378 advise(_("after resolving the conflicts, mark the corrected paths\n"
379 "with 'git add <paths>' or 'git rm <paths>'"));
380 else
381 advise(_("after resolving the conflicts, mark the corrected paths\n"
382 "with 'git add <paths>' or 'git rm <paths>'\n"
383 "and commit the result with 'git commit'"));
387 int write_message(const void *buf, size_t len, const char *filename,
388 int append_eol)
390 struct lock_file msg_file = LOCK_INIT;
392 int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
393 if (msg_fd < 0)
394 return error_errno(_("could not lock '%s'"), filename);
395 if (write_in_full(msg_fd, buf, len) < 0) {
396 error_errno(_("could not write to '%s'"), filename);
397 rollback_lock_file(&msg_file);
398 return -1;
400 if (append_eol && write(msg_fd, "\n", 1) < 0) {
401 error_errno(_("could not write eol to '%s'"), filename);
402 rollback_lock_file(&msg_file);
403 return -1;
405 if (commit_lock_file(&msg_file) < 0)
406 return error(_("failed to finalize '%s'"), filename);
408 return 0;
412 * Reads a file that was presumably written by a shell script, i.e. with an
413 * end-of-line marker that needs to be stripped.
415 * Note that only the last end-of-line marker is stripped, consistent with the
416 * behavior of "$(cat path)" in a shell script.
418 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
420 static int read_oneliner(struct strbuf *buf,
421 const char *path, int skip_if_empty)
423 int orig_len = buf->len;
425 if (!file_exists(path))
426 return 0;
428 if (strbuf_read_file(buf, path, 0) < 0) {
429 warning_errno(_("could not read '%s'"), path);
430 return 0;
433 if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
434 if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
435 --buf->len;
436 buf->buf[buf->len] = '\0';
439 if (skip_if_empty && buf->len == orig_len)
440 return 0;
442 return 1;
445 static struct tree *empty_tree(struct repository *r)
447 return lookup_tree(r, the_hash_algo->empty_tree);
450 static int error_dirty_index(struct repository *repo, struct replay_opts *opts)
452 if (repo_read_index_unmerged(repo))
453 return error_resolve_conflict(_(action_name(opts)));
455 error(_("your local changes would be overwritten by %s."),
456 _(action_name(opts)));
458 if (advice_commit_before_merge)
459 advise(_("commit your changes or stash them to proceed."));
460 return -1;
463 static void update_abort_safety_file(void)
465 struct object_id head;
467 /* Do nothing on a single-pick */
468 if (!file_exists(git_path_seq_dir()))
469 return;
471 if (!get_oid("HEAD", &head))
472 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
473 else
474 write_file(git_path_abort_safety_file(), "%s", "");
477 static int fast_forward_to(struct repository *r,
478 const struct object_id *to,
479 const struct object_id *from,
480 int unborn,
481 struct replay_opts *opts)
483 struct ref_transaction *transaction;
484 struct strbuf sb = STRBUF_INIT;
485 struct strbuf err = STRBUF_INIT;
487 repo_read_index(r);
488 if (checkout_fast_forward(r, from, to, 1))
489 return -1; /* the callee should have complained already */
491 strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
493 transaction = ref_transaction_begin(&err);
494 if (!transaction ||
495 ref_transaction_update(transaction, "HEAD",
496 to, unborn && !is_rebase_i(opts) ?
497 &null_oid : from,
498 0, sb.buf, &err) ||
499 ref_transaction_commit(transaction, &err)) {
500 ref_transaction_free(transaction);
501 error("%s", err.buf);
502 strbuf_release(&sb);
503 strbuf_release(&err);
504 return -1;
507 strbuf_release(&sb);
508 strbuf_release(&err);
509 ref_transaction_free(transaction);
510 update_abort_safety_file();
511 return 0;
514 void append_conflicts_hint(struct index_state *istate,
515 struct strbuf *msgbuf)
517 int i;
519 strbuf_addch(msgbuf, '\n');
520 strbuf_commented_addf(msgbuf, "Conflicts:\n");
521 for (i = 0; i < istate->cache_nr;) {
522 const struct cache_entry *ce = istate->cache[i++];
523 if (ce_stage(ce)) {
524 strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
525 while (i < istate->cache_nr &&
526 !strcmp(ce->name, istate->cache[i]->name))
527 i++;
532 static int do_recursive_merge(struct repository *r,
533 struct commit *base, struct commit *next,
534 const char *base_label, const char *next_label,
535 struct object_id *head, struct strbuf *msgbuf,
536 struct replay_opts *opts)
538 struct merge_options o;
539 struct tree *result, *next_tree, *base_tree, *head_tree;
540 int clean;
541 char **xopt;
542 struct lock_file index_lock = LOCK_INIT;
544 if (repo_hold_locked_index(r, &index_lock, LOCK_REPORT_ON_ERROR) < 0)
545 return -1;
547 repo_read_index(r);
549 init_merge_options(&o, r);
550 o.ancestor = base ? base_label : "(empty tree)";
551 o.branch1 = "HEAD";
552 o.branch2 = next ? next_label : "(empty tree)";
553 if (is_rebase_i(opts))
554 o.buffer_output = 2;
555 o.show_rename_progress = 1;
557 head_tree = parse_tree_indirect(head);
558 next_tree = next ? get_commit_tree(next) : empty_tree(r);
559 base_tree = base ? get_commit_tree(base) : empty_tree(r);
561 for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)
562 parse_merge_opt(&o, *xopt);
564 clean = merge_trees(&o,
565 head_tree,
566 next_tree, base_tree, &result);
567 if (is_rebase_i(opts) && clean <= 0)
568 fputs(o.obuf.buf, stdout);
569 strbuf_release(&o.obuf);
570 diff_warn_rename_limit("merge.renamelimit", o.needed_rename_limit, 0);
571 if (clean < 0) {
572 rollback_lock_file(&index_lock);
573 return clean;
576 if (write_locked_index(r->index, &index_lock,
577 COMMIT_LOCK | SKIP_IF_UNCHANGED))
579 * TRANSLATORS: %s will be "revert", "cherry-pick" or
580 * "rebase -i".
582 return error(_("%s: Unable to write new index file"),
583 _(action_name(opts)));
585 if (!clean)
586 append_conflicts_hint(r->index, msgbuf);
588 return !clean;
591 static struct object_id *get_cache_tree_oid(struct index_state *istate)
593 if (!istate->cache_tree)
594 istate->cache_tree = cache_tree();
596 if (!cache_tree_fully_valid(istate->cache_tree))
597 if (cache_tree_update(istate, 0)) {
598 error(_("unable to update cache tree"));
599 return NULL;
602 return &istate->cache_tree->oid;
605 static int is_index_unchanged(struct repository *r)
607 struct object_id head_oid, *cache_tree_oid;
608 struct commit *head_commit;
609 struct index_state *istate = r->index;
611 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
612 return error(_("could not resolve HEAD commit"));
614 head_commit = lookup_commit(r, &head_oid);
617 * If head_commit is NULL, check_commit, called from
618 * lookup_commit, would have indicated that head_commit is not
619 * a commit object already. parse_commit() will return failure
620 * without further complaints in such a case. Otherwise, if
621 * the commit is invalid, parse_commit() will complain. So
622 * there is nothing for us to say here. Just return failure.
624 if (parse_commit(head_commit))
625 return -1;
627 if (!(cache_tree_oid = get_cache_tree_oid(istate)))
628 return -1;
630 return oideq(cache_tree_oid, get_commit_tree_oid(head_commit));
633 static int write_author_script(const char *message)
635 struct strbuf buf = STRBUF_INIT;
636 const char *eol;
637 int res;
639 for (;;)
640 if (!*message || starts_with(message, "\n")) {
641 missing_author:
642 /* Missing 'author' line? */
643 unlink(rebase_path_author_script());
644 return 0;
645 } else if (skip_prefix(message, "author ", &message))
646 break;
647 else if ((eol = strchr(message, '\n')))
648 message = eol + 1;
649 else
650 goto missing_author;
652 strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
653 while (*message && *message != '\n' && *message != '\r')
654 if (skip_prefix(message, " <", &message))
655 break;
656 else if (*message != '\'')
657 strbuf_addch(&buf, *(message++));
658 else
659 strbuf_addf(&buf, "'\\%c'", *(message++));
660 strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
661 while (*message && *message != '\n' && *message != '\r')
662 if (skip_prefix(message, "> ", &message))
663 break;
664 else if (*message != '\'')
665 strbuf_addch(&buf, *(message++));
666 else
667 strbuf_addf(&buf, "'\\%c'", *(message++));
668 strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
669 while (*message && *message != '\n' && *message != '\r')
670 if (*message != '\'')
671 strbuf_addch(&buf, *(message++));
672 else
673 strbuf_addf(&buf, "'\\%c'", *(message++));
674 strbuf_addch(&buf, '\'');
675 res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
676 strbuf_release(&buf);
677 return res;
681 * Take a series of KEY='VALUE' lines where VALUE part is
682 * sq-quoted, and append <KEY, VALUE> at the end of the string list
684 static int parse_key_value_squoted(char *buf, struct string_list *list)
686 while (*buf) {
687 struct string_list_item *item;
688 char *np;
689 char *cp = strchr(buf, '=');
690 if (!cp) {
691 np = strchrnul(buf, '\n');
692 return error(_("no key present in '%.*s'"),
693 (int) (np - buf), buf);
695 np = strchrnul(cp, '\n');
696 *cp++ = '\0';
697 item = string_list_append(list, buf);
699 buf = np + (*np == '\n');
700 *np = '\0';
701 cp = sq_dequote(cp);
702 if (!cp)
703 return error(_("unable to dequote value of '%s'"),
704 item->string);
705 item->util = xstrdup(cp);
707 return 0;
711 * Reads and parses the state directory's "author-script" file, and sets name,
712 * email and date accordingly.
713 * Returns 0 on success, -1 if the file could not be parsed.
715 * The author script is of the format:
717 * GIT_AUTHOR_NAME='$author_name'
718 * GIT_AUTHOR_EMAIL='$author_email'
719 * GIT_AUTHOR_DATE='$author_date'
721 * where $author_name, $author_email and $author_date are quoted. We are strict
722 * with our parsing, as the file was meant to be eval'd in the old
723 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
724 * from what this function expects, it is better to bail out than to do
725 * something that the user does not expect.
727 int read_author_script(const char *path, char **name, char **email, char **date,
728 int allow_missing)
730 struct strbuf buf = STRBUF_INIT;
731 struct string_list kv = STRING_LIST_INIT_DUP;
732 int retval = -1; /* assume failure */
733 int i, name_i = -2, email_i = -2, date_i = -2, err = 0;
735 if (strbuf_read_file(&buf, path, 256) <= 0) {
736 strbuf_release(&buf);
737 if (errno == ENOENT && allow_missing)
738 return 0;
739 else
740 return error_errno(_("could not open '%s' for reading"),
741 path);
744 if (parse_key_value_squoted(buf.buf, &kv))
745 goto finish;
747 for (i = 0; i < kv.nr; i++) {
748 if (!strcmp(kv.items[i].string, "GIT_AUTHOR_NAME")) {
749 if (name_i != -2)
750 name_i = error(_("'GIT_AUTHOR_NAME' already given"));
751 else
752 name_i = i;
753 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_EMAIL")) {
754 if (email_i != -2)
755 email_i = error(_("'GIT_AUTHOR_EMAIL' already given"));
756 else
757 email_i = i;
758 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_DATE")) {
759 if (date_i != -2)
760 date_i = error(_("'GIT_AUTHOR_DATE' already given"));
761 else
762 date_i = i;
763 } else {
764 err = error(_("unknown variable '%s'"),
765 kv.items[i].string);
768 if (name_i == -2)
769 error(_("missing 'GIT_AUTHOR_NAME'"));
770 if (email_i == -2)
771 error(_("missing 'GIT_AUTHOR_EMAIL'"));
772 if (date_i == -2)
773 error(_("missing 'GIT_AUTHOR_DATE'"));
774 if (date_i < 0 || email_i < 0 || date_i < 0 || err)
775 goto finish;
776 *name = kv.items[name_i].util;
777 *email = kv.items[email_i].util;
778 *date = kv.items[date_i].util;
779 retval = 0;
780 finish:
781 string_list_clear(&kv, !!retval);
782 strbuf_release(&buf);
783 return retval;
787 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
788 * file with shell quoting into struct argv_array. Returns -1 on
789 * error, 0 otherwise.
791 static int read_env_script(struct argv_array *env)
793 char *name, *email, *date;
795 if (read_author_script(rebase_path_author_script(),
796 &name, &email, &date, 0))
797 return -1;
799 argv_array_pushf(env, "GIT_AUTHOR_NAME=%s", name);
800 argv_array_pushf(env, "GIT_AUTHOR_EMAIL=%s", email);
801 argv_array_pushf(env, "GIT_AUTHOR_DATE=%s", date);
802 free(name);
803 free(email);
804 free(date);
806 return 0;
809 static char *get_author(const char *message)
811 size_t len;
812 const char *a;
814 a = find_commit_header(message, "author", &len);
815 if (a)
816 return xmemdupz(a, len);
818 return NULL;
821 /* Read author-script and return an ident line (author <email> timestamp) */
822 static const char *read_author_ident(struct strbuf *buf)
824 struct strbuf out = STRBUF_INIT;
825 char *name, *email, *date;
827 if (read_author_script(rebase_path_author_script(),
828 &name, &email, &date, 0))
829 return NULL;
831 /* validate date since fmt_ident() will die() on bad value */
832 if (parse_date(date, &out)){
833 warning(_("invalid date format '%s' in '%s'"),
834 date, rebase_path_author_script());
835 strbuf_release(&out);
836 return NULL;
839 strbuf_reset(&out);
840 strbuf_addstr(&out, fmt_ident(name, email, WANT_AUTHOR_IDENT, date, 0));
841 strbuf_swap(buf, &out);
842 strbuf_release(&out);
843 free(name);
844 free(email);
845 free(date);
846 return buf->buf;
849 static const char staged_changes_advice[] =
850 N_("you have staged changes in your working tree\n"
851 "If these changes are meant to be squashed into the previous commit, run:\n"
852 "\n"
853 " git commit --amend %s\n"
854 "\n"
855 "If they are meant to go into a new commit, run:\n"
856 "\n"
857 " git commit %s\n"
858 "\n"
859 "In both cases, once you're done, continue with:\n"
860 "\n"
861 " git rebase --continue\n");
863 #define ALLOW_EMPTY (1<<0)
864 #define EDIT_MSG (1<<1)
865 #define AMEND_MSG (1<<2)
866 #define CLEANUP_MSG (1<<3)
867 #define VERIFY_MSG (1<<4)
868 #define CREATE_ROOT_COMMIT (1<<5)
870 static int run_command_silent_on_success(struct child_process *cmd)
872 struct strbuf buf = STRBUF_INIT;
873 int rc;
875 cmd->stdout_to_stderr = 1;
876 rc = pipe_command(cmd,
877 NULL, 0,
878 NULL, 0,
879 &buf, 0);
881 if (rc)
882 fputs(buf.buf, stderr);
883 strbuf_release(&buf);
884 return rc;
888 * If we are cherry-pick, and if the merge did not result in
889 * hand-editing, we will hit this commit and inherit the original
890 * author date and name.
892 * If we are revert, or if our cherry-pick results in a hand merge,
893 * we had better say that the current user is responsible for that.
895 * An exception is when run_git_commit() is called during an
896 * interactive rebase: in that case, we will want to retain the
897 * author metadata.
899 static int run_git_commit(struct repository *r,
900 const char *defmsg,
901 struct replay_opts *opts,
902 unsigned int flags)
904 struct child_process cmd = CHILD_PROCESS_INIT;
905 const char *value;
907 if ((flags & CREATE_ROOT_COMMIT) && !(flags & AMEND_MSG)) {
908 struct strbuf msg = STRBUF_INIT, script = STRBUF_INIT;
909 const char *author = NULL;
910 struct object_id root_commit, *cache_tree_oid;
911 int res = 0;
913 if (is_rebase_i(opts)) {
914 author = read_author_ident(&script);
915 if (!author) {
916 strbuf_release(&script);
917 return -1;
921 if (!defmsg)
922 BUG("root commit without message");
924 if (!(cache_tree_oid = get_cache_tree_oid(r->index)))
925 res = -1;
927 if (!res)
928 res = strbuf_read_file(&msg, defmsg, 0);
930 if (res <= 0)
931 res = error_errno(_("could not read '%s'"), defmsg);
932 else
933 res = commit_tree(msg.buf, msg.len, cache_tree_oid,
934 NULL, &root_commit, author,
935 opts->gpg_sign);
937 strbuf_release(&msg);
938 strbuf_release(&script);
939 if (!res) {
940 update_ref(NULL, "CHERRY_PICK_HEAD", &root_commit, NULL,
941 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR);
942 res = update_ref(NULL, "HEAD", &root_commit, NULL, 0,
943 UPDATE_REFS_MSG_ON_ERR);
945 return res < 0 ? error(_("writing root commit")) : 0;
948 cmd.git_cmd = 1;
950 if (is_rebase_i(opts) && read_env_script(&cmd.env_array)) {
951 const char *gpg_opt = gpg_sign_opt_quoted(opts);
953 return error(_(staged_changes_advice),
954 gpg_opt, gpg_opt);
957 argv_array_push(&cmd.args, "commit");
959 if (!(flags & VERIFY_MSG))
960 argv_array_push(&cmd.args, "-n");
961 if ((flags & AMEND_MSG))
962 argv_array_push(&cmd.args, "--amend");
963 if (opts->gpg_sign)
964 argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
965 if (defmsg)
966 argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
967 else if (!(flags & EDIT_MSG))
968 argv_array_pushl(&cmd.args, "-C", "HEAD", NULL);
969 if ((flags & CLEANUP_MSG))
970 argv_array_push(&cmd.args, "--cleanup=strip");
971 if ((flags & EDIT_MSG))
972 argv_array_push(&cmd.args, "-e");
973 else if (!(flags & CLEANUP_MSG) &&
974 !opts->signoff && !opts->record_origin &&
975 git_config_get_value("commit.cleanup", &value))
976 argv_array_push(&cmd.args, "--cleanup=verbatim");
978 if ((flags & ALLOW_EMPTY))
979 argv_array_push(&cmd.args, "--allow-empty");
981 if (!(flags & EDIT_MSG))
982 argv_array_push(&cmd.args, "--allow-empty-message");
984 if (is_rebase_i(opts) && !(flags & EDIT_MSG))
985 return run_command_silent_on_success(&cmd);
986 else
987 return run_command(&cmd);
990 static int rest_is_empty(const struct strbuf *sb, int start)
992 int i, eol;
993 const char *nl;
995 /* Check if the rest is just whitespace and Signed-off-by's. */
996 for (i = start; i < sb->len; i++) {
997 nl = memchr(sb->buf + i, '\n', sb->len - i);
998 if (nl)
999 eol = nl - sb->buf;
1000 else
1001 eol = sb->len;
1003 if (strlen(sign_off_header) <= eol - i &&
1004 starts_with(sb->buf + i, sign_off_header)) {
1005 i = eol;
1006 continue;
1008 while (i < eol)
1009 if (!isspace(sb->buf[i++]))
1010 return 0;
1013 return 1;
1017 * Find out if the message in the strbuf contains only whitespace and
1018 * Signed-off-by lines.
1020 int message_is_empty(const struct strbuf *sb,
1021 enum commit_msg_cleanup_mode cleanup_mode)
1023 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1024 return 0;
1025 return rest_is_empty(sb, 0);
1029 * See if the user edited the message in the editor or left what
1030 * was in the template intact
1032 int template_untouched(const struct strbuf *sb, const char *template_file,
1033 enum commit_msg_cleanup_mode cleanup_mode)
1035 struct strbuf tmpl = STRBUF_INIT;
1036 const char *start;
1038 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1039 return 0;
1041 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1042 return 0;
1044 strbuf_stripspace(&tmpl, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1045 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1046 start = sb->buf;
1047 strbuf_release(&tmpl);
1048 return rest_is_empty(sb, start - sb->buf);
1051 int update_head_with_reflog(const struct commit *old_head,
1052 const struct object_id *new_head,
1053 const char *action, const struct strbuf *msg,
1054 struct strbuf *err)
1056 struct ref_transaction *transaction;
1057 struct strbuf sb = STRBUF_INIT;
1058 const char *nl;
1059 int ret = 0;
1061 if (action) {
1062 strbuf_addstr(&sb, action);
1063 strbuf_addstr(&sb, ": ");
1066 nl = strchr(msg->buf, '\n');
1067 if (nl) {
1068 strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
1069 } else {
1070 strbuf_addbuf(&sb, msg);
1071 strbuf_addch(&sb, '\n');
1074 transaction = ref_transaction_begin(err);
1075 if (!transaction ||
1076 ref_transaction_update(transaction, "HEAD", new_head,
1077 old_head ? &old_head->object.oid : &null_oid,
1078 0, sb.buf, err) ||
1079 ref_transaction_commit(transaction, err)) {
1080 ret = -1;
1082 ref_transaction_free(transaction);
1083 strbuf_release(&sb);
1085 return ret;
1088 static int run_rewrite_hook(const struct object_id *oldoid,
1089 const struct object_id *newoid)
1091 struct child_process proc = CHILD_PROCESS_INIT;
1092 const char *argv[3];
1093 int code;
1094 struct strbuf sb = STRBUF_INIT;
1096 argv[0] = find_hook("post-rewrite");
1097 if (!argv[0])
1098 return 0;
1100 argv[1] = "amend";
1101 argv[2] = NULL;
1103 proc.argv = argv;
1104 proc.in = -1;
1105 proc.stdout_to_stderr = 1;
1106 proc.trace2_hook_name = "post-rewrite";
1108 code = start_command(&proc);
1109 if (code)
1110 return code;
1111 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1112 sigchain_push(SIGPIPE, SIG_IGN);
1113 write_in_full(proc.in, sb.buf, sb.len);
1114 close(proc.in);
1115 strbuf_release(&sb);
1116 sigchain_pop(SIGPIPE);
1117 return finish_command(&proc);
1120 void commit_post_rewrite(struct repository *r,
1121 const struct commit *old_head,
1122 const struct object_id *new_head)
1124 struct notes_rewrite_cfg *cfg;
1126 cfg = init_copy_notes_for_rewrite("amend");
1127 if (cfg) {
1128 /* we are amending, so old_head is not NULL */
1129 copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
1130 finish_copy_notes_for_rewrite(r, cfg, "Notes added by 'git commit --amend'");
1132 run_rewrite_hook(&old_head->object.oid, new_head);
1135 static int run_prepare_commit_msg_hook(struct repository *r,
1136 struct strbuf *msg,
1137 const char *commit)
1139 struct argv_array hook_env = ARGV_ARRAY_INIT;
1140 int ret;
1141 const char *name;
1143 name = git_path_commit_editmsg();
1144 if (write_message(msg->buf, msg->len, name, 0))
1145 return -1;
1147 argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", r->index_file);
1148 argv_array_push(&hook_env, "GIT_EDITOR=:");
1149 if (commit)
1150 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1151 "commit", commit, NULL);
1152 else
1153 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1154 "message", NULL);
1155 if (ret)
1156 ret = error(_("'prepare-commit-msg' hook failed"));
1157 argv_array_clear(&hook_env);
1159 return ret;
1162 static const char implicit_ident_advice_noconfig[] =
1163 N_("Your name and email address were configured automatically based\n"
1164 "on your username and hostname. Please check that they are accurate.\n"
1165 "You can suppress this message by setting them explicitly. Run the\n"
1166 "following command and follow the instructions in your editor to edit\n"
1167 "your configuration file:\n"
1168 "\n"
1169 " git config --global --edit\n"
1170 "\n"
1171 "After doing this, you may fix the identity used for this commit with:\n"
1172 "\n"
1173 " git commit --amend --reset-author\n");
1175 static const char implicit_ident_advice_config[] =
1176 N_("Your name and email address were configured automatically based\n"
1177 "on your username and hostname. Please check that they are accurate.\n"
1178 "You can suppress this message by setting them explicitly:\n"
1179 "\n"
1180 " git config --global user.name \"Your Name\"\n"
1181 " git config --global user.email you@example.com\n"
1182 "\n"
1183 "After doing this, you may fix the identity used for this commit with:\n"
1184 "\n"
1185 " git commit --amend --reset-author\n");
1187 static const char *implicit_ident_advice(void)
1189 char *user_config = expand_user_path("~/.gitconfig", 0);
1190 char *xdg_config = xdg_config_home("config");
1191 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1193 free(user_config);
1194 free(xdg_config);
1196 if (config_exists)
1197 return _(implicit_ident_advice_config);
1198 else
1199 return _(implicit_ident_advice_noconfig);
1203 void print_commit_summary(struct repository *r,
1204 const char *prefix,
1205 const struct object_id *oid,
1206 unsigned int flags)
1208 struct rev_info rev;
1209 struct commit *commit;
1210 struct strbuf format = STRBUF_INIT;
1211 const char *head;
1212 struct pretty_print_context pctx = {0};
1213 struct strbuf author_ident = STRBUF_INIT;
1214 struct strbuf committer_ident = STRBUF_INIT;
1216 commit = lookup_commit(r, oid);
1217 if (!commit)
1218 die(_("couldn't look up newly created commit"));
1219 if (parse_commit(commit))
1220 die(_("could not parse newly created commit"));
1222 strbuf_addstr(&format, "format:%h] %s");
1224 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1225 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1226 if (strbuf_cmp(&author_ident, &committer_ident)) {
1227 strbuf_addstr(&format, "\n Author: ");
1228 strbuf_addbuf_percentquote(&format, &author_ident);
1230 if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
1231 struct strbuf date = STRBUF_INIT;
1233 format_commit_message(commit, "%ad", &date, &pctx);
1234 strbuf_addstr(&format, "\n Date: ");
1235 strbuf_addbuf_percentquote(&format, &date);
1236 strbuf_release(&date);
1238 if (!committer_ident_sufficiently_given()) {
1239 strbuf_addstr(&format, "\n Committer: ");
1240 strbuf_addbuf_percentquote(&format, &committer_ident);
1241 if (advice_implicit_identity) {
1242 strbuf_addch(&format, '\n');
1243 strbuf_addstr(&format, implicit_ident_advice());
1246 strbuf_release(&author_ident);
1247 strbuf_release(&committer_ident);
1249 repo_init_revisions(r, &rev, prefix);
1250 setup_revisions(0, NULL, &rev, NULL);
1252 rev.diff = 1;
1253 rev.diffopt.output_format =
1254 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1256 rev.verbose_header = 1;
1257 rev.show_root_diff = 1;
1258 get_commit_format(format.buf, &rev);
1259 rev.always_show_header = 0;
1260 rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1261 rev.diffopt.break_opt = 0;
1262 diff_setup_done(&rev.diffopt);
1264 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1265 if (!head)
1266 die_errno(_("unable to resolve HEAD after creating commit"));
1267 if (!strcmp(head, "HEAD"))
1268 head = _("detached HEAD");
1269 else
1270 skip_prefix(head, "refs/heads/", &head);
1271 printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1272 _(" (root-commit)") : "");
1274 if (!log_tree_commit(&rev, commit)) {
1275 rev.always_show_header = 1;
1276 rev.use_terminator = 1;
1277 log_tree_commit(&rev, commit);
1280 strbuf_release(&format);
1283 static int parse_head(struct repository *r, struct commit **head)
1285 struct commit *current_head;
1286 struct object_id oid;
1288 if (get_oid("HEAD", &oid)) {
1289 current_head = NULL;
1290 } else {
1291 current_head = lookup_commit_reference(r, &oid);
1292 if (!current_head)
1293 return error(_("could not parse HEAD"));
1294 if (!oideq(&oid, &current_head->object.oid)) {
1295 warning(_("HEAD %s is not a commit!"),
1296 oid_to_hex(&oid));
1298 if (parse_commit(current_head))
1299 return error(_("could not parse HEAD commit"));
1301 *head = current_head;
1303 return 0;
1307 * Try to commit without forking 'git commit'. In some cases we need
1308 * to run 'git commit' to display an error message
1310 * Returns:
1311 * -1 - error unable to commit
1312 * 0 - success
1313 * 1 - run 'git commit'
1315 static int try_to_commit(struct repository *r,
1316 struct strbuf *msg, const char *author,
1317 struct replay_opts *opts, unsigned int flags,
1318 struct object_id *oid)
1320 struct object_id tree;
1321 struct commit *current_head;
1322 struct commit_list *parents = NULL;
1323 struct commit_extra_header *extra = NULL;
1324 struct strbuf err = STRBUF_INIT;
1325 struct strbuf commit_msg = STRBUF_INIT;
1326 char *amend_author = NULL;
1327 const char *hook_commit = NULL;
1328 enum commit_msg_cleanup_mode cleanup;
1329 int res = 0;
1331 if (parse_head(r, &current_head))
1332 return -1;
1334 if (flags & AMEND_MSG) {
1335 const char *exclude_gpgsig[] = { "gpgsig", NULL };
1336 const char *out_enc = get_commit_output_encoding();
1337 const char *message = logmsg_reencode(current_head, NULL,
1338 out_enc);
1340 if (!msg) {
1341 const char *orig_message = NULL;
1343 find_commit_subject(message, &orig_message);
1344 msg = &commit_msg;
1345 strbuf_addstr(msg, orig_message);
1346 hook_commit = "HEAD";
1348 author = amend_author = get_author(message);
1349 unuse_commit_buffer(current_head, message);
1350 if (!author) {
1351 res = error(_("unable to parse commit author"));
1352 goto out;
1354 parents = copy_commit_list(current_head->parents);
1355 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1356 } else if (current_head) {
1357 commit_list_insert(current_head, &parents);
1360 if (write_index_as_tree(&tree, r->index, r->index_file, 0, NULL)) {
1361 res = error(_("git write-tree failed to write a tree"));
1362 goto out;
1365 if (!(flags & ALLOW_EMPTY) && oideq(current_head ?
1366 get_commit_tree_oid(current_head) :
1367 the_hash_algo->empty_tree, &tree)) {
1368 res = 1; /* run 'git commit' to display error message */
1369 goto out;
1372 if (find_hook("prepare-commit-msg")) {
1373 res = run_prepare_commit_msg_hook(r, msg, hook_commit);
1374 if (res)
1375 goto out;
1376 if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1377 2048) < 0) {
1378 res = error_errno(_("unable to read commit message "
1379 "from '%s'"),
1380 git_path_commit_editmsg());
1381 goto out;
1383 msg = &commit_msg;
1386 cleanup = (flags & CLEANUP_MSG) ? COMMIT_MSG_CLEANUP_ALL :
1387 opts->default_msg_cleanup;
1389 if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1390 strbuf_stripspace(msg, cleanup == COMMIT_MSG_CLEANUP_ALL);
1391 if ((flags & EDIT_MSG) && message_is_empty(msg, cleanup)) {
1392 res = 1; /* run 'git commit' to display error message */
1393 goto out;
1396 reset_ident_date();
1398 if (commit_tree_extended(msg->buf, msg->len, &tree, parents,
1399 oid, author, opts->gpg_sign, extra)) {
1400 res = error(_("failed to write commit object"));
1401 goto out;
1404 if (update_head_with_reflog(current_head, oid,
1405 getenv("GIT_REFLOG_ACTION"), msg, &err)) {
1406 res = error("%s", err.buf);
1407 goto out;
1410 if (flags & AMEND_MSG)
1411 commit_post_rewrite(r, current_head, oid);
1413 out:
1414 free_commit_extra_headers(extra);
1415 strbuf_release(&err);
1416 strbuf_release(&commit_msg);
1417 free(amend_author);
1419 return res;
1422 static int do_commit(struct repository *r,
1423 const char *msg_file, const char *author,
1424 struct replay_opts *opts, unsigned int flags)
1426 int res = 1;
1428 if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG) &&
1429 !(flags & CREATE_ROOT_COMMIT)) {
1430 struct object_id oid;
1431 struct strbuf sb = STRBUF_INIT;
1433 if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1434 return error_errno(_("unable to read commit message "
1435 "from '%s'"),
1436 msg_file);
1438 res = try_to_commit(r, msg_file ? &sb : NULL,
1439 author, opts, flags, &oid);
1440 strbuf_release(&sb);
1441 if (!res) {
1442 unlink(git_path_cherry_pick_head(r));
1443 unlink(git_path_merge_msg(r));
1444 if (!is_rebase_i(opts))
1445 print_commit_summary(r, NULL, &oid,
1446 SUMMARY_SHOW_AUTHOR_DATE);
1447 return res;
1450 if (res == 1)
1451 return run_git_commit(r, msg_file, opts, flags);
1453 return res;
1456 static int is_original_commit_empty(struct commit *commit)
1458 const struct object_id *ptree_oid;
1460 if (parse_commit(commit))
1461 return error(_("could not parse commit %s"),
1462 oid_to_hex(&commit->object.oid));
1463 if (commit->parents) {
1464 struct commit *parent = commit->parents->item;
1465 if (parse_commit(parent))
1466 return error(_("could not parse parent commit %s"),
1467 oid_to_hex(&parent->object.oid));
1468 ptree_oid = get_commit_tree_oid(parent);
1469 } else {
1470 ptree_oid = the_hash_algo->empty_tree; /* commit is root */
1473 return oideq(ptree_oid, get_commit_tree_oid(commit));
1477 * Do we run "git commit" with "--allow-empty"?
1479 static int allow_empty(struct repository *r,
1480 struct replay_opts *opts,
1481 struct commit *commit)
1483 int index_unchanged, empty_commit;
1486 * Three cases:
1488 * (1) we do not allow empty at all and error out.
1490 * (2) we allow ones that were initially empty, but
1491 * forbid the ones that become empty;
1493 * (3) we allow both.
1495 if (!opts->allow_empty)
1496 return 0; /* let "git commit" barf as necessary */
1498 index_unchanged = is_index_unchanged(r);
1499 if (index_unchanged < 0)
1500 return index_unchanged;
1501 if (!index_unchanged)
1502 return 0; /* we do not have to say --allow-empty */
1504 if (opts->keep_redundant_commits)
1505 return 1;
1507 empty_commit = is_original_commit_empty(commit);
1508 if (empty_commit < 0)
1509 return empty_commit;
1510 if (!empty_commit)
1511 return 0;
1512 else
1513 return 1;
1517 * Note that ordering matters in this enum. Not only must it match the mapping
1518 * below, it is also divided into several sections that matter. When adding
1519 * new commands, make sure you add it in the right section.
1521 enum todo_command {
1522 /* commands that handle commits */
1523 TODO_PICK = 0,
1524 TODO_REVERT,
1525 TODO_EDIT,
1526 TODO_REWORD,
1527 TODO_FIXUP,
1528 TODO_SQUASH,
1529 /* commands that do something else than handling a single commit */
1530 TODO_EXEC,
1531 TODO_BREAK,
1532 TODO_LABEL,
1533 TODO_RESET,
1534 TODO_MERGE,
1535 /* commands that do nothing but are counted for reporting progress */
1536 TODO_NOOP,
1537 TODO_DROP,
1538 /* comments (not counted for reporting progress) */
1539 TODO_COMMENT
1542 static struct {
1543 char c;
1544 const char *str;
1545 } todo_command_info[] = {
1546 { 'p', "pick" },
1547 { 0, "revert" },
1548 { 'e', "edit" },
1549 { 'r', "reword" },
1550 { 'f', "fixup" },
1551 { 's', "squash" },
1552 { 'x', "exec" },
1553 { 'b', "break" },
1554 { 'l', "label" },
1555 { 't', "reset" },
1556 { 'm', "merge" },
1557 { 0, "noop" },
1558 { 'd', "drop" },
1559 { 0, NULL }
1562 static const char *command_to_string(const enum todo_command command)
1564 if (command < TODO_COMMENT)
1565 return todo_command_info[command].str;
1566 die(_("unknown command: %d"), command);
1569 static char command_to_char(const enum todo_command command)
1571 if (command < TODO_COMMENT && todo_command_info[command].c)
1572 return todo_command_info[command].c;
1573 return comment_line_char;
1576 static int is_noop(const enum todo_command command)
1578 return TODO_NOOP <= command;
1581 static int is_fixup(enum todo_command command)
1583 return command == TODO_FIXUP || command == TODO_SQUASH;
1586 /* Does this command create a (non-merge) commit? */
1587 static int is_pick_or_similar(enum todo_command command)
1589 switch (command) {
1590 case TODO_PICK:
1591 case TODO_REVERT:
1592 case TODO_EDIT:
1593 case TODO_REWORD:
1594 case TODO_FIXUP:
1595 case TODO_SQUASH:
1596 return 1;
1597 default:
1598 return 0;
1602 static int update_squash_messages(struct repository *r,
1603 enum todo_command command,
1604 struct commit *commit,
1605 struct replay_opts *opts)
1607 struct strbuf buf = STRBUF_INIT;
1608 int res;
1609 const char *message, *body;
1611 if (opts->current_fixup_count > 0) {
1612 struct strbuf header = STRBUF_INIT;
1613 char *eol;
1615 if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
1616 return error(_("could not read '%s'"),
1617 rebase_path_squash_msg());
1619 eol = buf.buf[0] != comment_line_char ?
1620 buf.buf : strchrnul(buf.buf, '\n');
1622 strbuf_addf(&header, "%c ", comment_line_char);
1623 strbuf_addf(&header, _("This is a combination of %d commits."),
1624 opts->current_fixup_count + 2);
1625 strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
1626 strbuf_release(&header);
1627 } else {
1628 struct object_id head;
1629 struct commit *head_commit;
1630 const char *head_message, *body;
1632 if (get_oid("HEAD", &head))
1633 return error(_("need a HEAD to fixup"));
1634 if (!(head_commit = lookup_commit_reference(r, &head)))
1635 return error(_("could not read HEAD"));
1636 if (!(head_message = get_commit_buffer(head_commit, NULL)))
1637 return error(_("could not read HEAD's commit message"));
1639 find_commit_subject(head_message, &body);
1640 if (write_message(body, strlen(body),
1641 rebase_path_fixup_msg(), 0)) {
1642 unuse_commit_buffer(head_commit, head_message);
1643 return error(_("cannot write '%s'"),
1644 rebase_path_fixup_msg());
1647 strbuf_addf(&buf, "%c ", comment_line_char);
1648 strbuf_addf(&buf, _("This is a combination of %d commits."), 2);
1649 strbuf_addf(&buf, "\n%c ", comment_line_char);
1650 strbuf_addstr(&buf, _("This is the 1st commit message:"));
1651 strbuf_addstr(&buf, "\n\n");
1652 strbuf_addstr(&buf, body);
1654 unuse_commit_buffer(head_commit, head_message);
1657 if (!(message = get_commit_buffer(commit, NULL)))
1658 return error(_("could not read commit message of %s"),
1659 oid_to_hex(&commit->object.oid));
1660 find_commit_subject(message, &body);
1662 if (command == TODO_SQUASH) {
1663 unlink(rebase_path_fixup_msg());
1664 strbuf_addf(&buf, "\n%c ", comment_line_char);
1665 strbuf_addf(&buf, _("This is the commit message #%d:"),
1666 ++opts->current_fixup_count + 1);
1667 strbuf_addstr(&buf, "\n\n");
1668 strbuf_addstr(&buf, body);
1669 } else if (command == TODO_FIXUP) {
1670 strbuf_addf(&buf, "\n%c ", comment_line_char);
1671 strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
1672 ++opts->current_fixup_count + 1);
1673 strbuf_addstr(&buf, "\n\n");
1674 strbuf_add_commented_lines(&buf, body, strlen(body));
1675 } else
1676 return error(_("unknown command: %d"), command);
1677 unuse_commit_buffer(commit, message);
1679 res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
1680 strbuf_release(&buf);
1682 if (!res) {
1683 strbuf_addf(&opts->current_fixups, "%s%s %s",
1684 opts->current_fixups.len ? "\n" : "",
1685 command_to_string(command),
1686 oid_to_hex(&commit->object.oid));
1687 res = write_message(opts->current_fixups.buf,
1688 opts->current_fixups.len,
1689 rebase_path_current_fixups(), 0);
1692 return res;
1695 static void flush_rewritten_pending(void)
1697 struct strbuf buf = STRBUF_INIT;
1698 struct object_id newoid;
1699 FILE *out;
1701 if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
1702 !get_oid("HEAD", &newoid) &&
1703 (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1704 char *bol = buf.buf, *eol;
1706 while (*bol) {
1707 eol = strchrnul(bol, '\n');
1708 fprintf(out, "%.*s %s\n", (int)(eol - bol),
1709 bol, oid_to_hex(&newoid));
1710 if (!*eol)
1711 break;
1712 bol = eol + 1;
1714 fclose(out);
1715 unlink(rebase_path_rewritten_pending());
1717 strbuf_release(&buf);
1720 static void record_in_rewritten(struct object_id *oid,
1721 enum todo_command next_command)
1723 FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
1725 if (!out)
1726 return;
1728 fprintf(out, "%s\n", oid_to_hex(oid));
1729 fclose(out);
1731 if (!is_fixup(next_command))
1732 flush_rewritten_pending();
1735 static int do_pick_commit(struct repository *r,
1736 enum todo_command command,
1737 struct commit *commit,
1738 struct replay_opts *opts,
1739 int final_fixup)
1741 unsigned int flags = opts->edit ? EDIT_MSG : 0;
1742 const char *msg_file = opts->edit ? NULL : git_path_merge_msg(r);
1743 struct object_id head;
1744 struct commit *base, *next, *parent;
1745 const char *base_label, *next_label;
1746 char *author = NULL;
1747 struct commit_message msg = { NULL, NULL, NULL, NULL };
1748 struct strbuf msgbuf = STRBUF_INIT;
1749 int res, unborn = 0, allow;
1751 if (opts->no_commit) {
1753 * We do not intend to commit immediately. We just want to
1754 * merge the differences in, so let's compute the tree
1755 * that represents the "current" state for merge-recursive
1756 * to work on.
1758 if (write_index_as_tree(&head, r->index, r->index_file, 0, NULL))
1759 return error(_("your index file is unmerged."));
1760 } else {
1761 unborn = get_oid("HEAD", &head);
1762 /* Do we want to generate a root commit? */
1763 if (is_pick_or_similar(command) && opts->have_squash_onto &&
1764 oideq(&head, &opts->squash_onto)) {
1765 if (is_fixup(command))
1766 return error(_("cannot fixup root commit"));
1767 flags |= CREATE_ROOT_COMMIT;
1768 unborn = 1;
1769 } else if (unborn)
1770 oidcpy(&head, the_hash_algo->empty_tree);
1771 if (index_differs_from(r, unborn ? empty_tree_oid_hex() : "HEAD",
1772 NULL, 0))
1773 return error_dirty_index(r, opts);
1775 discard_index(r->index);
1777 if (!commit->parents)
1778 parent = NULL;
1779 else if (commit->parents->next) {
1780 /* Reverting or cherry-picking a merge commit */
1781 int cnt;
1782 struct commit_list *p;
1784 if (!opts->mainline)
1785 return error(_("commit %s is a merge but no -m option was given."),
1786 oid_to_hex(&commit->object.oid));
1788 for (cnt = 1, p = commit->parents;
1789 cnt != opts->mainline && p;
1790 cnt++)
1791 p = p->next;
1792 if (cnt != opts->mainline || !p)
1793 return error(_("commit %s does not have parent %d"),
1794 oid_to_hex(&commit->object.oid), opts->mainline);
1795 parent = p->item;
1796 } else if (1 < opts->mainline)
1798 * Non-first parent explicitly specified as mainline for
1799 * non-merge commit
1801 return error(_("commit %s does not have parent %d"),
1802 oid_to_hex(&commit->object.oid), opts->mainline);
1803 else
1804 parent = commit->parents->item;
1806 if (get_message(commit, &msg) != 0)
1807 return error(_("cannot get commit message for %s"),
1808 oid_to_hex(&commit->object.oid));
1810 if (opts->allow_ff && !is_fixup(command) &&
1811 ((parent && oideq(&parent->object.oid, &head)) ||
1812 (!parent && unborn))) {
1813 if (is_rebase_i(opts))
1814 write_author_script(msg.message);
1815 res = fast_forward_to(r, &commit->object.oid, &head, unborn,
1816 opts);
1817 if (res || command != TODO_REWORD)
1818 goto leave;
1819 flags |= EDIT_MSG | AMEND_MSG | VERIFY_MSG;
1820 msg_file = NULL;
1821 goto fast_forward_edit;
1823 if (parent && parse_commit(parent) < 0)
1824 /* TRANSLATORS: The first %s will be a "todo" command like
1825 "revert" or "pick", the second %s a SHA1. */
1826 return error(_("%s: cannot parse parent commit %s"),
1827 command_to_string(command),
1828 oid_to_hex(&parent->object.oid));
1831 * "commit" is an existing commit. We would want to apply
1832 * the difference it introduces since its first parent "prev"
1833 * on top of the current HEAD if we are cherry-pick. Or the
1834 * reverse of it if we are revert.
1837 if (command == TODO_REVERT) {
1838 base = commit;
1839 base_label = msg.label;
1840 next = parent;
1841 next_label = msg.parent_label;
1842 strbuf_addstr(&msgbuf, "Revert \"");
1843 strbuf_addstr(&msgbuf, msg.subject);
1844 strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
1845 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1847 if (commit->parents && commit->parents->next) {
1848 strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
1849 strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
1851 strbuf_addstr(&msgbuf, ".\n");
1852 } else {
1853 const char *p;
1855 base = parent;
1856 base_label = msg.parent_label;
1857 next = commit;
1858 next_label = msg.label;
1860 /* Append the commit log message to msgbuf. */
1861 if (find_commit_subject(msg.message, &p))
1862 strbuf_addstr(&msgbuf, p);
1864 if (opts->record_origin) {
1865 strbuf_complete_line(&msgbuf);
1866 if (!has_conforming_footer(&msgbuf, NULL, 0))
1867 strbuf_addch(&msgbuf, '\n');
1868 strbuf_addstr(&msgbuf, cherry_picked_prefix);
1869 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1870 strbuf_addstr(&msgbuf, ")\n");
1872 if (!is_fixup(command))
1873 author = get_author(msg.message);
1876 if (command == TODO_REWORD)
1877 flags |= EDIT_MSG | VERIFY_MSG;
1878 else if (is_fixup(command)) {
1879 if (update_squash_messages(r, command, commit, opts))
1880 return -1;
1881 flags |= AMEND_MSG;
1882 if (!final_fixup)
1883 msg_file = rebase_path_squash_msg();
1884 else if (file_exists(rebase_path_fixup_msg())) {
1885 flags |= CLEANUP_MSG;
1886 msg_file = rebase_path_fixup_msg();
1887 } else {
1888 const char *dest = git_path_squash_msg(r);
1889 unlink(dest);
1890 if (copy_file(dest, rebase_path_squash_msg(), 0666))
1891 return error(_("could not rename '%s' to '%s'"),
1892 rebase_path_squash_msg(), dest);
1893 unlink(git_path_merge_msg(r));
1894 msg_file = dest;
1895 flags |= EDIT_MSG;
1899 if (opts->signoff && !is_fixup(command))
1900 append_signoff(&msgbuf, 0, 0);
1902 if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1903 res = -1;
1904 else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
1905 res = do_recursive_merge(r, base, next, base_label, next_label,
1906 &head, &msgbuf, opts);
1907 if (res < 0)
1908 goto leave;
1910 res |= write_message(msgbuf.buf, msgbuf.len,
1911 git_path_merge_msg(r), 0);
1912 } else {
1913 struct commit_list *common = NULL;
1914 struct commit_list *remotes = NULL;
1916 res = write_message(msgbuf.buf, msgbuf.len,
1917 git_path_merge_msg(r), 0);
1919 commit_list_insert(base, &common);
1920 commit_list_insert(next, &remotes);
1921 res |= try_merge_command(r, opts->strategy,
1922 opts->xopts_nr, (const char **)opts->xopts,
1923 common, oid_to_hex(&head), remotes);
1924 free_commit_list(common);
1925 free_commit_list(remotes);
1927 strbuf_release(&msgbuf);
1930 * If the merge was clean or if it failed due to conflict, we write
1931 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1932 * However, if the merge did not even start, then we don't want to
1933 * write it at all.
1935 if (command == TODO_PICK && !opts->no_commit && (res == 0 || res == 1) &&
1936 update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
1937 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1938 res = -1;
1939 if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
1940 update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
1941 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1942 res = -1;
1944 if (res) {
1945 error(command == TODO_REVERT
1946 ? _("could not revert %s... %s")
1947 : _("could not apply %s... %s"),
1948 short_commit_name(commit), msg.subject);
1949 print_advice(r, res == 1, opts);
1950 repo_rerere(r, opts->allow_rerere_auto);
1951 goto leave;
1954 allow = allow_empty(r, opts, commit);
1955 if (allow < 0) {
1956 res = allow;
1957 goto leave;
1958 } else if (allow)
1959 flags |= ALLOW_EMPTY;
1960 if (!opts->no_commit) {
1961 fast_forward_edit:
1962 if (author || command == TODO_REVERT || (flags & AMEND_MSG))
1963 res = do_commit(r, msg_file, author, opts, flags);
1964 else
1965 res = error(_("unable to parse commit author"));
1968 if (!res && final_fixup) {
1969 unlink(rebase_path_fixup_msg());
1970 unlink(rebase_path_squash_msg());
1971 unlink(rebase_path_current_fixups());
1972 strbuf_reset(&opts->current_fixups);
1973 opts->current_fixup_count = 0;
1976 leave:
1977 free_message(commit, &msg);
1978 free(author);
1979 update_abort_safety_file();
1981 return res;
1984 static int prepare_revs(struct replay_opts *opts)
1987 * picking (but not reverting) ranges (but not individual revisions)
1988 * should be done in reverse
1990 if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
1991 opts->revs->reverse ^= 1;
1993 if (prepare_revision_walk(opts->revs))
1994 return error(_("revision walk setup failed"));
1996 return 0;
1999 static int read_and_refresh_cache(struct repository *r,
2000 struct replay_opts *opts)
2002 struct lock_file index_lock = LOCK_INIT;
2003 int index_fd = repo_hold_locked_index(r, &index_lock, 0);
2004 if (repo_read_index(r) < 0) {
2005 rollback_lock_file(&index_lock);
2006 return error(_("git %s: failed to read the index"),
2007 _(action_name(opts)));
2009 refresh_index(r->index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
2010 if (index_fd >= 0) {
2011 if (write_locked_index(r->index, &index_lock,
2012 COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
2013 return error(_("git %s: failed to refresh the index"),
2014 _(action_name(opts)));
2017 return 0;
2020 enum todo_item_flags {
2021 TODO_EDIT_MERGE_MSG = 1
2024 struct todo_item {
2025 enum todo_command command;
2026 struct commit *commit;
2027 unsigned int flags;
2028 const char *arg;
2029 int arg_len;
2030 size_t offset_in_buf;
2033 struct todo_list {
2034 struct strbuf buf;
2035 struct todo_item *items;
2036 int nr, alloc, current;
2037 int done_nr, total_nr;
2038 struct stat_data stat;
2041 #define TODO_LIST_INIT { STRBUF_INIT }
2043 static void todo_list_release(struct todo_list *todo_list)
2045 strbuf_release(&todo_list->buf);
2046 FREE_AND_NULL(todo_list->items);
2047 todo_list->nr = todo_list->alloc = 0;
2050 static struct todo_item *append_new_todo(struct todo_list *todo_list)
2052 ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
2053 return todo_list->items + todo_list->nr++;
2056 static int parse_insn_line(struct repository *r, struct todo_item *item,
2057 const char *bol, char *eol)
2059 struct object_id commit_oid;
2060 char *end_of_object_name;
2061 int i, saved, status, padding;
2063 item->flags = 0;
2065 /* left-trim */
2066 bol += strspn(bol, " \t");
2068 if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
2069 item->command = TODO_COMMENT;
2070 item->commit = NULL;
2071 item->arg = bol;
2072 item->arg_len = eol - bol;
2073 return 0;
2076 for (i = 0; i < TODO_COMMENT; i++)
2077 if (skip_prefix(bol, todo_command_info[i].str, &bol)) {
2078 item->command = i;
2079 break;
2080 } else if ((bol + 1 == eol || bol[1] == ' ') &&
2081 *bol == todo_command_info[i].c) {
2082 bol++;
2083 item->command = i;
2084 break;
2086 if (i >= TODO_COMMENT)
2087 return -1;
2089 /* Eat up extra spaces/ tabs before object name */
2090 padding = strspn(bol, " \t");
2091 bol += padding;
2093 if (item->command == TODO_NOOP || item->command == TODO_BREAK) {
2094 if (bol != eol)
2095 return error(_("%s does not accept arguments: '%s'"),
2096 command_to_string(item->command), bol);
2097 item->commit = NULL;
2098 item->arg = bol;
2099 item->arg_len = eol - bol;
2100 return 0;
2103 if (!padding)
2104 return error(_("missing arguments for %s"),
2105 command_to_string(item->command));
2107 if (item->command == TODO_EXEC || item->command == TODO_LABEL ||
2108 item->command == TODO_RESET) {
2109 item->commit = NULL;
2110 item->arg = bol;
2111 item->arg_len = (int)(eol - bol);
2112 return 0;
2115 if (item->command == TODO_MERGE) {
2116 if (skip_prefix(bol, "-C", &bol))
2117 bol += strspn(bol, " \t");
2118 else if (skip_prefix(bol, "-c", &bol)) {
2119 bol += strspn(bol, " \t");
2120 item->flags |= TODO_EDIT_MERGE_MSG;
2121 } else {
2122 item->flags |= TODO_EDIT_MERGE_MSG;
2123 item->commit = NULL;
2124 item->arg = bol;
2125 item->arg_len = (int)(eol - bol);
2126 return 0;
2130 end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
2131 saved = *end_of_object_name;
2132 *end_of_object_name = '\0';
2133 status = get_oid(bol, &commit_oid);
2134 *end_of_object_name = saved;
2136 item->arg = end_of_object_name + strspn(end_of_object_name, " \t");
2137 item->arg_len = (int)(eol - item->arg);
2139 if (status < 0)
2140 return -1;
2142 item->commit = lookup_commit_reference(r, &commit_oid);
2143 return !item->commit;
2146 static int parse_insn_buffer(struct repository *r, char *buf,
2147 struct todo_list *todo_list)
2149 struct todo_item *item;
2150 char *p = buf, *next_p;
2151 int i, res = 0, fixup_okay = file_exists(rebase_path_done());
2153 for (i = 1; *p; i++, p = next_p) {
2154 char *eol = strchrnul(p, '\n');
2156 next_p = *eol ? eol + 1 /* skip LF */ : eol;
2158 if (p != eol && eol[-1] == '\r')
2159 eol--; /* strip Carriage Return */
2161 item = append_new_todo(todo_list);
2162 item->offset_in_buf = p - todo_list->buf.buf;
2163 if (parse_insn_line(r, item, p, eol)) {
2164 res = error(_("invalid line %d: %.*s"),
2165 i, (int)(eol - p), p);
2166 item->command = TODO_NOOP;
2169 if (fixup_okay)
2170 ; /* do nothing */
2171 else if (is_fixup(item->command))
2172 return error(_("cannot '%s' without a previous commit"),
2173 command_to_string(item->command));
2174 else if (!is_noop(item->command))
2175 fixup_okay = 1;
2178 return res;
2181 static int count_commands(struct todo_list *todo_list)
2183 int count = 0, i;
2185 for (i = 0; i < todo_list->nr; i++)
2186 if (todo_list->items[i].command != TODO_COMMENT)
2187 count++;
2189 return count;
2192 static int get_item_line_offset(struct todo_list *todo_list, int index)
2194 return index < todo_list->nr ?
2195 todo_list->items[index].offset_in_buf : todo_list->buf.len;
2198 static const char *get_item_line(struct todo_list *todo_list, int index)
2200 return todo_list->buf.buf + get_item_line_offset(todo_list, index);
2203 static int get_item_line_length(struct todo_list *todo_list, int index)
2205 return get_item_line_offset(todo_list, index + 1)
2206 - get_item_line_offset(todo_list, index);
2209 static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
2211 int fd;
2212 ssize_t len;
2214 fd = open(path, O_RDONLY);
2215 if (fd < 0)
2216 return error_errno(_("could not open '%s'"), path);
2217 len = strbuf_read(sb, fd, 0);
2218 close(fd);
2219 if (len < 0)
2220 return error(_("could not read '%s'."), path);
2221 return len;
2224 static int read_populate_todo(struct repository *r,
2225 struct todo_list *todo_list,
2226 struct replay_opts *opts)
2228 struct stat st;
2229 const char *todo_file = get_todo_path(opts);
2230 int res;
2232 strbuf_reset(&todo_list->buf);
2233 if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
2234 return -1;
2236 res = stat(todo_file, &st);
2237 if (res)
2238 return error(_("could not stat '%s'"), todo_file);
2239 fill_stat_data(&todo_list->stat, &st);
2241 res = parse_insn_buffer(r, todo_list->buf.buf, todo_list);
2242 if (res) {
2243 if (is_rebase_i(opts))
2244 return error(_("please fix this using "
2245 "'git rebase --edit-todo'."));
2246 return error(_("unusable instruction sheet: '%s'"), todo_file);
2249 if (!todo_list->nr &&
2250 (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
2251 return error(_("no commits parsed."));
2253 if (!is_rebase_i(opts)) {
2254 enum todo_command valid =
2255 opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
2256 int i;
2258 for (i = 0; i < todo_list->nr; i++)
2259 if (valid == todo_list->items[i].command)
2260 continue;
2261 else if (valid == TODO_PICK)
2262 return error(_("cannot cherry-pick during a revert."));
2263 else
2264 return error(_("cannot revert during a cherry-pick."));
2267 if (is_rebase_i(opts)) {
2268 struct todo_list done = TODO_LIST_INIT;
2269 FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
2271 if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
2272 !parse_insn_buffer(r, done.buf.buf, &done))
2273 todo_list->done_nr = count_commands(&done);
2274 else
2275 todo_list->done_nr = 0;
2277 todo_list->total_nr = todo_list->done_nr
2278 + count_commands(todo_list);
2279 todo_list_release(&done);
2281 if (f) {
2282 fprintf(f, "%d\n", todo_list->total_nr);
2283 fclose(f);
2287 return 0;
2290 static int git_config_string_dup(char **dest,
2291 const char *var, const char *value)
2293 if (!value)
2294 return config_error_nonbool(var);
2295 free(*dest);
2296 *dest = xstrdup(value);
2297 return 0;
2300 static int populate_opts_cb(const char *key, const char *value, void *data)
2302 struct replay_opts *opts = data;
2303 int error_flag = 1;
2305 if (!value)
2306 error_flag = 0;
2307 else if (!strcmp(key, "options.no-commit"))
2308 opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
2309 else if (!strcmp(key, "options.edit"))
2310 opts->edit = git_config_bool_or_int(key, value, &error_flag);
2311 else if (!strcmp(key, "options.signoff"))
2312 opts->signoff = git_config_bool_or_int(key, value, &error_flag);
2313 else if (!strcmp(key, "options.record-origin"))
2314 opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
2315 else if (!strcmp(key, "options.allow-ff"))
2316 opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
2317 else if (!strcmp(key, "options.mainline"))
2318 opts->mainline = git_config_int(key, value);
2319 else if (!strcmp(key, "options.strategy"))
2320 git_config_string_dup(&opts->strategy, key, value);
2321 else if (!strcmp(key, "options.gpg-sign"))
2322 git_config_string_dup(&opts->gpg_sign, key, value);
2323 else if (!strcmp(key, "options.strategy-option")) {
2324 ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
2325 opts->xopts[opts->xopts_nr++] = xstrdup(value);
2326 } else if (!strcmp(key, "options.allow-rerere-auto"))
2327 opts->allow_rerere_auto =
2328 git_config_bool_or_int(key, value, &error_flag) ?
2329 RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
2330 else
2331 return error(_("invalid key: %s"), key);
2333 if (!error_flag)
2334 return error(_("invalid value for %s: %s"), key, value);
2336 return 0;
2339 void parse_strategy_opts(struct replay_opts *opts, char *raw_opts)
2341 int i;
2342 char *strategy_opts_string = raw_opts;
2344 if (*strategy_opts_string == ' ')
2345 strategy_opts_string++;
2347 opts->xopts_nr = split_cmdline(strategy_opts_string,
2348 (const char ***)&opts->xopts);
2349 for (i = 0; i < opts->xopts_nr; i++) {
2350 const char *arg = opts->xopts[i];
2352 skip_prefix(arg, "--", &arg);
2353 opts->xopts[i] = xstrdup(arg);
2357 static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
2359 strbuf_reset(buf);
2360 if (!read_oneliner(buf, rebase_path_strategy(), 0))
2361 return;
2362 opts->strategy = strbuf_detach(buf, NULL);
2363 if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2364 return;
2366 parse_strategy_opts(opts, buf->buf);
2369 static int read_populate_opts(struct replay_opts *opts)
2371 if (is_rebase_i(opts)) {
2372 struct strbuf buf = STRBUF_INIT;
2374 if (read_oneliner(&buf, rebase_path_gpg_sign_opt(), 1)) {
2375 if (!starts_with(buf.buf, "-S"))
2376 strbuf_reset(&buf);
2377 else {
2378 free(opts->gpg_sign);
2379 opts->gpg_sign = xstrdup(buf.buf + 2);
2381 strbuf_reset(&buf);
2384 if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(), 1)) {
2385 if (!strcmp(buf.buf, "--rerere-autoupdate"))
2386 opts->allow_rerere_auto = RERERE_AUTOUPDATE;
2387 else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
2388 opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
2389 strbuf_reset(&buf);
2392 if (file_exists(rebase_path_verbose()))
2393 opts->verbose = 1;
2395 if (file_exists(rebase_path_quiet()))
2396 opts->quiet = 1;
2398 if (file_exists(rebase_path_signoff())) {
2399 opts->allow_ff = 0;
2400 opts->signoff = 1;
2403 if (file_exists(rebase_path_reschedule_failed_exec()))
2404 opts->reschedule_failed_exec = 1;
2406 read_strategy_opts(opts, &buf);
2407 strbuf_release(&buf);
2409 if (read_oneliner(&opts->current_fixups,
2410 rebase_path_current_fixups(), 1)) {
2411 const char *p = opts->current_fixups.buf;
2412 opts->current_fixup_count = 1;
2413 while ((p = strchr(p, '\n'))) {
2414 opts->current_fixup_count++;
2415 p++;
2419 if (read_oneliner(&buf, rebase_path_squash_onto(), 0)) {
2420 if (get_oid_hex(buf.buf, &opts->squash_onto) < 0)
2421 return error(_("unusable squash-onto"));
2422 opts->have_squash_onto = 1;
2425 return 0;
2428 if (!file_exists(git_path_opts_file()))
2429 return 0;
2431 * The function git_parse_source(), called from git_config_from_file(),
2432 * may die() in case of a syntactically incorrect file. We do not care
2433 * about this case, though, because we wrote that file ourselves, so we
2434 * are pretty certain that it is syntactically correct.
2436 if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
2437 return error(_("malformed options sheet: '%s'"),
2438 git_path_opts_file());
2439 return 0;
2442 static void write_strategy_opts(struct replay_opts *opts)
2444 int i;
2445 struct strbuf buf = STRBUF_INIT;
2447 for (i = 0; i < opts->xopts_nr; ++i)
2448 strbuf_addf(&buf, " --%s", opts->xopts[i]);
2450 write_file(rebase_path_strategy_opts(), "%s\n", buf.buf);
2451 strbuf_release(&buf);
2454 int write_basic_state(struct replay_opts *opts, const char *head_name,
2455 const char *onto, const char *orig_head)
2457 const char *quiet = getenv("GIT_QUIET");
2459 if (head_name)
2460 write_file(rebase_path_head_name(), "%s\n", head_name);
2461 if (onto)
2462 write_file(rebase_path_onto(), "%s\n", onto);
2463 if (orig_head)
2464 write_file(rebase_path_orig_head(), "%s\n", orig_head);
2466 if (quiet)
2467 write_file(rebase_path_quiet(), "%s\n", quiet);
2468 if (opts->verbose)
2469 write_file(rebase_path_verbose(), "%s", "");
2470 if (opts->strategy)
2471 write_file(rebase_path_strategy(), "%s\n", opts->strategy);
2472 if (opts->xopts_nr > 0)
2473 write_strategy_opts(opts);
2475 if (opts->allow_rerere_auto == RERERE_AUTOUPDATE)
2476 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2477 else if (opts->allow_rerere_auto == RERERE_NOAUTOUPDATE)
2478 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2480 if (opts->gpg_sign)
2481 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts->gpg_sign);
2482 if (opts->signoff)
2483 write_file(rebase_path_signoff(), "--signoff\n");
2484 if (opts->reschedule_failed_exec)
2485 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
2487 return 0;
2490 static int walk_revs_populate_todo(struct todo_list *todo_list,
2491 struct replay_opts *opts)
2493 enum todo_command command = opts->action == REPLAY_PICK ?
2494 TODO_PICK : TODO_REVERT;
2495 const char *command_string = todo_command_info[command].str;
2496 struct commit *commit;
2498 if (prepare_revs(opts))
2499 return -1;
2501 while ((commit = get_revision(opts->revs))) {
2502 struct todo_item *item = append_new_todo(todo_list);
2503 const char *commit_buffer = get_commit_buffer(commit, NULL);
2504 const char *subject;
2505 int subject_len;
2507 item->command = command;
2508 item->commit = commit;
2509 item->arg = NULL;
2510 item->arg_len = 0;
2511 item->offset_in_buf = todo_list->buf.len;
2512 subject_len = find_commit_subject(commit_buffer, &subject);
2513 strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
2514 short_commit_name(commit), subject_len, subject);
2515 unuse_commit_buffer(commit, commit_buffer);
2518 if (!todo_list->nr)
2519 return error(_("empty commit set passed"));
2521 return 0;
2524 static int create_seq_dir(void)
2526 if (file_exists(git_path_seq_dir())) {
2527 error(_("a cherry-pick or revert is already in progress"));
2528 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
2529 return -1;
2530 } else if (mkdir(git_path_seq_dir(), 0777) < 0)
2531 return error_errno(_("could not create sequencer directory '%s'"),
2532 git_path_seq_dir());
2533 return 0;
2536 static int save_head(const char *head)
2538 struct lock_file head_lock = LOCK_INIT;
2539 struct strbuf buf = STRBUF_INIT;
2540 int fd;
2541 ssize_t written;
2543 fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
2544 if (fd < 0)
2545 return error_errno(_("could not lock HEAD"));
2546 strbuf_addf(&buf, "%s\n", head);
2547 written = write_in_full(fd, buf.buf, buf.len);
2548 strbuf_release(&buf);
2549 if (written < 0) {
2550 error_errno(_("could not write to '%s'"), git_path_head_file());
2551 rollback_lock_file(&head_lock);
2552 return -1;
2554 if (commit_lock_file(&head_lock) < 0)
2555 return error(_("failed to finalize '%s'"), git_path_head_file());
2556 return 0;
2559 static int rollback_is_safe(void)
2561 struct strbuf sb = STRBUF_INIT;
2562 struct object_id expected_head, actual_head;
2564 if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2565 strbuf_trim(&sb);
2566 if (get_oid_hex(sb.buf, &expected_head)) {
2567 strbuf_release(&sb);
2568 die(_("could not parse %s"), git_path_abort_safety_file());
2570 strbuf_release(&sb);
2572 else if (errno == ENOENT)
2573 oidclr(&expected_head);
2574 else
2575 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2577 if (get_oid("HEAD", &actual_head))
2578 oidclr(&actual_head);
2580 return oideq(&actual_head, &expected_head);
2583 static int reset_for_rollback(const struct object_id *oid)
2585 const char *argv[4]; /* reset --merge <arg> + NULL */
2587 argv[0] = "reset";
2588 argv[1] = "--merge";
2589 argv[2] = oid_to_hex(oid);
2590 argv[3] = NULL;
2591 return run_command_v_opt(argv, RUN_GIT_CMD);
2594 static int rollback_single_pick(struct repository *r)
2596 struct object_id head_oid;
2598 if (!file_exists(git_path_cherry_pick_head(r)) &&
2599 !file_exists(git_path_revert_head(r)))
2600 return error(_("no cherry-pick or revert in progress"));
2601 if (read_ref_full("HEAD", 0, &head_oid, NULL))
2602 return error(_("cannot resolve HEAD"));
2603 if (is_null_oid(&head_oid))
2604 return error(_("cannot abort from a branch yet to be born"));
2605 return reset_for_rollback(&head_oid);
2608 int sequencer_rollback(struct repository *r, struct replay_opts *opts)
2610 FILE *f;
2611 struct object_id oid;
2612 struct strbuf buf = STRBUF_INIT;
2613 const char *p;
2615 f = fopen(git_path_head_file(), "r");
2616 if (!f && errno == ENOENT) {
2618 * There is no multiple-cherry-pick in progress.
2619 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2620 * a single-cherry-pick in progress, abort that.
2622 return rollback_single_pick(r);
2624 if (!f)
2625 return error_errno(_("cannot open '%s'"), git_path_head_file());
2626 if (strbuf_getline_lf(&buf, f)) {
2627 error(_("cannot read '%s': %s"), git_path_head_file(),
2628 ferror(f) ? strerror(errno) : _("unexpected end of file"));
2629 fclose(f);
2630 goto fail;
2632 fclose(f);
2633 if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
2634 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2635 git_path_head_file());
2636 goto fail;
2638 if (is_null_oid(&oid)) {
2639 error(_("cannot abort from a branch yet to be born"));
2640 goto fail;
2643 if (!rollback_is_safe()) {
2644 /* Do not error, just do not rollback */
2645 warning(_("You seem to have moved HEAD. "
2646 "Not rewinding, check your HEAD!"));
2647 } else
2648 if (reset_for_rollback(&oid))
2649 goto fail;
2650 strbuf_release(&buf);
2651 return sequencer_remove_state(opts);
2652 fail:
2653 strbuf_release(&buf);
2654 return -1;
2657 static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
2659 struct lock_file todo_lock = LOCK_INIT;
2660 const char *todo_path = get_todo_path(opts);
2661 int next = todo_list->current, offset, fd;
2664 * rebase -i writes "git-rebase-todo" without the currently executing
2665 * command, appending it to "done" instead.
2667 if (is_rebase_i(opts))
2668 next++;
2670 fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
2671 if (fd < 0)
2672 return error_errno(_("could not lock '%s'"), todo_path);
2673 offset = get_item_line_offset(todo_list, next);
2674 if (write_in_full(fd, todo_list->buf.buf + offset,
2675 todo_list->buf.len - offset) < 0)
2676 return error_errno(_("could not write to '%s'"), todo_path);
2677 if (commit_lock_file(&todo_lock) < 0)
2678 return error(_("failed to finalize '%s'"), todo_path);
2680 if (is_rebase_i(opts) && next > 0) {
2681 const char *done = rebase_path_done();
2682 int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
2683 int ret = 0;
2685 if (fd < 0)
2686 return 0;
2687 if (write_in_full(fd, get_item_line(todo_list, next - 1),
2688 get_item_line_length(todo_list, next - 1))
2689 < 0)
2690 ret = error_errno(_("could not write to '%s'"), done);
2691 if (close(fd) < 0)
2692 ret = error_errno(_("failed to finalize '%s'"), done);
2693 return ret;
2695 return 0;
2698 static int save_opts(struct replay_opts *opts)
2700 const char *opts_file = git_path_opts_file();
2701 int res = 0;
2703 if (opts->no_commit)
2704 res |= git_config_set_in_file_gently(opts_file, "options.no-commit", "true");
2705 if (opts->edit)
2706 res |= git_config_set_in_file_gently(opts_file, "options.edit", "true");
2707 if (opts->signoff)
2708 res |= git_config_set_in_file_gently(opts_file, "options.signoff", "true");
2709 if (opts->record_origin)
2710 res |= git_config_set_in_file_gently(opts_file, "options.record-origin", "true");
2711 if (opts->allow_ff)
2712 res |= git_config_set_in_file_gently(opts_file, "options.allow-ff", "true");
2713 if (opts->mainline) {
2714 struct strbuf buf = STRBUF_INIT;
2715 strbuf_addf(&buf, "%d", opts->mainline);
2716 res |= git_config_set_in_file_gently(opts_file, "options.mainline", buf.buf);
2717 strbuf_release(&buf);
2719 if (opts->strategy)
2720 res |= git_config_set_in_file_gently(opts_file, "options.strategy", opts->strategy);
2721 if (opts->gpg_sign)
2722 res |= git_config_set_in_file_gently(opts_file, "options.gpg-sign", opts->gpg_sign);
2723 if (opts->xopts) {
2724 int i;
2725 for (i = 0; i < opts->xopts_nr; i++)
2726 res |= git_config_set_multivar_in_file_gently(opts_file,
2727 "options.strategy-option",
2728 opts->xopts[i], "^$", 0);
2730 if (opts->allow_rerere_auto)
2731 res |= git_config_set_in_file_gently(opts_file, "options.allow-rerere-auto",
2732 opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
2733 "true" : "false");
2734 return res;
2737 static int make_patch(struct repository *r,
2738 struct commit *commit,
2739 struct replay_opts *opts)
2741 struct strbuf buf = STRBUF_INIT;
2742 struct rev_info log_tree_opt;
2743 const char *subject, *p;
2744 int res = 0;
2746 p = short_commit_name(commit);
2747 if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
2748 return -1;
2749 if (update_ref("rebase", "REBASE_HEAD", &commit->object.oid,
2750 NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2751 res |= error(_("could not update %s"), "REBASE_HEAD");
2753 strbuf_addf(&buf, "%s/patch", get_dir(opts));
2754 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
2755 repo_init_revisions(r, &log_tree_opt, NULL);
2756 log_tree_opt.abbrev = 0;
2757 log_tree_opt.diff = 1;
2758 log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
2759 log_tree_opt.disable_stdin = 1;
2760 log_tree_opt.no_commit_id = 1;
2761 log_tree_opt.diffopt.file = fopen(buf.buf, "w");
2762 log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
2763 if (!log_tree_opt.diffopt.file)
2764 res |= error_errno(_("could not open '%s'"), buf.buf);
2765 else {
2766 res |= log_tree_commit(&log_tree_opt, commit);
2767 fclose(log_tree_opt.diffopt.file);
2769 strbuf_reset(&buf);
2771 strbuf_addf(&buf, "%s/message", get_dir(opts));
2772 if (!file_exists(buf.buf)) {
2773 const char *commit_buffer = get_commit_buffer(commit, NULL);
2774 find_commit_subject(commit_buffer, &subject);
2775 res |= write_message(subject, strlen(subject), buf.buf, 1);
2776 unuse_commit_buffer(commit, commit_buffer);
2778 strbuf_release(&buf);
2780 return res;
2783 static int intend_to_amend(void)
2785 struct object_id head;
2786 char *p;
2788 if (get_oid("HEAD", &head))
2789 return error(_("cannot read HEAD"));
2791 p = oid_to_hex(&head);
2792 return write_message(p, strlen(p), rebase_path_amend(), 1);
2795 static int error_with_patch(struct repository *r,
2796 struct commit *commit,
2797 const char *subject, int subject_len,
2798 struct replay_opts *opts,
2799 int exit_code, int to_amend)
2801 if (commit) {
2802 if (make_patch(r, commit, opts))
2803 return -1;
2804 } else if (copy_file(rebase_path_message(),
2805 git_path_merge_msg(r), 0666))
2806 return error(_("unable to copy '%s' to '%s'"),
2807 git_path_merge_msg(r), rebase_path_message());
2809 if (to_amend) {
2810 if (intend_to_amend())
2811 return -1;
2813 fprintf(stderr,
2814 _("You can amend the commit now, with\n"
2815 "\n"
2816 " git commit --amend %s\n"
2817 "\n"
2818 "Once you are satisfied with your changes, run\n"
2819 "\n"
2820 " git rebase --continue\n"),
2821 gpg_sign_opt_quoted(opts));
2822 } else if (exit_code) {
2823 if (commit)
2824 fprintf_ln(stderr, _("Could not apply %s... %.*s"),
2825 short_commit_name(commit), subject_len, subject);
2826 else
2828 * We don't have the hash of the parent so
2829 * just print the line from the todo file.
2831 fprintf_ln(stderr, _("Could not merge %.*s"),
2832 subject_len, subject);
2835 return exit_code;
2838 static int error_failed_squash(struct repository *r,
2839 struct commit *commit,
2840 struct replay_opts *opts,
2841 int subject_len,
2842 const char *subject)
2844 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
2845 return error(_("could not copy '%s' to '%s'"),
2846 rebase_path_squash_msg(), rebase_path_message());
2847 unlink(git_path_merge_msg(r));
2848 if (copy_file(git_path_merge_msg(r), rebase_path_message(), 0666))
2849 return error(_("could not copy '%s' to '%s'"),
2850 rebase_path_message(),
2851 git_path_merge_msg(r));
2852 return error_with_patch(r, commit, subject, subject_len, opts, 1, 0);
2855 static int do_exec(struct repository *r, const char *command_line)
2857 struct argv_array child_env = ARGV_ARRAY_INIT;
2858 const char *child_argv[] = { NULL, NULL };
2859 int dirty, status;
2861 fprintf(stderr, "Executing: %s\n", command_line);
2862 child_argv[0] = command_line;
2863 argv_array_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
2864 argv_array_pushf(&child_env, "GIT_WORK_TREE=%s",
2865 absolute_path(get_git_work_tree()));
2866 status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
2867 child_env.argv);
2869 /* force re-reading of the cache */
2870 if (discard_index(r->index) < 0 || repo_read_index(r) < 0)
2871 return error(_("could not read index"));
2873 dirty = require_clean_work_tree(r, "rebase", NULL, 1, 1);
2875 if (status) {
2876 warning(_("execution failed: %s\n%s"
2877 "You can fix the problem, and then run\n"
2878 "\n"
2879 " git rebase --continue\n"
2880 "\n"),
2881 command_line,
2882 dirty ? N_("and made changes to the index and/or the "
2883 "working tree\n") : "");
2884 if (status == 127)
2885 /* command not found */
2886 status = 1;
2887 } else if (dirty) {
2888 warning(_("execution succeeded: %s\nbut "
2889 "left changes to the index and/or the working tree\n"
2890 "Commit or stash your changes, and then run\n"
2891 "\n"
2892 " git rebase --continue\n"
2893 "\n"), command_line);
2894 status = 1;
2897 argv_array_clear(&child_env);
2899 return status;
2902 static int safe_append(const char *filename, const char *fmt, ...)
2904 va_list ap;
2905 struct lock_file lock = LOCK_INIT;
2906 int fd = hold_lock_file_for_update(&lock, filename,
2907 LOCK_REPORT_ON_ERROR);
2908 struct strbuf buf = STRBUF_INIT;
2910 if (fd < 0)
2911 return -1;
2913 if (strbuf_read_file(&buf, filename, 0) < 0 && errno != ENOENT) {
2914 error_errno(_("could not read '%s'"), filename);
2915 rollback_lock_file(&lock);
2916 return -1;
2918 strbuf_complete(&buf, '\n');
2919 va_start(ap, fmt);
2920 strbuf_vaddf(&buf, fmt, ap);
2921 va_end(ap);
2923 if (write_in_full(fd, buf.buf, buf.len) < 0) {
2924 error_errno(_("could not write to '%s'"), filename);
2925 strbuf_release(&buf);
2926 rollback_lock_file(&lock);
2927 return -1;
2929 if (commit_lock_file(&lock) < 0) {
2930 strbuf_release(&buf);
2931 rollback_lock_file(&lock);
2932 return error(_("failed to finalize '%s'"), filename);
2935 strbuf_release(&buf);
2936 return 0;
2939 static int do_label(struct repository *r, const char *name, int len)
2941 struct ref_store *refs = get_main_ref_store(r);
2942 struct ref_transaction *transaction;
2943 struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
2944 struct strbuf msg = STRBUF_INIT;
2945 int ret = 0;
2946 struct object_id head_oid;
2948 if (len == 1 && *name == '#')
2949 return error(_("illegal label name: '%.*s'"), len, name);
2951 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
2952 strbuf_addf(&msg, "rebase -i (label) '%.*s'", len, name);
2954 transaction = ref_store_transaction_begin(refs, &err);
2955 if (!transaction) {
2956 error("%s", err.buf);
2957 ret = -1;
2958 } else if (get_oid("HEAD", &head_oid)) {
2959 error(_("could not read HEAD"));
2960 ret = -1;
2961 } else if (ref_transaction_update(transaction, ref_name.buf, &head_oid,
2962 NULL, 0, msg.buf, &err) < 0 ||
2963 ref_transaction_commit(transaction, &err)) {
2964 error("%s", err.buf);
2965 ret = -1;
2967 ref_transaction_free(transaction);
2968 strbuf_release(&err);
2969 strbuf_release(&msg);
2971 if (!ret)
2972 ret = safe_append(rebase_path_refs_to_delete(),
2973 "%s\n", ref_name.buf);
2974 strbuf_release(&ref_name);
2976 return ret;
2979 static const char *reflog_message(struct replay_opts *opts,
2980 const char *sub_action, const char *fmt, ...);
2982 static int do_reset(struct repository *r,
2983 const char *name, int len,
2984 struct replay_opts *opts)
2986 struct strbuf ref_name = STRBUF_INIT;
2987 struct object_id oid;
2988 struct lock_file lock = LOCK_INIT;
2989 struct tree_desc desc;
2990 struct tree *tree;
2991 struct unpack_trees_options unpack_tree_opts;
2992 int ret = 0;
2994 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0)
2995 return -1;
2997 if (len == 10 && !strncmp("[new root]", name, len)) {
2998 if (!opts->have_squash_onto) {
2999 const char *hex;
3000 if (commit_tree("", 0, the_hash_algo->empty_tree,
3001 NULL, &opts->squash_onto,
3002 NULL, NULL))
3003 return error(_("writing fake root commit"));
3004 opts->have_squash_onto = 1;
3005 hex = oid_to_hex(&opts->squash_onto);
3006 if (write_message(hex, strlen(hex),
3007 rebase_path_squash_onto(), 0))
3008 return error(_("writing squash-onto"));
3010 oidcpy(&oid, &opts->squash_onto);
3011 } else {
3012 int i;
3014 /* Determine the length of the label */
3015 for (i = 0; i < len; i++)
3016 if (isspace(name[i]))
3017 break;
3018 len = i;
3020 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3021 if (get_oid(ref_name.buf, &oid) &&
3022 get_oid(ref_name.buf + strlen("refs/rewritten/"), &oid)) {
3023 error(_("could not read '%s'"), ref_name.buf);
3024 rollback_lock_file(&lock);
3025 strbuf_release(&ref_name);
3026 return -1;
3030 memset(&unpack_tree_opts, 0, sizeof(unpack_tree_opts));
3031 setup_unpack_trees_porcelain(&unpack_tree_opts, "reset");
3032 unpack_tree_opts.head_idx = 1;
3033 unpack_tree_opts.src_index = r->index;
3034 unpack_tree_opts.dst_index = r->index;
3035 unpack_tree_opts.fn = oneway_merge;
3036 unpack_tree_opts.merge = 1;
3037 unpack_tree_opts.update = 1;
3039 if (repo_read_index_unmerged(r)) {
3040 rollback_lock_file(&lock);
3041 strbuf_release(&ref_name);
3042 return error_resolve_conflict(_(action_name(opts)));
3045 if (!fill_tree_descriptor(&desc, &oid)) {
3046 error(_("failed to find tree of %s"), oid_to_hex(&oid));
3047 rollback_lock_file(&lock);
3048 free((void *)desc.buffer);
3049 strbuf_release(&ref_name);
3050 return -1;
3053 if (unpack_trees(1, &desc, &unpack_tree_opts)) {
3054 rollback_lock_file(&lock);
3055 free((void *)desc.buffer);
3056 strbuf_release(&ref_name);
3057 return -1;
3060 tree = parse_tree_indirect(&oid);
3061 prime_cache_tree(r, r->index, tree);
3063 if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
3064 ret = error(_("could not write index"));
3065 free((void *)desc.buffer);
3067 if (!ret)
3068 ret = update_ref(reflog_message(opts, "reset", "'%.*s'",
3069 len, name), "HEAD", &oid,
3070 NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3072 strbuf_release(&ref_name);
3073 return ret;
3076 static struct commit *lookup_label(const char *label, int len,
3077 struct strbuf *buf)
3079 struct commit *commit;
3081 strbuf_reset(buf);
3082 strbuf_addf(buf, "refs/rewritten/%.*s", len, label);
3083 commit = lookup_commit_reference_by_name(buf->buf);
3084 if (!commit) {
3085 /* fall back to non-rewritten ref or commit */
3086 strbuf_splice(buf, 0, strlen("refs/rewritten/"), "", 0);
3087 commit = lookup_commit_reference_by_name(buf->buf);
3090 if (!commit)
3091 error(_("could not resolve '%s'"), buf->buf);
3093 return commit;
3096 static int do_merge(struct repository *r,
3097 struct commit *commit,
3098 const char *arg, int arg_len,
3099 int flags, struct replay_opts *opts)
3101 int run_commit_flags = (flags & TODO_EDIT_MERGE_MSG) ?
3102 EDIT_MSG | VERIFY_MSG : 0;
3103 struct strbuf ref_name = STRBUF_INIT;
3104 struct commit *head_commit, *merge_commit, *i;
3105 struct commit_list *bases, *j, *reversed = NULL;
3106 struct commit_list *to_merge = NULL, **tail = &to_merge;
3107 struct merge_options o;
3108 int merge_arg_len, oneline_offset, can_fast_forward, ret, k;
3109 static struct lock_file lock;
3110 const char *p;
3112 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0) {
3113 ret = -1;
3114 goto leave_merge;
3117 head_commit = lookup_commit_reference_by_name("HEAD");
3118 if (!head_commit) {
3119 ret = error(_("cannot merge without a current revision"));
3120 goto leave_merge;
3124 * For octopus merges, the arg starts with the list of revisions to be
3125 * merged. The list is optionally followed by '#' and the oneline.
3127 merge_arg_len = oneline_offset = arg_len;
3128 for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {
3129 if (!*p)
3130 break;
3131 if (*p == '#' && (!p[1] || isspace(p[1]))) {
3132 p += 1 + strspn(p + 1, " \t\n");
3133 oneline_offset = p - arg;
3134 break;
3136 k = strcspn(p, " \t\n");
3137 if (!k)
3138 continue;
3139 merge_commit = lookup_label(p, k, &ref_name);
3140 if (!merge_commit) {
3141 ret = error(_("unable to parse '%.*s'"), k, p);
3142 goto leave_merge;
3144 tail = &commit_list_insert(merge_commit, tail)->next;
3145 p += k;
3146 merge_arg_len = p - arg;
3149 if (!to_merge) {
3150 ret = error(_("nothing to merge: '%.*s'"), arg_len, arg);
3151 goto leave_merge;
3154 if (opts->have_squash_onto &&
3155 oideq(&head_commit->object.oid, &opts->squash_onto)) {
3157 * When the user tells us to "merge" something into a
3158 * "[new root]", let's simply fast-forward to the merge head.
3160 rollback_lock_file(&lock);
3161 if (to_merge->next)
3162 ret = error(_("octopus merge cannot be executed on "
3163 "top of a [new root]"));
3164 else
3165 ret = fast_forward_to(r, &to_merge->item->object.oid,
3166 &head_commit->object.oid, 0,
3167 opts);
3168 goto leave_merge;
3171 if (commit) {
3172 const char *message = get_commit_buffer(commit, NULL);
3173 const char *body;
3174 int len;
3176 if (!message) {
3177 ret = error(_("could not get commit message of '%s'"),
3178 oid_to_hex(&commit->object.oid));
3179 goto leave_merge;
3181 write_author_script(message);
3182 find_commit_subject(message, &body);
3183 len = strlen(body);
3184 ret = write_message(body, len, git_path_merge_msg(r), 0);
3185 unuse_commit_buffer(commit, message);
3186 if (ret) {
3187 error_errno(_("could not write '%s'"),
3188 git_path_merge_msg(r));
3189 goto leave_merge;
3191 } else {
3192 struct strbuf buf = STRBUF_INIT;
3193 int len;
3195 strbuf_addf(&buf, "author %s", git_author_info(0));
3196 write_author_script(buf.buf);
3197 strbuf_reset(&buf);
3199 if (oneline_offset < arg_len) {
3200 p = arg + oneline_offset;
3201 len = arg_len - oneline_offset;
3202 } else {
3203 strbuf_addf(&buf, "Merge %s '%.*s'",
3204 to_merge->next ? "branches" : "branch",
3205 merge_arg_len, arg);
3206 p = buf.buf;
3207 len = buf.len;
3210 ret = write_message(p, len, git_path_merge_msg(r), 0);
3211 strbuf_release(&buf);
3212 if (ret) {
3213 error_errno(_("could not write '%s'"),
3214 git_path_merge_msg(r));
3215 goto leave_merge;
3220 * If HEAD is not identical to the first parent of the original merge
3221 * commit, we cannot fast-forward.
3223 can_fast_forward = opts->allow_ff && commit && commit->parents &&
3224 oideq(&commit->parents->item->object.oid,
3225 &head_commit->object.oid);
3228 * If any merge head is different from the original one, we cannot
3229 * fast-forward.
3231 if (can_fast_forward) {
3232 struct commit_list *p = commit->parents->next;
3234 for (j = to_merge; j && p; j = j->next, p = p->next)
3235 if (!oideq(&j->item->object.oid,
3236 &p->item->object.oid)) {
3237 can_fast_forward = 0;
3238 break;
3241 * If the number of merge heads differs from the original merge
3242 * commit, we cannot fast-forward.
3244 if (j || p)
3245 can_fast_forward = 0;
3248 if (can_fast_forward) {
3249 rollback_lock_file(&lock);
3250 ret = fast_forward_to(r, &commit->object.oid,
3251 &head_commit->object.oid, 0, opts);
3252 goto leave_merge;
3255 if (to_merge->next) {
3256 /* Octopus merge */
3257 struct child_process cmd = CHILD_PROCESS_INIT;
3259 if (read_env_script(&cmd.env_array)) {
3260 const char *gpg_opt = gpg_sign_opt_quoted(opts);
3262 ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
3263 goto leave_merge;
3266 cmd.git_cmd = 1;
3267 argv_array_push(&cmd.args, "merge");
3268 argv_array_push(&cmd.args, "-s");
3269 argv_array_push(&cmd.args, "octopus");
3270 argv_array_push(&cmd.args, "--no-edit");
3271 argv_array_push(&cmd.args, "--no-ff");
3272 argv_array_push(&cmd.args, "--no-log");
3273 argv_array_push(&cmd.args, "--no-stat");
3274 argv_array_push(&cmd.args, "-F");
3275 argv_array_push(&cmd.args, git_path_merge_msg(r));
3276 if (opts->gpg_sign)
3277 argv_array_push(&cmd.args, opts->gpg_sign);
3279 /* Add the tips to be merged */
3280 for (j = to_merge; j; j = j->next)
3281 argv_array_push(&cmd.args,
3282 oid_to_hex(&j->item->object.oid));
3284 strbuf_release(&ref_name);
3285 unlink(git_path_cherry_pick_head(r));
3286 rollback_lock_file(&lock);
3288 rollback_lock_file(&lock);
3289 ret = run_command(&cmd);
3291 /* force re-reading of the cache */
3292 if (!ret && (discard_index(r->index) < 0 ||
3293 repo_read_index(r) < 0))
3294 ret = error(_("could not read index"));
3295 goto leave_merge;
3298 merge_commit = to_merge->item;
3299 bases = get_merge_bases(head_commit, merge_commit);
3300 if (bases && oideq(&merge_commit->object.oid,
3301 &bases->item->object.oid)) {
3302 ret = 0;
3303 /* skip merging an ancestor of HEAD */
3304 goto leave_merge;
3307 write_message(oid_to_hex(&merge_commit->object.oid), GIT_SHA1_HEXSZ,
3308 git_path_merge_head(r), 0);
3309 write_message("no-ff", 5, git_path_merge_mode(r), 0);
3311 for (j = bases; j; j = j->next)
3312 commit_list_insert(j->item, &reversed);
3313 free_commit_list(bases);
3315 repo_read_index(r);
3316 init_merge_options(&o, r);
3317 o.branch1 = "HEAD";
3318 o.branch2 = ref_name.buf;
3319 o.buffer_output = 2;
3321 ret = merge_recursive(&o, head_commit, merge_commit, reversed, &i);
3322 if (ret <= 0)
3323 fputs(o.obuf.buf, stdout);
3324 strbuf_release(&o.obuf);
3325 if (ret < 0) {
3326 error(_("could not even attempt to merge '%.*s'"),
3327 merge_arg_len, arg);
3328 goto leave_merge;
3331 * The return value of merge_recursive() is 1 on clean, and 0 on
3332 * unclean merge.
3334 * Let's reverse that, so that do_merge() returns 0 upon success and
3335 * 1 upon failed merge (keeping the return value -1 for the cases where
3336 * we will want to reschedule the `merge` command).
3338 ret = !ret;
3340 if (r->index->cache_changed &&
3341 write_locked_index(r->index, &lock, COMMIT_LOCK)) {
3342 ret = error(_("merge: Unable to write new index file"));
3343 goto leave_merge;
3346 rollback_lock_file(&lock);
3347 if (ret)
3348 repo_rerere(r, opts->allow_rerere_auto);
3349 else
3351 * In case of problems, we now want to return a positive
3352 * value (a negative one would indicate that the `merge`
3353 * command needs to be rescheduled).
3355 ret = !!run_git_commit(r, git_path_merge_msg(r), opts,
3356 run_commit_flags);
3358 leave_merge:
3359 strbuf_release(&ref_name);
3360 rollback_lock_file(&lock);
3361 free_commit_list(to_merge);
3362 return ret;
3365 static int is_final_fixup(struct todo_list *todo_list)
3367 int i = todo_list->current;
3369 if (!is_fixup(todo_list->items[i].command))
3370 return 0;
3372 while (++i < todo_list->nr)
3373 if (is_fixup(todo_list->items[i].command))
3374 return 0;
3375 else if (!is_noop(todo_list->items[i].command))
3376 break;
3377 return 1;
3380 static enum todo_command peek_command(struct todo_list *todo_list, int offset)
3382 int i;
3384 for (i = todo_list->current + offset; i < todo_list->nr; i++)
3385 if (!is_noop(todo_list->items[i].command))
3386 return todo_list->items[i].command;
3388 return -1;
3391 static int apply_autostash(struct replay_opts *opts)
3393 struct strbuf stash_sha1 = STRBUF_INIT;
3394 struct child_process child = CHILD_PROCESS_INIT;
3395 int ret = 0;
3397 if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
3398 strbuf_release(&stash_sha1);
3399 return 0;
3401 strbuf_trim(&stash_sha1);
3403 child.git_cmd = 1;
3404 child.no_stdout = 1;
3405 child.no_stderr = 1;
3406 argv_array_push(&child.args, "stash");
3407 argv_array_push(&child.args, "apply");
3408 argv_array_push(&child.args, stash_sha1.buf);
3409 if (!run_command(&child))
3410 fprintf(stderr, _("Applied autostash.\n"));
3411 else {
3412 struct child_process store = CHILD_PROCESS_INIT;
3414 store.git_cmd = 1;
3415 argv_array_push(&store.args, "stash");
3416 argv_array_push(&store.args, "store");
3417 argv_array_push(&store.args, "-m");
3418 argv_array_push(&store.args, "autostash");
3419 argv_array_push(&store.args, "-q");
3420 argv_array_push(&store.args, stash_sha1.buf);
3421 if (run_command(&store))
3422 ret = error(_("cannot store %s"), stash_sha1.buf);
3423 else
3424 fprintf(stderr,
3425 _("Applying autostash resulted in conflicts.\n"
3426 "Your changes are safe in the stash.\n"
3427 "You can run \"git stash pop\" or"
3428 " \"git stash drop\" at any time.\n"));
3431 strbuf_release(&stash_sha1);
3432 return ret;
3435 static const char *reflog_message(struct replay_opts *opts,
3436 const char *sub_action, const char *fmt, ...)
3438 va_list ap;
3439 static struct strbuf buf = STRBUF_INIT;
3441 va_start(ap, fmt);
3442 strbuf_reset(&buf);
3443 strbuf_addstr(&buf, action_name(opts));
3444 if (sub_action)
3445 strbuf_addf(&buf, " (%s)", sub_action);
3446 if (fmt) {
3447 strbuf_addstr(&buf, ": ");
3448 strbuf_vaddf(&buf, fmt, ap);
3450 va_end(ap);
3452 return buf.buf;
3455 static int run_git_checkout(struct replay_opts *opts, const char *commit,
3456 const char *action)
3458 struct child_process cmd = CHILD_PROCESS_INIT;
3460 cmd.git_cmd = 1;
3462 argv_array_push(&cmd.args, "checkout");
3463 argv_array_push(&cmd.args, commit);
3464 argv_array_pushf(&cmd.env_array, GIT_REFLOG_ACTION "=%s", action);
3466 if (opts->verbose)
3467 return run_command(&cmd);
3468 else
3469 return run_command_silent_on_success(&cmd);
3472 int prepare_branch_to_be_rebased(struct replay_opts *opts, const char *commit)
3474 const char *action;
3476 if (commit && *commit) {
3477 action = reflog_message(opts, "start", "checkout %s", commit);
3478 if (run_git_checkout(opts, commit, action))
3479 return error(_("could not checkout %s"), commit);
3482 return 0;
3485 static int checkout_onto(struct replay_opts *opts,
3486 const char *onto_name, const char *onto,
3487 const char *orig_head)
3489 struct object_id oid;
3490 const char *action = reflog_message(opts, "start", "checkout %s", onto_name);
3492 if (get_oid(orig_head, &oid))
3493 return error(_("%s: not a valid OID"), orig_head);
3495 if (run_git_checkout(opts, onto, action)) {
3496 apply_autostash(opts);
3497 sequencer_remove_state(opts);
3498 return error(_("could not detach HEAD"));
3501 return update_ref(NULL, "ORIG_HEAD", &oid, NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3504 static int stopped_at_head(struct repository *r)
3506 struct object_id head;
3507 struct commit *commit;
3508 struct commit_message message;
3510 if (get_oid("HEAD", &head) ||
3511 !(commit = lookup_commit(r, &head)) ||
3512 parse_commit(commit) || get_message(commit, &message))
3513 fprintf(stderr, _("Stopped at HEAD\n"));
3514 else {
3515 fprintf(stderr, _("Stopped at %s\n"), message.label);
3516 free_message(commit, &message);
3518 return 0;
3522 static const char rescheduled_advice[] =
3523 N_("Could not execute the todo command\n"
3524 "\n"
3525 " %.*s"
3526 "\n"
3527 "It has been rescheduled; To edit the command before continuing, please\n"
3528 "edit the todo list first:\n"
3529 "\n"
3530 " git rebase --edit-todo\n"
3531 " git rebase --continue\n");
3533 static int pick_commits(struct repository *r,
3534 struct todo_list *todo_list,
3535 struct replay_opts *opts)
3537 int res = 0, reschedule = 0;
3539 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
3540 if (opts->allow_ff)
3541 assert(!(opts->signoff || opts->no_commit ||
3542 opts->record_origin || opts->edit));
3543 if (read_and_refresh_cache(r, opts))
3544 return -1;
3546 while (todo_list->current < todo_list->nr) {
3547 struct todo_item *item = todo_list->items + todo_list->current;
3548 if (save_todo(todo_list, opts))
3549 return -1;
3550 if (is_rebase_i(opts)) {
3551 if (item->command != TODO_COMMENT) {
3552 FILE *f = fopen(rebase_path_msgnum(), "w");
3554 todo_list->done_nr++;
3556 if (f) {
3557 fprintf(f, "%d\n", todo_list->done_nr);
3558 fclose(f);
3560 if (!opts->quiet)
3561 fprintf(stderr, "Rebasing (%d/%d)%s",
3562 todo_list->done_nr,
3563 todo_list->total_nr,
3564 opts->verbose ? "\n" : "\r");
3566 unlink(rebase_path_message());
3567 unlink(rebase_path_author_script());
3568 unlink(rebase_path_stopped_sha());
3569 unlink(rebase_path_amend());
3570 unlink(git_path_merge_head(the_repository));
3571 delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
3573 if (item->command == TODO_BREAK)
3574 return stopped_at_head(r);
3576 if (item->command <= TODO_SQUASH) {
3577 if (is_rebase_i(opts))
3578 setenv("GIT_REFLOG_ACTION", reflog_message(opts,
3579 command_to_string(item->command), NULL),
3581 res = do_pick_commit(r, item->command, item->commit,
3582 opts, is_final_fixup(todo_list));
3583 if (is_rebase_i(opts) && res < 0) {
3584 /* Reschedule */
3585 advise(_(rescheduled_advice),
3586 get_item_line_length(todo_list,
3587 todo_list->current),
3588 get_item_line(todo_list,
3589 todo_list->current));
3590 todo_list->current--;
3591 if (save_todo(todo_list, opts))
3592 return -1;
3594 if (item->command == TODO_EDIT) {
3595 struct commit *commit = item->commit;
3596 if (!res)
3597 fprintf(stderr,
3598 _("Stopped at %s... %.*s\n"),
3599 short_commit_name(commit),
3600 item->arg_len, item->arg);
3601 return error_with_patch(r, commit,
3602 item->arg, item->arg_len, opts, res,
3603 !res);
3605 if (is_rebase_i(opts) && !res)
3606 record_in_rewritten(&item->commit->object.oid,
3607 peek_command(todo_list, 1));
3608 if (res && is_fixup(item->command)) {
3609 if (res == 1)
3610 intend_to_amend();
3611 return error_failed_squash(r, item->commit, opts,
3612 item->arg_len, item->arg);
3613 } else if (res && is_rebase_i(opts) && item->commit) {
3614 int to_amend = 0;
3615 struct object_id oid;
3618 * If we are rewording and have either
3619 * fast-forwarded already, or are about to
3620 * create a new root commit, we want to amend,
3621 * otherwise we do not.
3623 if (item->command == TODO_REWORD &&
3624 !get_oid("HEAD", &oid) &&
3625 (oideq(&item->commit->object.oid, &oid) ||
3626 (opts->have_squash_onto &&
3627 oideq(&opts->squash_onto, &oid))))
3628 to_amend = 1;
3630 return res | error_with_patch(r, item->commit,
3631 item->arg, item->arg_len, opts,
3632 res, to_amend);
3634 } else if (item->command == TODO_EXEC) {
3635 char *end_of_arg = (char *)(item->arg + item->arg_len);
3636 int saved = *end_of_arg;
3637 struct stat st;
3639 *end_of_arg = '\0';
3640 res = do_exec(r, item->arg);
3641 *end_of_arg = saved;
3643 /* Reread the todo file if it has changed. */
3644 if (res) {
3645 if (opts->reschedule_failed_exec)
3646 reschedule = 1;
3647 } else if (stat(get_todo_path(opts), &st))
3648 res = error_errno(_("could not stat '%s'"),
3649 get_todo_path(opts));
3650 else if (match_stat_data(&todo_list->stat, &st)) {
3651 todo_list_release(todo_list);
3652 if (read_populate_todo(r, todo_list, opts))
3653 res = -1; /* message was printed */
3654 /* `current` will be incremented below */
3655 todo_list->current = -1;
3657 } else if (item->command == TODO_LABEL) {
3658 if ((res = do_label(r, item->arg, item->arg_len)))
3659 reschedule = 1;
3660 } else if (item->command == TODO_RESET) {
3661 if ((res = do_reset(r, item->arg, item->arg_len, opts)))
3662 reschedule = 1;
3663 } else if (item->command == TODO_MERGE) {
3664 if ((res = do_merge(r, item->commit,
3665 item->arg, item->arg_len,
3666 item->flags, opts)) < 0)
3667 reschedule = 1;
3668 else if (item->commit)
3669 record_in_rewritten(&item->commit->object.oid,
3670 peek_command(todo_list, 1));
3671 if (res > 0)
3672 /* failed with merge conflicts */
3673 return error_with_patch(r, item->commit,
3674 item->arg,
3675 item->arg_len, opts,
3676 res, 0);
3677 } else if (!is_noop(item->command))
3678 return error(_("unknown command %d"), item->command);
3680 if (reschedule) {
3681 advise(_(rescheduled_advice),
3682 get_item_line_length(todo_list,
3683 todo_list->current),
3684 get_item_line(todo_list, todo_list->current));
3685 todo_list->current--;
3686 if (save_todo(todo_list, opts))
3687 return -1;
3688 if (item->commit)
3689 return error_with_patch(r,
3690 item->commit,
3691 item->arg,
3692 item->arg_len, opts,
3693 res, 0);
3696 todo_list->current++;
3697 if (res)
3698 return res;
3701 if (is_rebase_i(opts)) {
3702 struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
3703 struct stat st;
3705 /* Stopped in the middle, as planned? */
3706 if (todo_list->current < todo_list->nr)
3707 return 0;
3709 if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
3710 starts_with(head_ref.buf, "refs/")) {
3711 const char *msg;
3712 struct object_id head, orig;
3713 int res;
3715 if (get_oid("HEAD", &head)) {
3716 res = error(_("cannot read HEAD"));
3717 cleanup_head_ref:
3718 strbuf_release(&head_ref);
3719 strbuf_release(&buf);
3720 return res;
3722 if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
3723 get_oid_hex(buf.buf, &orig)) {
3724 res = error(_("could not read orig-head"));
3725 goto cleanup_head_ref;
3727 strbuf_reset(&buf);
3728 if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
3729 res = error(_("could not read 'onto'"));
3730 goto cleanup_head_ref;
3732 msg = reflog_message(opts, "finish", "%s onto %s",
3733 head_ref.buf, buf.buf);
3734 if (update_ref(msg, head_ref.buf, &head, &orig,
3735 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
3736 res = error(_("could not update %s"),
3737 head_ref.buf);
3738 goto cleanup_head_ref;
3740 msg = reflog_message(opts, "finish", "returning to %s",
3741 head_ref.buf);
3742 if (create_symref("HEAD", head_ref.buf, msg)) {
3743 res = error(_("could not update HEAD to %s"),
3744 head_ref.buf);
3745 goto cleanup_head_ref;
3747 strbuf_reset(&buf);
3750 if (opts->verbose) {
3751 struct rev_info log_tree_opt;
3752 struct object_id orig, head;
3754 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
3755 repo_init_revisions(r, &log_tree_opt, NULL);
3756 log_tree_opt.diff = 1;
3757 log_tree_opt.diffopt.output_format =
3758 DIFF_FORMAT_DIFFSTAT;
3759 log_tree_opt.disable_stdin = 1;
3761 if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
3762 !get_oid(buf.buf, &orig) &&
3763 !get_oid("HEAD", &head)) {
3764 diff_tree_oid(&orig, &head, "",
3765 &log_tree_opt.diffopt);
3766 log_tree_diff_flush(&log_tree_opt);
3769 flush_rewritten_pending();
3770 if (!stat(rebase_path_rewritten_list(), &st) &&
3771 st.st_size > 0) {
3772 struct child_process child = CHILD_PROCESS_INIT;
3773 const char *post_rewrite_hook =
3774 find_hook("post-rewrite");
3776 child.in = open(rebase_path_rewritten_list(), O_RDONLY);
3777 child.git_cmd = 1;
3778 argv_array_push(&child.args, "notes");
3779 argv_array_push(&child.args, "copy");
3780 argv_array_push(&child.args, "--for-rewrite=rebase");
3781 /* we don't care if this copying failed */
3782 run_command(&child);
3784 if (post_rewrite_hook) {
3785 struct child_process hook = CHILD_PROCESS_INIT;
3787 hook.in = open(rebase_path_rewritten_list(),
3788 O_RDONLY);
3789 hook.stdout_to_stderr = 1;
3790 hook.trace2_hook_name = "post-rewrite";
3791 argv_array_push(&hook.args, post_rewrite_hook);
3792 argv_array_push(&hook.args, "rebase");
3793 /* we don't care if this hook failed */
3794 run_command(&hook);
3797 apply_autostash(opts);
3799 if (!opts->quiet)
3800 fprintf(stderr,
3801 "Successfully rebased and updated %s.\n",
3802 head_ref.buf);
3804 strbuf_release(&buf);
3805 strbuf_release(&head_ref);
3809 * Sequence of picks finished successfully; cleanup by
3810 * removing the .git/sequencer directory
3812 return sequencer_remove_state(opts);
3815 static int continue_single_pick(struct repository *r)
3817 const char *argv[] = { "commit", NULL };
3819 if (!file_exists(git_path_cherry_pick_head(r)) &&
3820 !file_exists(git_path_revert_head(r)))
3821 return error(_("no cherry-pick or revert in progress"));
3822 return run_command_v_opt(argv, RUN_GIT_CMD);
3825 static int commit_staged_changes(struct repository *r,
3826 struct replay_opts *opts,
3827 struct todo_list *todo_list)
3829 unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
3830 unsigned int final_fixup = 0, is_clean;
3832 if (has_unstaged_changes(r, 1))
3833 return error(_("cannot rebase: You have unstaged changes."));
3835 is_clean = !has_uncommitted_changes(r, 0);
3837 if (file_exists(rebase_path_amend())) {
3838 struct strbuf rev = STRBUF_INIT;
3839 struct object_id head, to_amend;
3841 if (get_oid("HEAD", &head))
3842 return error(_("cannot amend non-existing commit"));
3843 if (!read_oneliner(&rev, rebase_path_amend(), 0))
3844 return error(_("invalid file: '%s'"), rebase_path_amend());
3845 if (get_oid_hex(rev.buf, &to_amend))
3846 return error(_("invalid contents: '%s'"),
3847 rebase_path_amend());
3848 if (!is_clean && !oideq(&head, &to_amend))
3849 return error(_("\nYou have uncommitted changes in your "
3850 "working tree. Please, commit them\n"
3851 "first and then run 'git rebase "
3852 "--continue' again."));
3854 * When skipping a failed fixup/squash, we need to edit the
3855 * commit message, the current fixup list and count, and if it
3856 * was the last fixup/squash in the chain, we need to clean up
3857 * the commit message and if there was a squash, let the user
3858 * edit it.
3860 if (!is_clean || !opts->current_fixup_count)
3861 ; /* this is not the final fixup */
3862 else if (!oideq(&head, &to_amend) ||
3863 !file_exists(rebase_path_stopped_sha())) {
3864 /* was a final fixup or squash done manually? */
3865 if (!is_fixup(peek_command(todo_list, 0))) {
3866 unlink(rebase_path_fixup_msg());
3867 unlink(rebase_path_squash_msg());
3868 unlink(rebase_path_current_fixups());
3869 strbuf_reset(&opts->current_fixups);
3870 opts->current_fixup_count = 0;
3872 } else {
3873 /* we are in a fixup/squash chain */
3874 const char *p = opts->current_fixups.buf;
3875 int len = opts->current_fixups.len;
3877 opts->current_fixup_count--;
3878 if (!len)
3879 BUG("Incorrect current_fixups:\n%s", p);
3880 while (len && p[len - 1] != '\n')
3881 len--;
3882 strbuf_setlen(&opts->current_fixups, len);
3883 if (write_message(p, len, rebase_path_current_fixups(),
3884 0) < 0)
3885 return error(_("could not write file: '%s'"),
3886 rebase_path_current_fixups());
3889 * If a fixup/squash in a fixup/squash chain failed, the
3890 * commit message is already correct, no need to commit
3891 * it again.
3893 * Only if it is the final command in the fixup/squash
3894 * chain, and only if the chain is longer than a single
3895 * fixup/squash command (which was just skipped), do we
3896 * actually need to re-commit with a cleaned up commit
3897 * message.
3899 if (opts->current_fixup_count > 0 &&
3900 !is_fixup(peek_command(todo_list, 0))) {
3901 final_fixup = 1;
3903 * If there was not a single "squash" in the
3904 * chain, we only need to clean up the commit
3905 * message, no need to bother the user with
3906 * opening the commit message in the editor.
3908 if (!starts_with(p, "squash ") &&
3909 !strstr(p, "\nsquash "))
3910 flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;
3911 } else if (is_fixup(peek_command(todo_list, 0))) {
3913 * We need to update the squash message to skip
3914 * the latest commit message.
3916 struct commit *commit;
3917 const char *path = rebase_path_squash_msg();
3919 if (parse_head(r, &commit) ||
3920 !(p = get_commit_buffer(commit, NULL)) ||
3921 write_message(p, strlen(p), path, 0)) {
3922 unuse_commit_buffer(commit, p);
3923 return error(_("could not write file: "
3924 "'%s'"), path);
3926 unuse_commit_buffer(commit, p);
3930 strbuf_release(&rev);
3931 flags |= AMEND_MSG;
3934 if (is_clean) {
3935 const char *cherry_pick_head = git_path_cherry_pick_head(r);
3937 if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
3938 return error(_("could not remove CHERRY_PICK_HEAD"));
3939 if (!final_fixup)
3940 return 0;
3943 if (run_git_commit(r, final_fixup ? NULL : rebase_path_message(),
3944 opts, flags))
3945 return error(_("could not commit staged changes."));
3946 unlink(rebase_path_amend());
3947 unlink(git_path_merge_head(the_repository));
3948 if (final_fixup) {
3949 unlink(rebase_path_fixup_msg());
3950 unlink(rebase_path_squash_msg());
3952 if (opts->current_fixup_count > 0) {
3954 * Whether final fixup or not, we just cleaned up the commit
3955 * message...
3957 unlink(rebase_path_current_fixups());
3958 strbuf_reset(&opts->current_fixups);
3959 opts->current_fixup_count = 0;
3961 return 0;
3964 int sequencer_continue(struct repository *r, struct replay_opts *opts)
3966 struct todo_list todo_list = TODO_LIST_INIT;
3967 int res;
3969 if (read_and_refresh_cache(r, opts))
3970 return -1;
3972 if (read_populate_opts(opts))
3973 return -1;
3974 if (is_rebase_i(opts)) {
3975 if ((res = read_populate_todo(r, &todo_list, opts)))
3976 goto release_todo_list;
3977 if (commit_staged_changes(r, opts, &todo_list))
3978 return -1;
3979 } else if (!file_exists(get_todo_path(opts)))
3980 return continue_single_pick(r);
3981 else if ((res = read_populate_todo(r, &todo_list, opts)))
3982 goto release_todo_list;
3984 if (!is_rebase_i(opts)) {
3985 /* Verify that the conflict has been resolved */
3986 if (file_exists(git_path_cherry_pick_head(r)) ||
3987 file_exists(git_path_revert_head(r))) {
3988 res = continue_single_pick(r);
3989 if (res)
3990 goto release_todo_list;
3992 if (index_differs_from(r, "HEAD", NULL, 0)) {
3993 res = error_dirty_index(r, opts);
3994 goto release_todo_list;
3996 todo_list.current++;
3997 } else if (file_exists(rebase_path_stopped_sha())) {
3998 struct strbuf buf = STRBUF_INIT;
3999 struct object_id oid;
4001 if (read_oneliner(&buf, rebase_path_stopped_sha(), 1) &&
4002 !get_oid_committish(buf.buf, &oid))
4003 record_in_rewritten(&oid, peek_command(&todo_list, 0));
4004 strbuf_release(&buf);
4007 res = pick_commits(r, &todo_list, opts);
4008 release_todo_list:
4009 todo_list_release(&todo_list);
4010 return res;
4013 static int single_pick(struct repository *r,
4014 struct commit *cmit,
4015 struct replay_opts *opts)
4017 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
4018 return do_pick_commit(r, opts->action == REPLAY_PICK ?
4019 TODO_PICK : TODO_REVERT, cmit, opts, 0);
4022 int sequencer_pick_revisions(struct repository *r,
4023 struct replay_opts *opts)
4025 struct todo_list todo_list = TODO_LIST_INIT;
4026 struct object_id oid;
4027 int i, res;
4029 assert(opts->revs);
4030 if (read_and_refresh_cache(r, opts))
4031 return -1;
4033 for (i = 0; i < opts->revs->pending.nr; i++) {
4034 struct object_id oid;
4035 const char *name = opts->revs->pending.objects[i].name;
4037 /* This happens when using --stdin. */
4038 if (!strlen(name))
4039 continue;
4041 if (!get_oid(name, &oid)) {
4042 if (!lookup_commit_reference_gently(r, &oid, 1)) {
4043 enum object_type type = oid_object_info(r,
4044 &oid,
4045 NULL);
4046 return error(_("%s: can't cherry-pick a %s"),
4047 name, type_name(type));
4049 } else
4050 return error(_("%s: bad revision"), name);
4054 * If we were called as "git cherry-pick <commit>", just
4055 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4056 * REVERT_HEAD, and don't touch the sequencer state.
4057 * This means it is possible to cherry-pick in the middle
4058 * of a cherry-pick sequence.
4060 if (opts->revs->cmdline.nr == 1 &&
4061 opts->revs->cmdline.rev->whence == REV_CMD_REV &&
4062 opts->revs->no_walk &&
4063 !opts->revs->cmdline.rev->flags) {
4064 struct commit *cmit;
4065 if (prepare_revision_walk(opts->revs))
4066 return error(_("revision walk setup failed"));
4067 cmit = get_revision(opts->revs);
4068 if (!cmit)
4069 return error(_("empty commit set passed"));
4070 if (get_revision(opts->revs))
4071 BUG("unexpected extra commit from walk");
4072 return single_pick(r, cmit, opts);
4076 * Start a new cherry-pick/ revert sequence; but
4077 * first, make sure that an existing one isn't in
4078 * progress
4081 if (walk_revs_populate_todo(&todo_list, opts) ||
4082 create_seq_dir() < 0)
4083 return -1;
4084 if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
4085 return error(_("can't revert as initial commit"));
4086 if (save_head(oid_to_hex(&oid)))
4087 return -1;
4088 if (save_opts(opts))
4089 return -1;
4090 update_abort_safety_file();
4091 res = pick_commits(r, &todo_list, opts);
4092 todo_list_release(&todo_list);
4093 return res;
4096 void append_signoff(struct strbuf *msgbuf, size_t ignore_footer, unsigned flag)
4098 unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
4099 struct strbuf sob = STRBUF_INIT;
4100 int has_footer;
4102 strbuf_addstr(&sob, sign_off_header);
4103 strbuf_addstr(&sob, fmt_name(WANT_COMMITTER_IDENT));
4104 strbuf_addch(&sob, '\n');
4106 if (!ignore_footer)
4107 strbuf_complete_line(msgbuf);
4110 * If the whole message buffer is equal to the sob, pretend that we
4111 * found a conforming footer with a matching sob
4113 if (msgbuf->len - ignore_footer == sob.len &&
4114 !strncmp(msgbuf->buf, sob.buf, sob.len))
4115 has_footer = 3;
4116 else
4117 has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
4119 if (!has_footer) {
4120 const char *append_newlines = NULL;
4121 size_t len = msgbuf->len - ignore_footer;
4123 if (!len) {
4125 * The buffer is completely empty. Leave foom for
4126 * the title and body to be filled in by the user.
4128 append_newlines = "\n\n";
4129 } else if (len == 1) {
4131 * Buffer contains a single newline. Add another
4132 * so that we leave room for the title and body.
4134 append_newlines = "\n";
4135 } else if (msgbuf->buf[len - 2] != '\n') {
4137 * Buffer ends with a single newline. Add another
4138 * so that there is an empty line between the message
4139 * body and the sob.
4141 append_newlines = "\n";
4142 } /* else, the buffer already ends with two newlines. */
4144 if (append_newlines)
4145 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4146 append_newlines, strlen(append_newlines));
4149 if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
4150 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4151 sob.buf, sob.len);
4153 strbuf_release(&sob);
4156 struct labels_entry {
4157 struct hashmap_entry entry;
4158 char label[FLEX_ARRAY];
4161 static int labels_cmp(const void *fndata, const struct labels_entry *a,
4162 const struct labels_entry *b, const void *key)
4164 return key ? strcmp(a->label, key) : strcmp(a->label, b->label);
4167 struct string_entry {
4168 struct oidmap_entry entry;
4169 char string[FLEX_ARRAY];
4172 struct label_state {
4173 struct oidmap commit2label;
4174 struct hashmap labels;
4175 struct strbuf buf;
4178 static const char *label_oid(struct object_id *oid, const char *label,
4179 struct label_state *state)
4181 struct labels_entry *labels_entry;
4182 struct string_entry *string_entry;
4183 struct object_id dummy;
4184 size_t len;
4185 int i;
4187 string_entry = oidmap_get(&state->commit2label, oid);
4188 if (string_entry)
4189 return string_entry->string;
4192 * For "uninteresting" commits, i.e. commits that are not to be
4193 * rebased, and which can therefore not be labeled, we use a unique
4194 * abbreviation of the commit name. This is slightly more complicated
4195 * than calling find_unique_abbrev() because we also need to make
4196 * sure that the abbreviation does not conflict with any other
4197 * label.
4199 * We disallow "interesting" commits to be labeled by a string that
4200 * is a valid full-length hash, to ensure that we always can find an
4201 * abbreviation for any uninteresting commit's names that does not
4202 * clash with any other label.
4204 if (!label) {
4205 char *p;
4207 strbuf_reset(&state->buf);
4208 strbuf_grow(&state->buf, GIT_SHA1_HEXSZ);
4209 label = p = state->buf.buf;
4211 find_unique_abbrev_r(p, oid, default_abbrev);
4214 * We may need to extend the abbreviated hash so that there is
4215 * no conflicting label.
4217 if (hashmap_get_from_hash(&state->labels, strihash(p), p)) {
4218 size_t i = strlen(p) + 1;
4220 oid_to_hex_r(p, oid);
4221 for (; i < GIT_SHA1_HEXSZ; i++) {
4222 char save = p[i];
4223 p[i] = '\0';
4224 if (!hashmap_get_from_hash(&state->labels,
4225 strihash(p), p))
4226 break;
4227 p[i] = save;
4230 } else if (((len = strlen(label)) == the_hash_algo->hexsz &&
4231 !get_oid_hex(label, &dummy)) ||
4232 (len == 1 && *label == '#') ||
4233 hashmap_get_from_hash(&state->labels,
4234 strihash(label), label)) {
4236 * If the label already exists, or if the label is a valid full
4237 * OID, or the label is a '#' (which we use as a separator
4238 * between merge heads and oneline), we append a dash and a
4239 * number to make it unique.
4241 struct strbuf *buf = &state->buf;
4243 strbuf_reset(buf);
4244 strbuf_add(buf, label, len);
4246 for (i = 2; ; i++) {
4247 strbuf_setlen(buf, len);
4248 strbuf_addf(buf, "-%d", i);
4249 if (!hashmap_get_from_hash(&state->labels,
4250 strihash(buf->buf),
4251 buf->buf))
4252 break;
4255 label = buf->buf;
4258 FLEX_ALLOC_STR(labels_entry, label, label);
4259 hashmap_entry_init(labels_entry, strihash(label));
4260 hashmap_add(&state->labels, labels_entry);
4262 FLEX_ALLOC_STR(string_entry, string, label);
4263 oidcpy(&string_entry->entry.oid, oid);
4264 oidmap_put(&state->commit2label, string_entry);
4266 return string_entry->string;
4269 static int make_script_with_merges(struct pretty_print_context *pp,
4270 struct rev_info *revs, FILE *out,
4271 unsigned flags)
4273 int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4274 int rebase_cousins = flags & TODO_LIST_REBASE_COUSINS;
4275 struct strbuf buf = STRBUF_INIT, oneline = STRBUF_INIT;
4276 struct strbuf label = STRBUF_INIT;
4277 struct commit_list *commits = NULL, **tail = &commits, *iter;
4278 struct commit_list *tips = NULL, **tips_tail = &tips;
4279 struct commit *commit;
4280 struct oidmap commit2todo = OIDMAP_INIT;
4281 struct string_entry *entry;
4282 struct oidset interesting = OIDSET_INIT, child_seen = OIDSET_INIT,
4283 shown = OIDSET_INIT;
4284 struct label_state state = { OIDMAP_INIT, { NULL }, STRBUF_INIT };
4286 int abbr = flags & TODO_LIST_ABBREVIATE_CMDS;
4287 const char *cmd_pick = abbr ? "p" : "pick",
4288 *cmd_label = abbr ? "l" : "label",
4289 *cmd_reset = abbr ? "t" : "reset",
4290 *cmd_merge = abbr ? "m" : "merge";
4292 oidmap_init(&commit2todo, 0);
4293 oidmap_init(&state.commit2label, 0);
4294 hashmap_init(&state.labels, (hashmap_cmp_fn) labels_cmp, NULL, 0);
4295 strbuf_init(&state.buf, 32);
4297 if (revs->cmdline.nr && (revs->cmdline.rev[0].flags & BOTTOM)) {
<