5 #include "object-store.h"
10 #include "run-command.h"
13 #include "cache-tree.h"
17 #include "merge-recursive.h"
19 #include "argv-array.h"
23 #include "wt-status.h"
25 #include "notes-utils.h"
27 #include "unpack-trees.h"
31 #include "commit-slab.h"
33 #include "commit-reach.h"
34 #include "rebase-interactive.h"
36 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
38 static const char sign_off_header
[] = "Signed-off-by: ";
39 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
41 GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
43 GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
45 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
46 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
47 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
48 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
50 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
52 * The file containing rebase commands, comments, and empty lines.
53 * This file is created by "git rebase -i" then edited by the user. As
54 * the lines are processed, they are removed from the front of this
55 * file and written to the tail of 'done'.
57 GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
58 GIT_PATH_FUNC(rebase_path_todo_backup
, "rebase-merge/git-rebase-todo.backup")
61 * The rebase command lines that have already been processed. A line
62 * is moved here when it is first handled, before any associated user
65 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
67 * The file to keep track of how many commands were already processed (e.g.
70 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum")
72 * The file to keep track of how many commands are to be processed in total
73 * (e.g. for the prompt).
75 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end")
77 * The commit message that is planned to be used for any changes that
78 * need to be committed following a user interaction.
80 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
82 * The file into which is accumulated the suggested commit message for
83 * squash/fixup commands. When the first of a series of squash/fixups
84 * is seen, the file is created and the commit message from the
85 * previous commit and from the first squash/fixup commit are written
86 * to it. The commit message for each subsequent squash/fixup commit
87 * is appended to the file as it is processed.
89 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
91 * If the current series of squash/fixups has not yet included a squash
92 * command, then this file exists and holds the commit message of the
93 * original "pick" commit. (If the series ends without a "squash"
94 * command, then this can be used as the commit message of the combined
95 * commit without opening the editor.)
97 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
99 * This file contains the list fixup/squash commands that have been
100 * accumulated into message-fixup or message-squash so far.
102 static GIT_PATH_FUNC(rebase_path_current_fixups
, "rebase-merge/current-fixups")
104 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
105 * GIT_AUTHOR_DATE that will be used for the commit that is currently
108 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
110 * When an "edit" rebase command is being processed, the SHA1 of the
111 * commit to be edited is recorded in this file. When "git rebase
112 * --continue" is executed, if there are any staged changes then they
113 * will be amended to the HEAD commit, but only provided the HEAD
114 * commit is still the commit to be edited. When any other rebase
115 * command is processed, this file is deleted.
117 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
119 * When we stop at a given patch via the "edit" command, this file contains
120 * the abbreviated commit name of the corresponding patch.
122 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
124 * For the post-rewrite hook, we make a list of rewritten commits and
125 * their new sha1s. The rewritten-pending list keeps the sha1s of
126 * commits that have been processed, but not committed yet,
127 * e.g. because they are waiting for a 'squash' command.
129 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
130 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
131 "rebase-merge/rewritten-pending")
134 * The path of the file containig the OID of the "squash onto" commit, i.e.
135 * the dummy commit used for `reset [new root]`.
137 static GIT_PATH_FUNC(rebase_path_squash_onto
, "rebase-merge/squash-onto")
140 * The path of the file listing refs that need to be deleted after the rebase
141 * finishes. This is used by the `label` command to record the need for cleanup.
143 static GIT_PATH_FUNC(rebase_path_refs_to_delete
, "rebase-merge/refs-to-delete")
146 * The following files are written by git-rebase just after parsing the
149 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
150 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
151 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
152 static GIT_PATH_FUNC(rebase_path_quiet
, "rebase-merge/quiet")
153 static GIT_PATH_FUNC(rebase_path_signoff
, "rebase-merge/signoff")
154 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
155 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
156 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
157 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
158 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
159 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
160 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec
, "rebase-merge/reschedule-failed-exec")
162 static int git_sequencer_config(const char *k
, const char *v
, void *cb
)
164 struct replay_opts
*opts
= cb
;
167 if (!strcmp(k
, "commit.cleanup")) {
170 status
= git_config_string(&s
, k
, v
);
174 if (!strcmp(s
, "verbatim")) {
175 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
176 opts
->explicit_cleanup
= 1;
177 } else if (!strcmp(s
, "whitespace")) {
178 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
179 opts
->explicit_cleanup
= 1;
180 } else if (!strcmp(s
, "strip")) {
181 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_ALL
;
182 opts
->explicit_cleanup
= 1;
183 } else if (!strcmp(s
, "scissors")) {
184 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SCISSORS
;
185 opts
->explicit_cleanup
= 1;
187 warning(_("invalid commit message cleanup mode '%s'"),
195 if (!strcmp(k
, "commit.gpgsign")) {
196 opts
->gpg_sign
= git_config_bool(k
, v
) ? xstrdup("") : NULL
;
200 status
= git_gpg_config(k
, v
, NULL
);
204 return git_diff_basic_config(k
, v
, NULL
);
207 void sequencer_init_config(struct replay_opts
*opts
)
209 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
210 git_config(git_sequencer_config
, opts
);
213 static inline int is_rebase_i(const struct replay_opts
*opts
)
215 return opts
->action
== REPLAY_INTERACTIVE_REBASE
;
218 static const char *get_dir(const struct replay_opts
*opts
)
220 if (is_rebase_i(opts
))
221 return rebase_path();
222 return git_path_seq_dir();
225 static const char *get_todo_path(const struct replay_opts
*opts
)
227 if (is_rebase_i(opts
))
228 return rebase_path_todo();
229 return git_path_todo_file();
233 * Returns 0 for non-conforming footer
234 * Returns 1 for conforming footer
235 * Returns 2 when sob exists within conforming footer
236 * Returns 3 when sob exists within conforming footer as last entry
238 static int has_conforming_footer(struct strbuf
*sb
, struct strbuf
*sob
,
239 size_t ignore_footer
)
241 struct process_trailer_options opts
= PROCESS_TRAILER_OPTIONS_INIT
;
242 struct trailer_info info
;
244 int found_sob
= 0, found_sob_last
= 0;
248 trailer_info_get(&info
, sb
->buf
, &opts
);
250 if (info
.trailer_start
== info
.trailer_end
)
253 for (i
= 0; i
< info
.trailer_nr
; i
++)
254 if (sob
&& !strncmp(info
.trailers
[i
], sob
->buf
, sob
->len
)) {
256 if (i
== info
.trailer_nr
- 1)
260 trailer_info_release(&info
);
269 static const char *gpg_sign_opt_quoted(struct replay_opts
*opts
)
271 static struct strbuf buf
= STRBUF_INIT
;
275 sq_quotef(&buf
, "-S%s", opts
->gpg_sign
);
279 int sequencer_remove_state(struct replay_opts
*opts
)
281 struct strbuf buf
= STRBUF_INIT
;
284 if (is_rebase_i(opts
) &&
285 strbuf_read_file(&buf
, rebase_path_refs_to_delete(), 0) > 0) {
288 char *eol
= strchr(p
, '\n');
291 if (delete_ref("(rebase -i) cleanup", p
, NULL
, 0) < 0) {
292 warning(_("could not delete '%s'"), p
);
301 free(opts
->gpg_sign
);
302 free(opts
->strategy
);
303 for (i
= 0; i
< opts
->xopts_nr
; i
++)
304 free(opts
->xopts
[i
]);
306 strbuf_release(&opts
->current_fixups
);
309 strbuf_addstr(&buf
, get_dir(opts
));
310 if (remove_dir_recursively(&buf
, 0))
311 ret
= error(_("could not remove '%s'"), buf
.buf
);
312 strbuf_release(&buf
);
317 static const char *action_name(const struct replay_opts
*opts
)
319 switch (opts
->action
) {
323 return N_("cherry-pick");
324 case REPLAY_INTERACTIVE_REBASE
:
325 return N_("rebase -i");
327 die(_("unknown action: %d"), opts
->action
);
330 struct commit_message
{
337 static const char *short_commit_name(struct commit
*commit
)
339 return find_unique_abbrev(&commit
->object
.oid
, DEFAULT_ABBREV
);
342 static int get_message(struct commit
*commit
, struct commit_message
*out
)
344 const char *abbrev
, *subject
;
347 out
->message
= logmsg_reencode(commit
, NULL
, get_commit_output_encoding());
348 abbrev
= short_commit_name(commit
);
350 subject_len
= find_commit_subject(out
->message
, &subject
);
352 out
->subject
= xmemdupz(subject
, subject_len
);
353 out
->label
= xstrfmt("%s... %s", abbrev
, out
->subject
);
354 out
->parent_label
= xstrfmt("parent of %s", out
->label
);
359 static void free_message(struct commit
*commit
, struct commit_message
*msg
)
361 free(msg
->parent_label
);
364 unuse_commit_buffer(commit
, msg
->message
);
367 static void print_advice(struct repository
*r
, int show_hint
,
368 struct replay_opts
*opts
)
370 char *msg
= getenv("GIT_CHERRY_PICK_HELP");
373 fprintf(stderr
, "%s\n", msg
);
375 * A conflict has occurred but the porcelain
376 * (typically rebase --interactive) wants to take care
377 * of the commit itself so remove CHERRY_PICK_HEAD
379 unlink(git_path_cherry_pick_head(r
));
385 advise(_("after resolving the conflicts, mark the corrected paths\n"
386 "with 'git add <paths>' or 'git rm <paths>'"));
388 advise(_("after resolving the conflicts, mark the corrected paths\n"
389 "with 'git add <paths>' or 'git rm <paths>'\n"
390 "and commit the result with 'git commit'"));
394 static int write_message(const void *buf
, size_t len
, const char *filename
,
397 struct lock_file msg_file
= LOCK_INIT
;
399 int msg_fd
= hold_lock_file_for_update(&msg_file
, filename
, 0);
401 return error_errno(_("could not lock '%s'"), filename
);
402 if (write_in_full(msg_fd
, buf
, len
) < 0) {
403 error_errno(_("could not write to '%s'"), filename
);
404 rollback_lock_file(&msg_file
);
407 if (append_eol
&& write(msg_fd
, "\n", 1) < 0) {
408 error_errno(_("could not write eol to '%s'"), filename
);
409 rollback_lock_file(&msg_file
);
412 if (commit_lock_file(&msg_file
) < 0)
413 return error(_("failed to finalize '%s'"), filename
);
419 * Reads a file that was presumably written by a shell script, i.e. with an
420 * end-of-line marker that needs to be stripped.
422 * Note that only the last end-of-line marker is stripped, consistent with the
423 * behavior of "$(cat path)" in a shell script.
425 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
427 static int read_oneliner(struct strbuf
*buf
,
428 const char *path
, int skip_if_empty
)
430 int orig_len
= buf
->len
;
432 if (!file_exists(path
))
435 if (strbuf_read_file(buf
, path
, 0) < 0) {
436 warning_errno(_("could not read '%s'"), path
);
440 if (buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\n') {
441 if (--buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\r')
443 buf
->buf
[buf
->len
] = '\0';
446 if (skip_if_empty
&& buf
->len
== orig_len
)
452 static struct tree
*empty_tree(struct repository
*r
)
454 return lookup_tree(r
, the_hash_algo
->empty_tree
);
457 static int error_dirty_index(struct repository
*repo
, struct replay_opts
*opts
)
459 if (repo_read_index_unmerged(repo
))
460 return error_resolve_conflict(_(action_name(opts
)));
462 error(_("your local changes would be overwritten by %s."),
463 _(action_name(opts
)));
465 if (advice_commit_before_merge
)
466 advise(_("commit your changes or stash them to proceed."));
470 static void update_abort_safety_file(void)
472 struct object_id head
;
474 /* Do nothing on a single-pick */
475 if (!file_exists(git_path_seq_dir()))
478 if (!get_oid("HEAD", &head
))
479 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head
));
481 write_file(git_path_abort_safety_file(), "%s", "");
484 static int fast_forward_to(struct repository
*r
,
485 const struct object_id
*to
,
486 const struct object_id
*from
,
488 struct replay_opts
*opts
)
490 struct ref_transaction
*transaction
;
491 struct strbuf sb
= STRBUF_INIT
;
492 struct strbuf err
= STRBUF_INIT
;
495 if (checkout_fast_forward(r
, from
, to
, 1))
496 return -1; /* the callee should have complained already */
498 strbuf_addf(&sb
, _("%s: fast-forward"), _(action_name(opts
)));
500 transaction
= ref_transaction_begin(&err
);
502 ref_transaction_update(transaction
, "HEAD",
503 to
, unborn
&& !is_rebase_i(opts
) ?
506 ref_transaction_commit(transaction
, &err
)) {
507 ref_transaction_free(transaction
);
508 error("%s", err
.buf
);
510 strbuf_release(&err
);
515 strbuf_release(&err
);
516 ref_transaction_free(transaction
);
517 update_abort_safety_file();
521 enum commit_msg_cleanup_mode
get_cleanup_mode(const char *cleanup_arg
,
524 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
525 return use_editor
? COMMIT_MSG_CLEANUP_ALL
:
526 COMMIT_MSG_CLEANUP_SPACE
;
527 else if (!strcmp(cleanup_arg
, "verbatim"))
528 return COMMIT_MSG_CLEANUP_NONE
;
529 else if (!strcmp(cleanup_arg
, "whitespace"))
530 return COMMIT_MSG_CLEANUP_SPACE
;
531 else if (!strcmp(cleanup_arg
, "strip"))
532 return COMMIT_MSG_CLEANUP_ALL
;
533 else if (!strcmp(cleanup_arg
, "scissors"))
534 return use_editor
? COMMIT_MSG_CLEANUP_SCISSORS
:
535 COMMIT_MSG_CLEANUP_SPACE
;
537 die(_("Invalid cleanup mode %s"), cleanup_arg
);
541 * NB using int rather than enum cleanup_mode to stop clang's
542 * -Wtautological-constant-out-of-range-compare complaining that the comparison
545 static const char *describe_cleanup_mode(int cleanup_mode
)
547 static const char *modes
[] = { "whitespace",
552 if (cleanup_mode
< ARRAY_SIZE(modes
))
553 return modes
[cleanup_mode
];
555 BUG("invalid cleanup_mode provided (%d)", cleanup_mode
);
558 void append_conflicts_hint(struct index_state
*istate
,
559 struct strbuf
*msgbuf
, enum commit_msg_cleanup_mode cleanup_mode
)
563 if (cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
) {
564 strbuf_addch(msgbuf
, '\n');
565 wt_status_append_cut_line(msgbuf
);
566 strbuf_addch(msgbuf
, comment_line_char
);
569 strbuf_addch(msgbuf
, '\n');
570 strbuf_commented_addf(msgbuf
, "Conflicts:\n");
571 for (i
= 0; i
< istate
->cache_nr
;) {
572 const struct cache_entry
*ce
= istate
->cache
[i
++];
574 strbuf_commented_addf(msgbuf
, "\t%s\n", ce
->name
);
575 while (i
< istate
->cache_nr
&&
576 !strcmp(ce
->name
, istate
->cache
[i
]->name
))
582 static int do_recursive_merge(struct repository
*r
,
583 struct commit
*base
, struct commit
*next
,
584 const char *base_label
, const char *next_label
,
585 struct object_id
*head
, struct strbuf
*msgbuf
,
586 struct replay_opts
*opts
)
588 struct merge_options o
;
589 struct tree
*result
, *next_tree
, *base_tree
, *head_tree
;
592 struct lock_file index_lock
= LOCK_INIT
;
594 if (repo_hold_locked_index(r
, &index_lock
, LOCK_REPORT_ON_ERROR
) < 0)
599 init_merge_options(&o
, r
);
600 o
.ancestor
= base
? base_label
: "(empty tree)";
602 o
.branch2
= next
? next_label
: "(empty tree)";
603 if (is_rebase_i(opts
))
605 o
.show_rename_progress
= 1;
607 head_tree
= parse_tree_indirect(head
);
608 next_tree
= next
? get_commit_tree(next
) : empty_tree(r
);
609 base_tree
= base
? get_commit_tree(base
) : empty_tree(r
);
611 for (xopt
= opts
->xopts
; xopt
!= opts
->xopts
+ opts
->xopts_nr
; xopt
++)
612 parse_merge_opt(&o
, *xopt
);
614 clean
= merge_trees(&o
,
616 next_tree
, base_tree
, &result
);
617 if (is_rebase_i(opts
) && clean
<= 0)
618 fputs(o
.obuf
.buf
, stdout
);
619 strbuf_release(&o
.obuf
);
620 diff_warn_rename_limit("merge.renamelimit", o
.needed_rename_limit
, 0);
622 rollback_lock_file(&index_lock
);
626 if (write_locked_index(r
->index
, &index_lock
,
627 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
629 * TRANSLATORS: %s will be "revert", "cherry-pick" or
632 return error(_("%s: Unable to write new index file"),
633 _(action_name(opts
)));
636 append_conflicts_hint(r
->index
, msgbuf
,
637 opts
->default_msg_cleanup
);
642 static struct object_id
*get_cache_tree_oid(struct index_state
*istate
)
644 if (!istate
->cache_tree
)
645 istate
->cache_tree
= cache_tree();
647 if (!cache_tree_fully_valid(istate
->cache_tree
))
648 if (cache_tree_update(istate
, 0)) {
649 error(_("unable to update cache tree"));
653 return &istate
->cache_tree
->oid
;
656 static int is_index_unchanged(struct repository
*r
)
658 struct object_id head_oid
, *cache_tree_oid
;
659 struct commit
*head_commit
;
660 struct index_state
*istate
= r
->index
;
662 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
663 return error(_("could not resolve HEAD commit"));
665 head_commit
= lookup_commit(r
, &head_oid
);
668 * If head_commit is NULL, check_commit, called from
669 * lookup_commit, would have indicated that head_commit is not
670 * a commit object already. parse_commit() will return failure
671 * without further complaints in such a case. Otherwise, if
672 * the commit is invalid, parse_commit() will complain. So
673 * there is nothing for us to say here. Just return failure.
675 if (parse_commit(head_commit
))
678 if (!(cache_tree_oid
= get_cache_tree_oid(istate
)))
681 return oideq(cache_tree_oid
, get_commit_tree_oid(head_commit
));
684 static int write_author_script(const char *message
)
686 struct strbuf buf
= STRBUF_INIT
;
691 if (!*message
|| starts_with(message
, "\n")) {
693 /* Missing 'author' line? */
694 unlink(rebase_path_author_script());
696 } else if (skip_prefix(message
, "author ", &message
))
698 else if ((eol
= strchr(message
, '\n')))
703 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
704 while (*message
&& *message
!= '\n' && *message
!= '\r')
705 if (skip_prefix(message
, " <", &message
))
707 else if (*message
!= '\'')
708 strbuf_addch(&buf
, *(message
++));
710 strbuf_addf(&buf
, "'\\%c'", *(message
++));
711 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
712 while (*message
&& *message
!= '\n' && *message
!= '\r')
713 if (skip_prefix(message
, "> ", &message
))
715 else if (*message
!= '\'')
716 strbuf_addch(&buf
, *(message
++));
718 strbuf_addf(&buf
, "'\\%c'", *(message
++));
719 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
720 while (*message
&& *message
!= '\n' && *message
!= '\r')
721 if (*message
!= '\'')
722 strbuf_addch(&buf
, *(message
++));
724 strbuf_addf(&buf
, "'\\%c'", *(message
++));
725 strbuf_addch(&buf
, '\'');
726 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
727 strbuf_release(&buf
);
732 * Take a series of KEY='VALUE' lines where VALUE part is
733 * sq-quoted, and append <KEY, VALUE> at the end of the string list
735 static int parse_key_value_squoted(char *buf
, struct string_list
*list
)
738 struct string_list_item
*item
;
740 char *cp
= strchr(buf
, '=');
742 np
= strchrnul(buf
, '\n');
743 return error(_("no key present in '%.*s'"),
744 (int) (np
- buf
), buf
);
746 np
= strchrnul(cp
, '\n');
748 item
= string_list_append(list
, buf
);
750 buf
= np
+ (*np
== '\n');
754 return error(_("unable to dequote value of '%s'"),
756 item
->util
= xstrdup(cp
);
762 * Reads and parses the state directory's "author-script" file, and sets name,
763 * email and date accordingly.
764 * Returns 0 on success, -1 if the file could not be parsed.
766 * The author script is of the format:
768 * GIT_AUTHOR_NAME='$author_name'
769 * GIT_AUTHOR_EMAIL='$author_email'
770 * GIT_AUTHOR_DATE='$author_date'
772 * where $author_name, $author_email and $author_date are quoted. We are strict
773 * with our parsing, as the file was meant to be eval'd in the old
774 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
775 * from what this function expects, it is better to bail out than to do
776 * something that the user does not expect.
778 int read_author_script(const char *path
, char **name
, char **email
, char **date
,
781 struct strbuf buf
= STRBUF_INIT
;
782 struct string_list kv
= STRING_LIST_INIT_DUP
;
783 int retval
= -1; /* assume failure */
784 int i
, name_i
= -2, email_i
= -2, date_i
= -2, err
= 0;
786 if (strbuf_read_file(&buf
, path
, 256) <= 0) {
787 strbuf_release(&buf
);
788 if (errno
== ENOENT
&& allow_missing
)
791 return error_errno(_("could not open '%s' for reading"),
795 if (parse_key_value_squoted(buf
.buf
, &kv
))
798 for (i
= 0; i
< kv
.nr
; i
++) {
799 if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_NAME")) {
801 name_i
= error(_("'GIT_AUTHOR_NAME' already given"));
804 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_EMAIL")) {
806 email_i
= error(_("'GIT_AUTHOR_EMAIL' already given"));
809 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_DATE")) {
811 date_i
= error(_("'GIT_AUTHOR_DATE' already given"));
815 err
= error(_("unknown variable '%s'"),
820 error(_("missing 'GIT_AUTHOR_NAME'"));
822 error(_("missing 'GIT_AUTHOR_EMAIL'"));
824 error(_("missing 'GIT_AUTHOR_DATE'"));
825 if (date_i
< 0 || email_i
< 0 || date_i
< 0 || err
)
827 *name
= kv
.items
[name_i
].util
;
828 *email
= kv
.items
[email_i
].util
;
829 *date
= kv
.items
[date_i
].util
;
832 string_list_clear(&kv
, !!retval
);
833 strbuf_release(&buf
);
838 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
839 * file with shell quoting into struct argv_array. Returns -1 on
840 * error, 0 otherwise.
842 static int read_env_script(struct argv_array
*env
)
844 char *name
, *email
, *date
;
846 if (read_author_script(rebase_path_author_script(),
847 &name
, &email
, &date
, 0))
850 argv_array_pushf(env
, "GIT_AUTHOR_NAME=%s", name
);
851 argv_array_pushf(env
, "GIT_AUTHOR_EMAIL=%s", email
);
852 argv_array_pushf(env
, "GIT_AUTHOR_DATE=%s", date
);
860 static char *get_author(const char *message
)
865 a
= find_commit_header(message
, "author", &len
);
867 return xmemdupz(a
, len
);
872 /* Read author-script and return an ident line (author <email> timestamp) */
873 static const char *read_author_ident(struct strbuf
*buf
)
875 struct strbuf out
= STRBUF_INIT
;
876 char *name
, *email
, *date
;
878 if (read_author_script(rebase_path_author_script(),
879 &name
, &email
, &date
, 0))
882 /* validate date since fmt_ident() will die() on bad value */
883 if (parse_date(date
, &out
)){
884 warning(_("invalid date format '%s' in '%s'"),
885 date
, rebase_path_author_script());
886 strbuf_release(&out
);
891 strbuf_addstr(&out
, fmt_ident(name
, email
, WANT_AUTHOR_IDENT
, date
, 0));
892 strbuf_swap(buf
, &out
);
893 strbuf_release(&out
);
900 static const char staged_changes_advice
[] =
901 N_("you have staged changes in your working tree\n"
902 "If these changes are meant to be squashed into the previous commit, run:\n"
904 " git commit --amend %s\n"
906 "If they are meant to go into a new commit, run:\n"
910 "In both cases, once you're done, continue with:\n"
912 " git rebase --continue\n");
914 #define ALLOW_EMPTY (1<<0)
915 #define EDIT_MSG (1<<1)
916 #define AMEND_MSG (1<<2)
917 #define CLEANUP_MSG (1<<3)
918 #define VERIFY_MSG (1<<4)
919 #define CREATE_ROOT_COMMIT (1<<5)
921 static int run_command_silent_on_success(struct child_process
*cmd
)
923 struct strbuf buf
= STRBUF_INIT
;
926 cmd
->stdout_to_stderr
= 1;
927 rc
= pipe_command(cmd
,
933 fputs(buf
.buf
, stderr
);
934 strbuf_release(&buf
);
939 * If we are cherry-pick, and if the merge did not result in
940 * hand-editing, we will hit this commit and inherit the original
941 * author date and name.
943 * If we are revert, or if our cherry-pick results in a hand merge,
944 * we had better say that the current user is responsible for that.
946 * An exception is when run_git_commit() is called during an
947 * interactive rebase: in that case, we will want to retain the
950 static int run_git_commit(struct repository
*r
,
952 struct replay_opts
*opts
,
955 struct child_process cmd
= CHILD_PROCESS_INIT
;
957 if ((flags
& CREATE_ROOT_COMMIT
) && !(flags
& AMEND_MSG
)) {
958 struct strbuf msg
= STRBUF_INIT
, script
= STRBUF_INIT
;
959 const char *author
= NULL
;
960 struct object_id root_commit
, *cache_tree_oid
;
963 if (is_rebase_i(opts
)) {
964 author
= read_author_ident(&script
);
966 strbuf_release(&script
);
972 BUG("root commit without message");
974 if (!(cache_tree_oid
= get_cache_tree_oid(r
->index
)))
978 res
= strbuf_read_file(&msg
, defmsg
, 0);
981 res
= error_errno(_("could not read '%s'"), defmsg
);
983 res
= commit_tree(msg
.buf
, msg
.len
, cache_tree_oid
,
984 NULL
, &root_commit
, author
,
987 strbuf_release(&msg
);
988 strbuf_release(&script
);
990 res
= update_ref(NULL
, "HEAD", &root_commit
, NULL
, 0,
991 UPDATE_REFS_MSG_ON_ERR
);
993 return res
< 0 ? error(_("writing root commit")) : 0;
998 if (is_rebase_i(opts
) && read_env_script(&cmd
.env_array
)) {
999 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
1001 return error(_(staged_changes_advice
),
1005 argv_array_push(&cmd
.args
, "commit");
1007 if (!(flags
& VERIFY_MSG
))
1008 argv_array_push(&cmd
.args
, "-n");
1009 if ((flags
& AMEND_MSG
))
1010 argv_array_push(&cmd
.args
, "--amend");
1012 argv_array_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
1014 argv_array_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
1015 else if (!(flags
& EDIT_MSG
))
1016 argv_array_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
1017 if ((flags
& CLEANUP_MSG
))
1018 argv_array_push(&cmd
.args
, "--cleanup=strip");
1019 if ((flags
& EDIT_MSG
))
1020 argv_array_push(&cmd
.args
, "-e");
1021 else if (!(flags
& CLEANUP_MSG
) &&
1022 !opts
->signoff
&& !opts
->record_origin
&&
1023 !opts
->explicit_cleanup
)
1024 argv_array_push(&cmd
.args
, "--cleanup=verbatim");
1026 if ((flags
& ALLOW_EMPTY
))
1027 argv_array_push(&cmd
.args
, "--allow-empty");
1029 if (!(flags
& EDIT_MSG
))
1030 argv_array_push(&cmd
.args
, "--allow-empty-message");
1032 if (is_rebase_i(opts
) && !(flags
& EDIT_MSG
))
1033 return run_command_silent_on_success(&cmd
);
1035 return run_command(&cmd
);
1038 static int rest_is_empty(const struct strbuf
*sb
, int start
)
1043 /* Check if the rest is just whitespace and Signed-off-by's. */
1044 for (i
= start
; i
< sb
->len
; i
++) {
1045 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1051 if (strlen(sign_off_header
) <= eol
- i
&&
1052 starts_with(sb
->buf
+ i
, sign_off_header
)) {
1057 if (!isspace(sb
->buf
[i
++]))
1064 void cleanup_message(struct strbuf
*msgbuf
,
1065 enum commit_msg_cleanup_mode cleanup_mode
, int verbose
)
1067 if (verbose
|| /* Truncate the message just before the diff, if any. */
1068 cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
1069 strbuf_setlen(msgbuf
, wt_status_locate_end(msgbuf
->buf
, msgbuf
->len
));
1070 if (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
)
1071 strbuf_stripspace(msgbuf
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1075 * Find out if the message in the strbuf contains only whitespace and
1076 * Signed-off-by lines.
1078 int message_is_empty(const struct strbuf
*sb
,
1079 enum commit_msg_cleanup_mode cleanup_mode
)
1081 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1083 return rest_is_empty(sb
, 0);
1087 * See if the user edited the message in the editor or left what
1088 * was in the template intact
1090 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
1091 enum commit_msg_cleanup_mode cleanup_mode
)
1093 struct strbuf tmpl
= STRBUF_INIT
;
1096 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1099 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
1102 strbuf_stripspace(&tmpl
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1103 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
1105 strbuf_release(&tmpl
);
1106 return rest_is_empty(sb
, start
- sb
->buf
);
1109 int update_head_with_reflog(const struct commit
*old_head
,
1110 const struct object_id
*new_head
,
1111 const char *action
, const struct strbuf
*msg
,
1114 struct ref_transaction
*transaction
;
1115 struct strbuf sb
= STRBUF_INIT
;
1120 strbuf_addstr(&sb
, action
);
1121 strbuf_addstr(&sb
, ": ");
1124 nl
= strchr(msg
->buf
, '\n');
1126 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
1128 strbuf_addbuf(&sb
, msg
);
1129 strbuf_addch(&sb
, '\n');
1132 transaction
= ref_transaction_begin(err
);
1134 ref_transaction_update(transaction
, "HEAD", new_head
,
1135 old_head
? &old_head
->object
.oid
: &null_oid
,
1137 ref_transaction_commit(transaction
, err
)) {
1140 ref_transaction_free(transaction
);
1141 strbuf_release(&sb
);
1146 static int run_rewrite_hook(const struct object_id
*oldoid
,
1147 const struct object_id
*newoid
)
1149 struct child_process proc
= CHILD_PROCESS_INIT
;
1150 const char *argv
[3];
1152 struct strbuf sb
= STRBUF_INIT
;
1154 argv
[0] = find_hook("post-rewrite");
1163 proc
.stdout_to_stderr
= 1;
1164 proc
.trace2_hook_name
= "post-rewrite";
1166 code
= start_command(&proc
);
1169 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
1170 sigchain_push(SIGPIPE
, SIG_IGN
);
1171 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
1173 strbuf_release(&sb
);
1174 sigchain_pop(SIGPIPE
);
1175 return finish_command(&proc
);
1178 void commit_post_rewrite(struct repository
*r
,
1179 const struct commit
*old_head
,
1180 const struct object_id
*new_head
)
1182 struct notes_rewrite_cfg
*cfg
;
1184 cfg
= init_copy_notes_for_rewrite("amend");
1186 /* we are amending, so old_head is not NULL */
1187 copy_note_for_rewrite(cfg
, &old_head
->object
.oid
, new_head
);
1188 finish_copy_notes_for_rewrite(r
, cfg
, "Notes added by 'git commit --amend'");
1190 run_rewrite_hook(&old_head
->object
.oid
, new_head
);
1193 static int run_prepare_commit_msg_hook(struct repository
*r
,
1197 struct argv_array hook_env
= ARGV_ARRAY_INIT
;
1201 name
= git_path_commit_editmsg();
1202 if (write_message(msg
->buf
, msg
->len
, name
, 0))
1205 argv_array_pushf(&hook_env
, "GIT_INDEX_FILE=%s", r
->index_file
);
1206 argv_array_push(&hook_env
, "GIT_EDITOR=:");
1208 ret
= run_hook_le(hook_env
.argv
, "prepare-commit-msg", name
,
1209 "commit", commit
, NULL
);
1211 ret
= run_hook_le(hook_env
.argv
, "prepare-commit-msg", name
,
1214 ret
= error(_("'prepare-commit-msg' hook failed"));
1215 argv_array_clear(&hook_env
);
1220 static const char implicit_ident_advice_noconfig
[] =
1221 N_("Your name and email address were configured automatically based\n"
1222 "on your username and hostname. Please check that they are accurate.\n"
1223 "You can suppress this message by setting them explicitly. Run the\n"
1224 "following command and follow the instructions in your editor to edit\n"
1225 "your configuration file:\n"
1227 " git config --global --edit\n"
1229 "After doing this, you may fix the identity used for this commit with:\n"
1231 " git commit --amend --reset-author\n");
1233 static const char implicit_ident_advice_config
[] =
1234 N_("Your name and email address were configured automatically based\n"
1235 "on your username and hostname. Please check that they are accurate.\n"
1236 "You can suppress this message by setting them explicitly:\n"
1238 " git config --global user.name \"Your Name\"\n"
1239 " git config --global user.email you@example.com\n"
1241 "After doing this, you may fix the identity used for this commit with:\n"
1243 " git commit --amend --reset-author\n");
1245 static const char *implicit_ident_advice(void)
1247 char *user_config
= expand_user_path("~/.gitconfig", 0);
1248 char *xdg_config
= xdg_config_home("config");
1249 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1255 return _(implicit_ident_advice_config
);
1257 return _(implicit_ident_advice_noconfig
);
1261 void print_commit_summary(struct repository
*r
,
1263 const struct object_id
*oid
,
1266 struct rev_info rev
;
1267 struct commit
*commit
;
1268 struct strbuf format
= STRBUF_INIT
;
1270 struct pretty_print_context pctx
= {0};
1271 struct strbuf author_ident
= STRBUF_INIT
;
1272 struct strbuf committer_ident
= STRBUF_INIT
;
1274 commit
= lookup_commit(r
, oid
);
1276 die(_("couldn't look up newly created commit"));
1277 if (parse_commit(commit
))
1278 die(_("could not parse newly created commit"));
1280 strbuf_addstr(&format
, "format:%h] %s");
1282 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1283 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1284 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1285 strbuf_addstr(&format
, "\n Author: ");
1286 strbuf_addbuf_percentquote(&format
, &author_ident
);
1288 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
1289 struct strbuf date
= STRBUF_INIT
;
1291 format_commit_message(commit
, "%ad", &date
, &pctx
);
1292 strbuf_addstr(&format
, "\n Date: ");
1293 strbuf_addbuf_percentquote(&format
, &date
);
1294 strbuf_release(&date
);
1296 if (!committer_ident_sufficiently_given()) {
1297 strbuf_addstr(&format
, "\n Committer: ");
1298 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1299 if (advice_implicit_identity
) {
1300 strbuf_addch(&format
, '\n');
1301 strbuf_addstr(&format
, implicit_ident_advice());
1304 strbuf_release(&author_ident
);
1305 strbuf_release(&committer_ident
);
1307 repo_init_revisions(r
, &rev
, prefix
);
1308 setup_revisions(0, NULL
, &rev
, NULL
);
1311 rev
.diffopt
.output_format
=
1312 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1314 rev
.verbose_header
= 1;
1315 rev
.show_root_diff
= 1;
1316 get_commit_format(format
.buf
, &rev
);
1317 rev
.always_show_header
= 0;
1318 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1319 rev
.diffopt
.break_opt
= 0;
1320 diff_setup_done(&rev
.diffopt
);
1322 head
= resolve_ref_unsafe("HEAD", 0, NULL
, NULL
);
1324 die_errno(_("unable to resolve HEAD after creating commit"));
1325 if (!strcmp(head
, "HEAD"))
1326 head
= _("detached HEAD");
1328 skip_prefix(head
, "refs/heads/", &head
);
1329 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1330 _(" (root-commit)") : "");
1332 if (!log_tree_commit(&rev
, commit
)) {
1333 rev
.always_show_header
= 1;
1334 rev
.use_terminator
= 1;
1335 log_tree_commit(&rev
, commit
);
1338 strbuf_release(&format
);
1341 static int parse_head(struct repository
*r
, struct commit
**head
)
1343 struct commit
*current_head
;
1344 struct object_id oid
;
1346 if (get_oid("HEAD", &oid
)) {
1347 current_head
= NULL
;
1349 current_head
= lookup_commit_reference(r
, &oid
);
1351 return error(_("could not parse HEAD"));
1352 if (!oideq(&oid
, ¤t_head
->object
.oid
)) {
1353 warning(_("HEAD %s is not a commit!"),
1356 if (parse_commit(current_head
))
1357 return error(_("could not parse HEAD commit"));
1359 *head
= current_head
;
1365 * Try to commit without forking 'git commit'. In some cases we need
1366 * to run 'git commit' to display an error message
1369 * -1 - error unable to commit
1371 * 1 - run 'git commit'
1373 static int try_to_commit(struct repository
*r
,
1374 struct strbuf
*msg
, const char *author
,
1375 struct replay_opts
*opts
, unsigned int flags
,
1376 struct object_id
*oid
)
1378 struct object_id tree
;
1379 struct commit
*current_head
;
1380 struct commit_list
*parents
= NULL
;
1381 struct commit_extra_header
*extra
= NULL
;
1382 struct strbuf err
= STRBUF_INIT
;
1383 struct strbuf commit_msg
= STRBUF_INIT
;
1384 char *amend_author
= NULL
;
1385 const char *hook_commit
= NULL
;
1386 enum commit_msg_cleanup_mode cleanup
;
1389 if (parse_head(r
, ¤t_head
))
1392 if (flags
& AMEND_MSG
) {
1393 const char *exclude_gpgsig
[] = { "gpgsig", NULL
};
1394 const char *out_enc
= get_commit_output_encoding();
1395 const char *message
= logmsg_reencode(current_head
, NULL
,
1399 const char *orig_message
= NULL
;
1401 find_commit_subject(message
, &orig_message
);
1403 strbuf_addstr(msg
, orig_message
);
1404 hook_commit
= "HEAD";
1406 author
= amend_author
= get_author(message
);
1407 unuse_commit_buffer(current_head
, message
);
1409 res
= error(_("unable to parse commit author"));
1412 parents
= copy_commit_list(current_head
->parents
);
1413 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1414 } else if (current_head
) {
1415 commit_list_insert(current_head
, &parents
);
1418 if (write_index_as_tree(&tree
, r
->index
, r
->index_file
, 0, NULL
)) {
1419 res
= error(_("git write-tree failed to write a tree"));
1423 if (!(flags
& ALLOW_EMPTY
) && oideq(current_head
?
1424 get_commit_tree_oid(current_head
) :
1425 the_hash_algo
->empty_tree
, &tree
)) {
1426 res
= 1; /* run 'git commit' to display error message */
1430 if (find_hook("prepare-commit-msg")) {
1431 res
= run_prepare_commit_msg_hook(r
, msg
, hook_commit
);
1434 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1436 res
= error_errno(_("unable to read commit message "
1438 git_path_commit_editmsg());
1444 if (flags
& CLEANUP_MSG
)
1445 cleanup
= COMMIT_MSG_CLEANUP_ALL
;
1446 else if ((opts
->signoff
|| opts
->record_origin
) &&
1447 !opts
->explicit_cleanup
)
1448 cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
1450 cleanup
= opts
->default_msg_cleanup
;
1452 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1453 strbuf_stripspace(msg
, cleanup
== COMMIT_MSG_CLEANUP_ALL
);
1454 if ((flags
& EDIT_MSG
) && message_is_empty(msg
, cleanup
)) {
1455 res
= 1; /* run 'git commit' to display error message */
1461 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
,
1462 oid
, author
, opts
->gpg_sign
, extra
)) {
1463 res
= error(_("failed to write commit object"));
1467 if (update_head_with_reflog(current_head
, oid
,
1468 getenv("GIT_REFLOG_ACTION"), msg
, &err
)) {
1469 res
= error("%s", err
.buf
);
1473 if (flags
& AMEND_MSG
)
1474 commit_post_rewrite(r
, current_head
, oid
);
1477 free_commit_extra_headers(extra
);
1478 strbuf_release(&err
);
1479 strbuf_release(&commit_msg
);
1485 static int do_commit(struct repository
*r
,
1486 const char *msg_file
, const char *author
,
1487 struct replay_opts
*opts
, unsigned int flags
)
1491 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
) &&
1492 !(flags
& CREATE_ROOT_COMMIT
)) {
1493 struct object_id oid
;
1494 struct strbuf sb
= STRBUF_INIT
;
1496 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1497 return error_errno(_("unable to read commit message "
1501 res
= try_to_commit(r
, msg_file
? &sb
: NULL
,
1502 author
, opts
, flags
, &oid
);
1503 strbuf_release(&sb
);
1505 unlink(git_path_cherry_pick_head(r
));
1506 unlink(git_path_merge_msg(r
));
1507 if (!is_rebase_i(opts
))
1508 print_commit_summary(r
, NULL
, &oid
,
1509 SUMMARY_SHOW_AUTHOR_DATE
);
1514 return run_git_commit(r
, msg_file
, opts
, flags
);
1519 static int is_original_commit_empty(struct commit
*commit
)
1521 const struct object_id
*ptree_oid
;
1523 if (parse_commit(commit
))
1524 return error(_("could not parse commit %s"),
1525 oid_to_hex(&commit
->object
.oid
));
1526 if (commit
->parents
) {
1527 struct commit
*parent
= commit
->parents
->item
;
1528 if (parse_commit(parent
))
1529 return error(_("could not parse parent commit %s"),
1530 oid_to_hex(&parent
->object
.oid
));
1531 ptree_oid
= get_commit_tree_oid(parent
);
1533 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1536 return oideq(ptree_oid
, get_commit_tree_oid(commit
));
1540 * Do we run "git commit" with "--allow-empty"?
1542 static int allow_empty(struct repository
*r
,
1543 struct replay_opts
*opts
,
1544 struct commit
*commit
)
1546 int index_unchanged
, empty_commit
;
1551 * (1) we do not allow empty at all and error out.
1553 * (2) we allow ones that were initially empty, but
1554 * forbid the ones that become empty;
1556 * (3) we allow both.
1558 if (!opts
->allow_empty
)
1559 return 0; /* let "git commit" barf as necessary */
1561 index_unchanged
= is_index_unchanged(r
);
1562 if (index_unchanged
< 0)
1563 return index_unchanged
;
1564 if (!index_unchanged
)
1565 return 0; /* we do not have to say --allow-empty */
1567 if (opts
->keep_redundant_commits
)
1570 empty_commit
= is_original_commit_empty(commit
);
1571 if (empty_commit
< 0)
1572 return empty_commit
;
1582 } todo_command_info
[] = {
1599 static const char *command_to_string(const enum todo_command command
)
1601 if (command
< TODO_COMMENT
)
1602 return todo_command_info
[command
].str
;
1603 die(_("unknown command: %d"), command
);
1606 static char command_to_char(const enum todo_command command
)
1608 if (command
< TODO_COMMENT
&& todo_command_info
[command
].c
)
1609 return todo_command_info
[command
].c
;
1610 return comment_line_char
;
1613 static int is_noop(const enum todo_command command
)
1615 return TODO_NOOP
<= command
;
1618 static int is_fixup(enum todo_command command
)
1620 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1623 /* Does this command create a (non-merge) commit? */
1624 static int is_pick_or_similar(enum todo_command command
)
1639 static int update_squash_messages(struct repository
*r
,
1640 enum todo_command command
,
1641 struct commit
*commit
,
1642 struct replay_opts
*opts
)
1644 struct strbuf buf
= STRBUF_INIT
;
1646 const char *message
, *body
;
1648 if (opts
->current_fixup_count
> 0) {
1649 struct strbuf header
= STRBUF_INIT
;
1652 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
1653 return error(_("could not read '%s'"),
1654 rebase_path_squash_msg());
1656 eol
= buf
.buf
[0] != comment_line_char
?
1657 buf
.buf
: strchrnul(buf
.buf
, '\n');
1659 strbuf_addf(&header
, "%c ", comment_line_char
);
1660 strbuf_addf(&header
, _("This is a combination of %d commits."),
1661 opts
->current_fixup_count
+ 2);
1662 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
1663 strbuf_release(&header
);
1665 struct object_id head
;
1666 struct commit
*head_commit
;
1667 const char *head_message
, *body
;
1669 if (get_oid("HEAD", &head
))
1670 return error(_("need a HEAD to fixup"));
1671 if (!(head_commit
= lookup_commit_reference(r
, &head
)))
1672 return error(_("could not read HEAD"));
1673 if (!(head_message
= get_commit_buffer(head_commit
, NULL
)))
1674 return error(_("could not read HEAD's commit message"));
1676 find_commit_subject(head_message
, &body
);
1677 if (write_message(body
, strlen(body
),
1678 rebase_path_fixup_msg(), 0)) {
1679 unuse_commit_buffer(head_commit
, head_message
);
1680 return error(_("cannot write '%s'"),
1681 rebase_path_fixup_msg());
1684 strbuf_addf(&buf
, "%c ", comment_line_char
);
1685 strbuf_addf(&buf
, _("This is a combination of %d commits."), 2);
1686 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1687 strbuf_addstr(&buf
, _("This is the 1st commit message:"));
1688 strbuf_addstr(&buf
, "\n\n");
1689 strbuf_addstr(&buf
, body
);
1691 unuse_commit_buffer(head_commit
, head_message
);
1694 if (!(message
= get_commit_buffer(commit
, NULL
)))
1695 return error(_("could not read commit message of %s"),
1696 oid_to_hex(&commit
->object
.oid
));
1697 find_commit_subject(message
, &body
);
1699 if (command
== TODO_SQUASH
) {
1700 unlink(rebase_path_fixup_msg());
1701 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1702 strbuf_addf(&buf
, _("This is the commit message #%d:"),
1703 ++opts
->current_fixup_count
+ 1);
1704 strbuf_addstr(&buf
, "\n\n");
1705 strbuf_addstr(&buf
, body
);
1706 } else if (command
== TODO_FIXUP
) {
1707 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1708 strbuf_addf(&buf
, _("The commit message #%d will be skipped:"),
1709 ++opts
->current_fixup_count
+ 1);
1710 strbuf_addstr(&buf
, "\n\n");
1711 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
1713 return error(_("unknown command: %d"), command
);
1714 unuse_commit_buffer(commit
, message
);
1716 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(), 0);
1717 strbuf_release(&buf
);
1720 strbuf_addf(&opts
->current_fixups
, "%s%s %s",
1721 opts
->current_fixups
.len
? "\n" : "",
1722 command_to_string(command
),
1723 oid_to_hex(&commit
->object
.oid
));
1724 res
= write_message(opts
->current_fixups
.buf
,
1725 opts
->current_fixups
.len
,
1726 rebase_path_current_fixups(), 0);
1732 static void flush_rewritten_pending(void)
1734 struct strbuf buf
= STRBUF_INIT
;
1735 struct object_id newoid
;
1738 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
1739 !get_oid("HEAD", &newoid
) &&
1740 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1741 char *bol
= buf
.buf
, *eol
;
1744 eol
= strchrnul(bol
, '\n');
1745 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
1746 bol
, oid_to_hex(&newoid
));
1752 unlink(rebase_path_rewritten_pending());
1754 strbuf_release(&buf
);
1757 static void record_in_rewritten(struct object_id
*oid
,
1758 enum todo_command next_command
)
1760 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
1765 fprintf(out
, "%s\n", oid_to_hex(oid
));
1768 if (!is_fixup(next_command
))
1769 flush_rewritten_pending();
1772 static int do_pick_commit(struct repository
*r
,
1773 enum todo_command command
,
1774 struct commit
*commit
,
1775 struct replay_opts
*opts
,
1776 int final_fixup
, int *check_todo
)
1778 unsigned int flags
= opts
->edit
? EDIT_MSG
: 0;
1779 const char *msg_file
= opts
->edit
? NULL
: git_path_merge_msg(r
);
1780 struct object_id head
;
1781 struct commit
*base
, *next
, *parent
;
1782 const char *base_label
, *next_label
;
1783 char *author
= NULL
;
1784 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
1785 struct strbuf msgbuf
= STRBUF_INIT
;
1786 int res
, unborn
= 0, reword
= 0, allow
;
1788 if (opts
->no_commit
) {
1790 * We do not intend to commit immediately. We just want to
1791 * merge the differences in, so let's compute the tree
1792 * that represents the "current" state for merge-recursive
1795 if (write_index_as_tree(&head
, r
->index
, r
->index_file
, 0, NULL
))
1796 return error(_("your index file is unmerged."));
1798 unborn
= get_oid("HEAD", &head
);
1799 /* Do we want to generate a root commit? */
1800 if (is_pick_or_similar(command
) && opts
->have_squash_onto
&&
1801 oideq(&head
, &opts
->squash_onto
)) {
1802 if (is_fixup(command
))
1803 return error(_("cannot fixup root commit"));
1804 flags
|= CREATE_ROOT_COMMIT
;
1807 oidcpy(&head
, the_hash_algo
->empty_tree
);
1808 if (index_differs_from(r
, unborn
? empty_tree_oid_hex() : "HEAD",
1810 return error_dirty_index(r
, opts
);
1812 discard_index(r
->index
);
1814 if (!commit
->parents
)
1816 else if (commit
->parents
->next
) {
1817 /* Reverting or cherry-picking a merge commit */
1819 struct commit_list
*p
;
1821 if (!opts
->mainline
)
1822 return error(_("commit %s is a merge but no -m option was given."),
1823 oid_to_hex(&commit
->object
.oid
));
1825 for (cnt
= 1, p
= commit
->parents
;
1826 cnt
!= opts
->mainline
&& p
;
1829 if (cnt
!= opts
->mainline
|| !p
)
1830 return error(_("commit %s does not have parent %d"),
1831 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
1833 } else if (1 < opts
->mainline
)
1835 * Non-first parent explicitly specified as mainline for
1838 return error(_("commit %s does not have parent %d"),
1839 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
1841 parent
= commit
->parents
->item
;
1843 if (get_message(commit
, &msg
) != 0)
1844 return error(_("cannot get commit message for %s"),
1845 oid_to_hex(&commit
->object
.oid
));
1847 if (opts
->allow_ff
&& !is_fixup(command
) &&
1848 ((parent
&& oideq(&parent
->object
.oid
, &head
)) ||
1849 (!parent
&& unborn
))) {
1850 if (is_rebase_i(opts
))
1851 write_author_script(msg
.message
);
1852 res
= fast_forward_to(r
, &commit
->object
.oid
, &head
, unborn
,
1854 if (res
|| command
!= TODO_REWORD
)
1858 goto fast_forward_edit
;
1860 if (parent
&& parse_commit(parent
) < 0)
1861 /* TRANSLATORS: The first %s will be a "todo" command like
1862 "revert" or "pick", the second %s a SHA1. */
1863 return error(_("%s: cannot parse parent commit %s"),
1864 command_to_string(command
),
1865 oid_to_hex(&parent
->object
.oid
));
1868 * "commit" is an existing commit. We would want to apply
1869 * the difference it introduces since its first parent "prev"
1870 * on top of the current HEAD if we are cherry-pick. Or the
1871 * reverse of it if we are revert.
1874 if (command
== TODO_REVERT
) {
1876 base_label
= msg
.label
;
1878 next_label
= msg
.parent_label
;
1879 strbuf_addstr(&msgbuf
, "Revert \"");
1880 strbuf_addstr(&msgbuf
, msg
.subject
);
1881 strbuf_addstr(&msgbuf
, "\"\n\nThis reverts commit ");
1882 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
1884 if (commit
->parents
&& commit
->parents
->next
) {
1885 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
1886 strbuf_addstr(&msgbuf
, oid_to_hex(&parent
->object
.oid
));
1888 strbuf_addstr(&msgbuf
, ".\n");
1893 base_label
= msg
.parent_label
;
1895 next_label
= msg
.label
;
1897 /* Append the commit log message to msgbuf. */
1898 if (find_commit_subject(msg
.message
, &p
))
1899 strbuf_addstr(&msgbuf
, p
);
1901 if (opts
->record_origin
) {
1902 strbuf_complete_line(&msgbuf
);
1903 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
1904 strbuf_addch(&msgbuf
, '\n');
1905 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
1906 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
1907 strbuf_addstr(&msgbuf
, ")\n");
1909 if (!is_fixup(command
))
1910 author
= get_author(msg
.message
);
1913 if (command
== TODO_REWORD
)
1915 else if (is_fixup(command
)) {
1916 if (update_squash_messages(r
, command
, commit
, opts
))
1920 msg_file
= rebase_path_squash_msg();
1921 else if (file_exists(rebase_path_fixup_msg())) {
1922 flags
|= CLEANUP_MSG
;
1923 msg_file
= rebase_path_fixup_msg();
1925 const char *dest
= git_path_squash_msg(r
);
1927 if (copy_file(dest
, rebase_path_squash_msg(), 0666))
1928 return error(_("could not rename '%s' to '%s'"),
1929 rebase_path_squash_msg(), dest
);
1930 unlink(git_path_merge_msg(r
));
1936 if (opts
->signoff
&& !is_fixup(command
))
1937 append_signoff(&msgbuf
, 0, 0);
1939 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
1941 else if (!opts
->strategy
|| !strcmp(opts
->strategy
, "recursive") || command
== TODO_REVERT
) {
1942 res
= do_recursive_merge(r
, base
, next
, base_label
, next_label
,
1943 &head
, &msgbuf
, opts
);
1947 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
1948 git_path_merge_msg(r
), 0);
1950 struct commit_list
*common
= NULL
;
1951 struct commit_list
*remotes
= NULL
;
1953 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
1954 git_path_merge_msg(r
), 0);
1956 commit_list_insert(base
, &common
);
1957 commit_list_insert(next
, &remotes
);
1958 res
|= try_merge_command(r
, opts
->strategy
,
1959 opts
->xopts_nr
, (const char **)opts
->xopts
,
1960 common
, oid_to_hex(&head
), remotes
);
1961 free_commit_list(common
);
1962 free_commit_list(remotes
);
1964 strbuf_release(&msgbuf
);
1967 * If the merge was clean or if it failed due to conflict, we write
1968 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1969 * However, if the merge did not even start, then we don't want to
1972 if (command
== TODO_PICK
&& !opts
->no_commit
&& (res
== 0 || res
== 1) &&
1973 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
1974 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1976 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
1977 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
1978 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1982 error(command
== TODO_REVERT
1983 ? _("could not revert %s... %s")
1984 : _("could not apply %s... %s"),
1985 short_commit_name(commit
), msg
.subject
);
1986 print_advice(r
, res
== 1, opts
);
1987 repo_rerere(r
, opts
->allow_rerere_auto
);
1991 allow
= allow_empty(r
, opts
, commit
);
1996 flags
|= ALLOW_EMPTY
;
1997 if (!opts
->no_commit
) {
1998 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
1999 res
= do_commit(r
, msg_file
, author
, opts
, flags
);
2001 res
= error(_("unable to parse commit author"));
2002 *check_todo
= !!(flags
& EDIT_MSG
);
2003 if (!res
&& reword
) {
2005 res
= run_git_commit(r
, NULL
, opts
, EDIT_MSG
|
2006 VERIFY_MSG
| AMEND_MSG
|
2007 (flags
& ALLOW_EMPTY
));
2013 if (!res
&& final_fixup
) {
2014 unlink(rebase_path_fixup_msg());
2015 unlink(rebase_path_squash_msg());
2016 unlink(rebase_path_current_fixups());
2017 strbuf_reset(&opts
->current_fixups
);
2018 opts
->current_fixup_count
= 0;
2022 free_message(commit
, &msg
);
2024 update_abort_safety_file();
2029 static int prepare_revs(struct replay_opts
*opts
)
2032 * picking (but not reverting) ranges (but not individual revisions)
2033 * should be done in reverse
2035 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
2036 opts
->revs
->reverse
^= 1;
2038 if (prepare_revision_walk(opts
->revs
))
2039 return error(_("revision walk setup failed"));
2044 static int read_and_refresh_cache(struct repository
*r
,
2045 struct replay_opts
*opts
)
2047 struct lock_file index_lock
= LOCK_INIT
;
2048 int index_fd
= repo_hold_locked_index(r
, &index_lock
, 0);
2049 if (repo_read_index(r
) < 0) {
2050 rollback_lock_file(&index_lock
);
2051 return error(_("git %s: failed to read the index"),
2052 _(action_name(opts
)));
2054 refresh_index(r
->index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
2055 if (index_fd
>= 0) {
2056 if (write_locked_index(r
->index
, &index_lock
,
2057 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
2058 return error(_("git %s: failed to refresh the index"),
2059 _(action_name(opts
)));
2065 enum todo_item_flags
{
2066 TODO_EDIT_MERGE_MSG
= 1
2069 void todo_list_release(struct todo_list
*todo_list
)
2071 strbuf_release(&todo_list
->buf
);
2072 FREE_AND_NULL(todo_list
->items
);
2073 todo_list
->nr
= todo_list
->alloc
= 0;
2076 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
2078 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
2079 return todo_list
->items
+ todo_list
->nr
++;
2082 const char *todo_item_get_arg(struct todo_list
*todo_list
,
2083 struct todo_item
*item
)
2085 return todo_list
->buf
.buf
+ item
->arg_offset
;
2088 static int parse_insn_line(struct repository
*r
, struct todo_item
*item
,
2089 const char *buf
, const char *bol
, char *eol
)
2091 struct object_id commit_oid
;
2092 char *end_of_object_name
;
2093 int i
, saved
, status
, padding
;
2098 bol
+= strspn(bol
, " \t");
2100 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
2101 item
->command
= TODO_COMMENT
;
2102 item
->commit
= NULL
;
2103 item
->arg_offset
= bol
- buf
;
2104 item
->arg_len
= eol
- bol
;
2108 for (i
= 0; i
< TODO_COMMENT
; i
++)
2109 if (skip_prefix(bol
, todo_command_info
[i
].str
, &bol
)) {
2112 } else if ((bol
+ 1 == eol
|| bol
[1] == ' ') &&
2113 *bol
== todo_command_info
[i
].c
) {
2118 if (i
>= TODO_COMMENT
)
2121 /* Eat up extra spaces/ tabs before object name */
2122 padding
= strspn(bol
, " \t");
2125 if (item
->command
== TODO_NOOP
|| item
->command
== TODO_BREAK
) {
2127 return error(_("%s does not accept arguments: '%s'"),
2128 command_to_string(item
->command
), bol
);
2129 item
->commit
= NULL
;
2130 item
->arg_offset
= bol
- buf
;
2131 item
->arg_len
= eol
- bol
;
2136 return error(_("missing arguments for %s"),
2137 command_to_string(item
->command
));
2139 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
2140 item
->command
== TODO_RESET
) {
2141 item
->commit
= NULL
;
2142 item
->arg_offset
= bol
- buf
;
2143 item
->arg_len
= (int)(eol
- bol
);
2147 if (item
->command
== TODO_MERGE
) {
2148 if (skip_prefix(bol
, "-C", &bol
))
2149 bol
+= strspn(bol
, " \t");
2150 else if (skip_prefix(bol
, "-c", &bol
)) {
2151 bol
+= strspn(bol
, " \t");
2152 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2154 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2155 item
->commit
= NULL
;
2156 item
->arg_offset
= bol
- buf
;
2157 item
->arg_len
= (int)(eol
- bol
);
2162 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
2163 saved
= *end_of_object_name
;
2164 *end_of_object_name
= '\0';
2165 status
= get_oid(bol
, &commit_oid
);
2166 *end_of_object_name
= saved
;
2168 bol
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2169 item
->arg_offset
= bol
- buf
;
2170 item
->arg_len
= (int)(eol
- bol
);
2173 return error(_("could not parse '%.*s'"),
2174 (int)(end_of_object_name
- bol
), bol
);
2176 item
->commit
= lookup_commit_reference(r
, &commit_oid
);
2177 return !item
->commit
;
2180 int sequencer_get_last_command(struct repository
*r
, enum replay_action
*action
)
2182 struct todo_item item
;
2184 const char *todo_file
;
2185 struct strbuf buf
= STRBUF_INIT
;
2188 todo_file
= git_path_todo_file();
2189 if (strbuf_read_file(&buf
, todo_file
, 0) < 0) {
2190 if (errno
== ENOENT
)
2193 return error_errno("unable to open '%s'", todo_file
);
2195 eol
= strchrnul(buf
.buf
, '\n');
2196 if (buf
.buf
!= eol
&& eol
[-1] == '\r')
2197 eol
--; /* strip Carriage Return */
2198 if (parse_insn_line(r
, &item
, buf
.buf
, buf
.buf
, eol
))
2200 if (item
.command
== TODO_PICK
)
2201 *action
= REPLAY_PICK
;
2202 else if (item
.command
== TODO_REVERT
)
2203 *action
= REPLAY_REVERT
;
2210 strbuf_release(&buf
);
2215 int todo_list_parse_insn_buffer(struct repository
*r
, char *buf
,
2216 struct todo_list
*todo_list
)
2218 struct todo_item
*item
;
2219 char *p
= buf
, *next_p
;
2220 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2222 todo_list
->current
= todo_list
->nr
= 0;
2224 for (i
= 1; *p
; i
++, p
= next_p
) {
2225 char *eol
= strchrnul(p
, '\n');
2227 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2229 if (p
!= eol
&& eol
[-1] == '\r')
2230 eol
--; /* strip Carriage Return */
2232 item
= append_new_todo(todo_list
);
2233 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2234 if (parse_insn_line(r
, item
, buf
, p
, eol
)) {
2235 res
= error(_("invalid line %d: %.*s"),
2236 i
, (int)(eol
- p
), p
);
2237 item
->command
= TODO_COMMENT
+ 1;
2238 item
->arg_offset
= p
- buf
;
2239 item
->arg_len
= (int)(eol
- p
);
2240 item
->commit
= NULL
;
2245 else if (is_fixup(item
->command
))
2246 return error(_("cannot '%s' without a previous commit"),
2247 command_to_string(item
->command
));
2248 else if (!is_noop(item
->command
))
2255 static int count_commands(struct todo_list
*todo_list
)
2259 for (i
= 0; i
< todo_list
->nr
; i
++)
2260 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2266 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2268 return index
< todo_list
->nr
?
2269 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2272 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2274 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2277 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2279 return get_item_line_offset(todo_list
, index
+ 1)
2280 - get_item_line_offset(todo_list
, index
);
2283 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2288 fd
= open(path
, O_RDONLY
);
2290 return error_errno(_("could not open '%s'"), path
);
2291 len
= strbuf_read(sb
, fd
, 0);
2294 return error(_("could not read '%s'."), path
);
2298 static int have_finished_the_last_pick(void)
2300 struct strbuf buf
= STRBUF_INIT
;
2302 const char *todo_path
= git_path_todo_file();
2305 if (strbuf_read_file(&buf
, todo_path
, 0) < 0) {
2306 if (errno
== ENOENT
) {
2309 error_errno("unable to open '%s'", todo_path
);
2313 /* If there is only one line then we are done */
2314 eol
= strchr(buf
.buf
, '\n');
2315 if (!eol
|| !eol
[1])
2318 strbuf_release(&buf
);
2323 void sequencer_post_commit_cleanup(struct repository
*r
)
2325 struct replay_opts opts
= REPLAY_OPTS_INIT
;
2326 int need_cleanup
= 0;
2328 if (file_exists(git_path_cherry_pick_head(r
))) {
2329 unlink(git_path_cherry_pick_head(r
));
2330 opts
.action
= REPLAY_PICK
;
2334 if (file_exists(git_path_revert_head(r
))) {
2335 unlink(git_path_revert_head(r
));
2336 opts
.action
= REPLAY_REVERT
;
2343 if (!have_finished_the_last_pick())
2346 sequencer_remove_state(&opts
);
2349 static int read_populate_todo(struct repository
*r
,
2350 struct todo_list
*todo_list
,
2351 struct replay_opts
*opts
)
2354 const char *todo_file
= get_todo_path(opts
);
2357 strbuf_reset(&todo_list
->buf
);
2358 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2361 res
= stat(todo_file
, &st
);
2363 return error(_("could not stat '%s'"), todo_file
);
2364 fill_stat_data(&todo_list
->stat
, &st
);
2366 res
= todo_list_parse_insn_buffer(r
, todo_list
->buf
.buf
, todo_list
);
2368 if (is_rebase_i(opts
))
2369 return error(_("please fix this using "
2370 "'git rebase --edit-todo'."));
2371 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2374 if (!todo_list
->nr
&&
2375 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2376 return error(_("no commits parsed."));
2378 if (!is_rebase_i(opts
)) {
2379 enum todo_command valid
=
2380 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2383 for (i
= 0; i
< todo_list
->nr
; i
++)
2384 if (valid
== todo_list
->items
[i
].command
)
2386 else if (valid
== TODO_PICK
)
2387 return error(_("cannot cherry-pick during a revert."));
2389 return error(_("cannot revert during a cherry-pick."));
2392 if (is_rebase_i(opts
)) {
2393 struct todo_list done
= TODO_LIST_INIT
;
2394 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2396 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2397 !todo_list_parse_insn_buffer(r
, done
.buf
.buf
, &done
))
2398 todo_list
->done_nr
= count_commands(&done
);
2400 todo_list
->done_nr
= 0;
2402 todo_list
->total_nr
= todo_list
->done_nr
2403 + count_commands(todo_list
);
2404 todo_list_release(&done
);
2407 fprintf(f
, "%d\n", todo_list
->total_nr
);
2415 static int git_config_string_dup(char **dest
,
2416 const char *var
, const char *value
)
2419 return config_error_nonbool(var
);
2421 *dest
= xstrdup(value
);
2425 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
2427 struct replay_opts
*opts
= data
;
2432 else if (!strcmp(key
, "options.no-commit"))
2433 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
2434 else if (!strcmp(key
, "options.edit"))
2435 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
2436 else if (!strcmp(key
, "options.allow-empty"))
2438 git_config_bool_or_int(key
, value
, &error_flag
);
2439 else if (!strcmp(key
, "options.allow-empty-message"))
2440 opts
->allow_empty_message
=
2441 git_config_bool_or_int(key
, value
, &error_flag
);
2442 else if (!strcmp(key
, "options.keep-redundant-commits"))
2443 opts
->keep_redundant_commits
=
2444 git_config_bool_or_int(key
, value
, &error_flag
);
2445 else if (!strcmp(key
, "options.signoff"))
2446 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
2447 else if (!strcmp(key
, "options.record-origin"))
2448 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
2449 else if (!strcmp(key
, "options.allow-ff"))
2450 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
2451 else if (!strcmp(key
, "options.mainline"))
2452 opts
->mainline
= git_config_int(key
, value
);
2453 else if (!strcmp(key
, "options.strategy"))
2454 git_config_string_dup(&opts
->strategy
, key
, value
);
2455 else if (!strcmp(key
, "options.gpg-sign"))
2456 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
2457 else if (!strcmp(key
, "options.strategy-option")) {
2458 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
2459 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(value
);
2460 } else if (!strcmp(key
, "options.allow-rerere-auto"))
2461 opts
->allow_rerere_auto
=
2462 git_config_bool_or_int(key
, value
, &error_flag
) ?
2463 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
2464 else if (!strcmp(key
, "options.default-msg-cleanup")) {
2465 opts
->explicit_cleanup
= 1;
2466 opts
->default_msg_cleanup
= get_cleanup_mode(value
, 1);
2468 return error(_("invalid key: %s"), key
);
2471 return error(_("invalid value for %s: %s"), key
, value
);
2476 void parse_strategy_opts(struct replay_opts
*opts
, char *raw_opts
)
2479 char *strategy_opts_string
= raw_opts
;
2481 if (*strategy_opts_string
== ' ')
2482 strategy_opts_string
++;
2484 opts
->xopts_nr
= split_cmdline(strategy_opts_string
,
2485 (const char ***)&opts
->xopts
);
2486 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
2487 const char *arg
= opts
->xopts
[i
];
2489 skip_prefix(arg
, "--", &arg
);
2490 opts
->xopts
[i
] = xstrdup(arg
);
2494 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2497 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2499 opts
->strategy
= strbuf_detach(buf
, NULL
);
2500 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2503 parse_strategy_opts(opts
, buf
->buf
);
2506 static int read_populate_opts(struct replay_opts
*opts
)
2508 if (is_rebase_i(opts
)) {
2509 struct strbuf buf
= STRBUF_INIT
;
2511 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(), 1)) {
2512 if (!starts_with(buf
.buf
, "-S"))
2515 free(opts
->gpg_sign
);
2516 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2521 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(), 1)) {
2522 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2523 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2524 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2525 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2529 if (file_exists(rebase_path_verbose()))
2532 if (file_exists(rebase_path_quiet()))
2535 if (file_exists(rebase_path_signoff())) {
2540 if (file_exists(rebase_path_reschedule_failed_exec()))
2541 opts
->reschedule_failed_exec
= 1;
2543 read_strategy_opts(opts
, &buf
);
2544 strbuf_release(&buf
);
2546 if (read_oneliner(&opts
->current_fixups
,
2547 rebase_path_current_fixups(), 1)) {
2548 const char *p
= opts
->current_fixups
.buf
;
2549 opts
->current_fixup_count
= 1;
2550 while ((p
= strchr(p
, '\n'))) {
2551 opts
->current_fixup_count
++;
2556 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
2557 if (get_oid_hex(buf
.buf
, &opts
->squash_onto
) < 0)
2558 return error(_("unusable squash-onto"));
2559 opts
->have_squash_onto
= 1;
2565 if (!file_exists(git_path_opts_file()))
2568 * The function git_parse_source(), called from git_config_from_file(),
2569 * may die() in case of a syntactically incorrect file. We do not care
2570 * about this case, though, because we wrote that file ourselves, so we
2571 * are pretty certain that it is syntactically correct.
2573 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
2574 return error(_("malformed options sheet: '%s'"),
2575 git_path_opts_file());
2579 static void write_strategy_opts(struct replay_opts
*opts
)
2582 struct strbuf buf
= STRBUF_INIT
;
2584 for (i
= 0; i
< opts
->xopts_nr
; ++i
)
2585 strbuf_addf(&buf
, " --%s", opts
->xopts
[i
]);
2587 write_file(rebase_path_strategy_opts(), "%s\n", buf
.buf
);
2588 strbuf_release(&buf
);
2591 int write_basic_state(struct replay_opts
*opts
, const char *head_name
,
2592 struct commit
*onto
, const char *orig_head
)
2594 const char *quiet
= getenv("GIT_QUIET");
2597 write_file(rebase_path_head_name(), "%s\n", head_name
);
2599 write_file(rebase_path_onto(), "%s\n",
2600 oid_to_hex(&onto
->object
.oid
));
2602 write_file(rebase_path_orig_head(), "%s\n", orig_head
);
2605 write_file(rebase_path_quiet(), "%s\n", quiet
);
2607 write_file(rebase_path_verbose(), "%s", "");
2609 write_file(rebase_path_strategy(), "%s\n", opts
->strategy
);
2610 if (opts
->xopts_nr
> 0)
2611 write_strategy_opts(opts
);
2613 if (opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
)
2614 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2615 else if (opts
->allow_rerere_auto
== RERERE_NOAUTOUPDATE
)
2616 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2619 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts
->gpg_sign
);
2621 write_file(rebase_path_signoff(), "--signoff\n");
2622 if (opts
->reschedule_failed_exec
)
2623 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
2628 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
2629 struct replay_opts
*opts
)
2631 enum todo_command command
= opts
->action
== REPLAY_PICK
?
2632 TODO_PICK
: TODO_REVERT
;
2633 const char *command_string
= todo_command_info
[command
].str
;
2634 struct commit
*commit
;
2636 if (prepare_revs(opts
))
2639 while ((commit
= get_revision(opts
->revs
))) {
2640 struct todo_item
*item
= append_new_todo(todo_list
);
2641 const char *commit_buffer
= get_commit_buffer(commit
, NULL
);
2642 const char *subject
;
2645 item
->command
= command
;
2646 item
->commit
= commit
;
2647 item
->arg_offset
= 0;
2649 item
->offset_in_buf
= todo_list
->buf
.len
;
2650 subject_len
= find_commit_subject(commit_buffer
, &subject
);
2651 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
2652 short_commit_name(commit
), subject_len
, subject
);
2653 unuse_commit_buffer(commit
, commit_buffer
);
2657 return error(_("empty commit set passed"));
2662 static int create_seq_dir(void)
2664 if (file_exists(git_path_seq_dir())) {
2665 error(_("a cherry-pick or revert is already in progress"));
2666 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
2668 } else if (mkdir(git_path_seq_dir(), 0777) < 0)
2669 return error_errno(_("could not create sequencer directory '%s'"),
2670 git_path_seq_dir());
2674 static int save_head(const char *head
)
2676 struct lock_file head_lock
= LOCK_INIT
;
2677 struct strbuf buf
= STRBUF_INIT
;
2681 fd
= hold_lock_file_for_update(&head_lock
, git_path_head_file(), 0);
2683 return error_errno(_("could not lock HEAD"));
2684 strbuf_addf(&buf
, "%s\n", head
);
2685 written
= write_in_full(fd
, buf
.buf
, buf
.len
);
2686 strbuf_release(&buf
);
2688 error_errno(_("could not write to '%s'"), git_path_head_file());
2689 rollback_lock_file(&head_lock
);
2692 if (commit_lock_file(&head_lock
) < 0)
2693 return error(_("failed to finalize '%s'"), git_path_head_file());
2697 static int rollback_is_safe(void)
2699 struct strbuf sb
= STRBUF_INIT
;
2700 struct object_id expected_head
, actual_head
;
2702 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
2704 if (get_oid_hex(sb
.buf
, &expected_head
)) {
2705 strbuf_release(&sb
);
2706 die(_("could not parse %s"), git_path_abort_safety_file());
2708 strbuf_release(&sb
);
2710 else if (errno
== ENOENT
)
2711 oidclr(&expected_head
);
2713 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2715 if (get_oid("HEAD", &actual_head
))
2716 oidclr(&actual_head
);
2718 return oideq(&actual_head
, &expected_head
);
2721 static int reset_for_rollback(const struct object_id
*oid
)
2723 const char *argv
[4]; /* reset --merge <arg> + NULL */
2726 argv
[1] = "--merge";
2727 argv
[2] = oid_to_hex(oid
);
2729 return run_command_v_opt(argv
, RUN_GIT_CMD
);
2732 static int rollback_single_pick(struct repository
*r
)
2734 struct object_id head_oid
;
2736 if (!file_exists(git_path_cherry_pick_head(r
)) &&
2737 !file_exists(git_path_revert_head(r
)))
2738 return error(_("no cherry-pick or revert in progress"));
2739 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
2740 return error(_("cannot resolve HEAD"));
2741 if (is_null_oid(&head_oid
))
2742 return error(_("cannot abort from a branch yet to be born"));
2743 return reset_for_rollback(&head_oid
);
2746 int sequencer_rollback(struct repository
*r
, struct replay_opts
*opts
)
2749 struct object_id oid
;
2750 struct strbuf buf
= STRBUF_INIT
;
2753 f
= fopen(git_path_head_file(), "r");
2754 if (!f
&& errno
== ENOENT
) {
2756 * There is no multiple-cherry-pick in progress.
2757 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2758 * a single-cherry-pick in progress, abort that.
2760 return rollback_single_pick(r
);
2763 return error_errno(_("cannot open '%s'"), git_path_head_file());
2764 if (strbuf_getline_lf(&buf
, f
)) {
2765 error(_("cannot read '%s': %s"), git_path_head_file(),
2766 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
2771 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
2772 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2773 git_path_head_file());
2776 if (is_null_oid(&oid
)) {
2777 error(_("cannot abort from a branch yet to be born"));
2781 if (!rollback_is_safe()) {
2782 /* Do not error, just do not rollback */
2783 warning(_("You seem to have moved HEAD. "
2784 "Not rewinding, check your HEAD!"));
2786 if (reset_for_rollback(&oid
))
2788 strbuf_release(&buf
);
2789 return sequencer_remove_state(opts
);
2791 strbuf_release(&buf
);
2795 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
2797 struct lock_file todo_lock
= LOCK_INIT
;
2798 const char *todo_path
= get_todo_path(opts
);
2799 int next
= todo_list
->current
, offset
, fd
;
2802 * rebase -i writes "git-rebase-todo" without the currently executing
2803 * command, appending it to "done" instead.
2805 if (is_rebase_i(opts
))
2808 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
2810 return error_errno(_("could not lock '%s'"), todo_path
);
2811 offset
= get_item_line_offset(todo_list
, next
);
2812 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
2813 todo_list
->buf
.len
- offset
) < 0)
2814 return error_errno(_("could not write to '%s'"), todo_path
);
2815 if (commit_lock_file(&todo_lock
) < 0)
2816 return error(_("failed to finalize '%s'"), todo_path
);
2818 if (is_rebase_i(opts
) && next
> 0) {
2819 const char *done
= rebase_path_done();
2820 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
2825 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
2826 get_item_line_length(todo_list
, next
- 1))
2828 ret
= error_errno(_("could not write to '%s'"), done
);
2830 ret
= error_errno(_("failed to finalize '%s'"), done
);
2836 static int save_opts(struct replay_opts
*opts
)
2838 const char *opts_file
= git_path_opts_file();
2841 if (opts
->no_commit
)
2842 res
|= git_config_set_in_file_gently(opts_file
,
2843 "options.no-commit", "true");
2845 res
|= git_config_set_in_file_gently(opts_file
,
2846 "options.edit", "true");
2847 if (opts
->allow_empty
)
2848 res
|= git_config_set_in_file_gently(opts_file
,
2849 "options.allow-empty", "true");
2850 if (opts
->allow_empty_message
)
2851 res
|= git_config_set_in_file_gently(opts_file
,
2852 "options.allow-empty-message", "true");
2853 if (opts
->keep_redundant_commits
)
2854 res
|= git_config_set_in_file_gently(opts_file
,
2855 "options.keep-redundant-commits", "true");
2857 res
|= git_config_set_in_file_gently(opts_file
,
2858 "options.signoff", "true");
2859 if (opts
->record_origin
)
2860 res
|= git_config_set_in_file_gently(opts_file
,
2861 "options.record-origin", "true");
2863 res
|= git_config_set_in_file_gently(opts_file
,
2864 "options.allow-ff", "true");
2865 if (opts
->mainline
) {
2866 struct strbuf buf
= STRBUF_INIT
;
2867 strbuf_addf(&buf
, "%d", opts
->mainline
);
2868 res
|= git_config_set_in_file_gently(opts_file
,
2869 "options.mainline", buf
.buf
);
2870 strbuf_release(&buf
);
2873 res
|= git_config_set_in_file_gently(opts_file
,
2874 "options.strategy", opts
->strategy
);
2876 res
|= git_config_set_in_file_gently(opts_file
,
2877 "options.gpg-sign", opts
->gpg_sign
);
2880 for (i
= 0; i
< opts
->xopts_nr
; i
++)
2881 res
|= git_config_set_multivar_in_file_gently(opts_file
,
2882 "options.strategy-option",
2883 opts
->xopts
[i
], "^$", 0);
2885 if (opts
->allow_rerere_auto
)
2886 res
|= git_config_set_in_file_gently(opts_file
,
2887 "options.allow-rerere-auto",
2888 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
2891 if (opts
->explicit_cleanup
)
2892 res
|= git_config_set_in_file_gently(opts_file
,
2893 "options.default-msg-cleanup",
2894 describe_cleanup_mode(opts
->default_msg_cleanup
));
2898 static int make_patch(struct repository
*r
,
2899 struct commit
*commit
,
2900 struct replay_opts
*opts
)
2902 struct strbuf buf
= STRBUF_INIT
;
2903 struct rev_info log_tree_opt
;
2904 const char *subject
, *p
;
2907 p
= short_commit_name(commit
);
2908 if (write_message(p
, strlen(p
), rebase_path_stopped_sha(), 1) < 0)
2910 if (update_ref("rebase", "REBASE_HEAD", &commit
->object
.oid
,
2911 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2912 res
|= error(_("could not update %s"), "REBASE_HEAD");
2914 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
2915 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
2916 repo_init_revisions(r
, &log_tree_opt
, NULL
);
2917 log_tree_opt
.abbrev
= 0;
2918 log_tree_opt
.diff
= 1;
2919 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
2920 log_tree_opt
.disable_stdin
= 1;
2921 log_tree_opt
.no_commit_id
= 1;
2922 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
2923 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
2924 if (!log_tree_opt
.diffopt
.file
)
2925 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
2927 res
|= log_tree_commit(&log_tree_opt
, commit
);
2928 fclose(log_tree_opt
.diffopt
.file
);
2932 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
2933 if (!file_exists(buf
.buf
)) {
2934 const char *commit_buffer
= get_commit_buffer(commit
, NULL
);
2935 find_commit_subject(commit_buffer
, &subject
);
2936 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
2937 unuse_commit_buffer(commit
, commit_buffer
);
2939 strbuf_release(&buf
);
2944 static int intend_to_amend(void)
2946 struct object_id head
;
2949 if (get_oid("HEAD", &head
))
2950 return error(_("cannot read HEAD"));
2952 p
= oid_to_hex(&head
);
2953 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
2956 static int error_with_patch(struct repository
*r
,
2957 struct commit
*commit
,
2958 const char *subject
, int subject_len
,
2959 struct replay_opts
*opts
,
2960 int exit_code
, int to_amend
)
2963 if (make_patch(r
, commit
, opts
))
2965 } else if (copy_file(rebase_path_message(),
2966 git_path_merge_msg(r
), 0666))
2967 return error(_("unable to copy '%s' to '%s'"),
2968 git_path_merge_msg(r
), rebase_path_message());
2971 if (intend_to_amend())
2975 _("You can amend the commit now, with\n"
2977 " git commit --amend %s\n"
2979 "Once you are satisfied with your changes, run\n"
2981 " git rebase --continue\n"),
2982 gpg_sign_opt_quoted(opts
));
2983 } else if (exit_code
) {
2985 fprintf_ln(stderr
, _("Could not apply %s... %.*s"),
2986 short_commit_name(commit
), subject_len
, subject
);
2989 * We don't have the hash of the parent so
2990 * just print the line from the todo file.
2992 fprintf_ln(stderr
, _("Could not merge %.*s"),
2993 subject_len
, subject
);
2999 static int error_failed_squash(struct repository
*r
,
3000 struct commit
*commit
,
3001 struct replay_opts
*opts
,
3003 const char *subject
)
3005 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3006 return error(_("could not copy '%s' to '%s'"),
3007 rebase_path_squash_msg(), rebase_path_message());
3008 unlink(git_path_merge_msg(r
));
3009 if (copy_file(git_path_merge_msg(r
), rebase_path_message(), 0666))
3010 return error(_("could not copy '%s' to '%s'"),
3011 rebase_path_message(),
3012 git_path_merge_msg(r
));
3013 return error_with_patch(r
, commit
, subject
, subject_len
, opts
, 1, 0);
3016 static int do_exec(struct repository
*r
, const char *command_line
)
3018 struct argv_array child_env
= ARGV_ARRAY_INIT
;
3019 const char *child_argv
[] = { NULL
, NULL
};
3022 fprintf(stderr
, "Executing: %s\n", command_line
);
3023 child_argv
[0] = command_line
;
3024 argv_array_pushf(&child_env
, "GIT_DIR=%s", absolute_path(get_git_dir()));
3025 argv_array_pushf(&child_env
, "GIT_WORK_TREE=%s",
3026 absolute_path(get_git_work_tree()));
3027 status
= run_command_v_opt_cd_env(child_argv
, RUN_USING_SHELL
, NULL
,
3030 /* force re-reading of the cache */
3031 if (discard_index(r
->index
) < 0 || repo_read_index(r
) < 0)
3032 return error(_("could not read index"));
3034 dirty
= require_clean_work_tree(r
, "rebase", NULL
, 1, 1);
3037 warning(_("execution failed: %s\n%s"
3038 "You can fix the problem, and then run\n"
3040 " git rebase --continue\n"
3043 dirty
? N_("and made changes to the index and/or the "
3044 "working tree\n") : "");
3046 /* command not found */
3049 warning(_("execution succeeded: %s\nbut "
3050 "left changes to the index and/or the working tree\n"
3051 "Commit or stash your changes, and then run\n"
3053 " git rebase --continue\n"
3054 "\n"), command_line
);
3058 argv_array_clear(&child_env
);
3063 static int safe_append(const char *filename
, const char *fmt
, ...)
3066 struct lock_file lock
= LOCK_INIT
;
3067 int fd
= hold_lock_file_for_update(&lock
, filename
,
3068 LOCK_REPORT_ON_ERROR
);
3069 struct strbuf buf
= STRBUF_INIT
;
3074 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
3075 error_errno(_("could not read '%s'"), filename
);
3076 rollback_lock_file(&lock
);
3079 strbuf_complete(&buf
, '\n');
3081 strbuf_vaddf(&buf
, fmt
, ap
);
3084 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
3085 error_errno(_("could not write to '%s'"), filename
);
3086 strbuf_release(&buf
);
3087 rollback_lock_file(&lock
);
3090 if (commit_lock_file(&lock
) < 0) {
3091 strbuf_release(&buf
);
3092 rollback_lock_file(&lock
);
3093 return error(_("failed to finalize '%s'"), filename
);
3096 strbuf_release(&buf
);
3100 static int do_label(struct repository
*r
, const char *name
, int len
)
3102 struct ref_store
*refs
= get_main_ref_store(r
);
3103 struct ref_transaction
*transaction
;
3104 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
3105 struct strbuf msg
= STRBUF_INIT
;
3107 struct object_id head_oid
;
3109 if (len
== 1 && *name
== '#')
3110 return error(_("illegal label name: '%.*s'"), len
, name
);
3112 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3113 strbuf_addf(&msg
, "rebase -i (label) '%.*s'", len
, name
);
3115 transaction
= ref_store_transaction_begin(refs
, &err
);
3117 error("%s", err
.buf
);
3119 } else if (get_oid("HEAD", &head_oid
)) {
3120 error(_("could not read HEAD"));
3122 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
3123 NULL
, 0, msg
.buf
, &err
) < 0 ||
3124 ref_transaction_commit(transaction
, &err
)) {
3125 error("%s", err
.buf
);
3128 ref_transaction_free(transaction
);
3129 strbuf_release(&err
);
3130 strbuf_release(&msg
);
3133 ret
= safe_append(rebase_path_refs_to_delete(),
3134 "%s\n", ref_name
.buf
);
3135 strbuf_release(&ref_name
);
3140 static const char *reflog_message(struct replay_opts
*opts
,
3141 const char *sub_action
, const char *fmt
, ...);
3143 static int do_reset(struct repository
*r
,
3144 const char *name
, int len
,
3145 struct replay_opts
*opts
)
3147 struct strbuf ref_name
= STRBUF_INIT
;
3148 struct object_id oid
;
3149 struct lock_file lock
= LOCK_INIT
;
3150 struct tree_desc desc
;
3152 struct unpack_trees_options unpack_tree_opts
;
3155 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0)
3158 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
3159 if (!opts
->have_squash_onto
) {
3161 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
3162 NULL
, &opts
->squash_onto
,
3164 return error(_("writing fake root commit"));
3165 opts
->have_squash_onto
= 1;
3166 hex
= oid_to_hex(&opts
->squash_onto
);
3167 if (write_message(hex
, strlen(hex
),
3168 rebase_path_squash_onto(), 0))
3169 return error(_("writing squash-onto"));
3171 oidcpy(&oid
, &opts
->squash_onto
);
3175 /* Determine the length of the label */
3176 for (i
= 0; i
< len
; i
++)
3177 if (isspace(name
[i
]))
3181 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3182 if (get_oid(ref_name
.buf
, &oid
) &&
3183 get_oid(ref_name
.buf
+ strlen("refs/rewritten/"), &oid
)) {
3184 error(_("could not read '%s'"), ref_name
.buf
);
3185 rollback_lock_file(&lock
);
3186 strbuf_release(&ref_name
);
3191 memset(&unpack_tree_opts
, 0, sizeof(unpack_tree_opts
));
3192 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
3193 unpack_tree_opts
.head_idx
= 1;
3194 unpack_tree_opts
.src_index
= r
->index
;
3195 unpack_tree_opts
.dst_index
= r
->index
;
3196 unpack_tree_opts
.fn
= oneway_merge
;
3197 unpack_tree_opts
.merge
= 1;
3198 unpack_tree_opts
.update
= 1;
3200 if (repo_read_index_unmerged(r
)) {
3201 rollback_lock_file(&lock
);
3202 strbuf_release(&ref_name
);
3203 return error_resolve_conflict(_(action_name(opts
)));
3206 if (!fill_tree_descriptor(&desc
, &oid
)) {
3207 error(_("failed to find tree of %s"), oid_to_hex(&oid
));
3208 rollback_lock_file(&lock
);
3209 free((void *)desc
.buffer
);
3210 strbuf_release(&ref_name
);
3214 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
3215 rollback_lock_file(&lock
);
3216 free((void *)desc
.buffer
);
3217 strbuf_release(&ref_name
);
3221 tree
= parse_tree_indirect(&oid
);
3222 prime_cache_tree(r
, r
->index
, tree
);
3224 if (write_locked_index(r
->index
, &lock
, COMMIT_LOCK
) < 0)
3225 ret
= error(_("could not write index"));
3226 free((void *)desc
.buffer
);
3229 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
3230 len
, name
), "HEAD", &oid
,
3231 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3233 strbuf_release(&ref_name
);
3237 static struct commit
*lookup_label(const char *label
, int len
,
3240 struct commit
*commit
;
3243 strbuf_addf(buf
, "refs/rewritten/%.*s", len
, label
);
3244 commit
= lookup_commit_reference_by_name(buf
->buf
);
3246 /* fall back to non-rewritten ref or commit */
3247 strbuf_splice(buf
, 0, strlen("refs/rewritten/"), "", 0);
3248 commit
= lookup_commit_reference_by_name(buf
->buf
);
3252 error(_("could not resolve '%s'"), buf
->buf
);
3257 static int do_merge(struct repository
*r
,
3258 struct commit
*commit
,
3259 const char *arg
, int arg_len
,
3260 int flags
, struct replay_opts
*opts
)
3262 int run_commit_flags
= (flags
& TODO_EDIT_MERGE_MSG
) ?
3263 EDIT_MSG
| VERIFY_MSG
: 0;
3264 struct strbuf ref_name
= STRBUF_INIT
;
3265 struct commit
*head_commit
, *merge_commit
, *i
;
3266 struct commit_list
*bases
, *j
, *reversed
= NULL
;
3267 struct commit_list
*to_merge
= NULL
, **tail
= &to_merge
;
3268 struct merge_options o
;
3269 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
, k
;
3270 static struct lock_file lock
;
3273 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0) {
3278 head_commit
= lookup_commit_reference_by_name("HEAD");
3280 ret
= error(_("cannot merge without a current revision"));
3285 * For octopus merges, the arg starts with the list of revisions to be
3286 * merged. The list is optionally followed by '#' and the oneline.
3288 merge_arg_len
= oneline_offset
= arg_len
;
3289 for (p
= arg
; p
- arg
< arg_len
; p
+= strspn(p
, " \t\n")) {
3292 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
3293 p
+= 1 + strspn(p
+ 1, " \t\n");
3294 oneline_offset
= p
- arg
;
3297 k
= strcspn(p
, " \t\n");
3300 merge_commit
= lookup_label(p
, k
, &ref_name
);
3301 if (!merge_commit
) {
3302 ret
= error(_("unable to parse '%.*s'"), k
, p
);
3305 tail
= &commit_list_insert(merge_commit
, tail
)->next
;
3307 merge_arg_len
= p
- arg
;
3311 ret
= error(_("nothing to merge: '%.*s'"), arg_len
, arg
);
3315 if (opts
->have_squash_onto
&&
3316 oideq(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
3318 * When the user tells us to "merge" something into a
3319 * "[new root]", let's simply fast-forward to the merge head.
3321 rollback_lock_file(&lock
);
3323 ret
= error(_("octopus merge cannot be executed on "
3324 "top of a [new root]"));
3326 ret
= fast_forward_to(r
, &to_merge
->item
->object
.oid
,
3327 &head_commit
->object
.oid
, 0,
3333 const char *message
= get_commit_buffer(commit
, NULL
);
3338 ret
= error(_("could not get commit message of '%s'"),
3339 oid_to_hex(&commit
->object
.oid
));
3342 write_author_script(message
);
3343 find_commit_subject(message
, &body
);
3345 ret
= write_message(body
, len
, git_path_merge_msg(r
), 0);
3346 unuse_commit_buffer(commit
, message
);
3348 error_errno(_("could not write '%s'"),
3349 git_path_merge_msg(r
));
3353 struct strbuf buf
= STRBUF_INIT
;
3356 strbuf_addf(&buf
, "author %s", git_author_info(0));
3357 write_author_script(buf
.buf
);
3360 if (oneline_offset
< arg_len
) {
3361 p
= arg
+ oneline_offset
;
3362 len
= arg_len
- oneline_offset
;
3364 strbuf_addf(&buf
, "Merge %s '%.*s'",
3365 to_merge
->next
? "branches" : "branch",
3366 merge_arg_len
, arg
);
3371 ret
= write_message(p
, len
, git_path_merge_msg(r
), 0);
3372 strbuf_release(&buf
);
3374 error_errno(_("could not write '%s'"),
3375 git_path_merge_msg(r
));
3381 * If HEAD is not identical to the first parent of the original merge
3382 * commit, we cannot fast-forward.
3384 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
3385 oideq(&commit
->parents
->item
->object
.oid
,
3386 &head_commit
->object
.oid
);
3389 * If any merge head is different from the original one, we cannot
3392 if (can_fast_forward
) {
3393 struct commit_list
*p
= commit
->parents
->next
;
3395 for (j
= to_merge
; j
&& p
; j
= j
->next
, p
= p
->next
)
3396 if (!oideq(&j
->item
->object
.oid
,
3397 &p
->item
->object
.oid
)) {
3398 can_fast_forward
= 0;
3402 * If the number of merge heads differs from the original merge
3403 * commit, we cannot fast-forward.
3406 can_fast_forward
= 0;
3409 if (can_fast_forward
) {
3410 rollback_lock_file(&lock
);
3411 ret
= fast_forward_to(r
, &commit
->object
.oid
,
3412 &head_commit
->object
.oid
, 0, opts
);
3416 if (to_merge
->next
) {
3418 struct child_process cmd
= CHILD_PROCESS_INIT
;
3420 if (read_env_script(&cmd
.env_array
)) {
3421 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
3423 ret
= error(_(staged_changes_advice
), gpg_opt
, gpg_opt
);
3428 argv_array_push(&cmd
.args
, "merge");
3429 argv_array_push(&cmd
.args
, "-s");
3430 argv_array_push(&cmd
.args
, "octopus");
3431 argv_array_push(&cmd
.args
, "--no-edit");
3432 argv_array_push(&cmd
.args
, "--no-ff");
3433 argv_array_push(&cmd
.args
, "--no-log");
3434 argv_array_push(&cmd
.args
, "--no-stat");
3435 argv_array_push(&cmd
.args
, "-F");
3436 argv_array_push(&cmd
.args
, git_path_merge_msg(r
));
3438 argv_array_push(&cmd
.args
, opts
->gpg_sign
);
3440 /* Add the tips to be merged */
3441 for (j
= to_merge
; j
; j
= j
->next
)
3442 argv_array_push(&cmd
.args
,
3443 oid_to_hex(&j
->item
->object
.oid
));
3445 strbuf_release(&ref_name
);
3446 unlink(git_path_cherry_pick_head(r
));
3447 rollback_lock_file(&lock
);
3449 rollback_lock_file(&lock
);
3450 ret
= run_command(&cmd
);
3452 /* force re-reading of the cache */
3453 if (!ret
&& (discard_index(r
->index
) < 0 ||
3454 repo_read_index(r
) < 0))
3455 ret
= error(_("could not read index"));
3459 merge_commit
= to_merge
->item
;
3460 bases
= get_merge_bases(head_commit
, merge_commit
);
3461 if (bases
&& oideq(&merge_commit
->object
.oid
,
3462 &bases
->item
->object
.oid
)) {
3464 /* skip merging an ancestor of HEAD */
3468 write_message(oid_to_hex(&merge_commit
->object
.oid
), GIT_SHA1_HEXSZ
,
3469 git_path_merge_head(r
), 0);
3470 write_message("no-ff", 5, git_path_merge_mode(r
), 0);
3472 for (j
= bases
; j
; j
= j
->next
)
3473 commit_list_insert(j
->item
, &reversed
);
3474 free_commit_list(bases
);
3477 init_merge_options(&o
, r
);
3479 o
.branch2
= ref_name
.buf
;
3480 o
.buffer_output
= 2;
3482 ret
= merge_recursive(&o
, head_commit
, merge_commit
, reversed
, &i
);
3484 fputs(o
.obuf
.buf
, stdout
);
3485 strbuf_release(&o
.obuf
);
3487 error(_("could not even attempt to merge '%.*s'"),
3488 merge_arg_len
, arg
);
3492 * The return value of merge_recursive() is 1 on clean, and 0 on
3495 * Let's reverse that, so that do_merge() returns 0 upon success and
3496 * 1 upon failed merge (keeping the return value -1 for the cases where
3497 * we will want to reschedule the `merge` command).
3501 if (r
->index
->cache_changed
&&
3502 write_locked_index(r
->index
, &lock
, COMMIT_LOCK
)) {
3503 ret
= error(_("merge: Unable to write new index file"));
3507 rollback_lock_file(&lock
);
3509 repo_rerere(r
, opts
->allow_rerere_auto
);
3512 * In case of problems, we now want to return a positive
3513 * value (a negative one would indicate that the `merge`
3514 * command needs to be rescheduled).
3516 ret
= !!run_git_commit(r
, git_path_merge_msg(r
), opts
,
3520 strbuf_release(&ref_name
);
3521 rollback_lock_file(&lock
);
3522 free_commit_list(to_merge
);
3526 static int is_final_fixup(struct todo_list
*todo_list
)
3528 int i
= todo_list
->current
;
3530 if (!is_fixup(todo_list
->items
[i
].command
))
3533 while (++i
< todo_list
->nr
)
3534 if (is_fixup(todo_list
->items
[i
].command
))
3536 else if (!is_noop(todo_list
->items
[i
].command
))
3541 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
3545 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
3546 if (!is_noop(todo_list
->items
[i
].command
))
3547 return todo_list
->items
[i
].command
;
3552 static int apply_autostash(struct replay_opts
*opts
)
3554 struct strbuf stash_sha1
= STRBUF_INIT
;
3555 struct child_process child
= CHILD_PROCESS_INIT
;
3558 if (!read_oneliner(&stash_sha1
, rebase_path_autostash(), 1)) {
3559 strbuf_release(&stash_sha1
);
3562 strbuf_trim(&stash_sha1
);
3565 child
.no_stdout
= 1;
3566 child
.no_stderr
= 1;
3567 argv_array_push(&child
.args
, "stash");
3568 argv_array_push(&child
.args
, "apply");
3569 argv_array_push(&child
.args
, stash_sha1
.buf
);
3570 if (!run_command(&child
))
3571 fprintf(stderr
, _("Applied autostash.\n"));
3573 struct child_process store
= CHILD_PROCESS_INIT
;
3576 argv_array_push(&store
.args
, "stash");
3577 argv_array_push(&store
.args
, "store");
3578 argv_array_push(&store
.args
, "-m");
3579 argv_array_push(&store
.args
, "autostash");
3580 argv_array_push(&store
.args
, "-q");
3581 argv_array_push(&store
.args
, stash_sha1
.buf
);
3582 if (run_command(&store
))
3583 ret
= error(_("cannot store %s"), stash_sha1
.buf
);
3586 _("Applying autostash resulted in conflicts.\n"
3587 "Your changes are safe in the stash.\n"
3588 "You can run \"git stash pop\" or"
3589 " \"git stash drop\" at any time.\n"));
3592 strbuf_release(&stash_sha1
);
3596 static const char *reflog_message(struct replay_opts
*opts
,
3597 const char *sub_action
, const char *fmt
, ...)
3600 static struct strbuf buf
= STRBUF_INIT
;
3604 strbuf_addstr(&buf
, action_name(opts
));
3606 strbuf_addf(&buf
, " (%s)", sub_action
);
3608 strbuf_addstr(&buf
, ": ");
3609 strbuf_vaddf(&buf
, fmt
, ap
);
3616 static int run_git_checkout(struct repository
*r
, struct replay_opts
*opts
,
3617 const char *commit
, const char *action
)
3619 struct child_process cmd
= CHILD_PROCESS_INIT
;
3624 argv_array_push(&cmd
.args
, "checkout");
3625 argv_array_push(&cmd
.args
, commit
);
3626 argv_array_pushf(&cmd
.env_array
, GIT_REFLOG_ACTION
"=%s", action
);
3629 ret
= run_command(&cmd
);
3631 ret
= run_command_silent_on_success(&cmd
);
3634 discard_index(r
->index
);
3639 int prepare_branch_to_be_rebased(struct repository
*r
, struct replay_opts
*opts
,
3644 if (commit
&& *commit
) {
3645 action
= reflog_message(opts
, "start", "checkout %s", commit
);
3646 if (run_git_checkout(r
, opts
, commit
, action
))
3647 return error(_("could not checkout %s"), commit
);
3653 static int checkout_onto(struct repository
*r
, struct replay_opts
*opts
,
3654 const char *onto_name
, const struct object_id
*onto
,
3655 const char *orig_head
)
3657 struct object_id oid
;
3658 const char *action
= reflog_message(opts
, "start", "checkout %s", onto_name
);
3660 if (get_oid(orig_head
, &oid
))
3661 return error(_("%s: not a valid OID"), orig_head
);
3663 if (run_git_checkout(r
, opts
, oid_to_hex(onto
), action
)) {
3664 apply_autostash(opts
);
3665 sequencer_remove_state(opts
);
3666 return error(_("could not detach HEAD"));
3669 return update_ref(NULL
, "ORIG_HEAD", &oid
, NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3672 static int stopped_at_head(struct repository
*r
)
3674 struct object_id head
;
3675 struct commit
*commit
;
3676 struct commit_message message
;
3678 if (get_oid("HEAD", &head
) ||
3679 !(commit
= lookup_commit(r
, &head
)) ||
3680 parse_commit(commit
) || get_message(commit
, &message
))
3681 fprintf(stderr
, _("Stopped at HEAD\n"));
3683 fprintf(stderr
, _("Stopped at %s\n"), message
.label
);
3684 free_message(commit
, &message
);
3690 static const char rescheduled_advice
[] =
3691 N_("Could not execute the todo command\n"
3695 "It has been rescheduled; To edit the command before continuing, please\n"
3696 "edit the todo list first:\n"
3698 " git rebase --edit-todo\n"
3699 " git rebase --continue\n");
3701 static int pick_commits(struct repository
*r
,
3702 struct todo_list
*todo_list
,
3703 struct replay_opts
*opts
)
3705 int res
= 0, reschedule
= 0;
3707 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
3709 assert(!(opts
->signoff
|| opts
->no_commit
||
3710 opts
->record_origin
|| opts
->edit
));
3711 if (read_and_refresh_cache(r
, opts
))
3714 while (todo_list
->current
< todo_list
->nr
) {
3715 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
3716 const char *arg
= todo_item_get_arg(todo_list
, item
);
3719 if (save_todo(todo_list
, opts
))
3721 if (is_rebase_i(opts
)) {
3722 if (item
->command
!= TODO_COMMENT
) {
3723 FILE *f
= fopen(rebase_path_msgnum(), "w");
3725 todo_list
->done_nr
++;
3728 fprintf(f
, "%d\n", todo_list
->done_nr
);
3732 fprintf(stderr
, "Rebasing (%d/%d)%s",
3734 todo_list
->total_nr
,
3735 opts
->verbose
? "\n" : "\r");
3737 unlink(rebase_path_message());
3738 unlink(rebase_path_author_script());
3739 unlink(rebase_path_stopped_sha());
3740 unlink(rebase_path_amend());
3741 unlink(git_path_merge_head(the_repository
));
3742 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
3744 if (item
->command
== TODO_BREAK
) {
3747 return stopped_at_head(r
);
3750 if (item
->command
<= TODO_SQUASH
) {
3751 if (is_rebase_i(opts
))
3752 setenv("GIT_REFLOG_ACTION", reflog_message(opts
,
3753 command_to_string(item
->command
), NULL
),
3755 res
= do_pick_commit(r
, item
->command
, item
->commit
,
3756 opts
, is_final_fixup(todo_list
),
3758 if (is_rebase_i(opts
) && res
< 0) {
3760 advise(_(rescheduled_advice
),
3761 get_item_line_length(todo_list
,
3762 todo_list
->current
),
3763 get_item_line(todo_list
,
3764 todo_list
->current
));
3765 todo_list
->current
--;
3766 if (save_todo(todo_list
, opts
))
3769 if (item
->command
== TODO_EDIT
) {
3770 struct commit
*commit
= item
->commit
;
3775 _("Stopped at %s... %.*s\n"),
3776 short_commit_name(commit
),
3777 item
->arg_len
, arg
);
3779 return error_with_patch(r
, commit
,
3780 arg
, item
->arg_len
, opts
, res
, !res
);
3782 if (is_rebase_i(opts
) && !res
)
3783 record_in_rewritten(&item
->commit
->object
.oid
,
3784 peek_command(todo_list
, 1));
3785 if (res
&& is_fixup(item
->command
)) {
3788 return error_failed_squash(r
, item
->commit
, opts
,
3789 item
->arg_len
, arg
);
3790 } else if (res
&& is_rebase_i(opts
) && item
->commit
) {
3792 struct object_id oid
;
3795 * If we are rewording and have either
3796 * fast-forwarded already, or are about to
3797 * create a new root commit, we want to amend,
3798 * otherwise we do not.
3800 if (item
->command
== TODO_REWORD
&&
3801 !get_oid("HEAD", &oid
) &&
3802 (oideq(&item
->commit
->object
.oid
, &oid
) ||
3803 (opts
->have_squash_onto
&&
3804 oideq(&opts
->squash_onto
, &oid
))))
3807 return res
| error_with_patch(r
, item
->commit
,
3808 arg
, item
->arg_len
, opts
,
3811 } else if (item
->command
== TODO_EXEC
) {
3812 char *end_of_arg
= (char *)(arg
+ item
->arg_len
);
3813 int saved
= *end_of_arg
;
3818 res
= do_exec(r
, arg
);
3819 *end_of_arg
= saved
;
3822 if (opts
->reschedule_failed_exec
)
3826 } else if (item
->command
== TODO_LABEL
) {
3827 if ((res
= do_label(r
, arg
, item
->arg_len
)))
3829 } else if (item
->command
== TODO_RESET
) {
3830 if ((res
= do_reset(r
, arg
, item
->arg_len
, opts
)))
3832 } else if (item
->command
== TODO_MERGE
) {
3833 if ((res
= do_merge(r
, item
->commit
,
3835 item
->flags
, opts
)) < 0)
3837 else if (item
->commit
)
3838 record_in_rewritten(&item
->commit
->object
.oid
,
3839 peek_command(todo_list
, 1));
3841 /* failed with merge conflicts */
3842 return error_with_patch(r
, item
->commit
,
3845 } else if (!is_noop(item
->command
))
3846 return error(_("unknown command %d"), item
->command
);
3849 advise(_(rescheduled_advice
),
3850 get_item_line_length(todo_list
,
3851 todo_list
->current
),
3852 get_item_line(todo_list
, todo_list
->current
));
3853 todo_list
->current
--;
3854 if (save_todo(todo_list
, opts
))
3857 return error_with_patch(r
,
3861 } else if (check_todo
&& !res
) {
3864 if (stat(get_todo_path(opts
), &st
)) {
3865 res
= error_errno(_("could not stat '%s'"),
3866 get_todo_path(opts
));
3867 } else if (match_stat_data(&todo_list
->stat
, &st
)) {
3868 /* Reread the todo file if it has changed. */
3869 todo_list_release(todo_list
);
3870 if (read_populate_todo(r
, todo_list
, opts
))
3871 res
= -1; /* message was printed */
3872 /* `current` will be incremented below */
3873 todo_list
->current
= -1;
3877 todo_list
->current
++;
3882 if (is_rebase_i(opts
)) {
3883 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
3886 /* Stopped in the middle, as planned? */
3887 if (todo_list
->current
< todo_list
->nr
)
3890 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
3891 starts_with(head_ref
.buf
, "refs/")) {
3893 struct object_id head
, orig
;
3896 if (get_oid("HEAD", &head
)) {
3897 res
= error(_("cannot read HEAD"));
3899 strbuf_release(&head_ref
);
3900 strbuf_release(&buf
);
3903 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
3904 get_oid_hex(buf
.buf
, &orig
)) {
3905 res
= error(_("could not read orig-head"));
3906 goto cleanup_head_ref
;
3909 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
3910 res
= error(_("could not read 'onto'"));
3911 goto cleanup_head_ref
;
3913 msg
= reflog_message(opts
, "finish", "%s onto %s",
3914 head_ref
.buf
, buf
.buf
);
3915 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
3916 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
3917 res
= error(_("could not update %s"),
3919 goto cleanup_head_ref
;
3921 msg
= reflog_message(opts
, "finish", "returning to %s",
3923 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
3924 res
= error(_("could not update HEAD to %s"),
3926 goto cleanup_head_ref
;
3931 if (opts
->verbose
) {
3932 struct rev_info log_tree_opt
;
3933 struct object_id orig
, head
;
3935 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3936 repo_init_revisions(r
, &log_tree_opt
, NULL
);
3937 log_tree_opt
.diff
= 1;
3938 log_tree_opt
.diffopt
.output_format
=
3939 DIFF_FORMAT_DIFFSTAT
;
3940 log_tree_opt
.disable_stdin
= 1;
3942 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
3943 !get_oid(buf
.buf
, &orig
) &&
3944 !get_oid("HEAD", &head
)) {
3945 diff_tree_oid(&orig
, &head
, "",
3946 &log_tree_opt
.diffopt
);
3947 log_tree_diff_flush(&log_tree_opt
);
3950 flush_rewritten_pending();
3951 if (!stat(rebase_path_rewritten_list(), &st
) &&
3953 struct child_process child
= CHILD_PROCESS_INIT
;
3954 const char *post_rewrite_hook
=
3955 find_hook("post-rewrite");
3957 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
3959 argv_array_push(&child
.args
, "notes");
3960 argv_array_push(&child
.args
, "copy");
3961 argv_array_push(&child
.args
, "--for-rewrite=rebase");
3962 /* we don't care if this copying failed */
3963 run_command(&child
);
3965 if (post_rewrite_hook
) {
3966 struct child_process hook
= CHILD_PROCESS_INIT
;
3968 hook
.in
= open(rebase_path_rewritten_list(),
3970 hook
.stdout_to_stderr
= 1;
3971 hook
.trace2_hook_name
= "post-rewrite";
3972 argv_array_push(&hook
.args
, post_rewrite_hook
);
3973 argv_array_push(&hook
.args
, "rebase");
3974 /* we don't care if this hook failed */
3978 apply_autostash(opts
);
3984 "Successfully rebased and updated %s.\n",
3988 strbuf_release(&buf
);
3989 strbuf_release(&head_ref
);
3993 * Sequence of picks finished successfully; cleanup by
3994 * removing the .git/sequencer directory
3996 return sequencer_remove_state(opts
);
3999 static int continue_single_pick(struct repository
*r
)
4001 const char *argv
[] = { "commit", NULL
};
4003 if (!file_exists(git_path_cherry_pick_head(r
)) &&
4004 !file_exists(git_path_revert_head(r
)))
4005 return error(_("no cherry-pick or revert in progress"));
4006 return run_command_v_opt(argv
, RUN_GIT_CMD
);
4009 static int commit_staged_changes(struct repository
*r
,
4010 struct replay_opts
*opts
,
4011 struct todo_list
*todo_list
)
4013 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
4014 unsigned int final_fixup
= 0, is_clean
;
4016 if (has_unstaged_changes(r
, 1))
4017 return error(_("cannot rebase: You have unstaged changes."));
4019 is_clean
= !has_uncommitted_changes(r
, 0);
4021 if (file_exists(rebase_path_amend())) {
4022 struct strbuf rev
= STRBUF_INIT
;
4023 struct object_id head
, to_amend
;
4025 if (get_oid("HEAD", &head
))
4026 return error(_("cannot amend non-existing commit"));
4027 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
4028 return error(_("invalid file: '%s'"), rebase_path_amend());
4029 if (get_oid_hex(rev
.buf
, &to_amend
))
4030 return error(_("invalid contents: '%s'"),
4031 rebase_path_amend());
4032 if (!is_clean
&& !oideq(&head
, &to_amend
))
4033 return error(_("\nYou have uncommitted changes in your "
4034 "working tree. Please, commit them\n"
4035 "first and then run 'git rebase "
4036 "--continue' again."));
4038 * When skipping a failed fixup/squash, we need to edit the
4039 * commit message, the current fixup list and count, and if it
4040 * was the last fixup/squash in the chain, we need to clean up
4041 * the commit message and if there was a squash, let the user
4044 if (!is_clean
|| !opts
->current_fixup_count
)
4045 ; /* this is not the final fixup */
4046 else if (!oideq(&head
, &to_amend
) ||
4047 !file_exists(rebase_path_stopped_sha())) {
4048 /* was a final fixup or squash done manually? */
4049 if (!is_fixup(peek_command(todo_list
, 0))) {
4050 unlink(rebase_path_fixup_msg());
4051 unlink(rebase_path_squash_msg());
4052 unlink(rebase_path_current_fixups());
4053 strbuf_reset(&opts
->current_fixups
);
4054 opts
->current_fixup_count
= 0;
4057 /* we are in a fixup/squash chain */
4058 const char *p
= opts
->current_fixups
.buf
;
4059 int len
= opts
->current_fixups
.len
;
4061 opts
->current_fixup_count
--;
4063 BUG("Incorrect current_fixups:\n%s", p
);
4064 while (len
&& p
[len
- 1] != '\n')
4066 strbuf_setlen(&opts
->current_fixups
, len
);
4067 if (write_message(p
, len
, rebase_path_current_fixups(),
4069 return error(_("could not write file: '%s'"),
4070 rebase_path_current_fixups());
4073 * If a fixup/squash in a fixup/squash chain failed, the
4074 * commit message is already correct, no need to commit
4077 * Only if it is the final command in the fixup/squash
4078 * chain, and only if the chain is longer than a single
4079 * fixup/squash command (which was just skipped), do we
4080 * actually need to re-commit with a cleaned up commit
4083 if (opts
->current_fixup_count
> 0 &&
4084 !is_fixup(peek_command(todo_list
, 0))) {
4087 * If there was not a single "squash" in the
4088 * chain, we only need to clean up the commit
4089 * message, no need to bother the user with
4090 * opening the commit message in the editor.
4092 if (!starts_with(p
, "squash ") &&
4093 !strstr(p
, "\nsquash "))
4094 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
4095 } else if (is_fixup(peek_command(todo_list
, 0))) {
4097 * We need to update the squash message to skip
4098 * the latest commit message.
4100 struct commit
*commit
;
4101 const char *path
= rebase_path_squash_msg();
4103 if (parse_head(r
, &commit
) ||
4104 !(p
= get_commit_buffer(commit
, NULL
)) ||
4105 write_message(p
, strlen(p
), path
, 0)) {
4106 unuse_commit_buffer(commit
, p
);
4107 return error(_("could not write file: "
4110 unuse_commit_buffer(commit
, p
);
4114 strbuf_release(&rev
);
4119 const char *cherry_pick_head
= git_path_cherry_pick_head(r
);
4121 if (file_exists(cherry_pick_head
) && unlink(cherry_pick_head
))
4122 return error(_("could not remove CHERRY_PICK_HEAD"));
4127 if (run_git_commit(r
, final_fixup
? NULL
: rebase_path_message(),
4129 return error(_("could not commit staged changes."));
4130 unlink(rebase_path_amend());
4131 unlink(git_path_merge_head(the_repository
));
4133 unlink(rebase_path_fixup_msg());
4134 unlink(rebase_path_squash_msg());
4136 if (opts
->current_fixup_count
> 0) {
4138 * Whether final fixup or not, we just cleaned up the commit
4141 unlink(rebase_path_current_fixups());
4142 strbuf_reset(&opts
->current_fixups
);
4143 opts
->current_fixup_count
= 0;
4148 int sequencer_continue(struct repository
*r
, struct replay_opts
*opts
)
4150 struct todo_list todo_list
= TODO_LIST_INIT
;
4153 if (read_and_refresh_cache(r
, opts
))
4156 if (read_populate_opts(opts
))
4158 if (is_rebase_i(opts
)) {
4159 if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
4160 goto release_todo_list
;
4161 if (commit_staged_changes(r
, opts
, &todo_list
))
4163 } else if (!file_exists(get_todo_path(opts
)))
4164 return continue_single_pick(r
);
4165 else if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
4166 goto release_todo_list
;
4168 if (!is_rebase_i(opts
)) {
4169 /* Verify that the conflict has been resolved */
4170 if (file_exists(git_path_cherry_pick_head(r
)) ||
4171 file_exists(git_path_revert_head(r
))) {
4172 res
= continue_single_pick(r
);
4174 goto release_todo_list
;
4176 if (index_differs_from(r
, "HEAD", NULL
, 0)) {
4177 res
= error_dirty_index(r
, opts
);
4178 goto release_todo_list
;
4180 todo_list
.current
++;
4181 } else if (file_exists(rebase_path_stopped_sha())) {
4182 struct strbuf buf
= STRBUF_INIT
;
4183 struct object_id oid
;
4185 if (read_oneliner(&buf
, rebase_path_stopped_sha(), 1) &&
4186 !get_oid_committish(buf
.buf
, &oid
))
4187 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
4188 strbuf_release(&buf
);
4191 res
= pick_commits(r
, &todo_list
, opts
);
4193 todo_list_release(&todo_list
);
4197 static int single_pick(struct repository
*r
,
4198 struct commit
*cmit
,
4199 struct replay_opts
*opts
)
4203 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
4204 return do_pick_commit(r
, opts
->action
== REPLAY_PICK
?
4205 TODO_PICK
: TODO_REVERT
, cmit
, opts
, 0,
4209 int sequencer_pick_revisions(struct repository
*r
,
4210 struct replay_opts
*opts
)
4212 struct todo_list todo_list
= TODO_LIST_INIT
;
4213 struct object_id oid
;
4217 if (read_and_refresh_cache(r
, opts
))
4220 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
4221 struct object_id oid
;
4222 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
4224 /* This happens when using --stdin. */
4228 if (!get_oid(name
, &oid
)) {
4229 if (!lookup_commit_reference_gently(r
, &oid
, 1)) {
4230 enum object_type type
= oid_object_info(r
,
4233 return error(_("%s: can't cherry-pick a %s"),
4234 name
, type_name(type
));
4237 return error(_("%s: bad revision"), name
);
4241 * If we were called as "git cherry-pick <commit>", just
4242 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4243 * REVERT_HEAD, and don't touch the sequencer state.
4244 * This means it is possible to cherry-pick in the middle
4245 * of a cherry-pick sequence.
4247 if (opts
->revs
->cmdline
.nr
== 1 &&
4248 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
4249 opts
->revs
->no_walk
&&
4250 !opts
->revs
->cmdline
.rev
->flags
) {
4251 struct commit
*cmit
;
4252 if (prepare_revision_walk(opts
->revs
))
4253 return error(_("revision walk setup failed"));
4254 cmit
= get_revision(opts
->revs
);
4256 return error(_("empty commit set passed"));
4257 if (get_revision(opts
->revs
))
4258 BUG("unexpected extra commit from walk");
4259 return single_pick(r
, cmit
, opts
);
4263 * Start a new cherry-pick/ revert sequence; but
4264 * first, make sure that an existing one isn't in
4268 if (walk_revs_populate_todo(&todo_list
, opts
) ||
4269 create_seq_dir() < 0)
4271 if (get_oid("HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
4272 return error(_("can't revert as initial commit"));
4273 if (save_head(oid_to_hex(&oid
)))
4275 if (save_opts(opts
))
4277 update_abort_safety_file();
4278 res
= pick_commits(r
, &todo_list
, opts
);
4279 todo_list_release(&todo_list
);
4283 void append_signoff(struct strbuf
*msgbuf
, size_t ignore_footer
, unsigned flag
)
4285 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
4286 struct strbuf sob
= STRBUF_INIT
;
4289 strbuf_addstr(&sob
, sign_off_header
);
4290 strbuf_addstr(&sob
, fmt_name(WANT_COMMITTER_IDENT
));
4291 strbuf_addch(&sob
, '\n');
4294 strbuf_complete_line(msgbuf
);
4297 * If the whole message buffer is equal to the sob, pretend that we
4298 * found a conforming footer with a matching sob
4300 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
4301 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
4304 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
4307 const char *append_newlines
= NULL
;
4308 size_t len
= msgbuf
->len
- ignore_footer
;
4312 * The buffer is completely empty. Leave foom for
4313 * the title and body to be filled in by the user.
4315 append_newlines
= "\n\n";
4316 } else if (len
== 1) {
4318 * Buffer contains a single newline. Add another
4319 * so that we leave room for the title and body.
4321 append_newlines
= "\n";
4322 } else if (msgbuf
->buf
[len
- 2] != '\n') {
4324 * Buffer ends with a single newline. Add another
4325 * so that there is an empty line between the message
4328 append_newlines
= "\n";
4329 } /* else, the buffer already ends with two newlines. */
4331 if (append_newlines
)
4332 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
4333 append_newlines
, strlen(append_newlines
));
4336 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
4337 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
4340 strbuf_release(&sob
);
4343 struct labels_entry
{
4344 struct hashmap_entry entry
;
4345 char label
[FLEX_ARRAY
];
4348 static int labels_cmp(const void *fndata
, const struct labels_entry
*a
,
4349 const struct labels_entry
*b
, const void *key
)
4351 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
4354 struct string_entry
{
4355 struct oidmap_entry entry
;
4356 char string
[FLEX_ARRAY
];
4359 struct label_state
{
4360 struct oidmap commit2label
;
4361 struct hashmap labels
;
4365 static const char *label_oid(struct object_id
*oid
, const char *label
,
4366 struct label_state
*state
)
4368 struct labels_entry
*labels_entry
;
4369 struct string_entry
*string_entry
;
4370 struct object_id dummy
;
4374 string_entry
= oidmap_get(&state
->commit2label
, oid
);
4376 return string_entry
->string
;
4379 * For "uninteresting" commits, i.e. commits that are not to be
4380 * rebased, and which can therefore not be labeled, we use a unique
4381 * abbreviation of the commit name. This is slightly more complicated
4382 * than calling find_unique_abbrev() because we also need to make
4383 * sure that the abbreviation does not conflict with any other
4386 * We disallow "interesting" commits to be labeled by a string that
4387 * is a valid full-length hash, to ensure that we always can find an
4388 * abbreviation for any uninteresting commit's names that does not
4389 * clash with any other label.
4394 strbuf_reset(&state
->buf
);
4395 strbuf_grow(&state
->buf
, GIT_SHA1_HEXSZ
);
4396 label
= p
= state
->buf
.buf
;
4398 find_unique_abbrev_r(p
, oid
, default_abbrev
);
4401 * We may need to extend the abbreviated hash so that there is
4402 * no conflicting label.
4404 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
4405 size_t i
= strlen(p
) + 1;
4407 oid_to_hex_r(p
, oid
);
4408 for (; i
< GIT_SHA1_HEXSZ
; i
++) {
4411 if (!hashmap_get_from_hash(&state
->labels
,
4417 } else if (((len
= strlen(label
)) == the_hash_algo
->hexsz
&&
4418 !get_oid_hex(label
, &dummy
)) ||
4419 (len
== 1 && *label
== '#') ||
4420 hashmap_get_from_hash(&state
->labels
,
4421 strihash(label
), label
)) {
4423 * If the label already exists, or if the label is a valid full
4424 * OID, or the label is a '#' (which we use as a separator
4425 * between merge heads and oneline), we append a dash and a
4426 * number to make it unique.
4428 struct strbuf
*buf
= &state
->buf
;
4431 strbuf_add(buf
, label
, len
);
4433 for (i
= 2; ; i
++) {
4434 strbuf_setlen(buf
, len
);
4435 strbuf_addf(buf
, "-%d", i
);
4436 if (!hashmap_get_from_hash(&state
->labels
,
4445 FLEX_ALLOC_STR(labels_entry
, label
, label
);
4446 hashmap_entry_init(labels_entry
, strihash(label
));
4447 hashmap_add(&state
->labels
, labels_entry
);
4449 FLEX_ALLOC_STR(string_entry
, string
, label
);
4450 oidcpy(&string_entry
->entry
.oid
, oid
);
4451 oidmap_put(&state
->commit2label
, string_entry
);
4453 return string_entry
->string
;
4456 static int make_script_with_merges(struct pretty_print_context
*pp
,
4457 struct rev_info
*revs
, struct strbuf
*out
,
4460 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
4461 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
4462 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
4463 struct strbuf label
= STRBUF_INIT
;
4464 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
4465 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
4466 struct commit
*commit
;
4467 struct oidmap commit2todo
= OIDMAP_INIT
;
4468 struct string_entry
*entry
;
4469 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
4470 shown
= OIDSET_INIT
;
4471 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
4473 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
4474 const char *cmd_pick
= abbr
? "p" : "pick",
4475 *cmd_label
= abbr
? "l" : "label",
4476 *cmd_reset
= abbr
? "t" : "reset",
4477 *cmd_merge
= abbr
? "m" : "merge";
4479 oidmap_init(&commit2todo
, 0);
4480 oidmap_init(&state
.commit2label
, 0);
4481 hashmap_init(&state
.labels
, (hashmap_cmp_fn
) labels_cmp
, NULL
, 0);
4482 strbuf_init(&state
.buf
, 32);
4484 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
4485 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
4486 FLEX_ALLOC_STR(entry
, string
, "onto");
4487 oidcpy(&entry
->entry
.oid
, oid
);
4488 oidmap_put(&state
.commit2label
, entry
);
4493 * - get onelines for all commits
4494 * - gather all branch tips (i.e. 2nd or later parents of merges)
4495 * - label all branch tips
4497 while ((commit
= get_revision(revs
))) {
4498 struct commit_list
*to_merge
;
4499 const char *p1
, *p2
;
4500 struct object_id
*oid
;
4503 tail
= &commit_list_insert(commit
, tail
)->next
;
4504 oidset_insert(&interesting
, &commit
->object
.oid
);
4506 is_empty
= is_original_commit_empty(commit
);
4507 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
))
4510 strbuf_reset(&oneline
);
4511 pretty_print_commit(pp
, commit
, &oneline
);
4513 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
4515 /* non-merge commit: easy case */
4517 if (!keep_empty
&& is_empty
)
4518 strbuf_addf(&buf
, "%c ", comment_line_char
);
4519 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
4520 oid_to_hex(&commit
->object
.oid
),
4523 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
4524 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
4525 oidmap_put(&commit2todo
, entry
);
4530 /* Create a label */
4531 strbuf_reset(&label
);
4532 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
4533 (p1
= strchr(p1
, '\'')) &&
4534 (p2
= strchr(++p1
, '\'')))
4535 strbuf_add(&label
, p1
, p2
- p1
);
4536 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
4538 (p1
= strstr(p1
, " from ")))
4539 strbuf_addstr(&label
, p1
+ strlen(" from "));
4541 strbuf_addbuf(&label
, &oneline
);
4543 for (p1
= label
.buf
; *p1
; p1
++)
4548 strbuf_addf(&buf
, "%s -C %s",
4549 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
4551 /* label the tips of merged branches */
4552 for (; to_merge
; to_merge
= to_merge
->next
) {
4553 oid
= &to_merge
->item
->object
.oid
;
4554 strbuf_addch(&buf
, ' ');
4556 if (!oidset_contains(&interesting
, oid
)) {
4557 strbuf_addstr(&buf
, label_oid(oid
, NULL
,
4562 tips_tail
= &commit_list_insert(to_merge
->item
,
4565 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
4567 strbuf_addf(&buf
, " # %s", oneline
.buf
);
4569 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
4570 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
4571 oidmap_put(&commit2todo
, entry
);
4576 * - label branch points
4577 * - add HEAD to the branch tips
4579 for (iter
= commits
; iter
; iter
= iter
->next
) {
4580 struct commit_list
*parent
= iter
->item
->parents
;
4581 for (; parent
; parent
= parent
->next
) {
4582 struct object_id
*oid
= &parent
->item
->object
.oid
;
4583 if (!oidset_contains(&interesting
, oid
))
4585 if (oidset_insert(&child_seen
, oid
))
4586 label_oid(oid
, "branch-point", &state
);
4589 /* Add HEAD as implict "tip of branch" */
4591 tips_tail
= &commit_list_insert(iter
->item
,
4596 * Third phase: output the todo list. This is a bit tricky, as we
4597 * want to avoid jumping back and forth between revisions. To
4598 * accomplish that goal, we walk backwards from the branch tips,
4599 * gathering commits not yet shown, reversing the list on the fly,
4600 * then outputting that list (labeling revisions as needed).
4602 strbuf_addf(out
, "%s onto\n", cmd_label
);
4603 for (iter
= tips
; iter
; iter
= iter
->next
) {
4604 struct commit_list
*list
= NULL
, *iter2
;
4606 commit
= iter
->item
;
4607 if (oidset_contains(&shown
, &commit
->object
.oid
))
4609 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
4612 strbuf_addf(out
, "\n%c Branch %s\n", comment_line_char
, entry
->string
);
4614 strbuf_addch(out
, '\n');
4616 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
4617 !oidset_contains(&shown
, &commit
->object
.oid
)) {
4618 commit_list_insert(commit
, &list
);
4619 if (!commit
->parents
) {
4623 commit
= commit
->parents
->item
;
4627 strbuf_addf(out
, "%s %s\n", cmd_reset
,
4628 rebase_cousins
? "onto" : "[new root]");
4630 const char *to
= NULL
;
4632 entry
= oidmap_get(&state
.commit2label
,
4633 &commit
->object
.oid
);
4636 else if (!rebase_cousins
)
4637 to
= label_oid(&commit
->object
.oid
, NULL
,
4640 if (!to
|| !strcmp(to
, "onto"))
4641 strbuf_addf(out
, "%s onto\n", cmd_reset
);
4643 strbuf_reset(&oneline
);
4644 pretty_print_commit(pp
, commit
, &oneline
);
4645 strbuf_addf(out
, "%s %s # %s\n",
4646 cmd_reset
, to
, oneline
.buf
);
4650 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
4651 struct object_id
*oid
= &iter2
->item
->object
.oid
;
4652 entry
= oidmap_get(&commit2todo
, oid
);
4653 /* only show if not already upstream */
4655 strbuf_addf(out
, "%s\n", entry
->string
);
4656 entry
= oidmap_get(&state
.commit2label
, oid
);
4658 strbuf_addf(out
, "%s %s\n",
4659 cmd_label
, entry
->string
);
4660 oidset_insert(&shown
, oid
);
4663 free_commit_list(list
);
4666 free_commit_list(commits
);
4667 free_commit_list(tips
);
4669 strbuf_release(&label
);
4670 strbuf_release(&oneline
);
4671 strbuf_release(&buf
);
4673 oidmap_free(&commit2todo
, 1);
4674 oidmap_free(&state
.commit2label
, 1);
4675 hashmap_free(&state
.labels
, 1);
4676 strbuf_release(&state
.buf
);
4681 int sequencer_make_script(struct repository
*r
, struct strbuf
*out
, int argc
,
4682 const char **argv
, unsigned flags
)
4684 char *format
= NULL
;
4685 struct pretty_print_context pp
= {0};
4686 struct rev_info revs
;
4687 struct commit
*commit
;
4688 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
4689 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
4690 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
4692 repo_init_revisions(r
, &revs
, NULL
);
4693 revs
.verbose_header
= 1;
4695 revs
.max_parents
= 1;
4696 revs
.cherry_mark
= 1;
4699 revs
.right_only
= 1;
4700 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
4701 revs
.topo_order
= 1;
4703 revs
.pretty_given
= 1;
4704 git_config_get_string("rebase.instructionFormat", &format
);
4705 if (!format
|| !*format
) {
4707 format
= xstrdup("%s");
4709 get_commit_format(format
, &revs
);
4711 pp
.fmt
= revs
.commit_format
;
4712 pp
.output_encoding
= get_log_output_encoding();
4714 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1)
4715 return error(_("make_script: unhandled options"));
4717 if (prepare_revision_walk(&revs
) < 0)
4718 return error(_("make_script: error preparing revisions"));
4721 return make_script_with_merges(&pp
, &revs
, out
, flags
);
4723 while ((commit
= get_revision(&revs
))) {
4724 int is_empty
= is_original_commit_empty(commit
);
4726 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
))
4728 if (!keep_empty
&& is_empty
)
4729 strbuf_addf(out
, "%c ", comment_line_char
);
4730 strbuf_addf(out
, "%s %s ", insn
,
4731 oid_to_hex(&commit
->object
.oid
));
4732 pretty_print_commit(&pp
, commit
, out
);
4733 strbuf_addch(out
, '\n');
4739 * Add commands after pick and (series of) squash/fixup commands
4742 void todo_list_add_exec_commands(struct todo_list
*todo_list
,
4743 struct string_list
*commands
)
4745 struct strbuf
*buf
= &todo_list
->buf
;
4746 size_t base_offset
= buf
->len
;
4747 int i
, insert
, nr
= 0, alloc
= 0;
4748 struct todo_item
*items
= NULL
, *base_items
= NULL
;
4750 base_items
= xcalloc(commands
->nr
, sizeof(struct todo_item
));
4751 for (i
= 0; i
< commands
->nr
; i
++) {
4752 size_t command_len
= strlen(commands
->items
[i
].string
);
4754 strbuf_addstr(buf
, commands
->items
[i
].string
);
4755 strbuf_addch(buf
, '\n');
4757 base_items
[i
].command
= TODO_EXEC
;
4758 base_items
[i
].offset_in_buf
= base_offset
;
4759 base_items
[i
].arg_offset
= base_offset
+ strlen("exec ");
4760 base_items
[i
].arg_len
= command_len
- strlen("exec ");
4762 base_offset
+= command_len
+ 1;
4766 * Insert <commands> after every pick. Here, fixup/squash chains
4767 * are considered part of the pick, so we insert the commands *after*
4768 * those chains if there are any.
4770 * As we insert the exec commands immediatly after rearranging
4771 * any fixups and before the user edits the list, a fixup chain
4772 * can never contain comments (any comments are empty picks that
4773 * have been commented out because the user did not specify
4774 * --keep-empty). So, it is safe to insert an exec command
4775 * without looking at the command following a comment.
4778 for (i
= 0; i
< todo_list
->nr
; i
++) {
4779 enum todo_command command
= todo_list
->items
[i
].command
;
4780 if (insert
&& !is_fixup(command
)) {
4781 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
4782 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
4788 ALLOC_GROW(items
, nr
+ 1, alloc
);
4789 items
[nr
++] = todo_list
->items
[i
];
4791 if (command
== TODO_PICK
|| command
== TODO_MERGE
)
4795 /* insert or append final <commands> */
4796 if (insert
|| nr
== todo_list
->nr
) {
4797 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
4798 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
4803 FREE_AND_NULL(todo_list
->items
);
4804 todo_list
->items
= items
;
4806 todo_list
->alloc
= alloc
;
4809 static void todo_list_to_strbuf(struct repository
*r
, struct todo_list
*todo_list
,
4810 struct strbuf
*buf
, int num
, unsigned flags
)
4812 struct todo_item
*item
;
4813 int i
, max
= todo_list
->nr
;
4815 if (num
> 0 && num
< max
)
4818 for (item
= todo_list
->items
, i
= 0; i
< max
; i
++, item
++) {
4819 /* if the item is not a command write it and continue */
4820 if (item
->command
>= TODO_COMMENT
) {
4821 strbuf_addf(buf
, "%.*s\n", item
->arg_len
,
4822 todo_item_get_arg(todo_list
, item
));
4826 /* add command to the buffer */
4827 if (flags
& TODO_LIST_ABBREVIATE_CMDS
)
4828 strbuf_addch(buf
, command_to_char(item
->command
));
4830 strbuf_addstr(buf
, command_to_string(item
->command
));
4834 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
4835 short_commit_name(item
->commit
) :
4836 oid_to_hex(&item
->commit
->object
.oid
);
4838 if (item
->command
== TODO_MERGE
) {
4839 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
4840 strbuf_addstr(buf
, " -c");
4842 strbuf_addstr(buf
, " -C");
4845 strbuf_addf(buf
, " %s", oid
);
4848 /* add all the rest */
4850 strbuf_addch(buf
, '\n');
4852 strbuf_addf(buf
, " %.*s\n", item
->arg_len
,
4853 todo_item_get_arg(todo_list
, item
));
4857 int todo_list_write_to_file(struct repository
*r
, struct todo_list
*todo_list
,
4858 const char *file
, const char *shortrevisions
,
4859 const char *shortonto
, int num
, unsigned flags
)
4862 struct strbuf buf
= STRBUF_INIT
;
4864 todo_list_to_strbuf(r
, todo_list
, &buf
, num
, flags
);
4865 if (flags
& TODO_LIST_APPEND_TODO_HELP
)
4866 append_todo_help(flags
& TODO_LIST_KEEP_EMPTY
, count_commands(todo_list
),
4867 shortrevisions
, shortonto
, &buf
);
4869 res
= write_message(buf
.buf
, buf
.len
, file
, 0);
4870 strbuf_release(&buf
);
4875 static const char edit_todo_list_advice
[] =
4876 N_("You can fix this with 'git rebase --edit-todo' "
4877 "and then run 'git rebase --continue'.\n"
4878 "Or you can abort the rebase with 'git rebase"
4881 int check_todo_list_from_file(struct repository
*r
)
4883 struct todo_list old_todo
= TODO_LIST_INIT
, new_todo
= TODO_LIST_INIT
;
4886 if (strbuf_read_file_or_whine(&new_todo
.buf
, rebase_path_todo()) < 0) {
4891 if (strbuf_read_file_or_whine(&old_todo
.buf
, rebase_path_todo_backup()) < 0) {
4896 res
= todo_list_parse_insn_buffer(r
, old_todo
.buf
.buf
, &old_todo
);
4898 res
= todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
);
4900 res
= todo_list_check(&old_todo
, &new_todo
);
4902 fprintf(stderr
, _(edit_todo_list_advice
));
4904 todo_list_release(&old_todo
);
4905 todo_list_release(&new_todo
);
4910 /* skip picking commits whose parents are unchanged */
4911 static int skip_unnecessary_picks(struct repository
*r
,
4912 struct todo_list
*todo_list
,
4913 struct object_id
*base_oid
)
4915 struct object_id
*parent_oid
;
4918 for (i
= 0; i
< todo_list
->nr
; i
++) {
4919 struct todo_item
*item
= todo_list
->items
+ i
;
4921 if (item
->command
>= TODO_NOOP
)
4923 if (item
->command
!= TODO_PICK
)
4925 if (parse_commit(item
->commit
)) {
4926 return error(_("could not parse commit '%s'"),
4927 oid_to_hex(&item
->commit
->object
.oid
));
4929 if (!item
->commit
->parents
)
4930 break; /* root commit */
4931 if (item
->commit
->parents
->next
)
4932 break; /* merge commit */
4933 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
4934 if (!oideq(parent_oid
, base_oid
))
4936 oidcpy(base_oid
, &item
->commit
->object
.oid
);
4939 const char *done_path
= rebase_path_done();
4941 if (todo_list_write_to_file(r
, todo_list
, done_path
, NULL
, NULL
, i
, 0)) {
4942 error_errno(_("could not write to '%s'"), done_path
);
4946 MOVE_ARRAY(todo_list
->items
, todo_list
->items
+ i
, todo_list
->nr
- i
);
4948 todo_list
->current
= 0;
4950 if (is_fixup(peek_command(todo_list
, 0)))
4951 record_in_rewritten(base_oid
, peek_command(todo_list
, 0));
4957 int complete_action(struct repository
*r
, struct replay_opts
*opts
, unsigned flags
,
4958 const char *shortrevisions
, const char *onto_name
,
4959 struct commit
*onto
, const char *orig_head
,
4960 struct string_list
*commands
, unsigned autosquash
,
4961 struct todo_list
*todo_list
)
4963 const char *shortonto
, *todo_file
= rebase_path_todo();
4964 struct todo_list new_todo
= TODO_LIST_INIT
;
4965 struct strbuf
*buf
= &todo_list
->buf
;
4966 struct object_id oid
= onto
->object
.oid
;
4969 shortonto
= find_unique_abbrev(&oid
, DEFAULT_ABBREV
);
4971 if (buf
->len
== 0) {
4972 struct todo_item
*item
= append_new_todo(todo_list
);
4973 item
->command
= TODO_NOOP
;
4974 item
->commit
= NULL
;
4975 item
->arg_len
= item
->arg_offset
= item
->flags
= item
->offset_in_buf
= 0;
4978 if (autosquash
&& todo_list_rearrange_squash(todo_list
))
4982 todo_list_add_exec_commands(todo_list
, commands
);
4984 if (count_commands(todo_list
) == 0) {
4985 apply_autostash(opts
);
4986 sequencer_remove_state(opts
);
4988 return error(_("nothing to do"));
4991 res
= edit_todo_list(r
, todo_list
, &new_todo
, shortrevisions
,
4995 else if (res
== -2) {
4996 apply_autostash(opts
);
4997 sequencer_remove_state(opts
);
5000 } else if (res
== -3) {
5001 apply_autostash(opts
);
5002 sequencer_remove_state(opts
);
5003 todo_list_release(&new_todo
);
5005 return error(_("nothing to do"));
5008 if (todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
) ||
5009 todo_list_check(todo_list
, &new_todo
)) {
5010 fprintf(stderr
, _(edit_todo_list_advice
));
5011 checkout_onto(r
, opts
, onto_name
, &onto
->object
.oid
, orig_head
);
5012 todo_list_release(&new_todo
);
5017 if (opts
->allow_ff
&& skip_unnecessary_picks(r
, &new_todo
, &oid
)) {
5018 todo_list_release(&new_todo
);
5019 return error(_("could not skip unnecessary pick commands"));
5022 if (todo_list_write_to_file(r
, &new_todo
, todo_file
, NULL
, NULL
, -1,
5023 flags
& ~(TODO_LIST_SHORTEN_IDS
))) {
5024 todo_list_release(&new_todo
);
5025 return error_errno(_("could not write '%s'"), todo_file
);
5028 todo_list_release(&new_todo
);
5030 if (checkout_onto(r
, opts
, onto_name
, &oid
, orig_head
))
5033 if (require_clean_work_tree(r
, "rebase", "", 1, 1))
5036 return sequencer_continue(r
, opts
);
5039 struct subject2item_entry
{
5040 struct hashmap_entry entry
;
5042 char subject
[FLEX_ARRAY
];
5045 static int subject2item_cmp(const void *fndata
,
5046 const struct subject2item_entry
*a
,
5047 const struct subject2item_entry
*b
, const void *key
)
5049 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
5052 define_commit_slab(commit_todo_item
, struct todo_item
*);
5055 * Rearrange the todo list that has both "pick commit-id msg" and "pick
5056 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
5057 * after the former, and change "pick" to "fixup"/"squash".
5059 * Note that if the config has specified a custom instruction format, each log
5060 * message will have to be retrieved from the commit (as the oneline in the
5061 * script cannot be trusted) in order to normalize the autosquash arrangement.
5063 int todo_list_rearrange_squash(struct todo_list
*todo_list
)
5065 struct hashmap subject2item
;
5066 int rearranged
= 0, *next
, *tail
, i
, nr
= 0, alloc
= 0;
5068 struct commit_todo_item commit_todo
;
5069 struct todo_item
*items
= NULL
;
5071 init_commit_todo_item(&commit_todo
);
5073 * The hashmap maps onelines to the respective todo list index.
5075 * If any items need to be rearranged, the next[i] value will indicate
5076 * which item was moved directly after the i'th.
5078 * In that case, last[i] will indicate the index of the latest item to
5079 * be moved to appear after the i'th.
5081 hashmap_init(&subject2item
, (hashmap_cmp_fn
) subject2item_cmp
,
5082 NULL
, todo_list
->nr
);
5083 ALLOC_ARRAY(next
, todo_list
->nr
);
5084 ALLOC_ARRAY(tail
, todo_list
->nr
);
5085 ALLOC_ARRAY(subjects
, todo_list
->nr
);
5086 for (i
= 0; i
< todo_list
->nr
; i
++) {
5087 struct strbuf buf
= STRBUF_INIT
;
5088 struct todo_item
*item
= todo_list
->items
+ i
;
5089 const char *commit_buffer
, *subject
, *p
;
5092 struct subject2item_entry
*entry
;
5094 next
[i
] = tail
[i
] = -1;
5095 if (!item
->commit
|| item
->command
== TODO_DROP
) {
5100 if (is_fixup(item
->command
)) {
5101 clear_commit_todo_item(&commit_todo
);
5102 return error(_("the script was already rearranged."));
5105 *commit_todo_item_at(&commit_todo
, item
->commit
) = item
;
5107 parse_commit(item
->commit
);
5108 commit_buffer
= get_commit_buffer(item
->commit
, NULL
);
5109 find_commit_subject(commit_buffer
, &subject
);
5110 format_subject(&buf
, subject
, " ");
5111 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
5112 unuse_commit_buffer(item
->commit
, commit_buffer
);
5113 if ((skip_prefix(subject
, "fixup! ", &p
) ||
5114 skip_prefix(subject
, "squash! ", &p
))) {
5115 struct commit
*commit2
;
5120 if (!skip_prefix(p
, "fixup! ", &p
) &&
5121 !skip_prefix(p
, "squash! ", &p
))
5125 if ((entry
= hashmap_get_from_hash(&subject2item
,
5127 /* found by title */
5129 else if (!strchr(p
, ' ') &&
5131 lookup_commit_reference_by_name(p
)) &&
5132 *commit_todo_item_at(&commit_todo
, commit2
))
5133 /* found by commit name */
5134 i2
= *commit_todo_item_at(&commit_todo
, commit2
)
5137 /* copy can be a prefix of the commit subject */
5138 for (i2
= 0; i2
< i
; i2
++)
5140 starts_with(subjects
[i2
], p
))
5148 todo_list
->items
[i
].command
=
5149 starts_with(subject
, "fixup!") ?
5150 TODO_FIXUP
: TODO_SQUASH
;
5156 } else if (!hashmap_get_from_hash(&subject2item
,
5157 strhash(subject
), subject
)) {
5158 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
5160 hashmap_entry_init(entry
, strhash(entry
->subject
));
5161 hashmap_put(&subject2item
, entry
);
5166 for (i
= 0; i
< todo_list
->nr
; i
++) {
5167 enum todo_command command
= todo_list
->items
[i
].command
;
5171 * Initially, all commands are 'pick's. If it is a
5172 * fixup or a squash now, we have rearranged it.
5174 if (is_fixup(command
))
5178 ALLOC_GROW(items
, nr
+ 1, alloc
);
5179 items
[nr
++] = todo_list
->items
[cur
];
5184 FREE_AND_NULL(todo_list
->items
);
5185 todo_list
->items
= items
;
5187 todo_list
->alloc
= alloc
;
5192 for (i
= 0; i
< todo_list
->nr
; i
++)
5195 hashmap_free(&subject2item
, 1);
5197 clear_commit_todo_item(&commit_todo
);