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 now-removed
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 update_ref(NULL
, "CHERRY_PICK_HEAD", &root_commit
, NULL
,
991 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
);
992 res
= update_ref(NULL
, "HEAD", &root_commit
, NULL
, 0,
993 UPDATE_REFS_MSG_ON_ERR
);
995 return res
< 0 ? error(_("writing root commit")) : 0;
1000 if (is_rebase_i(opts
) && read_env_script(&cmd
.env_array
)) {
1001 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
1003 return error(_(staged_changes_advice
),
1007 argv_array_push(&cmd
.args
, "commit");
1009 if (!(flags
& VERIFY_MSG
))
1010 argv_array_push(&cmd
.args
, "-n");
1011 if ((flags
& AMEND_MSG
))
1012 argv_array_push(&cmd
.args
, "--amend");
1014 argv_array_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
1016 argv_array_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
1017 else if (!(flags
& EDIT_MSG
))
1018 argv_array_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
1019 if ((flags
& CLEANUP_MSG
))
1020 argv_array_push(&cmd
.args
, "--cleanup=strip");
1021 if ((flags
& EDIT_MSG
))
1022 argv_array_push(&cmd
.args
, "-e");
1023 else if (!(flags
& CLEANUP_MSG
) &&
1024 !opts
->signoff
&& !opts
->record_origin
&&
1025 !opts
->explicit_cleanup
)
1026 argv_array_push(&cmd
.args
, "--cleanup=verbatim");
1028 if ((flags
& ALLOW_EMPTY
))
1029 argv_array_push(&cmd
.args
, "--allow-empty");
1031 if (!(flags
& EDIT_MSG
))
1032 argv_array_push(&cmd
.args
, "--allow-empty-message");
1034 if (is_rebase_i(opts
) && !(flags
& EDIT_MSG
))
1035 return run_command_silent_on_success(&cmd
);
1037 return run_command(&cmd
);
1040 static int rest_is_empty(const struct strbuf
*sb
, int start
)
1045 /* Check if the rest is just whitespace and Signed-off-by's. */
1046 for (i
= start
; i
< sb
->len
; i
++) {
1047 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1053 if (strlen(sign_off_header
) <= eol
- i
&&
1054 starts_with(sb
->buf
+ i
, sign_off_header
)) {
1059 if (!isspace(sb
->buf
[i
++]))
1066 void cleanup_message(struct strbuf
*msgbuf
,
1067 enum commit_msg_cleanup_mode cleanup_mode
, int verbose
)
1069 if (verbose
|| /* Truncate the message just before the diff, if any. */
1070 cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
1071 strbuf_setlen(msgbuf
, wt_status_locate_end(msgbuf
->buf
, msgbuf
->len
));
1072 if (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
)
1073 strbuf_stripspace(msgbuf
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1077 * Find out if the message in the strbuf contains only whitespace and
1078 * Signed-off-by lines.
1080 int message_is_empty(const struct strbuf
*sb
,
1081 enum commit_msg_cleanup_mode cleanup_mode
)
1083 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1085 return rest_is_empty(sb
, 0);
1089 * See if the user edited the message in the editor or left what
1090 * was in the template intact
1092 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
1093 enum commit_msg_cleanup_mode cleanup_mode
)
1095 struct strbuf tmpl
= STRBUF_INIT
;
1098 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1101 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
1104 strbuf_stripspace(&tmpl
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1105 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
1107 strbuf_release(&tmpl
);
1108 return rest_is_empty(sb
, start
- sb
->buf
);
1111 int update_head_with_reflog(const struct commit
*old_head
,
1112 const struct object_id
*new_head
,
1113 const char *action
, const struct strbuf
*msg
,
1116 struct ref_transaction
*transaction
;
1117 struct strbuf sb
= STRBUF_INIT
;
1122 strbuf_addstr(&sb
, action
);
1123 strbuf_addstr(&sb
, ": ");
1126 nl
= strchr(msg
->buf
, '\n');
1128 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
1130 strbuf_addbuf(&sb
, msg
);
1131 strbuf_addch(&sb
, '\n');
1134 transaction
= ref_transaction_begin(err
);
1136 ref_transaction_update(transaction
, "HEAD", new_head
,
1137 old_head
? &old_head
->object
.oid
: &null_oid
,
1139 ref_transaction_commit(transaction
, err
)) {
1142 ref_transaction_free(transaction
);
1143 strbuf_release(&sb
);
1148 static int run_rewrite_hook(const struct object_id
*oldoid
,
1149 const struct object_id
*newoid
)
1151 struct child_process proc
= CHILD_PROCESS_INIT
;
1152 const char *argv
[3];
1154 struct strbuf sb
= STRBUF_INIT
;
1156 argv
[0] = find_hook("post-rewrite");
1165 proc
.stdout_to_stderr
= 1;
1166 proc
.trace2_hook_name
= "post-rewrite";
1168 code
= start_command(&proc
);
1171 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
1172 sigchain_push(SIGPIPE
, SIG_IGN
);
1173 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
1175 strbuf_release(&sb
);
1176 sigchain_pop(SIGPIPE
);
1177 return finish_command(&proc
);
1180 void commit_post_rewrite(struct repository
*r
,
1181 const struct commit
*old_head
,
1182 const struct object_id
*new_head
)
1184 struct notes_rewrite_cfg
*cfg
;
1186 cfg
= init_copy_notes_for_rewrite("amend");
1188 /* we are amending, so old_head is not NULL */
1189 copy_note_for_rewrite(cfg
, &old_head
->object
.oid
, new_head
);
1190 finish_copy_notes_for_rewrite(r
, cfg
, "Notes added by 'git commit --amend'");
1192 run_rewrite_hook(&old_head
->object
.oid
, new_head
);
1195 static int run_prepare_commit_msg_hook(struct repository
*r
,
1199 struct argv_array hook_env
= ARGV_ARRAY_INIT
;
1203 name
= git_path_commit_editmsg();
1204 if (write_message(msg
->buf
, msg
->len
, name
, 0))
1207 argv_array_pushf(&hook_env
, "GIT_INDEX_FILE=%s", r
->index_file
);
1208 argv_array_push(&hook_env
, "GIT_EDITOR=:");
1210 ret
= run_hook_le(hook_env
.argv
, "prepare-commit-msg", name
,
1211 "commit", commit
, NULL
);
1213 ret
= run_hook_le(hook_env
.argv
, "prepare-commit-msg", name
,
1216 ret
= error(_("'prepare-commit-msg' hook failed"));
1217 argv_array_clear(&hook_env
);
1222 static const char implicit_ident_advice_noconfig
[] =
1223 N_("Your name and email address were configured automatically based\n"
1224 "on your username and hostname. Please check that they are accurate.\n"
1225 "You can suppress this message by setting them explicitly. Run the\n"
1226 "following command and follow the instructions in your editor to edit\n"
1227 "your configuration file:\n"
1229 " git config --global --edit\n"
1231 "After doing this, you may fix the identity used for this commit with:\n"
1233 " git commit --amend --reset-author\n");
1235 static const char implicit_ident_advice_config
[] =
1236 N_("Your name and email address were configured automatically based\n"
1237 "on your username and hostname. Please check that they are accurate.\n"
1238 "You can suppress this message by setting them explicitly:\n"
1240 " git config --global user.name \"Your Name\"\n"
1241 " git config --global user.email you@example.com\n"
1243 "After doing this, you may fix the identity used for this commit with:\n"
1245 " git commit --amend --reset-author\n");
1247 static const char *implicit_ident_advice(void)
1249 char *user_config
= expand_user_path("~/.gitconfig", 0);
1250 char *xdg_config
= xdg_config_home("config");
1251 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1257 return _(implicit_ident_advice_config
);
1259 return _(implicit_ident_advice_noconfig
);
1263 void print_commit_summary(struct repository
*r
,
1265 const struct object_id
*oid
,
1268 struct rev_info rev
;
1269 struct commit
*commit
;
1270 struct strbuf format
= STRBUF_INIT
;
1272 struct pretty_print_context pctx
= {0};
1273 struct strbuf author_ident
= STRBUF_INIT
;
1274 struct strbuf committer_ident
= STRBUF_INIT
;
1276 commit
= lookup_commit(r
, oid
);
1278 die(_("couldn't look up newly created commit"));
1279 if (parse_commit(commit
))
1280 die(_("could not parse newly created commit"));
1282 strbuf_addstr(&format
, "format:%h] %s");
1284 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1285 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1286 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1287 strbuf_addstr(&format
, "\n Author: ");
1288 strbuf_addbuf_percentquote(&format
, &author_ident
);
1290 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
1291 struct strbuf date
= STRBUF_INIT
;
1293 format_commit_message(commit
, "%ad", &date
, &pctx
);
1294 strbuf_addstr(&format
, "\n Date: ");
1295 strbuf_addbuf_percentquote(&format
, &date
);
1296 strbuf_release(&date
);
1298 if (!committer_ident_sufficiently_given()) {
1299 strbuf_addstr(&format
, "\n Committer: ");
1300 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1301 if (advice_implicit_identity
) {
1302 strbuf_addch(&format
, '\n');
1303 strbuf_addstr(&format
, implicit_ident_advice());
1306 strbuf_release(&author_ident
);
1307 strbuf_release(&committer_ident
);
1309 repo_init_revisions(r
, &rev
, prefix
);
1310 setup_revisions(0, NULL
, &rev
, NULL
);
1313 rev
.diffopt
.output_format
=
1314 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1316 rev
.verbose_header
= 1;
1317 rev
.show_root_diff
= 1;
1318 get_commit_format(format
.buf
, &rev
);
1319 rev
.always_show_header
= 0;
1320 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1321 rev
.diffopt
.break_opt
= 0;
1322 diff_setup_done(&rev
.diffopt
);
1324 head
= resolve_ref_unsafe("HEAD", 0, NULL
, NULL
);
1326 die_errno(_("unable to resolve HEAD after creating commit"));
1327 if (!strcmp(head
, "HEAD"))
1328 head
= _("detached HEAD");
1330 skip_prefix(head
, "refs/heads/", &head
);
1331 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1332 _(" (root-commit)") : "");
1334 if (!log_tree_commit(&rev
, commit
)) {
1335 rev
.always_show_header
= 1;
1336 rev
.use_terminator
= 1;
1337 log_tree_commit(&rev
, commit
);
1340 strbuf_release(&format
);
1343 static int parse_head(struct repository
*r
, struct commit
**head
)
1345 struct commit
*current_head
;
1346 struct object_id oid
;
1348 if (get_oid("HEAD", &oid
)) {
1349 current_head
= NULL
;
1351 current_head
= lookup_commit_reference(r
, &oid
);
1353 return error(_("could not parse HEAD"));
1354 if (!oideq(&oid
, ¤t_head
->object
.oid
)) {
1355 warning(_("HEAD %s is not a commit!"),
1358 if (parse_commit(current_head
))
1359 return error(_("could not parse HEAD commit"));
1361 *head
= current_head
;
1367 * Try to commit without forking 'git commit'. In some cases we need
1368 * to run 'git commit' to display an error message
1371 * -1 - error unable to commit
1373 * 1 - run 'git commit'
1375 static int try_to_commit(struct repository
*r
,
1376 struct strbuf
*msg
, const char *author
,
1377 struct replay_opts
*opts
, unsigned int flags
,
1378 struct object_id
*oid
)
1380 struct object_id tree
;
1381 struct commit
*current_head
;
1382 struct commit_list
*parents
= NULL
;
1383 struct commit_extra_header
*extra
= NULL
;
1384 struct strbuf err
= STRBUF_INIT
;
1385 struct strbuf commit_msg
= STRBUF_INIT
;
1386 char *amend_author
= NULL
;
1387 const char *hook_commit
= NULL
;
1388 enum commit_msg_cleanup_mode cleanup
;
1391 if (parse_head(r
, ¤t_head
))
1394 if (flags
& AMEND_MSG
) {
1395 const char *exclude_gpgsig
[] = { "gpgsig", NULL
};
1396 const char *out_enc
= get_commit_output_encoding();
1397 const char *message
= logmsg_reencode(current_head
, NULL
,
1401 const char *orig_message
= NULL
;
1403 find_commit_subject(message
, &orig_message
);
1405 strbuf_addstr(msg
, orig_message
);
1406 hook_commit
= "HEAD";
1408 author
= amend_author
= get_author(message
);
1409 unuse_commit_buffer(current_head
, message
);
1411 res
= error(_("unable to parse commit author"));
1414 parents
= copy_commit_list(current_head
->parents
);
1415 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1416 } else if (current_head
) {
1417 commit_list_insert(current_head
, &parents
);
1420 if (write_index_as_tree(&tree
, r
->index
, r
->index_file
, 0, NULL
)) {
1421 res
= error(_("git write-tree failed to write a tree"));
1425 if (!(flags
& ALLOW_EMPTY
) && oideq(current_head
?
1426 get_commit_tree_oid(current_head
) :
1427 the_hash_algo
->empty_tree
, &tree
)) {
1428 res
= 1; /* run 'git commit' to display error message */
1432 if (find_hook("prepare-commit-msg")) {
1433 res
= run_prepare_commit_msg_hook(r
, msg
, hook_commit
);
1436 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1438 res
= error_errno(_("unable to read commit message "
1440 git_path_commit_editmsg());
1446 if (flags
& CLEANUP_MSG
)
1447 cleanup
= COMMIT_MSG_CLEANUP_ALL
;
1448 else if ((opts
->signoff
|| opts
->record_origin
) &&
1449 !opts
->explicit_cleanup
)
1450 cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
1452 cleanup
= opts
->default_msg_cleanup
;
1454 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1455 strbuf_stripspace(msg
, cleanup
== COMMIT_MSG_CLEANUP_ALL
);
1456 if ((flags
& EDIT_MSG
) && message_is_empty(msg
, cleanup
)) {
1457 res
= 1; /* run 'git commit' to display error message */
1463 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
,
1464 oid
, author
, opts
->gpg_sign
, extra
)) {
1465 res
= error(_("failed to write commit object"));
1469 if (update_head_with_reflog(current_head
, oid
,
1470 getenv("GIT_REFLOG_ACTION"), msg
, &err
)) {
1471 res
= error("%s", err
.buf
);
1475 if (flags
& AMEND_MSG
)
1476 commit_post_rewrite(r
, current_head
, oid
);
1479 free_commit_extra_headers(extra
);
1480 strbuf_release(&err
);
1481 strbuf_release(&commit_msg
);
1487 static int do_commit(struct repository
*r
,
1488 const char *msg_file
, const char *author
,
1489 struct replay_opts
*opts
, unsigned int flags
)
1493 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
) &&
1494 !(flags
& CREATE_ROOT_COMMIT
)) {
1495 struct object_id oid
;
1496 struct strbuf sb
= STRBUF_INIT
;
1498 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1499 return error_errno(_("unable to read commit message "
1503 res
= try_to_commit(r
, msg_file
? &sb
: NULL
,
1504 author
, opts
, flags
, &oid
);
1505 strbuf_release(&sb
);
1507 unlink(git_path_cherry_pick_head(r
));
1508 unlink(git_path_merge_msg(r
));
1509 if (!is_rebase_i(opts
))
1510 print_commit_summary(r
, NULL
, &oid
,
1511 SUMMARY_SHOW_AUTHOR_DATE
);
1516 return run_git_commit(r
, msg_file
, opts
, flags
);
1521 static int is_original_commit_empty(struct commit
*commit
)
1523 const struct object_id
*ptree_oid
;
1525 if (parse_commit(commit
))
1526 return error(_("could not parse commit %s"),
1527 oid_to_hex(&commit
->object
.oid
));
1528 if (commit
->parents
) {
1529 struct commit
*parent
= commit
->parents
->item
;
1530 if (parse_commit(parent
))
1531 return error(_("could not parse parent commit %s"),
1532 oid_to_hex(&parent
->object
.oid
));
1533 ptree_oid
= get_commit_tree_oid(parent
);
1535 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1538 return oideq(ptree_oid
, get_commit_tree_oid(commit
));
1542 * Do we run "git commit" with "--allow-empty"?
1544 static int allow_empty(struct repository
*r
,
1545 struct replay_opts
*opts
,
1546 struct commit
*commit
)
1548 int index_unchanged
, empty_commit
;
1553 * (1) we do not allow empty at all and error out.
1555 * (2) we allow ones that were initially empty, but
1556 * forbid the ones that become empty;
1558 * (3) we allow both.
1560 if (!opts
->allow_empty
)
1561 return 0; /* let "git commit" barf as necessary */
1563 index_unchanged
= is_index_unchanged(r
);
1564 if (index_unchanged
< 0)
1565 return index_unchanged
;
1566 if (!index_unchanged
)
1567 return 0; /* we do not have to say --allow-empty */
1569 if (opts
->keep_redundant_commits
)
1572 empty_commit
= is_original_commit_empty(commit
);
1573 if (empty_commit
< 0)
1574 return empty_commit
;
1584 } todo_command_info
[] = {
1601 static const char *command_to_string(const enum todo_command command
)
1603 if (command
< TODO_COMMENT
)
1604 return todo_command_info
[command
].str
;
1605 die(_("unknown command: %d"), command
);
1608 static char command_to_char(const enum todo_command command
)
1610 if (command
< TODO_COMMENT
&& todo_command_info
[command
].c
)
1611 return todo_command_info
[command
].c
;
1612 return comment_line_char
;
1615 static int is_noop(const enum todo_command command
)
1617 return TODO_NOOP
<= command
;
1620 static int is_fixup(enum todo_command command
)
1622 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1625 /* Does this command create a (non-merge) commit? */
1626 static int is_pick_or_similar(enum todo_command command
)
1641 static int update_squash_messages(struct repository
*r
,
1642 enum todo_command command
,
1643 struct commit
*commit
,
1644 struct replay_opts
*opts
)
1646 struct strbuf buf
= STRBUF_INIT
;
1648 const char *message
, *body
;
1650 if (opts
->current_fixup_count
> 0) {
1651 struct strbuf header
= STRBUF_INIT
;
1654 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
1655 return error(_("could not read '%s'"),
1656 rebase_path_squash_msg());
1658 eol
= buf
.buf
[0] != comment_line_char
?
1659 buf
.buf
: strchrnul(buf
.buf
, '\n');
1661 strbuf_addf(&header
, "%c ", comment_line_char
);
1662 strbuf_addf(&header
, _("This is a combination of %d commits."),
1663 opts
->current_fixup_count
+ 2);
1664 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
1665 strbuf_release(&header
);
1667 struct object_id head
;
1668 struct commit
*head_commit
;
1669 const char *head_message
, *body
;
1671 if (get_oid("HEAD", &head
))
1672 return error(_("need a HEAD to fixup"));
1673 if (!(head_commit
= lookup_commit_reference(r
, &head
)))
1674 return error(_("could not read HEAD"));
1675 if (!(head_message
= get_commit_buffer(head_commit
, NULL
)))
1676 return error(_("could not read HEAD's commit message"));
1678 find_commit_subject(head_message
, &body
);
1679 if (write_message(body
, strlen(body
),
1680 rebase_path_fixup_msg(), 0)) {
1681 unuse_commit_buffer(head_commit
, head_message
);
1682 return error(_("cannot write '%s'"),
1683 rebase_path_fixup_msg());
1686 strbuf_addf(&buf
, "%c ", comment_line_char
);
1687 strbuf_addf(&buf
, _("This is a combination of %d commits."), 2);
1688 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1689 strbuf_addstr(&buf
, _("This is the 1st commit message:"));
1690 strbuf_addstr(&buf
, "\n\n");
1691 strbuf_addstr(&buf
, body
);
1693 unuse_commit_buffer(head_commit
, head_message
);
1696 if (!(message
= get_commit_buffer(commit
, NULL
)))
1697 return error(_("could not read commit message of %s"),
1698 oid_to_hex(&commit
->object
.oid
));
1699 find_commit_subject(message
, &body
);
1701 if (command
== TODO_SQUASH
) {
1702 unlink(rebase_path_fixup_msg());
1703 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1704 strbuf_addf(&buf
, _("This is the commit message #%d:"),
1705 ++opts
->current_fixup_count
+ 1);
1706 strbuf_addstr(&buf
, "\n\n");
1707 strbuf_addstr(&buf
, body
);
1708 } else if (command
== TODO_FIXUP
) {
1709 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
1710 strbuf_addf(&buf
, _("The commit message #%d will be skipped:"),
1711 ++opts
->current_fixup_count
+ 1);
1712 strbuf_addstr(&buf
, "\n\n");
1713 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
1715 return error(_("unknown command: %d"), command
);
1716 unuse_commit_buffer(commit
, message
);
1718 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(), 0);
1719 strbuf_release(&buf
);
1722 strbuf_addf(&opts
->current_fixups
, "%s%s %s",
1723 opts
->current_fixups
.len
? "\n" : "",
1724 command_to_string(command
),
1725 oid_to_hex(&commit
->object
.oid
));
1726 res
= write_message(opts
->current_fixups
.buf
,
1727 opts
->current_fixups
.len
,
1728 rebase_path_current_fixups(), 0);
1734 static void flush_rewritten_pending(void)
1736 struct strbuf buf
= STRBUF_INIT
;
1737 struct object_id newoid
;
1740 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
1741 !get_oid("HEAD", &newoid
) &&
1742 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1743 char *bol
= buf
.buf
, *eol
;
1746 eol
= strchrnul(bol
, '\n');
1747 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
1748 bol
, oid_to_hex(&newoid
));
1754 unlink(rebase_path_rewritten_pending());
1756 strbuf_release(&buf
);
1759 static void record_in_rewritten(struct object_id
*oid
,
1760 enum todo_command next_command
)
1762 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
1767 fprintf(out
, "%s\n", oid_to_hex(oid
));
1770 if (!is_fixup(next_command
))
1771 flush_rewritten_pending();
1774 static int do_pick_commit(struct repository
*r
,
1775 enum todo_command command
,
1776 struct commit
*commit
,
1777 struct replay_opts
*opts
,
1780 unsigned int flags
= opts
->edit
? EDIT_MSG
: 0;
1781 const char *msg_file
= opts
->edit
? NULL
: git_path_merge_msg(r
);
1782 struct object_id head
;
1783 struct commit
*base
, *next
, *parent
;
1784 const char *base_label
, *next_label
;
1785 char *author
= NULL
;
1786 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
1787 struct strbuf msgbuf
= STRBUF_INIT
;
1788 int res
, unborn
= 0, allow
;
1790 if (opts
->no_commit
) {
1792 * We do not intend to commit immediately. We just want to
1793 * merge the differences in, so let's compute the tree
1794 * that represents the "current" state for merge-recursive
1797 if (write_index_as_tree(&head
, r
->index
, r
->index_file
, 0, NULL
))
1798 return error(_("your index file is unmerged."));
1800 unborn
= get_oid("HEAD", &head
);
1801 /* Do we want to generate a root commit? */
1802 if (is_pick_or_similar(command
) && opts
->have_squash_onto
&&
1803 oideq(&head
, &opts
->squash_onto
)) {
1804 if (is_fixup(command
))
1805 return error(_("cannot fixup root commit"));
1806 flags
|= CREATE_ROOT_COMMIT
;
1809 oidcpy(&head
, the_hash_algo
->empty_tree
);
1810 if (index_differs_from(r
, unborn
? empty_tree_oid_hex() : "HEAD",
1812 return error_dirty_index(r
, opts
);
1814 discard_index(r
->index
);
1816 if (!commit
->parents
)
1818 else if (commit
->parents
->next
) {
1819 /* Reverting or cherry-picking a merge commit */
1821 struct commit_list
*p
;
1823 if (!opts
->mainline
)
1824 return error(_("commit %s is a merge but no -m option was given."),
1825 oid_to_hex(&commit
->object
.oid
));
1827 for (cnt
= 1, p
= commit
->parents
;
1828 cnt
!= opts
->mainline
&& p
;
1831 if (cnt
!= opts
->mainline
|| !p
)
1832 return error(_("commit %s does not have parent %d"),
1833 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
1835 } else if (1 < opts
->mainline
)
1837 * Non-first parent explicitly specified as mainline for
1840 return error(_("commit %s does not have parent %d"),
1841 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
1843 parent
= commit
->parents
->item
;
1845 if (get_message(commit
, &msg
) != 0)
1846 return error(_("cannot get commit message for %s"),
1847 oid_to_hex(&commit
->object
.oid
));
1849 if (opts
->allow_ff
&& !is_fixup(command
) &&
1850 ((parent
&& oideq(&parent
->object
.oid
, &head
)) ||
1851 (!parent
&& unborn
))) {
1852 if (is_rebase_i(opts
))
1853 write_author_script(msg
.message
);
1854 res
= fast_forward_to(r
, &commit
->object
.oid
, &head
, unborn
,
1856 if (res
|| command
!= TODO_REWORD
)
1858 flags
|= EDIT_MSG
| AMEND_MSG
| VERIFY_MSG
;
1860 goto fast_forward_edit
;
1862 if (parent
&& parse_commit(parent
) < 0)
1863 /* TRANSLATORS: The first %s will be a "todo" command like
1864 "revert" or "pick", the second %s a SHA1. */
1865 return error(_("%s: cannot parse parent commit %s"),
1866 command_to_string(command
),
1867 oid_to_hex(&parent
->object
.oid
));
1870 * "commit" is an existing commit. We would want to apply
1871 * the difference it introduces since its first parent "prev"
1872 * on top of the current HEAD if we are cherry-pick. Or the
1873 * reverse of it if we are revert.
1876 if (command
== TODO_REVERT
) {
1878 base_label
= msg
.label
;
1880 next_label
= msg
.parent_label
;
1881 strbuf_addstr(&msgbuf
, "Revert \"");
1882 strbuf_addstr(&msgbuf
, msg
.subject
);
1883 strbuf_addstr(&msgbuf
, "\"\n\nThis reverts commit ");
1884 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
1886 if (commit
->parents
&& commit
->parents
->next
) {
1887 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
1888 strbuf_addstr(&msgbuf
, oid_to_hex(&parent
->object
.oid
));
1890 strbuf_addstr(&msgbuf
, ".\n");
1895 base_label
= msg
.parent_label
;
1897 next_label
= msg
.label
;
1899 /* Append the commit log message to msgbuf. */
1900 if (find_commit_subject(msg
.message
, &p
))
1901 strbuf_addstr(&msgbuf
, p
);
1903 if (opts
->record_origin
) {
1904 strbuf_complete_line(&msgbuf
);
1905 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
1906 strbuf_addch(&msgbuf
, '\n');
1907 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
1908 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
1909 strbuf_addstr(&msgbuf
, ")\n");
1911 if (!is_fixup(command
))
1912 author
= get_author(msg
.message
);
1915 if (command
== TODO_REWORD
)
1916 flags
|= EDIT_MSG
| VERIFY_MSG
;
1917 else if (is_fixup(command
)) {
1918 if (update_squash_messages(r
, command
, commit
, opts
))
1922 msg_file
= rebase_path_squash_msg();
1923 else if (file_exists(rebase_path_fixup_msg())) {
1924 flags
|= CLEANUP_MSG
;
1925 msg_file
= rebase_path_fixup_msg();
1927 const char *dest
= git_path_squash_msg(r
);
1929 if (copy_file(dest
, rebase_path_squash_msg(), 0666))
1930 return error(_("could not rename '%s' to '%s'"),
1931 rebase_path_squash_msg(), dest
);
1932 unlink(git_path_merge_msg(r
));
1938 if (opts
->signoff
&& !is_fixup(command
))
1939 append_signoff(&msgbuf
, 0, 0);
1941 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
1943 else if (!opts
->strategy
|| !strcmp(opts
->strategy
, "recursive") || command
== TODO_REVERT
) {
1944 res
= do_recursive_merge(r
, base
, next
, base_label
, next_label
,
1945 &head
, &msgbuf
, opts
);
1949 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
1950 git_path_merge_msg(r
), 0);
1952 struct commit_list
*common
= NULL
;
1953 struct commit_list
*remotes
= NULL
;
1955 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
1956 git_path_merge_msg(r
), 0);
1958 commit_list_insert(base
, &common
);
1959 commit_list_insert(next
, &remotes
);
1960 res
|= try_merge_command(r
, opts
->strategy
,
1961 opts
->xopts_nr
, (const char **)opts
->xopts
,
1962 common
, oid_to_hex(&head
), remotes
);
1963 free_commit_list(common
);
1964 free_commit_list(remotes
);
1966 strbuf_release(&msgbuf
);
1969 * If the merge was clean or if it failed due to conflict, we write
1970 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1971 * However, if the merge did not even start, then we don't want to
1974 if (command
== TODO_PICK
&& !opts
->no_commit
&& (res
== 0 || res
== 1) &&
1975 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
1976 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1978 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
1979 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
1980 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1984 error(command
== TODO_REVERT
1985 ? _("could not revert %s... %s")
1986 : _("could not apply %s... %s"),
1987 short_commit_name(commit
), msg
.subject
);
1988 print_advice(r
, res
== 1, opts
);
1989 repo_rerere(r
, opts
->allow_rerere_auto
);
1993 allow
= allow_empty(r
, opts
, commit
);
1998 flags
|= ALLOW_EMPTY
;
1999 if (!opts
->no_commit
) {
2001 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
2002 res
= do_commit(r
, msg_file
, author
, opts
, flags
);
2004 res
= error(_("unable to parse commit author"));
2007 if (!res
&& final_fixup
) {
2008 unlink(rebase_path_fixup_msg());
2009 unlink(rebase_path_squash_msg());
2010 unlink(rebase_path_current_fixups());
2011 strbuf_reset(&opts
->current_fixups
);
2012 opts
->current_fixup_count
= 0;
2016 free_message(commit
, &msg
);
2018 update_abort_safety_file();
2023 static int prepare_revs(struct replay_opts
*opts
)
2026 * picking (but not reverting) ranges (but not individual revisions)
2027 * should be done in reverse
2029 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
2030 opts
->revs
->reverse
^= 1;
2032 if (prepare_revision_walk(opts
->revs
))
2033 return error(_("revision walk setup failed"));
2038 static int read_and_refresh_cache(struct repository
*r
,
2039 struct replay_opts
*opts
)
2041 struct lock_file index_lock
= LOCK_INIT
;
2042 int index_fd
= repo_hold_locked_index(r
, &index_lock
, 0);
2043 if (repo_read_index(r
) < 0) {
2044 rollback_lock_file(&index_lock
);
2045 return error(_("git %s: failed to read the index"),
2046 _(action_name(opts
)));
2048 refresh_index(r
->index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
2049 if (index_fd
>= 0) {
2050 if (write_locked_index(r
->index
, &index_lock
,
2051 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
2052 return error(_("git %s: failed to refresh the index"),
2053 _(action_name(opts
)));
2059 enum todo_item_flags
{
2060 TODO_EDIT_MERGE_MSG
= 1
2063 void todo_list_release(struct todo_list
*todo_list
)
2065 strbuf_release(&todo_list
->buf
);
2066 FREE_AND_NULL(todo_list
->items
);
2067 todo_list
->nr
= todo_list
->alloc
= 0;
2070 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
2072 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
2073 return todo_list
->items
+ todo_list
->nr
++;
2076 const char *todo_item_get_arg(struct todo_list
*todo_list
,
2077 struct todo_item
*item
)
2079 return todo_list
->buf
.buf
+ item
->arg_offset
;
2082 static int is_command(enum todo_command command
, const char **bol
)
2084 const char *str
= todo_command_info
[command
].str
;
2085 const char nick
= todo_command_info
[command
].c
;
2086 const char *p
= *bol
+ 1;
2088 return skip_prefix(*bol
, str
, bol
) ||
2089 ((nick
&& **bol
== nick
) &&
2090 (*p
== ' ' || *p
== '\t' || *p
== '\n' || *p
== '\r' || !*p
) &&
2094 static int parse_insn_line(struct repository
*r
, struct todo_item
*item
,
2095 const char *buf
, const char *bol
, char *eol
)
2097 struct object_id commit_oid
;
2098 char *end_of_object_name
;
2099 int i
, saved
, status
, padding
;
2104 bol
+= strspn(bol
, " \t");
2106 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
2107 item
->command
= TODO_COMMENT
;
2108 item
->commit
= NULL
;
2109 item
->arg_offset
= bol
- buf
;
2110 item
->arg_len
= eol
- bol
;
2114 for (i
= 0; i
< TODO_COMMENT
; i
++)
2115 if (is_command(i
, &bol
)) {
2119 if (i
>= TODO_COMMENT
)
2122 /* Eat up extra spaces/ tabs before object name */
2123 padding
= strspn(bol
, " \t");
2126 if (item
->command
== TODO_NOOP
|| item
->command
== TODO_BREAK
) {
2128 return error(_("%s does not accept arguments: '%s'"),
2129 command_to_string(item
->command
), bol
);
2130 item
->commit
= NULL
;
2131 item
->arg_offset
= bol
- buf
;
2132 item
->arg_len
= eol
- bol
;
2137 return error(_("missing arguments for %s"),
2138 command_to_string(item
->command
));
2140 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
2141 item
->command
== TODO_RESET
) {
2142 item
->commit
= NULL
;
2143 item
->arg_offset
= bol
- buf
;
2144 item
->arg_len
= (int)(eol
- bol
);
2148 if (item
->command
== TODO_MERGE
) {
2149 if (skip_prefix(bol
, "-C", &bol
))
2150 bol
+= strspn(bol
, " \t");
2151 else if (skip_prefix(bol
, "-c", &bol
)) {
2152 bol
+= strspn(bol
, " \t");
2153 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2155 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2156 item
->commit
= NULL
;
2157 item
->arg_offset
= bol
- buf
;
2158 item
->arg_len
= (int)(eol
- bol
);
2163 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
2164 saved
= *end_of_object_name
;
2165 *end_of_object_name
= '\0';
2166 status
= get_oid(bol
, &commit_oid
);
2167 *end_of_object_name
= saved
;
2169 bol
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2170 item
->arg_offset
= bol
- buf
;
2171 item
->arg_len
= (int)(eol
- bol
);
2174 return error(_("could not parse '%.*s'"),
2175 (int)(end_of_object_name
- bol
), bol
);
2177 item
->commit
= lookup_commit_reference(r
, &commit_oid
);
2178 return !item
->commit
;
2181 int sequencer_get_last_command(struct repository
*r
, enum replay_action
*action
)
2183 const char *todo_file
, *bol
;
2184 struct strbuf buf
= STRBUF_INIT
;
2187 todo_file
= git_path_todo_file();
2188 if (strbuf_read_file(&buf
, todo_file
, 0) < 0) {
2189 if (errno
== ENOENT
|| errno
== ENOTDIR
)
2192 return error_errno("unable to open '%s'", todo_file
);
2194 bol
= buf
.buf
+ strspn(buf
.buf
, " \t\r\n");
2195 if (is_command(TODO_PICK
, &bol
) && (*bol
== ' ' || *bol
== '\t'))
2196 *action
= REPLAY_PICK
;
2197 else if (is_command(TODO_REVERT
, &bol
) &&
2198 (*bol
== ' ' || *bol
== '\t'))
2199 *action
= REPLAY_REVERT
;
2203 strbuf_release(&buf
);
2208 int todo_list_parse_insn_buffer(struct repository
*r
, char *buf
,
2209 struct todo_list
*todo_list
)
2211 struct todo_item
*item
;
2212 char *p
= buf
, *next_p
;
2213 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2215 todo_list
->current
= todo_list
->nr
= 0;
2217 for (i
= 1; *p
; i
++, p
= next_p
) {
2218 char *eol
= strchrnul(p
, '\n');
2220 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2222 if (p
!= eol
&& eol
[-1] == '\r')
2223 eol
--; /* strip Carriage Return */
2225 item
= append_new_todo(todo_list
);
2226 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2227 if (parse_insn_line(r
, item
, buf
, p
, eol
)) {
2228 res
= error(_("invalid line %d: %.*s"),
2229 i
, (int)(eol
- p
), p
);
2230 item
->command
= TODO_COMMENT
+ 1;
2231 item
->arg_offset
= p
- buf
;
2232 item
->arg_len
= (int)(eol
- p
);
2233 item
->commit
= NULL
;
2238 else if (is_fixup(item
->command
))
2239 return error(_("cannot '%s' without a previous commit"),
2240 command_to_string(item
->command
));
2241 else if (!is_noop(item
->command
))
2248 static int count_commands(struct todo_list
*todo_list
)
2252 for (i
= 0; i
< todo_list
->nr
; i
++)
2253 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2259 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2261 return index
< todo_list
->nr
?
2262 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2265 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2267 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2270 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2272 return get_item_line_offset(todo_list
, index
+ 1)
2273 - get_item_line_offset(todo_list
, index
);
2276 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2281 fd
= open(path
, O_RDONLY
);
2283 return error_errno(_("could not open '%s'"), path
);
2284 len
= strbuf_read(sb
, fd
, 0);
2287 return error(_("could not read '%s'."), path
);
2291 static int have_finished_the_last_pick(void)
2293 struct strbuf buf
= STRBUF_INIT
;
2295 const char *todo_path
= git_path_todo_file();
2298 if (strbuf_read_file(&buf
, todo_path
, 0) < 0) {
2299 if (errno
== ENOENT
) {
2302 error_errno("unable to open '%s'", todo_path
);
2306 /* If there is only one line then we are done */
2307 eol
= strchr(buf
.buf
, '\n');
2308 if (!eol
|| !eol
[1])
2311 strbuf_release(&buf
);
2316 void sequencer_post_commit_cleanup(struct repository
*r
, int verbose
)
2318 struct replay_opts opts
= REPLAY_OPTS_INIT
;
2319 int need_cleanup
= 0;
2321 if (file_exists(git_path_cherry_pick_head(r
))) {
2322 if (!unlink(git_path_cherry_pick_head(r
)) && verbose
)
2323 warning(_("cancelling a cherry picking in progress"));
2324 opts
.action
= REPLAY_PICK
;
2328 if (file_exists(git_path_revert_head(r
))) {
2329 if (!unlink(git_path_revert_head(r
)) && verbose
)
2330 warning(_("cancelling a revert in progress"));
2331 opts
.action
= REPLAY_REVERT
;
2338 if (!have_finished_the_last_pick())
2341 sequencer_remove_state(&opts
);
2344 static int read_populate_todo(struct repository
*r
,
2345 struct todo_list
*todo_list
,
2346 struct replay_opts
*opts
)
2349 const char *todo_file
= get_todo_path(opts
);
2352 strbuf_reset(&todo_list
->buf
);
2353 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2356 res
= stat(todo_file
, &st
);
2358 return error(_("could not stat '%s'"), todo_file
);
2359 fill_stat_data(&todo_list
->stat
, &st
);
2361 res
= todo_list_parse_insn_buffer(r
, todo_list
->buf
.buf
, todo_list
);
2363 if (is_rebase_i(opts
))
2364 return error(_("please fix this using "
2365 "'git rebase --edit-todo'."));
2366 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2369 if (!todo_list
->nr
&&
2370 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2371 return error(_("no commits parsed."));
2373 if (!is_rebase_i(opts
)) {
2374 enum todo_command valid
=
2375 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2378 for (i
= 0; i
< todo_list
->nr
; i
++)
2379 if (valid
== todo_list
->items
[i
].command
)
2381 else if (valid
== TODO_PICK
)
2382 return error(_("cannot cherry-pick during a revert."));
2384 return error(_("cannot revert during a cherry-pick."));
2387 if (is_rebase_i(opts
)) {
2388 struct todo_list done
= TODO_LIST_INIT
;
2389 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2391 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2392 !todo_list_parse_insn_buffer(r
, done
.buf
.buf
, &done
))
2393 todo_list
->done_nr
= count_commands(&done
);
2395 todo_list
->done_nr
= 0;
2397 todo_list
->total_nr
= todo_list
->done_nr
2398 + count_commands(todo_list
);
2399 todo_list_release(&done
);
2402 fprintf(f
, "%d\n", todo_list
->total_nr
);
2410 static int git_config_string_dup(char **dest
,
2411 const char *var
, const char *value
)
2414 return config_error_nonbool(var
);
2416 *dest
= xstrdup(value
);
2420 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
2422 struct replay_opts
*opts
= data
;
2427 else if (!strcmp(key
, "options.no-commit"))
2428 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
2429 else if (!strcmp(key
, "options.edit"))
2430 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
2431 else if (!strcmp(key
, "options.allow-empty"))
2433 git_config_bool_or_int(key
, value
, &error_flag
);
2434 else if (!strcmp(key
, "options.allow-empty-message"))
2435 opts
->allow_empty_message
=
2436 git_config_bool_or_int(key
, value
, &error_flag
);
2437 else if (!strcmp(key
, "options.keep-redundant-commits"))
2438 opts
->keep_redundant_commits
=
2439 git_config_bool_or_int(key
, value
, &error_flag
);
2440 else if (!strcmp(key
, "options.signoff"))
2441 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
2442 else if (!strcmp(key
, "options.record-origin"))
2443 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
2444 else if (!strcmp(key
, "options.allow-ff"))
2445 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
2446 else if (!strcmp(key
, "options.mainline"))
2447 opts
->mainline
= git_config_int(key
, value
);
2448 else if (!strcmp(key
, "options.strategy"))
2449 git_config_string_dup(&opts
->strategy
, key
, value
);
2450 else if (!strcmp(key
, "options.gpg-sign"))
2451 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
2452 else if (!strcmp(key
, "options.strategy-option")) {
2453 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
2454 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(value
);
2455 } else if (!strcmp(key
, "options.allow-rerere-auto"))
2456 opts
->allow_rerere_auto
=
2457 git_config_bool_or_int(key
, value
, &error_flag
) ?
2458 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
2459 else if (!strcmp(key
, "options.default-msg-cleanup")) {
2460 opts
->explicit_cleanup
= 1;
2461 opts
->default_msg_cleanup
= get_cleanup_mode(value
, 1);
2463 return error(_("invalid key: %s"), key
);
2466 return error(_("invalid value for %s: %s"), key
, value
);
2471 void parse_strategy_opts(struct replay_opts
*opts
, char *raw_opts
)
2474 char *strategy_opts_string
= raw_opts
;
2476 if (*strategy_opts_string
== ' ')
2477 strategy_opts_string
++;
2479 opts
->xopts_nr
= split_cmdline(strategy_opts_string
,
2480 (const char ***)&opts
->xopts
);
2481 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
2482 const char *arg
= opts
->xopts
[i
];
2484 skip_prefix(arg
, "--", &arg
);
2485 opts
->xopts
[i
] = xstrdup(arg
);
2489 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2492 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2494 opts
->strategy
= strbuf_detach(buf
, NULL
);
2495 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2498 parse_strategy_opts(opts
, buf
->buf
);
2501 static int read_populate_opts(struct replay_opts
*opts
)
2503 if (is_rebase_i(opts
)) {
2504 struct strbuf buf
= STRBUF_INIT
;
2506 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(), 1)) {
2507 if (!starts_with(buf
.buf
, "-S"))
2510 free(opts
->gpg_sign
);
2511 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2516 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(), 1)) {
2517 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2518 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2519 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2520 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2524 if (file_exists(rebase_path_verbose()))
2527 if (file_exists(rebase_path_quiet()))
2530 if (file_exists(rebase_path_signoff())) {
2535 if (file_exists(rebase_path_reschedule_failed_exec()))
2536 opts
->reschedule_failed_exec
= 1;
2538 read_strategy_opts(opts
, &buf
);
2539 strbuf_release(&buf
);
2541 if (read_oneliner(&opts
->current_fixups
,
2542 rebase_path_current_fixups(), 1)) {
2543 const char *p
= opts
->current_fixups
.buf
;
2544 opts
->current_fixup_count
= 1;
2545 while ((p
= strchr(p
, '\n'))) {
2546 opts
->current_fixup_count
++;
2551 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
2552 if (get_oid_hex(buf
.buf
, &opts
->squash_onto
) < 0)
2553 return error(_("unusable squash-onto"));
2554 opts
->have_squash_onto
= 1;
2560 if (!file_exists(git_path_opts_file()))
2563 * The function git_parse_source(), called from git_config_from_file(),
2564 * may die() in case of a syntactically incorrect file. We do not care
2565 * about this case, though, because we wrote that file ourselves, so we
2566 * are pretty certain that it is syntactically correct.
2568 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
2569 return error(_("malformed options sheet: '%s'"),
2570 git_path_opts_file());
2574 static void write_strategy_opts(struct replay_opts
*opts
)
2577 struct strbuf buf
= STRBUF_INIT
;
2579 for (i
= 0; i
< opts
->xopts_nr
; ++i
)
2580 strbuf_addf(&buf
, " --%s", opts
->xopts
[i
]);
2582 write_file(rebase_path_strategy_opts(), "%s\n", buf
.buf
);
2583 strbuf_release(&buf
);
2586 int write_basic_state(struct replay_opts
*opts
, const char *head_name
,
2587 struct commit
*onto
, const char *orig_head
)
2589 const char *quiet
= getenv("GIT_QUIET");
2592 write_file(rebase_path_head_name(), "%s\n", head_name
);
2594 write_file(rebase_path_onto(), "%s\n",
2595 oid_to_hex(&onto
->object
.oid
));
2597 write_file(rebase_path_orig_head(), "%s\n", orig_head
);
2600 write_file(rebase_path_quiet(), "%s\n", quiet
);
2602 write_file(rebase_path_verbose(), "%s", "");
2604 write_file(rebase_path_strategy(), "%s\n", opts
->strategy
);
2605 if (opts
->xopts_nr
> 0)
2606 write_strategy_opts(opts
);
2608 if (opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
)
2609 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2610 else if (opts
->allow_rerere_auto
== RERERE_NOAUTOUPDATE
)
2611 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2614 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts
->gpg_sign
);
2616 write_file(rebase_path_signoff(), "--signoff\n");
2617 if (opts
->reschedule_failed_exec
)
2618 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
2623 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
2624 struct replay_opts
*opts
)
2626 enum todo_command command
= opts
->action
== REPLAY_PICK
?
2627 TODO_PICK
: TODO_REVERT
;
2628 const char *command_string
= todo_command_info
[command
].str
;
2629 struct commit
*commit
;
2631 if (prepare_revs(opts
))
2634 while ((commit
= get_revision(opts
->revs
))) {
2635 struct todo_item
*item
= append_new_todo(todo_list
);
2636 const char *commit_buffer
= get_commit_buffer(commit
, NULL
);
2637 const char *subject
;
2640 item
->command
= command
;
2641 item
->commit
= commit
;
2642 item
->arg_offset
= 0;
2644 item
->offset_in_buf
= todo_list
->buf
.len
;
2645 subject_len
= find_commit_subject(commit_buffer
, &subject
);
2646 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
2647 short_commit_name(commit
), subject_len
, subject
);
2648 unuse_commit_buffer(commit
, commit_buffer
);
2652 return error(_("empty commit set passed"));
2657 static int create_seq_dir(void)
2659 if (file_exists(git_path_seq_dir())) {
2660 error(_("a cherry-pick or revert is already in progress"));
2661 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
2663 } else if (mkdir(git_path_seq_dir(), 0777) < 0)
2664 return error_errno(_("could not create sequencer directory '%s'"),
2665 git_path_seq_dir());
2669 static int save_head(const char *head
)
2671 struct lock_file head_lock
= LOCK_INIT
;
2672 struct strbuf buf
= STRBUF_INIT
;
2676 fd
= hold_lock_file_for_update(&head_lock
, git_path_head_file(), 0);
2678 return error_errno(_("could not lock HEAD"));
2679 strbuf_addf(&buf
, "%s\n", head
);
2680 written
= write_in_full(fd
, buf
.buf
, buf
.len
);
2681 strbuf_release(&buf
);
2683 error_errno(_("could not write to '%s'"), git_path_head_file());
2684 rollback_lock_file(&head_lock
);
2687 if (commit_lock_file(&head_lock
) < 0)
2688 return error(_("failed to finalize '%s'"), git_path_head_file());
2692 static int rollback_is_safe(void)
2694 struct strbuf sb
= STRBUF_INIT
;
2695 struct object_id expected_head
, actual_head
;
2697 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
2699 if (get_oid_hex(sb
.buf
, &expected_head
)) {
2700 strbuf_release(&sb
);
2701 die(_("could not parse %s"), git_path_abort_safety_file());
2703 strbuf_release(&sb
);
2705 else if (errno
== ENOENT
)
2706 oidclr(&expected_head
);
2708 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2710 if (get_oid("HEAD", &actual_head
))
2711 oidclr(&actual_head
);
2713 return oideq(&actual_head
, &expected_head
);
2716 static int reset_for_rollback(const struct object_id
*oid
)
2718 const char *argv
[4]; /* reset --merge <arg> + NULL */
2721 argv
[1] = "--merge";
2722 argv
[2] = oid_to_hex(oid
);
2724 return run_command_v_opt(argv
, RUN_GIT_CMD
);
2727 static int rollback_single_pick(struct repository
*r
)
2729 struct object_id head_oid
;
2731 if (!file_exists(git_path_cherry_pick_head(r
)) &&
2732 !file_exists(git_path_revert_head(r
)))
2733 return error(_("no cherry-pick or revert in progress"));
2734 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
2735 return error(_("cannot resolve HEAD"));
2736 if (is_null_oid(&head_oid
))
2737 return error(_("cannot abort from a branch yet to be born"));
2738 return reset_for_rollback(&head_oid
);
2741 int sequencer_rollback(struct repository
*r
, struct replay_opts
*opts
)
2744 struct object_id oid
;
2745 struct strbuf buf
= STRBUF_INIT
;
2748 f
= fopen(git_path_head_file(), "r");
2749 if (!f
&& errno
== ENOENT
) {
2751 * There is no multiple-cherry-pick in progress.
2752 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2753 * a single-cherry-pick in progress, abort that.
2755 return rollback_single_pick(r
);
2758 return error_errno(_("cannot open '%s'"), git_path_head_file());
2759 if (strbuf_getline_lf(&buf
, f
)) {
2760 error(_("cannot read '%s': %s"), git_path_head_file(),
2761 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
2766 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
2767 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2768 git_path_head_file());
2771 if (is_null_oid(&oid
)) {
2772 error(_("cannot abort from a branch yet to be born"));
2776 if (!rollback_is_safe()) {
2777 /* Do not error, just do not rollback */
2778 warning(_("You seem to have moved HEAD. "
2779 "Not rewinding, check your HEAD!"));
2781 if (reset_for_rollback(&oid
))
2783 strbuf_release(&buf
);
2784 return sequencer_remove_state(opts
);
2786 strbuf_release(&buf
);
2790 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
2792 struct lock_file todo_lock
= LOCK_INIT
;
2793 const char *todo_path
= get_todo_path(opts
);
2794 int next
= todo_list
->current
, offset
, fd
;
2797 * rebase -i writes "git-rebase-todo" without the currently executing
2798 * command, appending it to "done" instead.
2800 if (is_rebase_i(opts
))
2803 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
2805 return error_errno(_("could not lock '%s'"), todo_path
);
2806 offset
= get_item_line_offset(todo_list
, next
);
2807 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
2808 todo_list
->buf
.len
- offset
) < 0)
2809 return error_errno(_("could not write to '%s'"), todo_path
);
2810 if (commit_lock_file(&todo_lock
) < 0)
2811 return error(_("failed to finalize '%s'"), todo_path
);
2813 if (is_rebase_i(opts
) && next
> 0) {
2814 const char *done
= rebase_path_done();
2815 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
2820 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
2821 get_item_line_length(todo_list
, next
- 1))
2823 ret
= error_errno(_("could not write to '%s'"), done
);
2825 ret
= error_errno(_("failed to finalize '%s'"), done
);
2831 static int save_opts(struct replay_opts
*opts
)
2833 const char *opts_file
= git_path_opts_file();
2836 if (opts
->no_commit
)
2837 res
|= git_config_set_in_file_gently(opts_file
,
2838 "options.no-commit", "true");
2840 res
|= git_config_set_in_file_gently(opts_file
,
2841 "options.edit", "true");
2842 if (opts
->allow_empty
)
2843 res
|= git_config_set_in_file_gently(opts_file
,
2844 "options.allow-empty", "true");
2845 if (opts
->allow_empty_message
)
2846 res
|= git_config_set_in_file_gently(opts_file
,
2847 "options.allow-empty-message", "true");
2848 if (opts
->keep_redundant_commits
)
2849 res
|= git_config_set_in_file_gently(opts_file
,
2850 "options.keep-redundant-commits", "true");
2852 res
|= git_config_set_in_file_gently(opts_file
,
2853 "options.signoff", "true");
2854 if (opts
->record_origin
)
2855 res
|= git_config_set_in_file_gently(opts_file
,
2856 "options.record-origin", "true");
2858 res
|= git_config_set_in_file_gently(opts_file
,
2859 "options.allow-ff", "true");
2860 if (opts
->mainline
) {
2861 struct strbuf buf
= STRBUF_INIT
;
2862 strbuf_addf(&buf
, "%d", opts
->mainline
);
2863 res
|= git_config_set_in_file_gently(opts_file
,
2864 "options.mainline", buf
.buf
);
2865 strbuf_release(&buf
);
2868 res
|= git_config_set_in_file_gently(opts_file
,
2869 "options.strategy", opts
->strategy
);
2871 res
|= git_config_set_in_file_gently(opts_file
,
2872 "options.gpg-sign", opts
->gpg_sign
);
2875 for (i
= 0; i
< opts
->xopts_nr
; i
++)
2876 res
|= git_config_set_multivar_in_file_gently(opts_file
,
2877 "options.strategy-option",
2878 opts
->xopts
[i
], "^$", 0);
2880 if (opts
->allow_rerere_auto
)
2881 res
|= git_config_set_in_file_gently(opts_file
,
2882 "options.allow-rerere-auto",
2883 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
2886 if (opts
->explicit_cleanup
)
2887 res
|= git_config_set_in_file_gently(opts_file
,
2888 "options.default-msg-cleanup",
2889 describe_cleanup_mode(opts
->default_msg_cleanup
));
2893 static int make_patch(struct repository
*r
,
2894 struct commit
*commit
,
2895 struct replay_opts
*opts
)
2897 struct strbuf buf
= STRBUF_INIT
;
2898 struct rev_info log_tree_opt
;
2899 const char *subject
, *p
;
2902 p
= short_commit_name(commit
);
2903 if (write_message(p
, strlen(p
), rebase_path_stopped_sha(), 1) < 0)
2905 if (update_ref("rebase", "REBASE_HEAD", &commit
->object
.oid
,
2906 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2907 res
|= error(_("could not update %s"), "REBASE_HEAD");
2909 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
2910 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
2911 repo_init_revisions(r
, &log_tree_opt
, NULL
);
2912 log_tree_opt
.abbrev
= 0;
2913 log_tree_opt
.diff
= 1;
2914 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
2915 log_tree_opt
.disable_stdin
= 1;
2916 log_tree_opt
.no_commit_id
= 1;
2917 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
2918 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
2919 if (!log_tree_opt
.diffopt
.file
)
2920 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
2922 res
|= log_tree_commit(&log_tree_opt
, commit
);
2923 fclose(log_tree_opt
.diffopt
.file
);
2927 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
2928 if (!file_exists(buf
.buf
)) {
2929 const char *commit_buffer
= get_commit_buffer(commit
, NULL
);
2930 find_commit_subject(commit_buffer
, &subject
);
2931 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
2932 unuse_commit_buffer(commit
, commit_buffer
);
2934 strbuf_release(&buf
);
2939 static int intend_to_amend(void)
2941 struct object_id head
;
2944 if (get_oid("HEAD", &head
))
2945 return error(_("cannot read HEAD"));
2947 p
= oid_to_hex(&head
);
2948 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
2951 static int error_with_patch(struct repository
*r
,
2952 struct commit
*commit
,
2953 const char *subject
, int subject_len
,
2954 struct replay_opts
*opts
,
2955 int exit_code
, int to_amend
)
2958 if (make_patch(r
, commit
, opts
))
2960 } else if (copy_file(rebase_path_message(),
2961 git_path_merge_msg(r
), 0666))
2962 return error(_("unable to copy '%s' to '%s'"),
2963 git_path_merge_msg(r
), rebase_path_message());
2966 if (intend_to_amend())
2970 _("You can amend the commit now, with\n"
2972 " git commit --amend %s\n"
2974 "Once you are satisfied with your changes, run\n"
2976 " git rebase --continue\n"),
2977 gpg_sign_opt_quoted(opts
));
2978 } else if (exit_code
) {
2980 fprintf_ln(stderr
, _("Could not apply %s... %.*s"),
2981 short_commit_name(commit
), subject_len
, subject
);
2984 * We don't have the hash of the parent so
2985 * just print the line from the todo file.
2987 fprintf_ln(stderr
, _("Could not merge %.*s"),
2988 subject_len
, subject
);
2994 static int error_failed_squash(struct repository
*r
,
2995 struct commit
*commit
,
2996 struct replay_opts
*opts
,
2998 const char *subject
)
3000 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3001 return error(_("could not copy '%s' to '%s'"),
3002 rebase_path_squash_msg(), rebase_path_message());
3003 unlink(git_path_merge_msg(r
));
3004 if (copy_file(git_path_merge_msg(r
), rebase_path_message(), 0666))
3005 return error(_("could not copy '%s' to '%s'"),
3006 rebase_path_message(),
3007 git_path_merge_msg(r
));
3008 return error_with_patch(r
, commit
, subject
, subject_len
, opts
, 1, 0);
3011 static int do_exec(struct repository
*r
, const char *command_line
)
3013 struct argv_array child_env
= ARGV_ARRAY_INIT
;
3014 const char *child_argv
[] = { NULL
, NULL
};
3017 fprintf(stderr
, "Executing: %s\n", command_line
);
3018 child_argv
[0] = command_line
;
3019 argv_array_pushf(&child_env
, "GIT_DIR=%s", absolute_path(get_git_dir()));
3020 argv_array_pushf(&child_env
, "GIT_WORK_TREE=%s",
3021 absolute_path(get_git_work_tree()));
3022 status
= run_command_v_opt_cd_env(child_argv
, RUN_USING_SHELL
, NULL
,
3025 /* force re-reading of the cache */
3026 if (discard_index(r
->index
) < 0 || repo_read_index(r
) < 0)
3027 return error(_("could not read index"));
3029 dirty
= require_clean_work_tree(r
, "rebase", NULL
, 1, 1);
3032 warning(_("execution failed: %s\n%s"
3033 "You can fix the problem, and then run\n"
3035 " git rebase --continue\n"
3038 dirty
? N_("and made changes to the index and/or the "
3039 "working tree\n") : "");
3041 /* command not found */
3044 warning(_("execution succeeded: %s\nbut "
3045 "left changes to the index and/or the working tree\n"
3046 "Commit or stash your changes, and then run\n"
3048 " git rebase --continue\n"
3049 "\n"), command_line
);
3053 argv_array_clear(&child_env
);
3058 static int safe_append(const char *filename
, const char *fmt
, ...)
3061 struct lock_file lock
= LOCK_INIT
;
3062 int fd
= hold_lock_file_for_update(&lock
, filename
,
3063 LOCK_REPORT_ON_ERROR
);
3064 struct strbuf buf
= STRBUF_INIT
;
3069 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
3070 error_errno(_("could not read '%s'"), filename
);
3071 rollback_lock_file(&lock
);
3074 strbuf_complete(&buf
, '\n');
3076 strbuf_vaddf(&buf
, fmt
, ap
);
3079 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
3080 error_errno(_("could not write to '%s'"), filename
);
3081 strbuf_release(&buf
);
3082 rollback_lock_file(&lock
);
3085 if (commit_lock_file(&lock
) < 0) {
3086 strbuf_release(&buf
);
3087 rollback_lock_file(&lock
);
3088 return error(_("failed to finalize '%s'"), filename
);
3091 strbuf_release(&buf
);
3095 static int do_label(struct repository
*r
, const char *name
, int len
)
3097 struct ref_store
*refs
= get_main_ref_store(r
);
3098 struct ref_transaction
*transaction
;
3099 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
3100 struct strbuf msg
= STRBUF_INIT
;
3102 struct object_id head_oid
;
3104 if (len
== 1 && *name
== '#')
3105 return error(_("illegal label name: '%.*s'"), len
, name
);
3107 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3108 strbuf_addf(&msg
, "rebase -i (label) '%.*s'", len
, name
);
3110 transaction
= ref_store_transaction_begin(refs
, &err
);
3112 error("%s", err
.buf
);
3114 } else if (get_oid("HEAD", &head_oid
)) {
3115 error(_("could not read HEAD"));
3117 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
3118 NULL
, 0, msg
.buf
, &err
) < 0 ||
3119 ref_transaction_commit(transaction
, &err
)) {
3120 error("%s", err
.buf
);
3123 ref_transaction_free(transaction
);
3124 strbuf_release(&err
);
3125 strbuf_release(&msg
);
3128 ret
= safe_append(rebase_path_refs_to_delete(),
3129 "%s\n", ref_name
.buf
);
3130 strbuf_release(&ref_name
);
3135 static const char *reflog_message(struct replay_opts
*opts
,
3136 const char *sub_action
, const char *fmt
, ...);
3138 static int do_reset(struct repository
*r
,
3139 const char *name
, int len
,
3140 struct replay_opts
*opts
)
3142 struct strbuf ref_name
= STRBUF_INIT
;
3143 struct object_id oid
;
3144 struct lock_file lock
= LOCK_INIT
;
3145 struct tree_desc desc
;
3147 struct unpack_trees_options unpack_tree_opts
;
3150 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0)
3153 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
3154 if (!opts
->have_squash_onto
) {
3156 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
3157 NULL
, &opts
->squash_onto
,
3159 return error(_("writing fake root commit"));
3160 opts
->have_squash_onto
= 1;
3161 hex
= oid_to_hex(&opts
->squash_onto
);
3162 if (write_message(hex
, strlen(hex
),
3163 rebase_path_squash_onto(), 0))
3164 return error(_("writing squash-onto"));
3166 oidcpy(&oid
, &opts
->squash_onto
);
3170 /* Determine the length of the label */
3171 for (i
= 0; i
< len
; i
++)
3172 if (isspace(name
[i
]))
3176 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3177 if (get_oid(ref_name
.buf
, &oid
) &&
3178 get_oid(ref_name
.buf
+ strlen("refs/rewritten/"), &oid
)) {
3179 error(_("could not read '%s'"), ref_name
.buf
);
3180 rollback_lock_file(&lock
);
3181 strbuf_release(&ref_name
);
3186 memset(&unpack_tree_opts
, 0, sizeof(unpack_tree_opts
));
3187 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
3188 unpack_tree_opts
.head_idx
= 1;
3189 unpack_tree_opts
.src_index
= r
->index
;
3190 unpack_tree_opts
.dst_index
= r
->index
;
3191 unpack_tree_opts
.fn
= oneway_merge
;
3192 unpack_tree_opts
.merge
= 1;
3193 unpack_tree_opts
.update
= 1;
3195 if (repo_read_index_unmerged(r
)) {
3196 rollback_lock_file(&lock
);
3197 strbuf_release(&ref_name
);
3198 return error_resolve_conflict(_(action_name(opts
)));
3201 if (!fill_tree_descriptor(&desc
, &oid
)) {
3202 error(_("failed to find tree of %s"), oid_to_hex(&oid
));
3203 rollback_lock_file(&lock
);
3204 free((void *)desc
.buffer
);
3205 strbuf_release(&ref_name
);
3209 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
3210 rollback_lock_file(&lock
);
3211 free((void *)desc
.buffer
);
3212 strbuf_release(&ref_name
);
3216 tree
= parse_tree_indirect(&oid
);
3217 prime_cache_tree(r
, r
->index
, tree
);
3219 if (write_locked_index(r
->index
, &lock
, COMMIT_LOCK
) < 0)
3220 ret
= error(_("could not write index"));
3221 free((void *)desc
.buffer
);
3224 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
3225 len
, name
), "HEAD", &oid
,
3226 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3228 strbuf_release(&ref_name
);
3232 static struct commit
*lookup_label(const char *label
, int len
,
3235 struct commit
*commit
;
3238 strbuf_addf(buf
, "refs/rewritten/%.*s", len
, label
);
3239 commit
= lookup_commit_reference_by_name(buf
->buf
);
3241 /* fall back to non-rewritten ref or commit */
3242 strbuf_splice(buf
, 0, strlen("refs/rewritten/"), "", 0);
3243 commit
= lookup_commit_reference_by_name(buf
->buf
);
3247 error(_("could not resolve '%s'"), buf
->buf
);
3252 static int do_merge(struct repository
*r
,
3253 struct commit
*commit
,
3254 const char *arg
, int arg_len
,
3255 int flags
, struct replay_opts
*opts
)
3257 int run_commit_flags
= (flags
& TODO_EDIT_MERGE_MSG
) ?
3258 EDIT_MSG
| VERIFY_MSG
: 0;
3259 struct strbuf ref_name
= STRBUF_INIT
;
3260 struct commit
*head_commit
, *merge_commit
, *i
;
3261 struct commit_list
*bases
, *j
, *reversed
= NULL
;
3262 struct commit_list
*to_merge
= NULL
, **tail
= &to_merge
;
3263 struct merge_options o
;
3264 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
, k
;
3265 static struct lock_file lock
;
3268 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0) {
3273 head_commit
= lookup_commit_reference_by_name("HEAD");
3275 ret
= error(_("cannot merge without a current revision"));
3280 * For octopus merges, the arg starts with the list of revisions to be
3281 * merged. The list is optionally followed by '#' and the oneline.
3283 merge_arg_len
= oneline_offset
= arg_len
;
3284 for (p
= arg
; p
- arg
< arg_len
; p
+= strspn(p
, " \t\n")) {
3287 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
3288 p
+= 1 + strspn(p
+ 1, " \t\n");
3289 oneline_offset
= p
- arg
;
3292 k
= strcspn(p
, " \t\n");
3295 merge_commit
= lookup_label(p
, k
, &ref_name
);
3296 if (!merge_commit
) {
3297 ret
= error(_("unable to parse '%.*s'"), k
, p
);
3300 tail
= &commit_list_insert(merge_commit
, tail
)->next
;
3302 merge_arg_len
= p
- arg
;
3306 ret
= error(_("nothing to merge: '%.*s'"), arg_len
, arg
);
3310 if (opts
->have_squash_onto
&&
3311 oideq(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
3313 * When the user tells us to "merge" something into a
3314 * "[new root]", let's simply fast-forward to the merge head.
3316 rollback_lock_file(&lock
);
3318 ret
= error(_("octopus merge cannot be executed on "
3319 "top of a [new root]"));
3321 ret
= fast_forward_to(r
, &to_merge
->item
->object
.oid
,
3322 &head_commit
->object
.oid
, 0,
3328 const char *message
= get_commit_buffer(commit
, NULL
);
3333 ret
= error(_("could not get commit message of '%s'"),
3334 oid_to_hex(&commit
->object
.oid
));
3337 write_author_script(message
);
3338 find_commit_subject(message
, &body
);
3340 ret
= write_message(body
, len
, git_path_merge_msg(r
), 0);
3341 unuse_commit_buffer(commit
, message
);
3343 error_errno(_("could not write '%s'"),
3344 git_path_merge_msg(r
));
3348 struct strbuf buf
= STRBUF_INIT
;
3351 strbuf_addf(&buf
, "author %s", git_author_info(0));
3352 write_author_script(buf
.buf
);
3355 if (oneline_offset
< arg_len
) {
3356 p
= arg
+ oneline_offset
;
3357 len
= arg_len
- oneline_offset
;
3359 strbuf_addf(&buf
, "Merge %s '%.*s'",
3360 to_merge
->next
? "branches" : "branch",
3361 merge_arg_len
, arg
);
3366 ret
= write_message(p
, len
, git_path_merge_msg(r
), 0);
3367 strbuf_release(&buf
);
3369 error_errno(_("could not write '%s'"),
3370 git_path_merge_msg(r
));
3376 * If HEAD is not identical to the first parent of the original merge
3377 * commit, we cannot fast-forward.
3379 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
3380 oideq(&commit
->parents
->item
->object
.oid
,
3381 &head_commit
->object
.oid
);
3384 * If any merge head is different from the original one, we cannot
3387 if (can_fast_forward
) {
3388 struct commit_list
*p
= commit
->parents
->next
;
3390 for (j
= to_merge
; j
&& p
; j
= j
->next
, p
= p
->next
)
3391 if (!oideq(&j
->item
->object
.oid
,
3392 &p
->item
->object
.oid
)) {
3393 can_fast_forward
= 0;
3397 * If the number of merge heads differs from the original merge
3398 * commit, we cannot fast-forward.
3401 can_fast_forward
= 0;
3404 if (can_fast_forward
) {
3405 rollback_lock_file(&lock
);
3406 ret
= fast_forward_to(r
, &commit
->object
.oid
,
3407 &head_commit
->object
.oid
, 0, opts
);
3408 if (flags
& TODO_EDIT_MERGE_MSG
) {
3409 run_commit_flags
|= AMEND_MSG
;
3410 goto fast_forward_edit
;
3415 if (to_merge
->next
) {
3417 struct child_process cmd
= CHILD_PROCESS_INIT
;
3419 if (read_env_script(&cmd
.env_array
)) {
3420 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
3422 ret
= error(_(staged_changes_advice
), gpg_opt
, gpg_opt
);
3427 argv_array_push(&cmd
.args
, "merge");
3428 argv_array_push(&cmd
.args
, "-s");
3429 argv_array_push(&cmd
.args
, "octopus");
3430 argv_array_push(&cmd
.args
, "--no-edit");
3431 argv_array_push(&cmd
.args
, "--no-ff");
3432 argv_array_push(&cmd
.args
, "--no-log");
3433 argv_array_push(&cmd
.args
, "--no-stat");
3434 argv_array_push(&cmd
.args
, "-F");
3435 argv_array_push(&cmd
.args
, git_path_merge_msg(r
));
3437 argv_array_push(&cmd
.args
, opts
->gpg_sign
);
3439 /* Add the tips to be merged */
3440 for (j
= to_merge
; j
; j
= j
->next
)
3441 argv_array_push(&cmd
.args
,
3442 oid_to_hex(&j
->item
->object
.oid
));
3444 strbuf_release(&ref_name
);
3445 unlink(git_path_cherry_pick_head(r
));
3446 rollback_lock_file(&lock
);
3448 rollback_lock_file(&lock
);
3449 ret
= run_command(&cmd
);
3451 /* force re-reading of the cache */
3452 if (!ret
&& (discard_index(r
->index
) < 0 ||
3453 repo_read_index(r
) < 0))
3454 ret
= error(_("could not read index"));
3458 merge_commit
= to_merge
->item
;
3459 bases
= get_merge_bases(head_commit
, merge_commit
);
3460 if (bases
&& oideq(&merge_commit
->object
.oid
,
3461 &bases
->item
->object
.oid
)) {
3463 /* skip merging an ancestor of HEAD */
3467 write_message(oid_to_hex(&merge_commit
->object
.oid
), GIT_SHA1_HEXSZ
,
3468 git_path_merge_head(r
), 0);
3469 write_message("no-ff", 5, git_path_merge_mode(r
), 0);
3471 for (j
= bases
; j
; j
= j
->next
)
3472 commit_list_insert(j
->item
, &reversed
);
3473 free_commit_list(bases
);
3476 init_merge_options(&o
, r
);
3478 o
.branch2
= ref_name
.buf
;
3479 o
.buffer_output
= 2;
3481 ret
= merge_recursive(&o
, head_commit
, merge_commit
, reversed
, &i
);
3483 fputs(o
.obuf
.buf
, stdout
);
3484 strbuf_release(&o
.obuf
);
3486 error(_("could not even attempt to merge '%.*s'"),
3487 merge_arg_len
, arg
);
3491 * The return value of merge_recursive() is 1 on clean, and 0 on
3494 * Let's reverse that, so that do_merge() returns 0 upon success and
3495 * 1 upon failed merge (keeping the return value -1 for the cases where
3496 * we will want to reschedule the `merge` command).
3500 if (r
->index
->cache_changed
&&
3501 write_locked_index(r
->index
, &lock
, COMMIT_LOCK
)) {
3502 ret
= error(_("merge: Unable to write new index file"));
3506 rollback_lock_file(&lock
);
3508 repo_rerere(r
, opts
->allow_rerere_auto
);
3511 * In case of problems, we now want to return a positive
3512 * value (a negative one would indicate that the `merge`
3513 * 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
);
3718 if (save_todo(todo_list
, opts
))
3720 if (is_rebase_i(opts
)) {
3721 if (item
->command
!= TODO_COMMENT
) {
3722 FILE *f
= fopen(rebase_path_msgnum(), "w");
3724 todo_list
->done_nr
++;
3727 fprintf(f
, "%d\n", todo_list
->done_nr
);
3731 fprintf(stderr
, "Rebasing (%d/%d)%s",
3733 todo_list
->total_nr
,
3734 opts
->verbose
? "\n" : "\r");
3736 unlink(rebase_path_message());
3737 unlink(rebase_path_author_script());
3738 unlink(rebase_path_stopped_sha());
3739 unlink(rebase_path_amend());
3740 unlink(git_path_merge_head(the_repository
));
3741 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
3743 if (item
->command
== TODO_BREAK
) {
3746 return stopped_at_head(r
);
3749 if (item
->command
<= TODO_SQUASH
) {
3750 if (is_rebase_i(opts
))
3751 setenv("GIT_REFLOG_ACTION", reflog_message(opts
,
3752 command_to_string(item
->command
), NULL
),
3754 res
= do_pick_commit(r
, item
->command
, item
->commit
,
3755 opts
, is_final_fixup(todo_list
));
3756 if (is_rebase_i(opts
) && res
< 0) {
3758 advise(_(rescheduled_advice
),
3759 get_item_line_length(todo_list
,
3760 todo_list
->current
),
3761 get_item_line(todo_list
,
3762 todo_list
->current
));
3763 todo_list
->current
--;
3764 if (save_todo(todo_list
, opts
))
3767 if (item
->command
== TODO_EDIT
) {
3768 struct commit
*commit
= item
->commit
;
3773 _("Stopped at %s... %.*s\n"),
3774 short_commit_name(commit
),
3775 item
->arg_len
, arg
);
3777 return error_with_patch(r
, commit
,
3778 arg
, item
->arg_len
, opts
, res
, !res
);
3780 if (is_rebase_i(opts
) && !res
)
3781 record_in_rewritten(&item
->commit
->object
.oid
,
3782 peek_command(todo_list
, 1));
3783 if (res
&& is_fixup(item
->command
)) {
3786 return error_failed_squash(r
, item
->commit
, opts
,
3787 item
->arg_len
, arg
);
3788 } else if (res
&& is_rebase_i(opts
) && item
->commit
) {
3790 struct object_id oid
;
3793 * If we are rewording and have either
3794 * fast-forwarded already, or are about to
3795 * create a new root commit, we want to amend,
3796 * otherwise we do not.
3798 if (item
->command
== TODO_REWORD
&&
3799 !get_oid("HEAD", &oid
) &&
3800 (oideq(&item
->commit
->object
.oid
, &oid
) ||
3801 (opts
->have_squash_onto
&&
3802 oideq(&opts
->squash_onto
, &oid
))))
3805 return res
| error_with_patch(r
, item
->commit
,
3806 arg
, item
->arg_len
, opts
,
3809 } else if (item
->command
== TODO_EXEC
) {
3810 char *end_of_arg
= (char *)(arg
+ item
->arg_len
);
3811 int saved
= *end_of_arg
;
3817 res
= do_exec(r
, arg
);
3818 *end_of_arg
= saved
;
3821 if (opts
->reschedule_failed_exec
)
3823 } else if (stat(get_todo_path(opts
), &st
))
3824 res
= error_errno(_("could not stat '%s'"),
3825 get_todo_path(opts
));
3826 else if (match_stat_data(&todo_list
->stat
, &st
)) {
3827 /* Reread the todo file if it has changed. */
3828 todo_list_release(todo_list
);
3829 if (read_populate_todo(r
, todo_list
, opts
))
3830 res
= -1; /* message was printed */
3831 /* `current` will be incremented below */
3832 todo_list
->current
= -1;
3834 } else if (item
->command
== TODO_LABEL
) {
3835 if ((res
= do_label(r
, arg
, item
->arg_len
)))
3837 } else if (item
->command
== TODO_RESET
) {
3838 if ((res
= do_reset(r
, arg
, item
->arg_len
, opts
)))
3840 } else if (item
->command
== TODO_MERGE
) {
3841 if ((res
= do_merge(r
, item
->commit
,
3843 item
->flags
, opts
)) < 0)
3845 else if (item
->commit
)
3846 record_in_rewritten(&item
->commit
->object
.oid
,
3847 peek_command(todo_list
, 1));
3849 /* failed with merge conflicts */
3850 return error_with_patch(r
, item
->commit
,
3853 } else if (!is_noop(item
->command
))
3854 return error(_("unknown command %d"), item
->command
);
3857 advise(_(rescheduled_advice
),
3858 get_item_line_length(todo_list
,
3859 todo_list
->current
),
3860 get_item_line(todo_list
, todo_list
->current
));
3861 todo_list
->current
--;
3862 if (save_todo(todo_list
, opts
))
3865 return error_with_patch(r
,
3871 todo_list
->current
++;
3876 if (is_rebase_i(opts
)) {
3877 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
3880 /* Stopped in the middle, as planned? */
3881 if (todo_list
->current
< todo_list
->nr
)
3884 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
3885 starts_with(head_ref
.buf
, "refs/")) {
3887 struct object_id head
, orig
;
3890 if (get_oid("HEAD", &head
)) {
3891 res
= error(_("cannot read HEAD"));
3893 strbuf_release(&head_ref
);
3894 strbuf_release(&buf
);
3897 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
3898 get_oid_hex(buf
.buf
, &orig
)) {
3899 res
= error(_("could not read orig-head"));
3900 goto cleanup_head_ref
;
3903 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
3904 res
= error(_("could not read 'onto'"));
3905 goto cleanup_head_ref
;
3907 msg
= reflog_message(opts
, "finish", "%s onto %s",
3908 head_ref
.buf
, buf
.buf
);
3909 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
3910 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
3911 res
= error(_("could not update %s"),
3913 goto cleanup_head_ref
;
3915 msg
= reflog_message(opts
, "finish", "returning to %s",
3917 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
3918 res
= error(_("could not update HEAD to %s"),
3920 goto cleanup_head_ref
;
3925 if (opts
->verbose
) {
3926 struct rev_info log_tree_opt
;
3927 struct object_id orig
, head
;
3929 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3930 repo_init_revisions(r
, &log_tree_opt
, NULL
);
3931 log_tree_opt
.diff
= 1;
3932 log_tree_opt
.diffopt
.output_format
=
3933 DIFF_FORMAT_DIFFSTAT
;
3934 log_tree_opt
.disable_stdin
= 1;
3936 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
3937 !get_oid(buf
.buf
, &orig
) &&
3938 !get_oid("HEAD", &head
)) {
3939 diff_tree_oid(&orig
, &head
, "",
3940 &log_tree_opt
.diffopt
);
3941 log_tree_diff_flush(&log_tree_opt
);
3944 flush_rewritten_pending();
3945 if (!stat(rebase_path_rewritten_list(), &st
) &&
3947 struct child_process child
= CHILD_PROCESS_INIT
;
3948 const char *post_rewrite_hook
=
3949 find_hook("post-rewrite");
3951 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
3953 argv_array_push(&child
.args
, "notes");
3954 argv_array_push(&child
.args
, "copy");
3955 argv_array_push(&child
.args
, "--for-rewrite=rebase");
3956 /* we don't care if this copying failed */
3957 run_command(&child
);
3959 if (post_rewrite_hook
) {
3960 struct child_process hook
= CHILD_PROCESS_INIT
;
3962 hook
.in
= open(rebase_path_rewritten_list(),
3964 hook
.stdout_to_stderr
= 1;
3965 hook
.trace2_hook_name
= "post-rewrite";
3966 argv_array_push(&hook
.args
, post_rewrite_hook
);
3967 argv_array_push(&hook
.args
, "rebase");
3968 /* we don't care if this hook failed */
3972 apply_autostash(opts
);
3978 "Successfully rebased and updated %s.\n",
3982 strbuf_release(&buf
);
3983 strbuf_release(&head_ref
);
3987 * Sequence of picks finished successfully; cleanup by
3988 * removing the .git/sequencer directory
3990 return sequencer_remove_state(opts
);
3993 static int continue_single_pick(struct repository
*r
)
3995 const char *argv
[] = { "commit", NULL
};
3997 if (!file_exists(git_path_cherry_pick_head(r
)) &&
3998 !file_exists(git_path_revert_head(r
)))
3999 return error(_("no cherry-pick or revert in progress"));
4000 return run_command_v_opt(argv
, RUN_GIT_CMD
);
4003 static int commit_staged_changes(struct repository
*r
,
4004 struct replay_opts
*opts
,
4005 struct todo_list
*todo_list
)
4007 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
4008 unsigned int final_fixup
= 0, is_clean
;
4010 if (has_unstaged_changes(r
, 1))
4011 return error(_("cannot rebase: You have unstaged changes."));
4013 is_clean
= !has_uncommitted_changes(r
, 0);
4015 if (file_exists(rebase_path_amend())) {
4016 struct strbuf rev
= STRBUF_INIT
;
4017 struct object_id head
, to_amend
;
4019 if (get_oid("HEAD", &head
))
4020 return error(_("cannot amend non-existing commit"));
4021 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
4022 return error(_("invalid file: '%s'"), rebase_path_amend());
4023 if (get_oid_hex(rev
.buf
, &to_amend
))
4024 return error(_("invalid contents: '%s'"),
4025 rebase_path_amend());
4026 if (!is_clean
&& !oideq(&head
, &to_amend
))
4027 return error(_("\nYou have uncommitted changes in your "
4028 "working tree. Please, commit them\n"
4029 "first and then run 'git rebase "
4030 "--continue' again."));
4032 * When skipping a failed fixup/squash, we need to edit the
4033 * commit message, the current fixup list and count, and if it
4034 * was the last fixup/squash in the chain, we need to clean up
4035 * the commit message and if there was a squash, let the user
4038 if (!is_clean
|| !opts
->current_fixup_count
)
4039 ; /* this is not the final fixup */
4040 else if (!oideq(&head
, &to_amend
) ||
4041 !file_exists(rebase_path_stopped_sha())) {
4042 /* was a final fixup or squash done manually? */
4043 if (!is_fixup(peek_command(todo_list
, 0))) {
4044 unlink(rebase_path_fixup_msg());
4045 unlink(rebase_path_squash_msg());
4046 unlink(rebase_path_current_fixups());
4047 strbuf_reset(&opts
->current_fixups
);
4048 opts
->current_fixup_count
= 0;
4051 /* we are in a fixup/squash chain */
4052 const char *p
= opts
->current_fixups
.buf
;
4053 int len
= opts
->current_fixups
.len
;
4055 opts
->current_fixup_count
--;
4057 BUG("Incorrect current_fixups:\n%s", p
);
4058 while (len
&& p
[len
- 1] != '\n')
4060 strbuf_setlen(&opts
->current_fixups
, len
);
4061 if (write_message(p
, len
, rebase_path_current_fixups(),
4063 return error(_("could not write file: '%s'"),
4064 rebase_path_current_fixups());
4067 * If a fixup/squash in a fixup/squash chain failed, the
4068 * commit message is already correct, no need to commit
4071 * Only if it is the final command in the fixup/squash
4072 * chain, and only if the chain is longer than a single
4073 * fixup/squash command (which was just skipped), do we
4074 * actually need to re-commit with a cleaned up commit
4077 if (opts
->current_fixup_count
> 0 &&
4078 !is_fixup(peek_command(todo_list
, 0))) {
4081 * If there was not a single "squash" in the
4082 * chain, we only need to clean up the commit
4083 * message, no need to bother the user with
4084 * opening the commit message in the editor.
4086 if (!starts_with(p
, "squash ") &&
4087 !strstr(p
, "\nsquash "))
4088 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
4089 } else if (is_fixup(peek_command(todo_list
, 0))) {
4091 * We need to update the squash message to skip
4092 * the latest commit message.
4094 struct commit
*commit
;
4095 const char *path
= rebase_path_squash_msg();
4097 if (parse_head(r
, &commit
) ||
4098 !(p
= get_commit_buffer(commit
, NULL
)) ||
4099 write_message(p
, strlen(p
), path
, 0)) {
4100 unuse_commit_buffer(commit
, p
);
4101 return error(_("could not write file: "
4104 unuse_commit_buffer(commit
, p
);
4108 strbuf_release(&rev
);
4113 const char *cherry_pick_head
= git_path_cherry_pick_head(r
);
4115 if (file_exists(cherry_pick_head
) && unlink(cherry_pick_head
))
4116 return error(_("could not remove CHERRY_PICK_HEAD"));
4121 if (run_git_commit(r
, final_fixup
? NULL
: rebase_path_message(),
4123 return error(_("could not commit staged changes."));
4124 unlink(rebase_path_amend());
4125 unlink(git_path_merge_head(the_repository
));
4127 unlink(rebase_path_fixup_msg());
4128 unlink(rebase_path_squash_msg());
4130 if (opts
->current_fixup_count
> 0) {
4132 * Whether final fixup or not, we just cleaned up the commit
4135 unlink(rebase_path_current_fixups());
4136 strbuf_reset(&opts
->current_fixups
);
4137 opts
->current_fixup_count
= 0;
4142 int sequencer_continue(struct repository
*r
, struct replay_opts
*opts
)
4144 struct todo_list todo_list
= TODO_LIST_INIT
;
4147 if (read_and_refresh_cache(r
, opts
))
4150 if (read_populate_opts(opts
))
4152 if (is_rebase_i(opts
)) {
4153 if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
4154 goto release_todo_list
;
4155 if (commit_staged_changes(r
, opts
, &todo_list
))
4157 } else if (!file_exists(get_todo_path(opts
)))
4158 return continue_single_pick(r
);
4159 else if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
4160 goto release_todo_list
;
4162 if (!is_rebase_i(opts
)) {
4163 /* Verify that the conflict has been resolved */
4164 if (file_exists(git_path_cherry_pick_head(r
)) ||
4165 file_exists(git_path_revert_head(r
))) {
4166 res
= continue_single_pick(r
);
4168 goto release_todo_list
;
4170 if (index_differs_from(r
, "HEAD", NULL
, 0)) {
4171 res
= error_dirty_index(r
, opts
);
4172 goto release_todo_list
;
4174 todo_list
.current
++;
4175 } else if (file_exists(rebase_path_stopped_sha())) {
4176 struct strbuf buf
= STRBUF_INIT
;
4177 struct object_id oid
;
4179 if (read_oneliner(&buf
, rebase_path_stopped_sha(), 1) &&
4180 !get_oid_committish(buf
.buf
, &oid
))
4181 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
4182 strbuf_release(&buf
);
4185 res
= pick_commits(r
, &todo_list
, opts
);
4187 todo_list_release(&todo_list
);
4191 static int single_pick(struct repository
*r
,
4192 struct commit
*cmit
,
4193 struct replay_opts
*opts
)
4195 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
4196 return do_pick_commit(r
, opts
->action
== REPLAY_PICK
?
4197 TODO_PICK
: TODO_REVERT
, cmit
, opts
, 0);
4200 int sequencer_pick_revisions(struct repository
*r
,
4201 struct replay_opts
*opts
)
4203 struct todo_list todo_list
= TODO_LIST_INIT
;
4204 struct object_id oid
;
4208 if (read_and_refresh_cache(r
, opts
))
4211 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
4212 struct object_id oid
;
4213 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
4215 /* This happens when using --stdin. */
4219 if (!get_oid(name
, &oid
)) {
4220 if (!lookup_commit_reference_gently(r
, &oid
, 1)) {
4221 enum object_type type
= oid_object_info(r
,
4224 return error(_("%s: can't cherry-pick a %s"),
4225 name
, type_name(type
));
4228 return error(_("%s: bad revision"), name
);
4232 * If we were called as "git cherry-pick <commit>", just
4233 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4234 * REVERT_HEAD, and don't touch the sequencer state.
4235 * This means it is possible to cherry-pick in the middle
4236 * of a cherry-pick sequence.
4238 if (opts
->revs
->cmdline
.nr
== 1 &&
4239 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
4240 opts
->revs
->no_walk
&&
4241 !opts
->revs
->cmdline
.rev
->flags
) {
4242 struct commit
*cmit
;
4243 if (prepare_revision_walk(opts
->revs
))
4244 return error(_("revision walk setup failed"));
4245 cmit
= get_revision(opts
->revs
);
4247 return error(_("empty commit set passed"));
4248 if (get_revision(opts
->revs
))
4249 BUG("unexpected extra commit from walk");
4250 return single_pick(r
, cmit
, opts
);
4254 * Start a new cherry-pick/ revert sequence; but
4255 * first, make sure that an existing one isn't in
4259 if (walk_revs_populate_todo(&todo_list
, opts
) ||
4260 create_seq_dir() < 0)
4262 if (get_oid("HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
4263 return error(_("can't revert as initial commit"));
4264 if (save_head(oid_to_hex(&oid
)))
4266 if (save_opts(opts
))
4268 update_abort_safety_file();
4269 res
= pick_commits(r
, &todo_list
, opts
);
4270 todo_list_release(&todo_list
);
4274 void append_signoff(struct strbuf
*msgbuf
, size_t ignore_footer
, unsigned flag
)
4276 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
4277 struct strbuf sob
= STRBUF_INIT
;
4280 strbuf_addstr(&sob
, sign_off_header
);
4281 strbuf_addstr(&sob
, fmt_name(WANT_COMMITTER_IDENT
));
4282 strbuf_addch(&sob
, '\n');
4285 strbuf_complete_line(msgbuf
);
4288 * If the whole message buffer is equal to the sob, pretend that we
4289 * found a conforming footer with a matching sob
4291 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
4292 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
4295 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
4298 const char *append_newlines
= NULL
;
4299 size_t len
= msgbuf
->len
- ignore_footer
;
4303 * The buffer is completely empty. Leave foom for
4304 * the title and body to be filled in by the user.
4306 append_newlines
= "\n\n";
4307 } else if (len
== 1) {
4309 * Buffer contains a single newline. Add another
4310 * so that we leave room for the title and body.
4312 append_newlines
= "\n";
4313 } else if (msgbuf
->buf
[len
- 2] != '\n') {
4315 * Buffer ends with a single newline. Add another
4316 * so that there is an empty line between the message
4319 append_newlines
= "\n";
4320 } /* else, the buffer already ends with two newlines. */
4322 if (append_newlines
)
4323 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
4324 append_newlines
, strlen(append_newlines
));
4327 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
4328 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
4331 strbuf_release(&sob
);
4334 struct labels_entry
{
4335 struct hashmap_entry entry
;
4336 char label
[FLEX_ARRAY
];
4339 static int labels_cmp(const void *fndata
, const struct labels_entry
*a
,
4340 const struct labels_entry
*b
, const void *key
)
4342 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
4345 struct string_entry
{
4346 struct oidmap_entry entry
;
4347 char string
[FLEX_ARRAY
];
4350 struct label_state
{
4351 struct oidmap commit2label
;
4352 struct hashmap labels
;
4356 static const char *label_oid(struct object_id
*oid
, const char *label
,
4357 struct label_state
*state
)
4359 struct labels_entry
*labels_entry
;
4360 struct string_entry
*string_entry
;
4361 struct object_id dummy
;
4365 string_entry
= oidmap_get(&state
->commit2label
, oid
);
4367 return string_entry
->string
;
4370 * For "uninteresting" commits, i.e. commits that are not to be
4371 * rebased, and which can therefore not be labeled, we use a unique
4372 * abbreviation of the commit name. This is slightly more complicated
4373 * than calling find_unique_abbrev() because we also need to make
4374 * sure that the abbreviation does not conflict with any other
4377 * We disallow "interesting" commits to be labeled by a string that
4378 * is a valid full-length hash, to ensure that we always can find an
4379 * abbreviation for any uninteresting commit's names that does not
4380 * clash with any other label.
4385 strbuf_reset(&state
->buf
);
4386 strbuf_grow(&state
->buf
, GIT_SHA1_HEXSZ
);
4387 label
= p
= state
->buf
.buf
;
4389 find_unique_abbrev_r(p
, oid
, default_abbrev
);
4392 * We may need to extend the abbreviated hash so that there is
4393 * no conflicting label.
4395 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
4396 size_t i
= strlen(p
) + 1;
4398 oid_to_hex_r(p
, oid
);
4399 for (; i
< GIT_SHA1_HEXSZ
; i
++) {
4402 if (!hashmap_get_from_hash(&state
->labels
,
4408 } else if (((len
= strlen(label
)) == the_hash_algo
->hexsz
&&
4409 !get_oid_hex(label
, &dummy
)) ||
4410 (len
== 1 && *label
== '#') ||
4411 hashmap_get_from_hash(&state
->labels
,
4412 strihash(label
), label
)) {
4414 * If the label already exists, or if the label is a valid full
4415 * OID, or the label is a '#' (which we use as a separator
4416 * between merge heads and oneline), we append a dash and a
4417 * number to make it unique.
4419 struct strbuf
*buf
= &state
->buf
;
4422 strbuf_add(buf
, label
, len
);
4424 for (i
= 2; ; i
++) {
4425 strbuf_setlen(buf
, len
);
4426 strbuf_addf(buf
, "-%d", i
);
4427 if (!hashmap_get_from_hash(&state
->labels
,
4436 FLEX_ALLOC_STR(labels_entry
, label
, label
);
4437 hashmap_entry_init(labels_entry
, strihash(label
));
4438 hashmap_add(&state
->labels
, labels_entry
);
4440 FLEX_ALLOC_STR(string_entry
, string
, label
);
4441 oidcpy(&string_entry
->entry
.oid
, oid
);
4442 oidmap_put(&state
->commit2label
, string_entry
);
4444 return string_entry
->string
;
4447 static int make_script_with_merges(struct pretty_print_context
*pp
,
4448 struct rev_info
*revs
, struct strbuf
*out
,
4451 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
4452 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
4453 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
4454 struct strbuf label
= STRBUF_INIT
;
4455 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
4456 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
4457 struct commit
*commit
;
4458 struct oidmap commit2todo
= OIDMAP_INIT
;
4459 struct string_entry
*entry
;
4460 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
4461 shown
= OIDSET_INIT
;
4462 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
4464 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
4465 const char *cmd_pick
= abbr
? "p" : "pick",
4466 *cmd_label
= abbr
? "l" : "label",
4467 *cmd_reset
= abbr
? "t" : "reset",
4468 *cmd_merge
= abbr
? "m" : "merge";
4470 oidmap_init(&commit2todo
, 0);
4471 oidmap_init(&state
.commit2label
, 0);
4472 hashmap_init(&state
.labels
, (hashmap_cmp_fn
) labels_cmp
, NULL
, 0);
4473 strbuf_init(&state
.buf
, 32);
4475 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
4476 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
4477 FLEX_ALLOC_STR(entry
, string
, "onto");
4478 oidcpy(&entry
->entry
.oid
, oid
);
4479 oidmap_put(&state
.commit2label
, entry
);
4484 * - get onelines for all commits
4485 * - gather all branch tips (i.e. 2nd or later parents of merges)
4486 * - label all branch tips
4488 while ((commit
= get_revision(revs
))) {
4489 struct commit_list
*to_merge
;
4490 const char *p1
, *p2
;
4491 struct object_id
*oid
;
4494 tail
= &commit_list_insert(commit
, tail
)->next
;
4495 oidset_insert(&interesting
, &commit
->object
.oid
);
4497 is_empty
= is_original_commit_empty(commit
);
4498 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
))
4501 strbuf_reset(&oneline
);
4502 pretty_print_commit(pp
, commit
, &oneline
);
4504 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
4506 /* non-merge commit: easy case */
4508 if (!keep_empty
&& is_empty
)
4509 strbuf_addf(&buf
, "%c ", comment_line_char
);
4510 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
4511 oid_to_hex(&commit
->object
.oid
),
4514 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
4515 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
4516 oidmap_put(&commit2todo
, entry
);
4521 /* Create a label */
4522 strbuf_reset(&label
);
4523 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
4524 (p1
= strchr(p1
, '\'')) &&
4525 (p2
= strchr(++p1
, '\'')))
4526 strbuf_add(&label
, p1
, p2
- p1
);
4527 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
4529 (p1
= strstr(p1
, " from ")))
4530 strbuf_addstr(&label
, p1
+ strlen(" from "));
4532 strbuf_addbuf(&label
, &oneline
);
4534 for (p1
= label
.buf
; *p1
; p1
++)
4539 strbuf_addf(&buf
, "%s -C %s",
4540 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
4542 /* label the tips of merged branches */
4543 for (; to_merge
; to_merge
= to_merge
->next
) {
4544 oid
= &to_merge
->item
->object
.oid
;
4545 strbuf_addch(&buf
, ' ');
4547 if (!oidset_contains(&interesting
, oid
)) {
4548 strbuf_addstr(&buf
, label_oid(oid
, NULL
,
4553 tips_tail
= &commit_list_insert(to_merge
->item
,
4556 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
4558 strbuf_addf(&buf
, " # %s", oneline
.buf
);
4560 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
4561 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
4562 oidmap_put(&commit2todo
, entry
);
4567 * - label branch points
4568 * - add HEAD to the branch tips
4570 for (iter
= commits
; iter
; iter
= iter
->next
) {
4571 struct commit_list
*parent
= iter
->item
->parents
;
4572 for (; parent
; parent
= parent
->next
) {
4573 struct object_id
*oid
= &parent
->item
->object
.oid
;
4574 if (!oidset_contains(&interesting
, oid
))
4576 if (oidset_insert(&child_seen
, oid
))
4577 label_oid(oid
, "branch-point", &state
);
4580 /* Add HEAD as implict "tip of branch" */
4582 tips_tail
= &commit_list_insert(iter
->item
,
4587 * Third phase: output the todo list. This is a bit tricky, as we
4588 * want to avoid jumping back and forth between revisions. To
4589 * accomplish that goal, we walk backwards from the branch tips,
4590 * gathering commits not yet shown, reversing the list on the fly,
4591 * then outputting that list (labeling revisions as needed).
4593 strbuf_addf(out
, "%s onto\n", cmd_label
);
4594 for (iter
= tips
; iter
; iter
= iter
->next
) {
4595 struct commit_list
*list
= NULL
, *iter2
;
4597 commit
= iter
->item
;
4598 if (oidset_contains(&shown
, &commit
->object
.oid
))
4600 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
4603 strbuf_addf(out
, "\n%c Branch %s\n", comment_line_char
, entry
->string
);
4605 strbuf_addch(out
, '\n');
4607 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
4608 !oidset_contains(&shown
, &commit
->object
.oid
)) {
4609 commit_list_insert(commit
, &list
);
4610 if (!commit
->parents
) {
4614 commit
= commit
->parents
->item
;
4618 strbuf_addf(out
, "%s %s\n", cmd_reset
,
4619 rebase_cousins
? "onto" : "[new root]");
4621 const char *to
= NULL
;
4623 entry
= oidmap_get(&state
.commit2label
,
4624 &commit
->object
.oid
);
4627 else if (!rebase_cousins
)
4628 to
= label_oid(&commit
->object
.oid
, NULL
,
4631 if (!to
|| !strcmp(to
, "onto"))
4632 strbuf_addf(out
, "%s onto\n", cmd_reset
);
4634 strbuf_reset(&oneline
);
4635 pretty_print_commit(pp
, commit
, &oneline
);
4636 strbuf_addf(out
, "%s %s # %s\n",
4637 cmd_reset
, to
, oneline
.buf
);
4641 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
4642 struct object_id
*oid
= &iter2
->item
->object
.oid
;
4643 entry
= oidmap_get(&commit2todo
, oid
);
4644 /* only show if not already upstream */
4646 strbuf_addf(out
, "%s\n", entry
->string
);
4647 entry
= oidmap_get(&state
.commit2label
, oid
);
4649 strbuf_addf(out
, "%s %s\n",
4650 cmd_label
, entry
->string
);
4651 oidset_insert(&shown
, oid
);
4654 free_commit_list(list
);
4657 free_commit_list(commits
);
4658 free_commit_list(tips
);
4660 strbuf_release(&label
);
4661 strbuf_release(&oneline
);
4662 strbuf_release(&buf
);
4664 oidmap_free(&commit2todo
, 1);
4665 oidmap_free(&state
.commit2label
, 1);
4666 hashmap_free(&state
.labels
, 1);
4667 strbuf_release(&state
.buf
);
4672 int sequencer_make_script(struct repository
*r
, struct strbuf
*out
, int argc
,
4673 const char **argv
, unsigned flags
)
4675 char *format
= NULL
;
4676 struct pretty_print_context pp
= {0};
4677 struct rev_info revs
;
4678 struct commit
*commit
;
4679 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
4680 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
4681 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
4683 repo_init_revisions(r
, &revs
, NULL
);
4684 revs
.verbose_header
= 1;
4686 revs
.max_parents
= 1;
4687 revs
.cherry_mark
= 1;
4690 revs
.right_only
= 1;
4691 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
4692 revs
.topo_order
= 1;
4694 revs
.pretty_given
= 1;
4695 git_config_get_string("rebase.instructionFormat", &format
);
4696 if (!format
|| !*format
) {
4698 format
= xstrdup("%s");
4700 get_commit_format(format
, &revs
);
4702 pp
.fmt
= revs
.commit_format
;
4703 pp
.output_encoding
= get_log_output_encoding();
4705 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1)
4706 return error(_("make_script: unhandled options"));
4708 if (prepare_revision_walk(&revs
) < 0)
4709 return error(_("make_script: error preparing revisions"));
4712 return make_script_with_merges(&pp
, &revs
, out
, flags
);
4714 while ((commit
= get_revision(&revs
))) {
4715 int is_empty
= is_original_commit_empty(commit
);
4717 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
))
4719 if (!keep_empty
&& is_empty
)
4720 strbuf_addf(out
, "%c ", comment_line_char
);
4721 strbuf_addf(out
, "%s %s ", insn
,
4722 oid_to_hex(&commit
->object
.oid
));
4723 pretty_print_commit(&pp
, commit
, out
);
4724 strbuf_addch(out
, '\n');
4730 * Add commands after pick and (series of) squash/fixup commands
4733 void todo_list_add_exec_commands(struct todo_list
*todo_list
,
4734 struct string_list
*commands
)
4736 struct strbuf
*buf
= &todo_list
->buf
;
4737 size_t base_offset
= buf
->len
;
4738 int i
, insert
, nr
= 0, alloc
= 0;
4739 struct todo_item
*items
= NULL
, *base_items
= NULL
;
4741 base_items
= xcalloc(commands
->nr
, sizeof(struct todo_item
));
4742 for (i
= 0; i
< commands
->nr
; i
++) {
4743 size_t command_len
= strlen(commands
->items
[i
].string
);
4745 strbuf_addstr(buf
, commands
->items
[i
].string
);
4746 strbuf_addch(buf
, '\n');
4748 base_items
[i
].command
= TODO_EXEC
;
4749 base_items
[i
].offset_in_buf
= base_offset
;
4750 base_items
[i
].arg_offset
= base_offset
+ strlen("exec ");
4751 base_items
[i
].arg_len
= command_len
- strlen("exec ");
4753 base_offset
+= command_len
+ 1;
4757 * Insert <commands> after every pick. Here, fixup/squash chains
4758 * are considered part of the pick, so we insert the commands *after*
4759 * those chains if there are any.
4761 * As we insert the exec commands immediatly after rearranging
4762 * any fixups and before the user edits the list, a fixup chain
4763 * can never contain comments (any comments are empty picks that
4764 * have been commented out because the user did not specify
4765 * --keep-empty). So, it is safe to insert an exec command
4766 * without looking at the command following a comment.
4769 for (i
= 0; i
< todo_list
->nr
; i
++) {
4770 enum todo_command command
= todo_list
->items
[i
].command
;
4771 if (insert
&& !is_fixup(command
)) {
4772 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
4773 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
4779 ALLOC_GROW(items
, nr
+ 1, alloc
);
4780 items
[nr
++] = todo_list
->items
[i
];
4782 if (command
== TODO_PICK
|| command
== TODO_MERGE
)
4786 /* insert or append final <commands> */
4787 if (insert
|| nr
== todo_list
->nr
) {
4788 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
4789 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
4794 FREE_AND_NULL(todo_list
->items
);
4795 todo_list
->items
= items
;
4797 todo_list
->alloc
= alloc
;
4800 static void todo_list_to_strbuf(struct repository
*r
, struct todo_list
*todo_list
,
4801 struct strbuf
*buf
, int num
, unsigned flags
)
4803 struct todo_item
*item
;
4804 int i
, max
= todo_list
->nr
;
4806 if (num
> 0 && num
< max
)
4809 for (item
= todo_list
->items
, i
= 0; i
< max
; i
++, item
++) {
4810 /* if the item is not a command write it and continue */
4811 if (item
->command
>= TODO_COMMENT
) {
4812 strbuf_addf(buf
, "%.*s\n", item
->arg_len
,
4813 todo_item_get_arg(todo_list
, item
));
4817 /* add command to the buffer */
4818 if (flags
& TODO_LIST_ABBREVIATE_CMDS
)
4819 strbuf_addch(buf
, command_to_char(item
->command
));
4821 strbuf_addstr(buf
, command_to_string(item
->command
));
4825 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
4826 short_commit_name(item
->commit
) :
4827 oid_to_hex(&item
->commit
->object
.oid
);
4829 if (item
->command
== TODO_MERGE
) {
4830 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
4831 strbuf_addstr(buf
, " -c");
4833 strbuf_addstr(buf
, " -C");
4836 strbuf_addf(buf
, " %s", oid
);
4839 /* add all the rest */
4841 strbuf_addch(buf
, '\n');
4843 strbuf_addf(buf
, " %.*s\n", item
->arg_len
,
4844 todo_item_get_arg(todo_list
, item
));
4848 int todo_list_write_to_file(struct repository
*r
, struct todo_list
*todo_list
,
4849 const char *file
, const char *shortrevisions
,
4850 const char *shortonto
, int num
, unsigned flags
)
4853 struct strbuf buf
= STRBUF_INIT
;
4855 todo_list_to_strbuf(r
, todo_list
, &buf
, num
, flags
);
4856 if (flags
& TODO_LIST_APPEND_TODO_HELP
)
4857 append_todo_help(flags
& TODO_LIST_KEEP_EMPTY
, count_commands(todo_list
),
4858 shortrevisions
, shortonto
, &buf
);
4860 res
= write_message(buf
.buf
, buf
.len
, file
, 0);
4861 strbuf_release(&buf
);
4866 static const char edit_todo_list_advice
[] =
4867 N_("You can fix this with 'git rebase --edit-todo' "
4868 "and then run 'git rebase --continue'.\n"
4869 "Or you can abort the rebase with 'git rebase"
4872 int check_todo_list_from_file(struct repository
*r
)
4874 struct todo_list old_todo
= TODO_LIST_INIT
, new_todo
= TODO_LIST_INIT
;
4877 if (strbuf_read_file_or_whine(&new_todo
.buf
, rebase_path_todo()) < 0) {
4882 if (strbuf_read_file_or_whine(&old_todo
.buf
, rebase_path_todo_backup()) < 0) {
4887 res
= todo_list_parse_insn_buffer(r
, old_todo
.buf
.buf
, &old_todo
);
4889 res
= todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
);
4891 res
= todo_list_check(&old_todo
, &new_todo
);
4893 fprintf(stderr
, _(edit_todo_list_advice
));
4895 todo_list_release(&old_todo
);
4896 todo_list_release(&new_todo
);
4901 /* skip picking commits whose parents are unchanged */
4902 static int skip_unnecessary_picks(struct repository
*r
,
4903 struct todo_list
*todo_list
,
4904 struct object_id
*base_oid
)
4906 struct object_id
*parent_oid
;
4909 for (i
= 0; i
< todo_list
->nr
; i
++) {
4910 struct todo_item
*item
= todo_list
->items
+ i
;
4912 if (item
->command
>= TODO_NOOP
)
4914 if (item
->command
!= TODO_PICK
)
4916 if (parse_commit(item
->commit
)) {
4917 return error(_("could not parse commit '%s'"),
4918 oid_to_hex(&item
->commit
->object
.oid
));
4920 if (!item
->commit
->parents
)
4921 break; /* root commit */
4922 if (item
->commit
->parents
->next
)
4923 break; /* merge commit */
4924 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
4925 if (!oideq(parent_oid
, base_oid
))
4927 oidcpy(base_oid
, &item
->commit
->object
.oid
);
4930 const char *done_path
= rebase_path_done();
4932 if (todo_list_write_to_file(r
, todo_list
, done_path
, NULL
, NULL
, i
, 0)) {
4933 error_errno(_("could not write to '%s'"), done_path
);
4937 MOVE_ARRAY(todo_list
->items
, todo_list
->items
+ i
, todo_list
->nr
- i
);
4939 todo_list
->current
= 0;
4941 if (is_fixup(peek_command(todo_list
, 0)))
4942 record_in_rewritten(base_oid
, peek_command(todo_list
, 0));
4948 int complete_action(struct repository
*r
, struct replay_opts
*opts
, unsigned flags
,
4949 const char *shortrevisions
, const char *onto_name
,
4950 struct commit
*onto
, const char *orig_head
,
4951 struct string_list
*commands
, unsigned autosquash
,
4952 struct todo_list
*todo_list
)
4954 const char *shortonto
, *todo_file
= rebase_path_todo();
4955 struct todo_list new_todo
= TODO_LIST_INIT
;
4956 struct strbuf
*buf
= &todo_list
->buf
;
4957 struct object_id oid
= onto
->object
.oid
;
4960 shortonto
= find_unique_abbrev(&oid
, DEFAULT_ABBREV
);
4962 if (buf
->len
== 0) {
4963 struct todo_item
*item
= append_new_todo(todo_list
);
4964 item
->command
= TODO_NOOP
;
4965 item
->commit
= NULL
;
4966 item
->arg_len
= item
->arg_offset
= item
->flags
= item
->offset_in_buf
= 0;
4969 if (autosquash
&& todo_list_rearrange_squash(todo_list
))
4973 todo_list_add_exec_commands(todo_list
, commands
);
4975 if (count_commands(todo_list
) == 0) {
4976 apply_autostash(opts
);
4977 sequencer_remove_state(opts
);
4979 return error(_("nothing to do"));
4982 res
= edit_todo_list(r
, todo_list
, &new_todo
, shortrevisions
,
4986 else if (res
== -2) {
4987 apply_autostash(opts
);
4988 sequencer_remove_state(opts
);
4991 } else if (res
== -3) {
4992 apply_autostash(opts
);
4993 sequencer_remove_state(opts
);
4994 todo_list_release(&new_todo
);
4996 return error(_("nothing to do"));
4999 if (todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
) ||
5000 todo_list_check(todo_list
, &new_todo
)) {
5001 fprintf(stderr
, _(edit_todo_list_advice
));
5002 checkout_onto(r
, opts
, onto_name
, &onto
->object
.oid
, orig_head
);
5003 todo_list_release(&new_todo
);
5008 if (opts
->allow_ff
&& skip_unnecessary_picks(r
, &new_todo
, &oid
)) {
5009 todo_list_release(&new_todo
);
5010 return error(_("could not skip unnecessary pick commands"));
5013 if (todo_list_write_to_file(r
, &new_todo
, todo_file
, NULL
, NULL
, -1,
5014 flags
& ~(TODO_LIST_SHORTEN_IDS
))) {
5015 todo_list_release(&new_todo
);
5016 return error_errno(_("could not write '%s'"), todo_file
);
5019 todo_list_release(&new_todo
);
5021 if (checkout_onto(r
, opts
, onto_name
, &oid
, orig_head
))
5024 if (require_clean_work_tree(r
, "rebase", "", 1, 1))
5027 return sequencer_continue(r
, opts
);
5030 struct subject2item_entry
{
5031 struct hashmap_entry entry
;
5033 char subject
[FLEX_ARRAY
];
5036 static int subject2item_cmp(const void *fndata
,
5037 const struct subject2item_entry
*a
,
5038 const struct subject2item_entry
*b
, const void *key
)
5040 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
5043 define_commit_slab(commit_todo_item
, struct todo_item
*);
5046 * Rearrange the todo list that has both "pick commit-id msg" and "pick
5047 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
5048 * after the former, and change "pick" to "fixup"/"squash".
5050 * Note that if the config has specified a custom instruction format, each log
5051 * message will have to be retrieved from the commit (as the oneline in the
5052 * script cannot be trusted) in order to normalize the autosquash arrangement.
5054 int todo_list_rearrange_squash(struct todo_list
*todo_list
)
5056 struct hashmap subject2item
;
5057 int rearranged
= 0, *next
, *tail
, i
, nr
= 0, alloc
= 0;
5059 struct commit_todo_item commit_todo
;
5060 struct todo_item
*items
= NULL
;
5062 init_commit_todo_item(&commit_todo
);
5064 * The hashmap maps onelines to the respective todo list index.
5066 * If any items need to be rearranged, the next[i] value will indicate
5067 * which item was moved directly after the i'th.
5069 * In that case, last[i] will indicate the index of the latest item to
5070 * be moved to appear after the i'th.
5072 hashmap_init(&subject2item
, (hashmap_cmp_fn
) subject2item_cmp
,
5073 NULL
, todo_list
->nr
);
5074 ALLOC_ARRAY(next
, todo_list
->nr
);
5075 ALLOC_ARRAY(tail
, todo_list
->nr
);
5076 ALLOC_ARRAY(subjects
, todo_list
->nr
);
5077 for (i
= 0; i
< todo_list
->nr
; i
++) {
5078 struct strbuf buf
= STRBUF_INIT
;
5079 struct todo_item
*item
= todo_list
->items
+ i
;
5080 const char *commit_buffer
, *subject
, *p
;
5083 struct subject2item_entry
*entry
;
5085 next
[i
] = tail
[i
] = -1;
5086 if (!item
->commit
|| item
->command
== TODO_DROP
) {
5091 if (is_fixup(item
->command
)) {
5092 clear_commit_todo_item(&commit_todo
);
5093 return error(_("the script was already rearranged."));
5096 *commit_todo_item_at(&commit_todo
, item
->commit
) = item
;
5098 parse_commit(item
->commit
);
5099 commit_buffer
= get_commit_buffer(item
->commit
, NULL
);
5100 find_commit_subject(commit_buffer
, &subject
);
5101 format_subject(&buf
, subject
, " ");
5102 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
5103 unuse_commit_buffer(item
->commit
, commit_buffer
);
5104 if ((skip_prefix(subject
, "fixup! ", &p
) ||
5105 skip_prefix(subject
, "squash! ", &p
))) {
5106 struct commit
*commit2
;
5111 if (!skip_prefix(p
, "fixup! ", &p
) &&
5112 !skip_prefix(p
, "squash! ", &p
))
5116 if ((entry
= hashmap_get_from_hash(&subject2item
,
5118 /* found by title */
5120 else if (!strchr(p
, ' ') &&
5122 lookup_commit_reference_by_name(p
)) &&
5123 *commit_todo_item_at(&commit_todo
, commit2
))
5124 /* found by commit name */
5125 i2
= *commit_todo_item_at(&commit_todo
, commit2
)
5128 /* copy can be a prefix of the commit subject */
5129 for (i2
= 0; i2
< i
; i2
++)
5131 starts_with(subjects
[i2
], p
))
5139 todo_list
->items
[i
].command
=
5140 starts_with(subject
, "fixup!") ?
5141 TODO_FIXUP
: TODO_SQUASH
;
5147 } else if (!hashmap_get_from_hash(&subject2item
,
5148 strhash(subject
), subject
)) {
5149 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
5151 hashmap_entry_init(entry
, strhash(entry
->subject
));
5152 hashmap_put(&subject2item
, entry
);
5157 for (i
= 0; i
< todo_list
->nr
; i
++) {
5158 enum todo_command command
= todo_list
->items
[i
].command
;
5162 * Initially, all commands are 'pick's. If it is a
5163 * fixup or a squash now, we have rearranged it.
5165 if (is_fixup(command
))
5169 ALLOC_GROW(items
, nr
+ 1, alloc
);
5170 items
[nr
++] = todo_list
->items
[cur
];
5175 FREE_AND_NULL(todo_list
->items
);
5176 todo_list
->items
= items
;
5178 todo_list
->alloc
= alloc
;
5183 for (i
= 0; i
< todo_list
->nr
; i
++)
5186 hashmap_free(&subject2item
, 1);
5188 clear_commit_todo_item(&commit_todo
);