7 #include "environment.h"
12 #include "object-file.h"
13 #include "object-name.h"
14 #include "object-store.h"
18 #include "sequencer.h"
20 #include "run-command.h"
24 #include "cache-tree.h"
28 #include "merge-ort.h"
29 #include "merge-ort-wrappers.h"
35 #include "wt-status.h"
37 #include "notes-utils.h"
39 #include "unpack-trees.h"
43 #include "commit-slab.h"
45 #include "commit-reach.h"
46 #include "rebase-interactive.h"
51 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
53 static const char sign_off_header
[] = "Signed-off-by: ";
54 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
56 GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
58 static GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
60 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
61 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
62 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
63 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
65 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
67 * The file containing rebase commands, comments, and empty lines.
68 * This file is created by "git rebase -i" then edited by the user. As
69 * the lines are processed, they are removed from the front of this
70 * file and written to the tail of 'done'.
72 GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
73 GIT_PATH_FUNC(rebase_path_todo_backup
, "rebase-merge/git-rebase-todo.backup")
75 GIT_PATH_FUNC(rebase_path_dropped
, "rebase-merge/dropped")
78 * The rebase command lines that have already been processed. A line
79 * is moved here when it is first handled, before any associated user
82 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
84 * The file to keep track of how many commands were already processed (e.g.
87 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum")
89 * The file to keep track of how many commands are to be processed in total
90 * (e.g. for the prompt).
92 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end")
94 * The commit message that is planned to be used for any changes that
95 * need to be committed following a user interaction.
97 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
99 * The file into which is accumulated the suggested commit message for
100 * squash/fixup commands. When the first of a series of squash/fixups
101 * is seen, the file is created and the commit message from the
102 * previous commit and from the first squash/fixup commit are written
103 * to it. The commit message for each subsequent squash/fixup commit
104 * is appended to the file as it is processed.
106 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
108 * If the current series of squash/fixups has not yet included a squash
109 * command, then this file exists and holds the commit message of the
110 * original "pick" commit. (If the series ends without a "squash"
111 * command, then this can be used as the commit message of the combined
112 * commit without opening the editor.)
114 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
116 * This file contains the list fixup/squash commands that have been
117 * accumulated into message-fixup or message-squash so far.
119 static GIT_PATH_FUNC(rebase_path_current_fixups
, "rebase-merge/current-fixups")
121 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
122 * GIT_AUTHOR_DATE that will be used for the commit that is currently
125 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
127 * When an "edit" rebase command is being processed, the SHA1 of the
128 * commit to be edited is recorded in this file. When "git rebase
129 * --continue" is executed, if there are any staged changes then they
130 * will be amended to the HEAD commit, but only provided the HEAD
131 * commit is still the commit to be edited. When any other rebase
132 * command is processed, this file is deleted.
134 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
136 * When we stop at a given patch via the "edit" command, this file contains
137 * the commit object name of the corresponding patch.
139 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
141 * For the post-rewrite hook, we make a list of rewritten commits and
142 * their new sha1s. The rewritten-pending list keeps the sha1s of
143 * commits that have been processed, but not committed yet,
144 * e.g. because they are waiting for a 'squash' command.
146 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
147 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
148 "rebase-merge/rewritten-pending")
151 * The path of the file containing the OID of the "squash onto" commit, i.e.
152 * the dummy commit used for `reset [new root]`.
154 static GIT_PATH_FUNC(rebase_path_squash_onto
, "rebase-merge/squash-onto")
157 * The path of the file listing refs that need to be deleted after the rebase
158 * finishes. This is used by the `label` command to record the need for cleanup.
160 static GIT_PATH_FUNC(rebase_path_refs_to_delete
, "rebase-merge/refs-to-delete")
163 * The update-refs file stores a list of refs that will be updated at the end
164 * of the rebase sequence. The 'update-ref <ref>' commands in the todo file
165 * update the OIDs for the refs in this file, but the refs are not updated
166 * until the end of the rebase sequence.
168 * rebase_path_update_refs() returns the path to this file for a given
169 * worktree directory. For the current worktree, pass the_repository->gitdir.
171 static char *rebase_path_update_refs(const char *wt_git_dir
)
173 return xstrfmt("%s/rebase-merge/update-refs", wt_git_dir
);
177 * The following files are written by git-rebase just after parsing the
180 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
181 static GIT_PATH_FUNC(rebase_path_cdate_is_adate
, "rebase-merge/cdate_is_adate")
182 static GIT_PATH_FUNC(rebase_path_ignore_date
, "rebase-merge/ignore_date")
183 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
184 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
185 static GIT_PATH_FUNC(rebase_path_quiet
, "rebase-merge/quiet")
186 static GIT_PATH_FUNC(rebase_path_signoff
, "rebase-merge/signoff")
187 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
188 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
189 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
190 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
191 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
192 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
193 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec
, "rebase-merge/reschedule-failed-exec")
194 static GIT_PATH_FUNC(rebase_path_no_reschedule_failed_exec
, "rebase-merge/no-reschedule-failed-exec")
195 static GIT_PATH_FUNC(rebase_path_drop_redundant_commits
, "rebase-merge/drop_redundant_commits")
196 static GIT_PATH_FUNC(rebase_path_keep_redundant_commits
, "rebase-merge/keep_redundant_commits")
199 * A 'struct update_refs_record' represents a value in the update-refs
200 * list. We use a string_list to map refs to these (before, after) pairs.
202 struct update_ref_record
{
203 struct object_id before
;
204 struct object_id after
;
207 static struct update_ref_record
*init_update_ref_record(const char *ref
)
209 struct update_ref_record
*rec
;
211 CALLOC_ARRAY(rec
, 1);
213 oidcpy(&rec
->before
, null_oid());
214 oidcpy(&rec
->after
, null_oid());
216 /* This may fail, but that's fine, we will keep the null OID. */
217 read_ref(ref
, &rec
->before
);
222 static int git_sequencer_config(const char *k
, const char *v
,
223 const struct config_context
*ctx
, void *cb
)
225 struct replay_opts
*opts
= cb
;
228 if (!strcmp(k
, "commit.cleanup")) {
231 status
= git_config_string(&s
, k
, v
);
235 if (!strcmp(s
, "verbatim")) {
236 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
237 opts
->explicit_cleanup
= 1;
238 } else if (!strcmp(s
, "whitespace")) {
239 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
240 opts
->explicit_cleanup
= 1;
241 } else if (!strcmp(s
, "strip")) {
242 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_ALL
;
243 opts
->explicit_cleanup
= 1;
244 } else if (!strcmp(s
, "scissors")) {
245 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SCISSORS
;
246 opts
->explicit_cleanup
= 1;
248 warning(_("invalid commit message cleanup mode '%s'"),
256 if (!strcmp(k
, "commit.gpgsign")) {
257 opts
->gpg_sign
= git_config_bool(k
, v
) ? xstrdup("") : NULL
;
261 if (!opts
->default_strategy
&& !strcmp(k
, "pull.twohead")) {
262 int ret
= git_config_string((const char**)&opts
->default_strategy
, k
, v
);
265 * pull.twohead is allowed to be multi-valued; we only
266 * care about the first value.
268 char *tmp
= strchr(opts
->default_strategy
, ' ');
275 if (opts
->action
== REPLAY_REVERT
&& !strcmp(k
, "revert.reference"))
276 opts
->commit_use_reference
= git_config_bool(k
, v
);
278 return git_diff_basic_config(k
, v
, ctx
, NULL
);
281 void sequencer_init_config(struct replay_opts
*opts
)
283 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
284 git_config(git_sequencer_config
, opts
);
287 static inline int is_rebase_i(const struct replay_opts
*opts
)
289 return opts
->action
== REPLAY_INTERACTIVE_REBASE
;
292 static const char *get_dir(const struct replay_opts
*opts
)
294 if (is_rebase_i(opts
))
295 return rebase_path();
296 return git_path_seq_dir();
299 static const char *get_todo_path(const struct replay_opts
*opts
)
301 if (is_rebase_i(opts
))
302 return rebase_path_todo();
303 return git_path_todo_file();
307 * Returns 0 for non-conforming footer
308 * Returns 1 for conforming footer
309 * Returns 2 when sob exists within conforming footer
310 * Returns 3 when sob exists within conforming footer as last entry
312 static int has_conforming_footer(struct strbuf
*sb
, struct strbuf
*sob
,
313 size_t ignore_footer
)
315 struct process_trailer_options opts
= PROCESS_TRAILER_OPTIONS_INIT
;
316 struct trailer_info info
;
318 int found_sob
= 0, found_sob_last
= 0;
324 saved_char
= sb
->buf
[sb
->len
- ignore_footer
];
325 sb
->buf
[sb
->len
- ignore_footer
] = '\0';
328 trailer_info_get(&info
, sb
->buf
, &opts
);
331 sb
->buf
[sb
->len
- ignore_footer
] = saved_char
;
333 if (info
.trailer_start
== info
.trailer_end
)
336 for (i
= 0; i
< info
.trailer_nr
; i
++)
337 if (sob
&& !strncmp(info
.trailers
[i
], sob
->buf
, sob
->len
)) {
339 if (i
== info
.trailer_nr
- 1)
343 trailer_info_release(&info
);
352 static const char *gpg_sign_opt_quoted(struct replay_opts
*opts
)
354 static struct strbuf buf
= STRBUF_INIT
;
358 sq_quotef(&buf
, "-S%s", opts
->gpg_sign
);
362 void replay_opts_release(struct replay_opts
*opts
)
364 free(opts
->gpg_sign
);
365 free(opts
->reflog_action
);
366 free(opts
->default_strategy
);
367 free(opts
->strategy
);
368 strvec_clear (&opts
->xopts
);
369 strbuf_release(&opts
->current_fixups
);
371 release_revisions(opts
->revs
);
375 int sequencer_remove_state(struct replay_opts
*opts
)
377 struct strbuf buf
= STRBUF_INIT
;
380 if (is_rebase_i(opts
) &&
381 strbuf_read_file(&buf
, rebase_path_refs_to_delete(), 0) > 0) {
384 char *eol
= strchr(p
, '\n');
387 if (delete_ref("(rebase) cleanup", p
, NULL
, 0) < 0) {
388 warning(_("could not delete '%s'"), p
);
398 strbuf_addstr(&buf
, get_dir(opts
));
399 if (remove_dir_recursively(&buf
, 0))
400 ret
= error(_("could not remove '%s'"), buf
.buf
);
401 strbuf_release(&buf
);
406 static const char *action_name(const struct replay_opts
*opts
)
408 switch (opts
->action
) {
412 return N_("cherry-pick");
413 case REPLAY_INTERACTIVE_REBASE
:
416 die(_("unknown action: %d"), opts
->action
);
419 struct commit_message
{
426 static const char *short_commit_name(struct commit
*commit
)
428 return repo_find_unique_abbrev(the_repository
, &commit
->object
.oid
,
432 static int get_message(struct commit
*commit
, struct commit_message
*out
)
434 const char *abbrev
, *subject
;
437 out
->message
= repo_logmsg_reencode(the_repository
, commit
, NULL
,
438 get_commit_output_encoding());
439 abbrev
= short_commit_name(commit
);
441 subject_len
= find_commit_subject(out
->message
, &subject
);
443 out
->subject
= xmemdupz(subject
, subject_len
);
444 out
->label
= xstrfmt("%s (%s)", abbrev
, out
->subject
);
445 out
->parent_label
= xstrfmt("parent of %s", out
->label
);
450 static void free_message(struct commit
*commit
, struct commit_message
*msg
)
452 free(msg
->parent_label
);
455 repo_unuse_commit_buffer(the_repository
, commit
, msg
->message
);
458 static void print_advice(struct repository
*r
, int show_hint
,
459 struct replay_opts
*opts
)
461 char *msg
= getenv("GIT_CHERRY_PICK_HELP");
466 * A conflict has occurred but the porcelain
467 * (typically rebase --interactive) wants to take care
468 * of the commit itself so remove CHERRY_PICK_HEAD
470 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
477 advise(_("after resolving the conflicts, mark the corrected paths\n"
478 "with 'git add <paths>' or 'git rm <paths>'"));
479 else if (opts
->action
== REPLAY_PICK
)
480 advise(_("After resolving the conflicts, mark them with\n"
481 "\"git add/rm <pathspec>\", then run\n"
482 "\"git cherry-pick --continue\".\n"
483 "You can instead skip this commit with \"git cherry-pick --skip\".\n"
484 "To abort and get back to the state before \"git cherry-pick\",\n"
485 "run \"git cherry-pick --abort\"."));
486 else if (opts
->action
== REPLAY_REVERT
)
487 advise(_("After resolving the conflicts, mark them with\n"
488 "\"git add/rm <pathspec>\", then run\n"
489 "\"git revert --continue\".\n"
490 "You can instead skip this commit with \"git revert --skip\".\n"
491 "To abort and get back to the state before \"git revert\",\n"
492 "run \"git revert --abort\"."));
494 BUG("unexpected pick action in print_advice()");
498 static int write_message(const void *buf
, size_t len
, const char *filename
,
501 struct lock_file msg_file
= LOCK_INIT
;
503 int msg_fd
= hold_lock_file_for_update(&msg_file
, filename
, 0);
505 return error_errno(_("could not lock '%s'"), filename
);
506 if (write_in_full(msg_fd
, buf
, len
) < 0) {
507 error_errno(_("could not write to '%s'"), filename
);
508 rollback_lock_file(&msg_file
);
511 if (append_eol
&& write(msg_fd
, "\n", 1) < 0) {
512 error_errno(_("could not write eol to '%s'"), filename
);
513 rollback_lock_file(&msg_file
);
516 if (commit_lock_file(&msg_file
) < 0)
517 return error(_("failed to finalize '%s'"), filename
);
522 int read_oneliner(struct strbuf
*buf
,
523 const char *path
, unsigned flags
)
525 int orig_len
= buf
->len
;
527 if (strbuf_read_file(buf
, path
, 0) < 0) {
528 if ((flags
& READ_ONELINER_WARN_MISSING
) ||
529 (errno
!= ENOENT
&& errno
!= ENOTDIR
))
530 warning_errno(_("could not read '%s'"), path
);
534 if (buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\n') {
535 if (--buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\r')
537 buf
->buf
[buf
->len
] = '\0';
540 if ((flags
& READ_ONELINER_SKIP_IF_EMPTY
) && buf
->len
== orig_len
)
546 static struct tree
*empty_tree(struct repository
*r
)
548 return lookup_tree(r
, the_hash_algo
->empty_tree
);
551 static int error_dirty_index(struct repository
*repo
, struct replay_opts
*opts
)
553 if (repo_read_index_unmerged(repo
))
554 return error_resolve_conflict(action_name(opts
));
556 error(_("your local changes would be overwritten by %s."),
557 _(action_name(opts
)));
559 if (advice_enabled(ADVICE_COMMIT_BEFORE_MERGE
))
560 advise(_("commit your changes or stash them to proceed."));
564 static void update_abort_safety_file(void)
566 struct object_id head
;
568 /* Do nothing on a single-pick */
569 if (!file_exists(git_path_seq_dir()))
572 if (!repo_get_oid(the_repository
, "HEAD", &head
))
573 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head
));
575 write_file(git_path_abort_safety_file(), "%s", "");
578 static int fast_forward_to(struct repository
*r
,
579 const struct object_id
*to
,
580 const struct object_id
*from
,
582 struct replay_opts
*opts
)
584 struct ref_transaction
*transaction
;
585 struct strbuf sb
= STRBUF_INIT
;
586 struct strbuf err
= STRBUF_INIT
;
589 if (checkout_fast_forward(r
, from
, to
, 1))
590 return -1; /* the callee should have complained already */
592 strbuf_addf(&sb
, "%s: fast-forward", action_name(opts
));
594 transaction
= ref_transaction_begin(&err
);
596 ref_transaction_update(transaction
, "HEAD",
597 to
, unborn
&& !is_rebase_i(opts
) ?
600 ref_transaction_commit(transaction
, &err
)) {
601 ref_transaction_free(transaction
);
602 error("%s", err
.buf
);
604 strbuf_release(&err
);
609 strbuf_release(&err
);
610 ref_transaction_free(transaction
);
611 update_abort_safety_file();
615 enum commit_msg_cleanup_mode
get_cleanup_mode(const char *cleanup_arg
,
618 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
619 return use_editor
? COMMIT_MSG_CLEANUP_ALL
:
620 COMMIT_MSG_CLEANUP_SPACE
;
621 else if (!strcmp(cleanup_arg
, "verbatim"))
622 return COMMIT_MSG_CLEANUP_NONE
;
623 else if (!strcmp(cleanup_arg
, "whitespace"))
624 return COMMIT_MSG_CLEANUP_SPACE
;
625 else if (!strcmp(cleanup_arg
, "strip"))
626 return COMMIT_MSG_CLEANUP_ALL
;
627 else if (!strcmp(cleanup_arg
, "scissors"))
628 return use_editor
? COMMIT_MSG_CLEANUP_SCISSORS
:
629 COMMIT_MSG_CLEANUP_SPACE
;
631 die(_("Invalid cleanup mode %s"), cleanup_arg
);
635 * NB using int rather than enum cleanup_mode to stop clang's
636 * -Wtautological-constant-out-of-range-compare complaining that the comparison
639 static const char *describe_cleanup_mode(int cleanup_mode
)
641 static const char *modes
[] = { "whitespace",
646 if (cleanup_mode
< ARRAY_SIZE(modes
))
647 return modes
[cleanup_mode
];
649 BUG("invalid cleanup_mode provided (%d)", cleanup_mode
);
652 void append_conflicts_hint(struct index_state
*istate
,
653 struct strbuf
*msgbuf
, enum commit_msg_cleanup_mode cleanup_mode
)
657 if (cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
) {
658 strbuf_addch(msgbuf
, '\n');
659 wt_status_append_cut_line(msgbuf
);
660 strbuf_addch(msgbuf
, comment_line_char
);
663 strbuf_addch(msgbuf
, '\n');
664 strbuf_commented_addf(msgbuf
, "Conflicts:\n");
665 for (i
= 0; i
< istate
->cache_nr
;) {
666 const struct cache_entry
*ce
= istate
->cache
[i
++];
668 strbuf_commented_addf(msgbuf
, "\t%s\n", ce
->name
);
669 while (i
< istate
->cache_nr
&&
670 !strcmp(ce
->name
, istate
->cache
[i
]->name
))
676 static int do_recursive_merge(struct repository
*r
,
677 struct commit
*base
, struct commit
*next
,
678 const char *base_label
, const char *next_label
,
679 struct object_id
*head
, struct strbuf
*msgbuf
,
680 struct replay_opts
*opts
)
682 struct merge_options o
;
683 struct merge_result result
;
684 struct tree
*next_tree
, *base_tree
, *head_tree
;
685 int clean
, show_output
;
687 struct lock_file index_lock
= LOCK_INIT
;
689 if (repo_hold_locked_index(r
, &index_lock
, LOCK_REPORT_ON_ERROR
) < 0)
694 init_merge_options(&o
, r
);
695 o
.ancestor
= base
? base_label
: "(empty tree)";
697 o
.branch2
= next
? next_label
: "(empty tree)";
698 if (is_rebase_i(opts
))
700 o
.show_rename_progress
= 1;
702 head_tree
= parse_tree_indirect(head
);
703 next_tree
= next
? repo_get_commit_tree(r
, next
) : empty_tree(r
);
704 base_tree
= base
? repo_get_commit_tree(r
, base
) : empty_tree(r
);
706 for (i
= 0; i
< opts
->xopts
.nr
; i
++)
707 parse_merge_opt(&o
, opts
->xopts
.v
[i
]);
709 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
710 memset(&result
, 0, sizeof(result
));
711 merge_incore_nonrecursive(&o
, base_tree
, head_tree
, next_tree
,
713 show_output
= !is_rebase_i(opts
) || !result
.clean
;
715 * TODO: merge_switch_to_result will update index/working tree;
716 * we only really want to do that if !result.clean || this is
717 * the final patch to be picked. But determining this is the
718 * final patch would take some work, and "head_tree" would need
719 * to be replace with the tree the index matched before we
720 * started doing any picks.
722 merge_switch_to_result(&o
, head_tree
, &result
, 1, show_output
);
723 clean
= result
.clean
;
725 ensure_full_index(r
->index
);
726 clean
= merge_trees(&o
, head_tree
, next_tree
, base_tree
);
727 if (is_rebase_i(opts
) && clean
<= 0)
728 fputs(o
.obuf
.buf
, stdout
);
729 strbuf_release(&o
.obuf
);
732 rollback_lock_file(&index_lock
);
736 if (write_locked_index(r
->index
, &index_lock
,
737 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
739 * TRANSLATORS: %s will be "revert", "cherry-pick" or
742 return error(_("%s: Unable to write new index file"),
743 _(action_name(opts
)));
746 append_conflicts_hint(r
->index
, msgbuf
,
747 opts
->default_msg_cleanup
);
752 static struct object_id
*get_cache_tree_oid(struct index_state
*istate
)
754 if (!cache_tree_fully_valid(istate
->cache_tree
))
755 if (cache_tree_update(istate
, 0)) {
756 error(_("unable to update cache tree"));
760 return &istate
->cache_tree
->oid
;
763 static int is_index_unchanged(struct repository
*r
)
765 struct object_id head_oid
, *cache_tree_oid
;
766 struct commit
*head_commit
;
767 struct index_state
*istate
= r
->index
;
769 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
770 return error(_("could not resolve HEAD commit"));
772 head_commit
= lookup_commit(r
, &head_oid
);
775 * If head_commit is NULL, check_commit, called from
776 * lookup_commit, would have indicated that head_commit is not
777 * a commit object already. repo_parse_commit() will return failure
778 * without further complaints in such a case. Otherwise, if
779 * the commit is invalid, repo_parse_commit() will complain. So
780 * there is nothing for us to say here. Just return failure.
782 if (repo_parse_commit(r
, head_commit
))
785 if (!(cache_tree_oid
= get_cache_tree_oid(istate
)))
788 return oideq(cache_tree_oid
, get_commit_tree_oid(head_commit
));
791 static int write_author_script(const char *message
)
793 struct strbuf buf
= STRBUF_INIT
;
798 if (!*message
|| starts_with(message
, "\n")) {
800 /* Missing 'author' line? */
801 unlink(rebase_path_author_script());
803 } else if (skip_prefix(message
, "author ", &message
))
805 else if ((eol
= strchr(message
, '\n')))
810 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
811 while (*message
&& *message
!= '\n' && *message
!= '\r')
812 if (skip_prefix(message
, " <", &message
))
814 else if (*message
!= '\'')
815 strbuf_addch(&buf
, *(message
++));
817 strbuf_addf(&buf
, "'\\%c'", *(message
++));
818 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
819 while (*message
&& *message
!= '\n' && *message
!= '\r')
820 if (skip_prefix(message
, "> ", &message
))
822 else if (*message
!= '\'')
823 strbuf_addch(&buf
, *(message
++));
825 strbuf_addf(&buf
, "'\\%c'", *(message
++));
826 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
827 while (*message
&& *message
!= '\n' && *message
!= '\r')
828 if (*message
!= '\'')
829 strbuf_addch(&buf
, *(message
++));
831 strbuf_addf(&buf
, "'\\%c'", *(message
++));
832 strbuf_addch(&buf
, '\'');
833 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
834 strbuf_release(&buf
);
839 * Take a series of KEY='VALUE' lines where VALUE part is
840 * sq-quoted, and append <KEY, VALUE> at the end of the string list
842 static int parse_key_value_squoted(char *buf
, struct string_list
*list
)
845 struct string_list_item
*item
;
847 char *cp
= strchr(buf
, '=');
849 np
= strchrnul(buf
, '\n');
850 return error(_("no key present in '%.*s'"),
851 (int) (np
- buf
), buf
);
853 np
= strchrnul(cp
, '\n');
855 item
= string_list_append(list
, buf
);
857 buf
= np
+ (*np
== '\n');
861 return error(_("unable to dequote value of '%s'"),
863 item
->util
= xstrdup(cp
);
869 * Reads and parses the state directory's "author-script" file, and sets name,
870 * email and date accordingly.
871 * Returns 0 on success, -1 if the file could not be parsed.
873 * The author script is of the format:
875 * GIT_AUTHOR_NAME='$author_name'
876 * GIT_AUTHOR_EMAIL='$author_email'
877 * GIT_AUTHOR_DATE='$author_date'
879 * where $author_name, $author_email and $author_date are quoted. We are strict
880 * with our parsing, as the file was meant to be eval'd in the now-removed
881 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
882 * from what this function expects, it is better to bail out than to do
883 * something that the user does not expect.
885 int read_author_script(const char *path
, char **name
, char **email
, char **date
,
888 struct strbuf buf
= STRBUF_INIT
;
889 struct string_list kv
= STRING_LIST_INIT_DUP
;
890 int retval
= -1; /* assume failure */
891 int i
, name_i
= -2, email_i
= -2, date_i
= -2, err
= 0;
893 if (strbuf_read_file(&buf
, path
, 256) <= 0) {
894 strbuf_release(&buf
);
895 if (errno
== ENOENT
&& allow_missing
)
898 return error_errno(_("could not open '%s' for reading"),
902 if (parse_key_value_squoted(buf
.buf
, &kv
))
905 for (i
= 0; i
< kv
.nr
; i
++) {
906 if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_NAME")) {
908 name_i
= error(_("'GIT_AUTHOR_NAME' already given"));
911 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_EMAIL")) {
913 email_i
= error(_("'GIT_AUTHOR_EMAIL' already given"));
916 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_DATE")) {
918 date_i
= error(_("'GIT_AUTHOR_DATE' already given"));
922 err
= error(_("unknown variable '%s'"),
927 error(_("missing 'GIT_AUTHOR_NAME'"));
929 error(_("missing 'GIT_AUTHOR_EMAIL'"));
931 error(_("missing 'GIT_AUTHOR_DATE'"));
932 if (name_i
< 0 || email_i
< 0 || date_i
< 0 || err
)
934 *name
= kv
.items
[name_i
].util
;
935 *email
= kv
.items
[email_i
].util
;
936 *date
= kv
.items
[date_i
].util
;
939 string_list_clear(&kv
, !!retval
);
940 strbuf_release(&buf
);
945 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
946 * file with shell quoting into struct strvec. Returns -1 on
947 * error, 0 otherwise.
949 static int read_env_script(struct strvec
*env
)
951 char *name
, *email
, *date
;
953 if (read_author_script(rebase_path_author_script(),
954 &name
, &email
, &date
, 0))
957 strvec_pushf(env
, "GIT_AUTHOR_NAME=%s", name
);
958 strvec_pushf(env
, "GIT_AUTHOR_EMAIL=%s", email
);
959 strvec_pushf(env
, "GIT_AUTHOR_DATE=%s", date
);
967 static char *get_author(const char *message
)
972 a
= find_commit_header(message
, "author", &len
);
974 return xmemdupz(a
, len
);
979 static const char *author_date_from_env(const struct strvec
*env
)
984 for (i
= 0; i
< env
->nr
; i
++)
985 if (skip_prefix(env
->v
[i
],
986 "GIT_AUTHOR_DATE=", &date
))
989 * If GIT_AUTHOR_DATE is missing we should have already errored out when
992 BUG("GIT_AUTHOR_DATE missing from author script");
995 static const char staged_changes_advice
[] =
996 N_("you have staged changes in your working tree\n"
997 "If these changes are meant to be squashed into the previous commit, run:\n"
999 " git commit --amend %s\n"
1001 "If they are meant to go into a new commit, run:\n"
1005 "In both cases, once you're done, continue with:\n"
1007 " git rebase --continue\n");
1009 #define ALLOW_EMPTY (1<<0)
1010 #define EDIT_MSG (1<<1)
1011 #define AMEND_MSG (1<<2)
1012 #define CLEANUP_MSG (1<<3)
1013 #define VERIFY_MSG (1<<4)
1014 #define CREATE_ROOT_COMMIT (1<<5)
1015 #define VERBATIM_MSG (1<<6)
1017 static int run_command_silent_on_success(struct child_process
*cmd
)
1019 struct strbuf buf
= STRBUF_INIT
;
1022 cmd
->stdout_to_stderr
= 1;
1023 rc
= pipe_command(cmd
,
1029 fputs(buf
.buf
, stderr
);
1030 strbuf_release(&buf
);
1035 * If we are cherry-pick, and if the merge did not result in
1036 * hand-editing, we will hit this commit and inherit the original
1037 * author date and name.
1039 * If we are revert, or if our cherry-pick results in a hand merge,
1040 * we had better say that the current user is responsible for that.
1042 * An exception is when run_git_commit() is called during an
1043 * interactive rebase: in that case, we will want to retain the
1046 static int run_git_commit(const char *defmsg
,
1047 struct replay_opts
*opts
,
1050 struct child_process cmd
= CHILD_PROCESS_INIT
;
1052 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1053 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1057 if (is_rebase_i(opts
) &&
1058 ((opts
->committer_date_is_author_date
&& !opts
->ignore_date
) ||
1059 !(!defmsg
&& (flags
& AMEND_MSG
))) &&
1060 read_env_script(&cmd
.env
)) {
1061 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
1063 return error(_(staged_changes_advice
),
1067 strvec_pushf(&cmd
.env
, GIT_REFLOG_ACTION
"=%s", opts
->reflog_message
);
1069 if (opts
->committer_date_is_author_date
)
1070 strvec_pushf(&cmd
.env
, "GIT_COMMITTER_DATE=%s",
1073 author_date_from_env(&cmd
.env
));
1074 if (opts
->ignore_date
)
1075 strvec_push(&cmd
.env
, "GIT_AUTHOR_DATE=");
1077 strvec_push(&cmd
.args
, "commit");
1079 if (!(flags
& VERIFY_MSG
))
1080 strvec_push(&cmd
.args
, "-n");
1081 if ((flags
& AMEND_MSG
))
1082 strvec_push(&cmd
.args
, "--amend");
1084 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
1086 strvec_push(&cmd
.args
, "--no-gpg-sign");
1088 strvec_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
1089 else if (!(flags
& EDIT_MSG
))
1090 strvec_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
1091 if ((flags
& CLEANUP_MSG
))
1092 strvec_push(&cmd
.args
, "--cleanup=strip");
1093 if ((flags
& VERBATIM_MSG
))
1094 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1095 if ((flags
& EDIT_MSG
))
1096 strvec_push(&cmd
.args
, "-e");
1097 else if (!(flags
& CLEANUP_MSG
) &&
1098 !opts
->signoff
&& !opts
->record_origin
&&
1099 !opts
->explicit_cleanup
)
1100 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1102 if ((flags
& ALLOW_EMPTY
))
1103 strvec_push(&cmd
.args
, "--allow-empty");
1105 if (!(flags
& EDIT_MSG
))
1106 strvec_push(&cmd
.args
, "--allow-empty-message");
1108 if (is_rebase_i(opts
) && !(flags
& EDIT_MSG
))
1109 return run_command_silent_on_success(&cmd
);
1111 return run_command(&cmd
);
1114 static int rest_is_empty(const struct strbuf
*sb
, int start
)
1119 /* Check if the rest is just whitespace and Signed-off-by's. */
1120 for (i
= start
; i
< sb
->len
; i
++) {
1121 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1127 if (strlen(sign_off_header
) <= eol
- i
&&
1128 starts_with(sb
->buf
+ i
, sign_off_header
)) {
1133 if (!isspace(sb
->buf
[i
++]))
1140 void cleanup_message(struct strbuf
*msgbuf
,
1141 enum commit_msg_cleanup_mode cleanup_mode
, int verbose
)
1143 if (verbose
|| /* Truncate the message just before the diff, if any. */
1144 cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
1145 strbuf_setlen(msgbuf
, wt_status_locate_end(msgbuf
->buf
, msgbuf
->len
));
1146 if (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
)
1147 strbuf_stripspace(msgbuf
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1151 * Find out if the message in the strbuf contains only whitespace and
1152 * Signed-off-by lines.
1154 int message_is_empty(const struct strbuf
*sb
,
1155 enum commit_msg_cleanup_mode cleanup_mode
)
1157 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1159 return rest_is_empty(sb
, 0);
1163 * See if the user edited the message in the editor or left what
1164 * was in the template intact
1166 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
1167 enum commit_msg_cleanup_mode cleanup_mode
)
1169 struct strbuf tmpl
= STRBUF_INIT
;
1172 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1175 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
1178 strbuf_stripspace(&tmpl
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1179 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
1181 strbuf_release(&tmpl
);
1182 return rest_is_empty(sb
, start
- sb
->buf
);
1185 int update_head_with_reflog(const struct commit
*old_head
,
1186 const struct object_id
*new_head
,
1187 const char *action
, const struct strbuf
*msg
,
1190 struct ref_transaction
*transaction
;
1191 struct strbuf sb
= STRBUF_INIT
;
1196 strbuf_addstr(&sb
, action
);
1197 strbuf_addstr(&sb
, ": ");
1200 nl
= strchr(msg
->buf
, '\n');
1202 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
1204 strbuf_addbuf(&sb
, msg
);
1205 strbuf_addch(&sb
, '\n');
1208 transaction
= ref_transaction_begin(err
);
1210 ref_transaction_update(transaction
, "HEAD", new_head
,
1211 old_head
? &old_head
->object
.oid
: null_oid(),
1213 ref_transaction_commit(transaction
, err
)) {
1216 ref_transaction_free(transaction
);
1217 strbuf_release(&sb
);
1222 static int run_rewrite_hook(const struct object_id
*oldoid
,
1223 const struct object_id
*newoid
)
1225 struct child_process proc
= CHILD_PROCESS_INIT
;
1227 struct strbuf sb
= STRBUF_INIT
;
1228 const char *hook_path
= find_hook("post-rewrite");
1233 strvec_pushl(&proc
.args
, hook_path
, "amend", NULL
);
1235 proc
.stdout_to_stderr
= 1;
1236 proc
.trace2_hook_name
= "post-rewrite";
1238 code
= start_command(&proc
);
1241 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
1242 sigchain_push(SIGPIPE
, SIG_IGN
);
1243 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
1245 strbuf_release(&sb
);
1246 sigchain_pop(SIGPIPE
);
1247 return finish_command(&proc
);
1250 void commit_post_rewrite(struct repository
*r
,
1251 const struct commit
*old_head
,
1252 const struct object_id
*new_head
)
1254 struct notes_rewrite_cfg
*cfg
;
1256 cfg
= init_copy_notes_for_rewrite("amend");
1258 /* we are amending, so old_head is not NULL */
1259 copy_note_for_rewrite(cfg
, &old_head
->object
.oid
, new_head
);
1260 finish_copy_notes_for_rewrite(r
, cfg
, "Notes added by 'git commit --amend'");
1262 run_rewrite_hook(&old_head
->object
.oid
, new_head
);
1265 static int run_prepare_commit_msg_hook(struct repository
*r
,
1270 const char *name
, *arg1
= NULL
, *arg2
= NULL
;
1272 name
= git_path_commit_editmsg();
1273 if (write_message(msg
->buf
, msg
->len
, name
, 0))
1282 if (run_commit_hook(0, r
->index_file
, NULL
, "prepare-commit-msg", name
,
1284 ret
= error(_("'prepare-commit-msg' hook failed"));
1289 static const char implicit_ident_advice_noconfig
[] =
1290 N_("Your name and email address were configured automatically based\n"
1291 "on your username and hostname. Please check that they are accurate.\n"
1292 "You can suppress this message by setting them explicitly. Run the\n"
1293 "following command and follow the instructions in your editor to edit\n"
1294 "your configuration file:\n"
1296 " git config --global --edit\n"
1298 "After doing this, you may fix the identity used for this commit with:\n"
1300 " git commit --amend --reset-author\n");
1302 static const char implicit_ident_advice_config
[] =
1303 N_("Your name and email address were configured automatically based\n"
1304 "on your username and hostname. Please check that they are accurate.\n"
1305 "You can suppress this message by setting them explicitly:\n"
1307 " git config --global user.name \"Your Name\"\n"
1308 " git config --global user.email you@example.com\n"
1310 "After doing this, you may fix the identity used for this commit with:\n"
1312 " git commit --amend --reset-author\n");
1314 static const char *implicit_ident_advice(void)
1316 char *user_config
= interpolate_path("~/.gitconfig", 0);
1317 char *xdg_config
= xdg_config_home("config");
1318 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1324 return _(implicit_ident_advice_config
);
1326 return _(implicit_ident_advice_noconfig
);
1330 void print_commit_summary(struct repository
*r
,
1332 const struct object_id
*oid
,
1335 struct rev_info rev
;
1336 struct commit
*commit
;
1337 struct strbuf format
= STRBUF_INIT
;
1339 struct pretty_print_context pctx
= {0};
1340 struct strbuf author_ident
= STRBUF_INIT
;
1341 struct strbuf committer_ident
= STRBUF_INIT
;
1342 struct ref_store
*refs
;
1344 commit
= lookup_commit(r
, oid
);
1346 die(_("couldn't look up newly created commit"));
1347 if (repo_parse_commit(r
, commit
))
1348 die(_("could not parse newly created commit"));
1350 strbuf_addstr(&format
, "format:%h] %s");
1352 repo_format_commit_message(r
, commit
, "%an <%ae>", &author_ident
,
1354 repo_format_commit_message(r
, commit
, "%cn <%ce>", &committer_ident
,
1356 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1357 strbuf_addstr(&format
, "\n Author: ");
1358 strbuf_addbuf_percentquote(&format
, &author_ident
);
1360 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
1361 struct strbuf date
= STRBUF_INIT
;
1363 repo_format_commit_message(r
, commit
, "%ad", &date
, &pctx
);
1364 strbuf_addstr(&format
, "\n Date: ");
1365 strbuf_addbuf_percentquote(&format
, &date
);
1366 strbuf_release(&date
);
1368 if (!committer_ident_sufficiently_given()) {
1369 strbuf_addstr(&format
, "\n Committer: ");
1370 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1371 if (advice_enabled(ADVICE_IMPLICIT_IDENTITY
)) {
1372 strbuf_addch(&format
, '\n');
1373 strbuf_addstr(&format
, implicit_ident_advice());
1376 strbuf_release(&author_ident
);
1377 strbuf_release(&committer_ident
);
1379 repo_init_revisions(r
, &rev
, prefix
);
1380 setup_revisions(0, NULL
, &rev
, NULL
);
1383 rev
.diffopt
.output_format
=
1384 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1386 rev
.verbose_header
= 1;
1387 rev
.show_root_diff
= 1;
1388 get_commit_format(format
.buf
, &rev
);
1389 rev
.always_show_header
= 0;
1390 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1391 diff_setup_done(&rev
.diffopt
);
1393 refs
= get_main_ref_store(r
);
1394 head
= refs_resolve_ref_unsafe(refs
, "HEAD", 0, NULL
, NULL
);
1396 die(_("unable to resolve HEAD after creating commit"));
1397 if (!strcmp(head
, "HEAD"))
1398 head
= _("detached HEAD");
1400 skip_prefix(head
, "refs/heads/", &head
);
1401 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1402 _(" (root-commit)") : "");
1404 if (!log_tree_commit(&rev
, commit
)) {
1405 rev
.always_show_header
= 1;
1406 rev
.use_terminator
= 1;
1407 log_tree_commit(&rev
, commit
);
1410 release_revisions(&rev
);
1411 strbuf_release(&format
);
1414 static int parse_head(struct repository
*r
, struct commit
**head
)
1416 struct commit
*current_head
;
1417 struct object_id oid
;
1419 if (repo_get_oid(r
, "HEAD", &oid
)) {
1420 current_head
= NULL
;
1422 current_head
= lookup_commit_reference(r
, &oid
);
1424 return error(_("could not parse HEAD"));
1425 if (!oideq(&oid
, ¤t_head
->object
.oid
)) {
1426 warning(_("HEAD %s is not a commit!"),
1429 if (repo_parse_commit(r
, current_head
))
1430 return error(_("could not parse HEAD commit"));
1432 *head
= current_head
;
1438 * Try to commit without forking 'git commit'. In some cases we need
1439 * to run 'git commit' to display an error message
1442 * -1 - error unable to commit
1444 * 1 - run 'git commit'
1446 static int try_to_commit(struct repository
*r
,
1447 struct strbuf
*msg
, const char *author
,
1448 struct replay_opts
*opts
, unsigned int flags
,
1449 struct object_id
*oid
)
1451 struct object_id tree
;
1452 struct commit
*current_head
= NULL
;
1453 struct commit_list
*parents
= NULL
;
1454 struct commit_extra_header
*extra
= NULL
;
1455 struct strbuf err
= STRBUF_INIT
;
1456 struct strbuf commit_msg
= STRBUF_INIT
;
1457 char *amend_author
= NULL
;
1458 const char *committer
= NULL
;
1459 const char *hook_commit
= NULL
;
1460 enum commit_msg_cleanup_mode cleanup
;
1463 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1464 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1466 if (parse_head(r
, ¤t_head
))
1469 if (flags
& AMEND_MSG
) {
1470 const char *exclude_gpgsig
[] = { "gpgsig", "gpgsig-sha256", NULL
};
1471 const char *out_enc
= get_commit_output_encoding();
1472 const char *message
= repo_logmsg_reencode(r
, current_head
,
1476 const char *orig_message
= NULL
;
1478 find_commit_subject(message
, &orig_message
);
1480 strbuf_addstr(msg
, orig_message
);
1481 hook_commit
= "HEAD";
1483 author
= amend_author
= get_author(message
);
1484 repo_unuse_commit_buffer(r
, current_head
,
1487 res
= error(_("unable to parse commit author"));
1490 parents
= copy_commit_list(current_head
->parents
);
1491 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1492 } else if (current_head
&&
1493 (!(flags
& CREATE_ROOT_COMMIT
) || (flags
& AMEND_MSG
))) {
1494 commit_list_insert(current_head
, &parents
);
1497 if (write_index_as_tree(&tree
, r
->index
, r
->index_file
, 0, NULL
)) {
1498 res
= error(_("git write-tree failed to write a tree"));
1502 if (!(flags
& ALLOW_EMPTY
)) {
1503 struct commit
*first_parent
= current_head
;
1505 if (flags
& AMEND_MSG
) {
1506 if (current_head
->parents
) {
1507 first_parent
= current_head
->parents
->item
;
1508 if (repo_parse_commit(r
, first_parent
)) {
1509 res
= error(_("could not parse HEAD commit"));
1513 first_parent
= NULL
;
1516 if (oideq(first_parent
1517 ? get_commit_tree_oid(first_parent
)
1518 : the_hash_algo
->empty_tree
,
1520 res
= 1; /* run 'git commit' to display error message */
1525 if (hook_exists("prepare-commit-msg")) {
1526 res
= run_prepare_commit_msg_hook(r
, msg
, hook_commit
);
1529 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1531 res
= error_errno(_("unable to read commit message "
1533 git_path_commit_editmsg());
1539 if (flags
& CLEANUP_MSG
)
1540 cleanup
= COMMIT_MSG_CLEANUP_ALL
;
1541 else if (flags
& VERBATIM_MSG
)
1542 cleanup
= COMMIT_MSG_CLEANUP_NONE
;
1543 else if ((opts
->signoff
|| opts
->record_origin
) &&
1544 !opts
->explicit_cleanup
)
1545 cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
1547 cleanup
= opts
->default_msg_cleanup
;
1549 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1550 strbuf_stripspace(msg
, cleanup
== COMMIT_MSG_CLEANUP_ALL
);
1551 if ((flags
& EDIT_MSG
) && message_is_empty(msg
, cleanup
)) {
1552 res
= 1; /* run 'git commit' to display error message */
1556 if (opts
->committer_date_is_author_date
) {
1557 struct ident_split id
;
1558 struct strbuf date
= STRBUF_INIT
;
1560 if (!opts
->ignore_date
) {
1561 if (split_ident_line(&id
, author
, (int)strlen(author
)) < 0) {
1562 res
= error(_("invalid author identity '%s'"),
1566 if (!id
.date_begin
) {
1568 "corrupt author: missing date information"));
1571 strbuf_addf(&date
, "@%.*s %.*s",
1572 (int)(id
.date_end
- id
.date_begin
),
1574 (int)(id
.tz_end
- id
.tz_begin
),
1579 committer
= fmt_ident(getenv("GIT_COMMITTER_NAME"),
1580 getenv("GIT_COMMITTER_EMAIL"),
1581 WANT_COMMITTER_IDENT
,
1582 opts
->ignore_date
? NULL
: date
.buf
,
1584 strbuf_release(&date
);
1589 if (opts
->ignore_date
) {
1590 struct ident_split id
;
1593 if (split_ident_line(&id
, author
, strlen(author
)) < 0) {
1594 error(_("invalid author identity '%s'"), author
);
1597 name
= xmemdupz(id
.name_begin
, id
.name_end
- id
.name_begin
);
1598 email
= xmemdupz(id
.mail_begin
, id
.mail_end
- id
.mail_begin
);
1599 author
= fmt_ident(name
, email
, WANT_AUTHOR_IDENT
, NULL
,
1605 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
, oid
,
1606 author
, committer
, opts
->gpg_sign
, extra
)) {
1607 res
= error(_("failed to write commit object"));
1611 if (update_head_with_reflog(current_head
, oid
, opts
->reflog_message
,
1613 res
= error("%s", err
.buf
);
1617 run_commit_hook(0, r
->index_file
, NULL
, "post-commit", NULL
);
1618 if (flags
& AMEND_MSG
)
1619 commit_post_rewrite(r
, current_head
, oid
);
1622 free_commit_extra_headers(extra
);
1623 strbuf_release(&err
);
1624 strbuf_release(&commit_msg
);
1630 static int write_rebase_head(struct object_id
*oid
)
1632 if (update_ref("rebase", "REBASE_HEAD", oid
,
1633 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1634 return error(_("could not update %s"), "REBASE_HEAD");
1639 static int do_commit(struct repository
*r
,
1640 const char *msg_file
, const char *author
,
1641 struct replay_opts
*opts
, unsigned int flags
,
1642 struct object_id
*oid
)
1646 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
)) {
1647 struct object_id oid
;
1648 struct strbuf sb
= STRBUF_INIT
;
1650 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1651 return error_errno(_("unable to read commit message "
1655 res
= try_to_commit(r
, msg_file
? &sb
: NULL
,
1656 author
, opts
, flags
, &oid
);
1657 strbuf_release(&sb
);
1659 refs_delete_ref(get_main_ref_store(r
), "",
1660 "CHERRY_PICK_HEAD", NULL
, 0);
1661 unlink(git_path_merge_msg(r
));
1662 if (!is_rebase_i(opts
))
1663 print_commit_summary(r
, NULL
, &oid
,
1664 SUMMARY_SHOW_AUTHOR_DATE
);
1669 if (is_rebase_i(opts
) && oid
)
1670 if (write_rebase_head(oid
))
1672 return run_git_commit(msg_file
, opts
, flags
);
1678 static int is_original_commit_empty(struct commit
*commit
)
1680 const struct object_id
*ptree_oid
;
1682 if (repo_parse_commit(the_repository
, commit
))
1683 return error(_("could not parse commit %s"),
1684 oid_to_hex(&commit
->object
.oid
));
1685 if (commit
->parents
) {
1686 struct commit
*parent
= commit
->parents
->item
;
1687 if (repo_parse_commit(the_repository
, parent
))
1688 return error(_("could not parse parent commit %s"),
1689 oid_to_hex(&parent
->object
.oid
));
1690 ptree_oid
= get_commit_tree_oid(parent
);
1692 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1695 return oideq(ptree_oid
, get_commit_tree_oid(commit
));
1699 * Should empty commits be allowed? Return status:
1700 * <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1701 * 0: Halt on empty commit
1702 * 1: Allow empty commit
1703 * 2: Drop empty commit
1705 static int allow_empty(struct repository
*r
,
1706 struct replay_opts
*opts
,
1707 struct commit
*commit
)
1709 int index_unchanged
, originally_empty
;
1714 * (1) we do not allow empty at all and error out.
1716 * (2) we allow ones that were initially empty, and
1717 * just drop the ones that become empty
1719 * (3) we allow ones that were initially empty, but
1720 * halt for the ones that become empty;
1722 * (4) we allow both.
1724 if (!opts
->allow_empty
)
1725 return 0; /* let "git commit" barf as necessary */
1727 index_unchanged
= is_index_unchanged(r
);
1728 if (index_unchanged
< 0)
1729 return index_unchanged
;
1730 if (!index_unchanged
)
1731 return 0; /* we do not have to say --allow-empty */
1733 if (opts
->keep_redundant_commits
)
1736 originally_empty
= is_original_commit_empty(commit
);
1737 if (originally_empty
< 0)
1738 return originally_empty
;
1739 if (originally_empty
)
1741 else if (opts
->drop_redundant_commits
)
1750 } todo_command_info
[] = {
1751 [TODO_PICK
] = { 'p', "pick" },
1752 [TODO_REVERT
] = { 0, "revert" },
1753 [TODO_EDIT
] = { 'e', "edit" },
1754 [TODO_REWORD
] = { 'r', "reword" },
1755 [TODO_FIXUP
] = { 'f', "fixup" },
1756 [TODO_SQUASH
] = { 's', "squash" },
1757 [TODO_EXEC
] = { 'x', "exec" },
1758 [TODO_BREAK
] = { 'b', "break" },
1759 [TODO_LABEL
] = { 'l', "label" },
1760 [TODO_RESET
] = { 't', "reset" },
1761 [TODO_MERGE
] = { 'm', "merge" },
1762 [TODO_UPDATE_REF
] = { 'u', "update-ref" },
1763 [TODO_NOOP
] = { 0, "noop" },
1764 [TODO_DROP
] = { 'd', "drop" },
1765 [TODO_COMMENT
] = { 0, NULL
},
1768 static const char *command_to_string(const enum todo_command command
)
1770 if (command
< TODO_COMMENT
)
1771 return todo_command_info
[command
].str
;
1772 die(_("unknown command: %d"), command
);
1775 static char command_to_char(const enum todo_command command
)
1777 if (command
< TODO_COMMENT
)
1778 return todo_command_info
[command
].c
;
1779 return comment_line_char
;
1782 static int is_noop(const enum todo_command command
)
1784 return TODO_NOOP
<= command
;
1787 static int is_fixup(enum todo_command command
)
1789 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1792 /* Does this command create a (non-merge) commit? */
1793 static int is_pick_or_similar(enum todo_command command
)
1808 enum todo_item_flags
{
1809 TODO_EDIT_MERGE_MSG
= (1 << 0),
1810 TODO_REPLACE_FIXUP_MSG
= (1 << 1),
1811 TODO_EDIT_FIXUP_MSG
= (1 << 2),
1814 static const char first_commit_msg_str
[] = N_("This is the 1st commit message:");
1815 static const char nth_commit_msg_fmt
[] = N_("This is the commit message #%d:");
1816 static const char skip_first_commit_msg_str
[] = N_("The 1st commit message will be skipped:");
1817 static const char skip_nth_commit_msg_fmt
[] = N_("The commit message #%d will be skipped:");
1818 static const char combined_commit_msg_fmt
[] = N_("This is a combination of %d commits.");
1820 static int is_fixup_flag(enum todo_command command
, unsigned flag
)
1822 return command
== TODO_FIXUP
&& ((flag
& TODO_REPLACE_FIXUP_MSG
) ||
1823 (flag
& TODO_EDIT_FIXUP_MSG
));
1827 * Wrapper around strbuf_add_commented_lines() which avoids double
1828 * commenting commit subjects.
1830 static void add_commented_lines(struct strbuf
*buf
, const void *str
, size_t len
)
1832 const char *s
= str
;
1833 while (len
> 0 && s
[0] == comment_line_char
) {
1835 const char *n
= memchr(s
, '\n', len
);
1840 strbuf_add(buf
, s
, count
);
1844 strbuf_add_commented_lines(buf
, s
, len
);
1847 /* Does the current fixup chain contain a squash command? */
1848 static int seen_squash(struct replay_opts
*opts
)
1850 return starts_with(opts
->current_fixups
.buf
, "squash") ||
1851 strstr(opts
->current_fixups
.buf
, "\nsquash");
1854 static void update_comment_bufs(struct strbuf
*buf1
, struct strbuf
*buf2
, int n
)
1856 strbuf_setlen(buf1
, 2);
1857 strbuf_addf(buf1
, _(nth_commit_msg_fmt
), n
);
1858 strbuf_addch(buf1
, '\n');
1859 strbuf_setlen(buf2
, 2);
1860 strbuf_addf(buf2
, _(skip_nth_commit_msg_fmt
), n
);
1861 strbuf_addch(buf2
, '\n');
1865 * Comment out any un-commented commit messages, updating the message comments
1866 * to say they will be skipped but do not comment out the empty lines that
1867 * surround commit messages and their comments.
1869 static void update_squash_message_for_fixup(struct strbuf
*msg
)
1871 void (*copy_lines
)(struct strbuf
*, const void *, size_t) = strbuf_add
;
1872 struct strbuf buf1
= STRBUF_INIT
, buf2
= STRBUF_INIT
;
1873 const char *s
, *start
;
1875 size_t orig_msg_len
;
1878 strbuf_addf(&buf1
, "# %s\n", _(first_commit_msg_str
));
1879 strbuf_addf(&buf2
, "# %s\n", _(skip_first_commit_msg_str
));
1880 s
= start
= orig_msg
= strbuf_detach(msg
, &orig_msg_len
);
1884 if (skip_prefix(s
, buf1
.buf
, &next
)) {
1886 * Copy the last message, preserving the blank line
1887 * preceding the current line
1889 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1890 copy_lines(msg
, start
, s
- start
- off
);
1892 strbuf_addch(msg
, '\n');
1894 * The next message needs to be commented out but the
1895 * message header is already commented out so just copy
1896 * it and the blank line that follows it.
1898 strbuf_addbuf(msg
, &buf2
);
1900 strbuf_addch(msg
, *next
++);
1902 copy_lines
= add_commented_lines
;
1903 update_comment_bufs(&buf1
, &buf2
, ++i
);
1904 } else if (skip_prefix(s
, buf2
.buf
, &next
)) {
1905 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1906 copy_lines(msg
, start
, s
- start
- off
);
1909 copy_lines
= strbuf_add
;
1910 update_comment_bufs(&buf1
, &buf2
, ++i
);
1912 s
= strchr(s
, '\n');
1917 copy_lines(msg
, start
, orig_msg_len
- (start
- orig_msg
));
1919 strbuf_release(&buf1
);
1920 strbuf_release(&buf2
);
1923 static int append_squash_message(struct strbuf
*buf
, const char *body
,
1924 enum todo_command command
, struct replay_opts
*opts
,
1927 const char *fixup_msg
;
1928 size_t commented_len
= 0, fixup_off
;
1930 * amend is non-interactive and not normally used with fixup!
1931 * or squash! commits, so only comment out those subjects when
1932 * squashing commit messages.
1934 if (starts_with(body
, "amend!") ||
1935 ((command
== TODO_SQUASH
|| seen_squash(opts
)) &&
1936 (starts_with(body
, "squash!") || starts_with(body
, "fixup!"))))
1937 commented_len
= commit_subject_length(body
);
1939 strbuf_addf(buf
, "\n%c ", comment_line_char
);
1940 strbuf_addf(buf
, _(nth_commit_msg_fmt
),
1941 ++opts
->current_fixup_count
+ 1);
1942 strbuf_addstr(buf
, "\n\n");
1943 strbuf_add_commented_lines(buf
, body
, commented_len
);
1944 /* buf->buf may be reallocated so store an offset into the buffer */
1945 fixup_off
= buf
->len
;
1946 strbuf_addstr(buf
, body
+ commented_len
);
1948 /* fixup -C after squash behaves like squash */
1949 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
)) {
1951 * We're replacing the commit message so we need to
1952 * append the Signed-off-by: trailer if the user
1953 * requested '--signoff'.
1956 append_signoff(buf
, 0, 0);
1958 if ((command
== TODO_FIXUP
) &&
1959 (flag
& TODO_REPLACE_FIXUP_MSG
) &&
1960 (file_exists(rebase_path_fixup_msg()) ||
1961 !file_exists(rebase_path_squash_msg()))) {
1962 fixup_msg
= skip_blank_lines(buf
->buf
+ fixup_off
);
1963 if (write_message(fixup_msg
, strlen(fixup_msg
),
1964 rebase_path_fixup_msg(), 0) < 0)
1965 return error(_("cannot write '%s'"),
1966 rebase_path_fixup_msg());
1968 unlink(rebase_path_fixup_msg());
1971 unlink(rebase_path_fixup_msg());
1977 static int update_squash_messages(struct repository
*r
,
1978 enum todo_command command
,
1979 struct commit
*commit
,
1980 struct replay_opts
*opts
,
1983 struct strbuf buf
= STRBUF_INIT
;
1985 const char *message
, *body
;
1986 const char *encoding
= get_commit_output_encoding();
1988 if (opts
->current_fixup_count
> 0) {
1989 struct strbuf header
= STRBUF_INIT
;
1992 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
1993 return error(_("could not read '%s'"),
1994 rebase_path_squash_msg());
1996 eol
= buf
.buf
[0] != comment_line_char
?
1997 buf
.buf
: strchrnul(buf
.buf
, '\n');
1999 strbuf_addf(&header
, "%c ", comment_line_char
);
2000 strbuf_addf(&header
, _(combined_commit_msg_fmt
),
2001 opts
->current_fixup_count
+ 2);
2002 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
2003 strbuf_release(&header
);
2004 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
))
2005 update_squash_message_for_fixup(&buf
);
2007 struct object_id head
;
2008 struct commit
*head_commit
;
2009 const char *head_message
, *body
;
2011 if (repo_get_oid(r
, "HEAD", &head
))
2012 return error(_("need a HEAD to fixup"));
2013 if (!(head_commit
= lookup_commit_reference(r
, &head
)))
2014 return error(_("could not read HEAD"));
2015 if (!(head_message
= repo_logmsg_reencode(r
, head_commit
, NULL
,
2017 return error(_("could not read HEAD's commit message"));
2019 find_commit_subject(head_message
, &body
);
2020 if (command
== TODO_FIXUP
&& !flag
&& write_message(body
, strlen(body
),
2021 rebase_path_fixup_msg(), 0) < 0) {
2022 repo_unuse_commit_buffer(r
, head_commit
, head_message
);
2023 return error(_("cannot write '%s'"), rebase_path_fixup_msg());
2025 strbuf_addf(&buf
, "%c ", comment_line_char
);
2026 strbuf_addf(&buf
, _(combined_commit_msg_fmt
), 2);
2027 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
2028 strbuf_addstr(&buf
, is_fixup_flag(command
, flag
) ?
2029 _(skip_first_commit_msg_str
) :
2030 _(first_commit_msg_str
));
2031 strbuf_addstr(&buf
, "\n\n");
2032 if (is_fixup_flag(command
, flag
))
2033 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
2035 strbuf_addstr(&buf
, body
);
2037 repo_unuse_commit_buffer(r
, head_commit
, head_message
);
2040 if (!(message
= repo_logmsg_reencode(r
, commit
, NULL
, encoding
)))
2041 return error(_("could not read commit message of %s"),
2042 oid_to_hex(&commit
->object
.oid
));
2043 find_commit_subject(message
, &body
);
2045 if (command
== TODO_SQUASH
|| is_fixup_flag(command
, flag
)) {
2046 res
= append_squash_message(&buf
, body
, command
, opts
, flag
);
2047 } else if (command
== TODO_FIXUP
) {
2048 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
2049 strbuf_addf(&buf
, _(skip_nth_commit_msg_fmt
),
2050 ++opts
->current_fixup_count
+ 1);
2051 strbuf_addstr(&buf
, "\n\n");
2052 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
2054 return error(_("unknown command: %d"), command
);
2055 repo_unuse_commit_buffer(r
, commit
, message
);
2058 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(),
2060 strbuf_release(&buf
);
2063 strbuf_addf(&opts
->current_fixups
, "%s%s %s",
2064 opts
->current_fixups
.len
? "\n" : "",
2065 command_to_string(command
),
2066 oid_to_hex(&commit
->object
.oid
));
2067 res
= write_message(opts
->current_fixups
.buf
,
2068 opts
->current_fixups
.len
,
2069 rebase_path_current_fixups(), 0);
2075 static void flush_rewritten_pending(void)
2077 struct strbuf buf
= STRBUF_INIT
;
2078 struct object_id newoid
;
2081 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
2082 !repo_get_oid(the_repository
, "HEAD", &newoid
) &&
2083 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
2084 char *bol
= buf
.buf
, *eol
;
2087 eol
= strchrnul(bol
, '\n');
2088 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
2089 bol
, oid_to_hex(&newoid
));
2095 unlink(rebase_path_rewritten_pending());
2097 strbuf_release(&buf
);
2100 static void record_in_rewritten(struct object_id
*oid
,
2101 enum todo_command next_command
)
2103 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
2108 fprintf(out
, "%s\n", oid_to_hex(oid
));
2111 if (!is_fixup(next_command
))
2112 flush_rewritten_pending();
2115 static int should_edit(struct replay_opts
*opts
) {
2118 * Note that we only handle the case of non-conflicted
2119 * commits; continue_single_pick() handles the conflicted
2120 * commits itself instead of calling this function.
2122 return (opts
->action
== REPLAY_REVERT
&& isatty(0)) ? 1 : 0;
2126 static void refer_to_commit(struct replay_opts
*opts
,
2127 struct strbuf
*msgbuf
, struct commit
*commit
)
2129 if (opts
->commit_use_reference
) {
2130 struct pretty_print_context ctx
= {
2131 .abbrev
= DEFAULT_ABBREV
,
2132 .date_mode
.type
= DATE_SHORT
,
2134 repo_format_commit_message(the_repository
, commit
,
2135 "%h (%s, %ad)", msgbuf
, &ctx
);
2137 strbuf_addstr(msgbuf
, oid_to_hex(&commit
->object
.oid
));
2141 static int do_pick_commit(struct repository
*r
,
2142 struct todo_item
*item
,
2143 struct replay_opts
*opts
,
2144 int final_fixup
, int *check_todo
)
2146 unsigned int flags
= should_edit(opts
) ? EDIT_MSG
: 0;
2147 const char *msg_file
= should_edit(opts
) ? NULL
: git_path_merge_msg(r
);
2148 struct object_id head
;
2149 struct commit
*base
, *next
, *parent
;
2150 const char *base_label
, *next_label
;
2151 char *author
= NULL
;
2152 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
2153 struct strbuf msgbuf
= STRBUF_INIT
;
2154 int res
, unborn
= 0, reword
= 0, allow
, drop_commit
;
2155 enum todo_command command
= item
->command
;
2156 struct commit
*commit
= item
->commit
;
2158 if (opts
->no_commit
) {
2160 * We do not intend to commit immediately. We just want to
2161 * merge the differences in, so let's compute the tree
2162 * that represents the "current" state for the merge machinery
2165 if (write_index_as_tree(&head
, r
->index
, r
->index_file
, 0, NULL
))
2166 return error(_("your index file is unmerged."));
2168 unborn
= repo_get_oid(r
, "HEAD", &head
);
2169 /* Do we want to generate a root commit? */
2170 if (is_pick_or_similar(command
) && opts
->have_squash_onto
&&
2171 oideq(&head
, &opts
->squash_onto
)) {
2172 if (is_fixup(command
))
2173 return error(_("cannot fixup root commit"));
2174 flags
|= CREATE_ROOT_COMMIT
;
2177 oidcpy(&head
, the_hash_algo
->empty_tree
);
2178 if (index_differs_from(r
, unborn
? empty_tree_oid_hex() : "HEAD",
2180 return error_dirty_index(r
, opts
);
2182 discard_index(r
->index
);
2184 if (!commit
->parents
)
2186 else if (commit
->parents
->next
) {
2187 /* Reverting or cherry-picking a merge commit */
2189 struct commit_list
*p
;
2191 if (!opts
->mainline
)
2192 return error(_("commit %s is a merge but no -m option was given."),
2193 oid_to_hex(&commit
->object
.oid
));
2195 for (cnt
= 1, p
= commit
->parents
;
2196 cnt
!= opts
->mainline
&& p
;
2199 if (cnt
!= opts
->mainline
|| !p
)
2200 return error(_("commit %s does not have parent %d"),
2201 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2203 } else if (1 < opts
->mainline
)
2205 * Non-first parent explicitly specified as mainline for
2208 return error(_("commit %s does not have parent %d"),
2209 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2211 parent
= commit
->parents
->item
;
2213 if (get_message(commit
, &msg
) != 0)
2214 return error(_("cannot get commit message for %s"),
2215 oid_to_hex(&commit
->object
.oid
));
2217 if (opts
->allow_ff
&& !is_fixup(command
) &&
2218 ((parent
&& oideq(&parent
->object
.oid
, &head
)) ||
2219 (!parent
&& unborn
))) {
2220 if (is_rebase_i(opts
))
2221 write_author_script(msg
.message
);
2222 res
= fast_forward_to(r
, &commit
->object
.oid
, &head
, unborn
,
2224 if (res
|| command
!= TODO_REWORD
)
2228 goto fast_forward_edit
;
2230 if (parent
&& repo_parse_commit(r
, parent
) < 0)
2231 /* TRANSLATORS: The first %s will be a "todo" command like
2232 "revert" or "pick", the second %s a SHA1. */
2233 return error(_("%s: cannot parse parent commit %s"),
2234 command_to_string(command
),
2235 oid_to_hex(&parent
->object
.oid
));
2238 * "commit" is an existing commit. We would want to apply
2239 * the difference it introduces since its first parent "prev"
2240 * on top of the current HEAD if we are cherry-pick. Or the
2241 * reverse of it if we are revert.
2244 if (command
== TODO_REVERT
) {
2246 base_label
= msg
.label
;
2248 next_label
= msg
.parent_label
;
2249 if (opts
->commit_use_reference
) {
2250 strbuf_addstr(&msgbuf
,
2251 "# *** SAY WHY WE ARE REVERTING ON THE TITLE LINE ***");
2253 strbuf_addstr(&msgbuf
, "Revert \"");
2254 strbuf_addstr(&msgbuf
, msg
.subject
);
2255 strbuf_addstr(&msgbuf
, "\"");
2257 strbuf_addstr(&msgbuf
, "\n\nThis reverts commit ");
2258 refer_to_commit(opts
, &msgbuf
, commit
);
2260 if (commit
->parents
&& commit
->parents
->next
) {
2261 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
2262 refer_to_commit(opts
, &msgbuf
, parent
);
2264 strbuf_addstr(&msgbuf
, ".\n");
2269 base_label
= msg
.parent_label
;
2271 next_label
= msg
.label
;
2273 /* Append the commit log message to msgbuf. */
2274 if (find_commit_subject(msg
.message
, &p
))
2275 strbuf_addstr(&msgbuf
, p
);
2277 if (opts
->record_origin
) {
2278 strbuf_complete_line(&msgbuf
);
2279 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
2280 strbuf_addch(&msgbuf
, '\n');
2281 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
2282 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
2283 strbuf_addstr(&msgbuf
, ")\n");
2285 if (!is_fixup(command
))
2286 author
= get_author(msg
.message
);
2289 if (command
== TODO_REWORD
)
2291 else if (is_fixup(command
)) {
2292 if (update_squash_messages(r
, command
, commit
,
2293 opts
, item
->flags
)) {
2299 msg_file
= rebase_path_squash_msg();
2300 else if (file_exists(rebase_path_fixup_msg())) {
2301 flags
|= VERBATIM_MSG
;
2302 msg_file
= rebase_path_fixup_msg();
2304 const char *dest
= git_path_squash_msg(r
);
2306 if (copy_file(dest
, rebase_path_squash_msg(), 0666)) {
2307 res
= error(_("could not rename '%s' to '%s'"),
2308 rebase_path_squash_msg(), dest
);
2311 unlink(git_path_merge_msg(r
));
2317 if (opts
->signoff
&& !is_fixup(command
))
2318 append_signoff(&msgbuf
, 0, 0);
2320 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
2322 else if (!opts
->strategy
||
2323 !strcmp(opts
->strategy
, "recursive") ||
2324 !strcmp(opts
->strategy
, "ort") ||
2325 command
== TODO_REVERT
) {
2326 res
= do_recursive_merge(r
, base
, next
, base_label
, next_label
,
2327 &head
, &msgbuf
, opts
);
2331 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
2332 git_path_merge_msg(r
), 0);
2334 struct commit_list
*common
= NULL
;
2335 struct commit_list
*remotes
= NULL
;
2337 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
2338 git_path_merge_msg(r
), 0);
2340 commit_list_insert(base
, &common
);
2341 commit_list_insert(next
, &remotes
);
2342 res
|= try_merge_command(r
, opts
->strategy
,
2343 opts
->xopts
.nr
, opts
->xopts
.v
,
2344 common
, oid_to_hex(&head
), remotes
);
2345 free_commit_list(common
);
2346 free_commit_list(remotes
);
2350 * If the merge was clean or if it failed due to conflict, we write
2351 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
2352 * However, if the merge did not even start, then we don't want to
2355 if ((command
== TODO_PICK
|| command
== TODO_REWORD
||
2356 command
== TODO_EDIT
) && !opts
->no_commit
&&
2357 (res
== 0 || res
== 1) &&
2358 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
2359 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2361 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
2362 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
2363 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2367 error(command
== TODO_REVERT
2368 ? _("could not revert %s... %s")
2369 : _("could not apply %s... %s"),
2370 short_commit_name(commit
), msg
.subject
);
2371 print_advice(r
, res
== 1, opts
);
2372 repo_rerere(r
, opts
->allow_rerere_auto
);
2377 allow
= allow_empty(r
, opts
, commit
);
2381 } else if (allow
== 1) {
2382 flags
|= ALLOW_EMPTY
;
2383 } else if (allow
== 2) {
2385 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
2387 unlink(git_path_merge_msg(r
));
2388 unlink(git_path_auto_merge(r
));
2390 _("dropping %s %s -- patch contents already upstream\n"),
2391 oid_to_hex(&commit
->object
.oid
), msg
.subject
);
2392 } /* else allow == 0 and there's nothing special to do */
2393 if (!opts
->no_commit
&& !drop_commit
) {
2394 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
2395 res
= do_commit(r
, msg_file
, author
, opts
, flags
,
2396 commit
? &commit
->object
.oid
: NULL
);
2398 res
= error(_("unable to parse commit author"));
2399 *check_todo
= !!(flags
& EDIT_MSG
);
2400 if (!res
&& reword
) {
2402 res
= run_git_commit(NULL
, opts
, EDIT_MSG
|
2403 VERIFY_MSG
| AMEND_MSG
|
2404 (flags
& ALLOW_EMPTY
));
2410 if (!res
&& final_fixup
) {
2411 unlink(rebase_path_fixup_msg());
2412 unlink(rebase_path_squash_msg());
2413 unlink(rebase_path_current_fixups());
2414 strbuf_reset(&opts
->current_fixups
);
2415 opts
->current_fixup_count
= 0;
2419 free_message(commit
, &msg
);
2421 strbuf_release(&msgbuf
);
2422 update_abort_safety_file();
2427 static int prepare_revs(struct replay_opts
*opts
)
2430 * picking (but not reverting) ranges (but not individual revisions)
2431 * should be done in reverse
2433 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
2434 opts
->revs
->reverse
^= 1;
2436 if (prepare_revision_walk(opts
->revs
))
2437 return error(_("revision walk setup failed"));
2442 static int read_and_refresh_cache(struct repository
*r
,
2443 struct replay_opts
*opts
)
2445 struct lock_file index_lock
= LOCK_INIT
;
2446 int index_fd
= repo_hold_locked_index(r
, &index_lock
, 0);
2447 if (repo_read_index(r
) < 0) {
2448 rollback_lock_file(&index_lock
);
2449 return error(_("git %s: failed to read the index"),
2452 refresh_index(r
->index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
2454 if (index_fd
>= 0) {
2455 if (write_locked_index(r
->index
, &index_lock
,
2456 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
2457 return error(_("git %s: failed to refresh the index"),
2463 * If we are resolving merges in any way other than "ort", then
2464 * expand the sparse index.
2466 if (opts
->strategy
&& strcmp(opts
->strategy
, "ort"))
2467 ensure_full_index(r
->index
);
2471 void todo_list_release(struct todo_list
*todo_list
)
2473 strbuf_release(&todo_list
->buf
);
2474 FREE_AND_NULL(todo_list
->items
);
2475 todo_list
->nr
= todo_list
->alloc
= 0;
2478 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
2480 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
2481 return todo_list
->items
+ todo_list
->nr
++;
2484 const char *todo_item_get_arg(struct todo_list
*todo_list
,
2485 struct todo_item
*item
)
2487 return todo_list
->buf
.buf
+ item
->arg_offset
;
2490 static int is_command(enum todo_command command
, const char **bol
)
2492 const char *str
= todo_command_info
[command
].str
;
2493 const char nick
= todo_command_info
[command
].c
;
2494 const char *p
= *bol
;
2496 return (skip_prefix(p
, str
, &p
) || (nick
&& *p
++ == nick
)) &&
2497 (*p
== ' ' || *p
== '\t' || *p
== '\n' || *p
== '\r' || !*p
) &&
2501 static int check_label_or_ref_arg(enum todo_command command
, const char *arg
)
2506 * '#' is not a valid label as the merge command uses it to
2507 * separate merge parents from the commit subject.
2509 if (!strcmp(arg
, "#") ||
2510 check_refname_format(arg
, REFNAME_ALLOW_ONELEVEL
))
2511 return error(_("'%s' is not a valid label"), arg
);
2514 case TODO_UPDATE_REF
:
2515 if (check_refname_format(arg
, REFNAME_ALLOW_ONELEVEL
))
2516 return error(_("'%s' is not a valid refname"), arg
);
2517 if (check_refname_format(arg
, 0))
2518 return error(_("update-ref requires a fully qualified "
2519 "refname e.g. refs/heads/%s"), arg
);
2523 BUG("unexpected todo_command");
2529 static int parse_insn_line(struct repository
*r
, struct todo_item
*item
,
2530 const char *buf
, const char *bol
, char *eol
)
2532 struct object_id commit_oid
;
2533 char *end_of_object_name
;
2534 int i
, saved
, status
, padding
;
2539 bol
+= strspn(bol
, " \t");
2541 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
2542 item
->command
= TODO_COMMENT
;
2543 item
->commit
= NULL
;
2544 item
->arg_offset
= bol
- buf
;
2545 item
->arg_len
= eol
- bol
;
2549 for (i
= 0; i
< TODO_COMMENT
; i
++)
2550 if (is_command(i
, &bol
)) {
2554 if (i
>= TODO_COMMENT
)
2555 return error(_("invalid command '%.*s'"),
2556 (int)strcspn(bol
, " \t\r\n"), bol
);
2558 /* Eat up extra spaces/ tabs before object name */
2559 padding
= strspn(bol
, " \t");
2562 if (item
->command
== TODO_NOOP
|| item
->command
== TODO_BREAK
) {
2564 return error(_("%s does not accept arguments: '%s'"),
2565 command_to_string(item
->command
), bol
);
2566 item
->commit
= NULL
;
2567 item
->arg_offset
= bol
- buf
;
2568 item
->arg_len
= eol
- bol
;
2573 return error(_("missing arguments for %s"),
2574 command_to_string(item
->command
));
2576 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
2577 item
->command
== TODO_RESET
|| item
->command
== TODO_UPDATE_REF
) {
2580 item
->commit
= NULL
;
2581 item
->arg_offset
= bol
- buf
;
2582 item
->arg_len
= (int)(eol
- bol
);
2583 if (item
->command
== TODO_LABEL
||
2584 item
->command
== TODO_UPDATE_REF
) {
2587 ret
= check_label_or_ref_arg(item
->command
, bol
);
2593 if (item
->command
== TODO_FIXUP
) {
2594 if (skip_prefix(bol
, "-C", &bol
)) {
2595 bol
+= strspn(bol
, " \t");
2596 item
->flags
|= TODO_REPLACE_FIXUP_MSG
;
2597 } else if (skip_prefix(bol
, "-c", &bol
)) {
2598 bol
+= strspn(bol
, " \t");
2599 item
->flags
|= TODO_EDIT_FIXUP_MSG
;
2603 if (item
->command
== TODO_MERGE
) {
2604 if (skip_prefix(bol
, "-C", &bol
))
2605 bol
+= strspn(bol
, " \t");
2606 else if (skip_prefix(bol
, "-c", &bol
)) {
2607 bol
+= strspn(bol
, " \t");
2608 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2610 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2611 item
->commit
= NULL
;
2612 item
->arg_offset
= bol
- buf
;
2613 item
->arg_len
= (int)(eol
- bol
);
2618 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
2619 saved
= *end_of_object_name
;
2620 *end_of_object_name
= '\0';
2621 status
= repo_get_oid(r
, bol
, &commit_oid
);
2623 error(_("could not parse '%s'"), bol
); /* return later */
2624 *end_of_object_name
= saved
;
2626 bol
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2627 item
->arg_offset
= bol
- buf
;
2628 item
->arg_len
= (int)(eol
- bol
);
2633 item
->commit
= lookup_commit_reference(r
, &commit_oid
);
2634 return item
->commit
? 0 : -1;
2637 int sequencer_get_last_command(struct repository
*r
, enum replay_action
*action
)
2639 const char *todo_file
, *bol
;
2640 struct strbuf buf
= STRBUF_INIT
;
2643 todo_file
= git_path_todo_file();
2644 if (strbuf_read_file(&buf
, todo_file
, 0) < 0) {
2645 if (errno
== ENOENT
|| errno
== ENOTDIR
)
2648 return error_errno("unable to open '%s'", todo_file
);
2650 bol
= buf
.buf
+ strspn(buf
.buf
, " \t\r\n");
2651 if (is_command(TODO_PICK
, &bol
) && (*bol
== ' ' || *bol
== '\t'))
2652 *action
= REPLAY_PICK
;
2653 else if (is_command(TODO_REVERT
, &bol
) &&
2654 (*bol
== ' ' || *bol
== '\t'))
2655 *action
= REPLAY_REVERT
;
2659 strbuf_release(&buf
);
2664 int todo_list_parse_insn_buffer(struct repository
*r
, char *buf
,
2665 struct todo_list
*todo_list
)
2667 struct todo_item
*item
;
2668 char *p
= buf
, *next_p
;
2669 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2671 todo_list
->current
= todo_list
->nr
= todo_list
->total_nr
= 0;
2673 for (i
= 1; *p
; i
++, p
= next_p
) {
2674 char *eol
= strchrnul(p
, '\n');
2676 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2678 if (p
!= eol
&& eol
[-1] == '\r')
2679 eol
--; /* strip Carriage Return */
2681 item
= append_new_todo(todo_list
);
2682 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2683 if (parse_insn_line(r
, item
, buf
, p
, eol
)) {
2684 res
= error(_("invalid line %d: %.*s"),
2685 i
, (int)(eol
- p
), p
);
2686 item
->command
= TODO_COMMENT
+ 1;
2687 item
->arg_offset
= p
- buf
;
2688 item
->arg_len
= (int)(eol
- p
);
2689 item
->commit
= NULL
;
2692 if (item
->command
!= TODO_COMMENT
)
2693 todo_list
->total_nr
++;
2697 else if (is_fixup(item
->command
))
2698 return error(_("cannot '%s' without a previous commit"),
2699 command_to_string(item
->command
));
2700 else if (!is_noop(item
->command
))
2707 static int count_commands(struct todo_list
*todo_list
)
2711 for (i
= 0; i
< todo_list
->nr
; i
++)
2712 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2718 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2720 return index
< todo_list
->nr
?
2721 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2724 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2726 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2729 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2731 return get_item_line_offset(todo_list
, index
+ 1)
2732 - get_item_line_offset(todo_list
, index
);
2735 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2740 fd
= open(path
, O_RDONLY
);
2742 return error_errno(_("could not open '%s'"), path
);
2743 len
= strbuf_read(sb
, fd
, 0);
2746 return error(_("could not read '%s'."), path
);
2750 static int have_finished_the_last_pick(void)
2752 struct strbuf buf
= STRBUF_INIT
;
2754 const char *todo_path
= git_path_todo_file();
2757 if (strbuf_read_file(&buf
, todo_path
, 0) < 0) {
2758 if (errno
== ENOENT
) {
2761 error_errno("unable to open '%s'", todo_path
);
2765 /* If there is only one line then we are done */
2766 eol
= strchr(buf
.buf
, '\n');
2767 if (!eol
|| !eol
[1])
2770 strbuf_release(&buf
);
2775 void sequencer_post_commit_cleanup(struct repository
*r
, int verbose
)
2777 struct replay_opts opts
= REPLAY_OPTS_INIT
;
2778 int need_cleanup
= 0;
2780 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
2781 if (!refs_delete_ref(get_main_ref_store(r
), "",
2782 "CHERRY_PICK_HEAD", NULL
, 0) &&
2784 warning(_("cancelling a cherry picking in progress"));
2785 opts
.action
= REPLAY_PICK
;
2789 if (refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
2790 if (!refs_delete_ref(get_main_ref_store(r
), "", "REVERT_HEAD",
2793 warning(_("cancelling a revert in progress"));
2794 opts
.action
= REPLAY_REVERT
;
2798 unlink(git_path_auto_merge(r
));
2803 if (!have_finished_the_last_pick())
2806 sequencer_remove_state(&opts
);
2809 static void todo_list_write_total_nr(struct todo_list
*todo_list
)
2811 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2814 fprintf(f
, "%d\n", todo_list
->total_nr
);
2819 static int read_populate_todo(struct repository
*r
,
2820 struct todo_list
*todo_list
,
2821 struct replay_opts
*opts
)
2823 const char *todo_file
= get_todo_path(opts
);
2826 strbuf_reset(&todo_list
->buf
);
2827 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2830 res
= todo_list_parse_insn_buffer(r
, todo_list
->buf
.buf
, todo_list
);
2832 if (is_rebase_i(opts
))
2833 return error(_("please fix this using "
2834 "'git rebase --edit-todo'."));
2835 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2838 if (!todo_list
->nr
&&
2839 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2840 return error(_("no commits parsed."));
2842 if (!is_rebase_i(opts
)) {
2843 enum todo_command valid
=
2844 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2847 for (i
= 0; i
< todo_list
->nr
; i
++)
2848 if (valid
== todo_list
->items
[i
].command
)
2850 else if (valid
== TODO_PICK
)
2851 return error(_("cannot cherry-pick during a revert."));
2853 return error(_("cannot revert during a cherry-pick."));
2856 if (is_rebase_i(opts
)) {
2857 struct todo_list done
= TODO_LIST_INIT
;
2859 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2860 !todo_list_parse_insn_buffer(r
, done
.buf
.buf
, &done
))
2861 todo_list
->done_nr
= count_commands(&done
);
2863 todo_list
->done_nr
= 0;
2865 todo_list
->total_nr
= todo_list
->done_nr
2866 + count_commands(todo_list
);
2867 todo_list_release(&done
);
2869 todo_list_write_total_nr(todo_list
);
2875 static int git_config_string_dup(char **dest
,
2876 const char *var
, const char *value
)
2879 return config_error_nonbool(var
);
2881 *dest
= xstrdup(value
);
2885 static int populate_opts_cb(const char *key
, const char *value
,
2886 const struct config_context
*ctx
,
2889 struct replay_opts
*opts
= data
;
2894 else if (!strcmp(key
, "options.no-commit"))
2895 opts
->no_commit
= git_config_bool_or_int(key
, value
, ctx
->kvi
, &error_flag
);
2896 else if (!strcmp(key
, "options.edit"))
2897 opts
->edit
= git_config_bool_or_int(key
, value
, ctx
->kvi
, &error_flag
);
2898 else if (!strcmp(key
, "options.allow-empty"))
2900 git_config_bool_or_int(key
, value
, ctx
->kvi
, &error_flag
);
2901 else if (!strcmp(key
, "options.allow-empty-message"))
2902 opts
->allow_empty_message
=
2903 git_config_bool_or_int(key
, value
, ctx
->kvi
, &error_flag
);
2904 else if (!strcmp(key
, "options.keep-redundant-commits"))
2905 opts
->keep_redundant_commits
=
2906 git_config_bool_or_int(key
, value
, ctx
->kvi
, &error_flag
);
2907 else if (!strcmp(key
, "options.signoff"))
2908 opts
->signoff
= git_config_bool_or_int(key
, value
, ctx
->kvi
, &error_flag
);
2909 else if (!strcmp(key
, "options.record-origin"))
2910 opts
->record_origin
= git_config_bool_or_int(key
, value
, ctx
->kvi
, &error_flag
);
2911 else if (!strcmp(key
, "options.allow-ff"))
2912 opts
->allow_ff
= git_config_bool_or_int(key
, value
, ctx
->kvi
, &error_flag
);
2913 else if (!strcmp(key
, "options.mainline"))
2914 opts
->mainline
= git_config_int(key
, value
, ctx
->kvi
);
2915 else if (!strcmp(key
, "options.strategy"))
2916 git_config_string_dup(&opts
->strategy
, key
, value
);
2917 else if (!strcmp(key
, "options.gpg-sign"))
2918 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
2919 else if (!strcmp(key
, "options.strategy-option")) {
2920 strvec_push(&opts
->xopts
, value
);
2921 } else if (!strcmp(key
, "options.allow-rerere-auto"))
2922 opts
->allow_rerere_auto
=
2923 git_config_bool_or_int(key
, value
, ctx
->kvi
, &error_flag
) ?
2924 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
2925 else if (!strcmp(key
, "options.default-msg-cleanup")) {
2926 opts
->explicit_cleanup
= 1;
2927 opts
->default_msg_cleanup
= get_cleanup_mode(value
, 1);
2929 return error(_("invalid key: %s"), key
);
2932 return error(_("invalid value for '%s': '%s'"), key
, value
);
2937 static void parse_strategy_opts(struct replay_opts
*opts
, char *raw_opts
)
2942 char *strategy_opts_string
= raw_opts
;
2944 if (*strategy_opts_string
== ' ')
2945 strategy_opts_string
++;
2947 count
= split_cmdline(strategy_opts_string
, &argv
);
2949 BUG("could not split '%s': %s", strategy_opts_string
,
2950 split_cmdline_strerror(count
));
2951 for (i
= 0; i
< count
; i
++) {
2952 const char *arg
= argv
[i
];
2954 skip_prefix(arg
, "--", &arg
);
2955 strvec_push(&opts
->xopts
, arg
);
2960 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2963 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2965 opts
->strategy
= strbuf_detach(buf
, NULL
);
2966 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2969 parse_strategy_opts(opts
, buf
->buf
);
2972 static int read_populate_opts(struct replay_opts
*opts
)
2974 if (is_rebase_i(opts
)) {
2975 struct strbuf buf
= STRBUF_INIT
;
2978 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(),
2979 READ_ONELINER_SKIP_IF_EMPTY
)) {
2980 if (!starts_with(buf
.buf
, "-S"))
2983 free(opts
->gpg_sign
);
2984 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2989 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(),
2990 READ_ONELINER_SKIP_IF_EMPTY
)) {
2991 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2992 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2993 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2994 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2998 if (file_exists(rebase_path_verbose()))
3001 if (file_exists(rebase_path_quiet()))
3004 if (file_exists(rebase_path_signoff())) {
3009 if (file_exists(rebase_path_cdate_is_adate())) {
3011 opts
->committer_date_is_author_date
= 1;
3014 if (file_exists(rebase_path_ignore_date())) {
3016 opts
->ignore_date
= 1;
3019 if (file_exists(rebase_path_reschedule_failed_exec()))
3020 opts
->reschedule_failed_exec
= 1;
3021 else if (file_exists(rebase_path_no_reschedule_failed_exec()))
3022 opts
->reschedule_failed_exec
= 0;
3024 if (file_exists(rebase_path_drop_redundant_commits()))
3025 opts
->drop_redundant_commits
= 1;
3027 if (file_exists(rebase_path_keep_redundant_commits()))
3028 opts
->keep_redundant_commits
= 1;
3030 read_strategy_opts(opts
, &buf
);
3033 if (read_oneliner(&opts
->current_fixups
,
3034 rebase_path_current_fixups(),
3035 READ_ONELINER_SKIP_IF_EMPTY
)) {
3036 const char *p
= opts
->current_fixups
.buf
;
3037 opts
->current_fixup_count
= 1;
3038 while ((p
= strchr(p
, '\n'))) {
3039 opts
->current_fixup_count
++;
3044 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
3045 if (repo_get_oid_committish(the_repository
, buf
.buf
, &opts
->squash_onto
) < 0) {
3046 ret
= error(_("unusable squash-onto"));
3049 opts
->have_squash_onto
= 1;
3053 strbuf_release(&buf
);
3057 if (!file_exists(git_path_opts_file()))
3060 * The function git_parse_source(), called from git_config_from_file(),
3061 * may die() in case of a syntactically incorrect file. We do not care
3062 * about this case, though, because we wrote that file ourselves, so we
3063 * are pretty certain that it is syntactically correct.
3065 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
3066 return error(_("malformed options sheet: '%s'"),
3067 git_path_opts_file());
3071 static void write_strategy_opts(struct replay_opts
*opts
)
3073 struct strbuf buf
= STRBUF_INIT
;
3076 * Quote strategy options so that they can be read correctly
3077 * by split_cmdline().
3079 quote_cmdline(&buf
, opts
->xopts
.v
);
3080 write_file(rebase_path_strategy_opts(), "%s\n", buf
.buf
);
3081 strbuf_release(&buf
);
3084 int write_basic_state(struct replay_opts
*opts
, const char *head_name
,
3085 struct commit
*onto
, const struct object_id
*orig_head
)
3088 write_file(rebase_path_head_name(), "%s\n", head_name
);
3090 write_file(rebase_path_onto(), "%s\n",
3091 oid_to_hex(&onto
->object
.oid
));
3093 write_file(rebase_path_orig_head(), "%s\n",
3094 oid_to_hex(orig_head
));
3097 write_file(rebase_path_quiet(), "%s", "");
3099 write_file(rebase_path_verbose(), "%s", "");
3101 write_file(rebase_path_strategy(), "%s\n", opts
->strategy
);
3102 if (opts
->xopts
.nr
> 0)
3103 write_strategy_opts(opts
);
3105 if (opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
)
3106 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
3107 else if (opts
->allow_rerere_auto
== RERERE_NOAUTOUPDATE
)
3108 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
3111 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts
->gpg_sign
);
3113 write_file(rebase_path_signoff(), "--signoff\n");
3114 if (opts
->drop_redundant_commits
)
3115 write_file(rebase_path_drop_redundant_commits(), "%s", "");
3116 if (opts
->keep_redundant_commits
)
3117 write_file(rebase_path_keep_redundant_commits(), "%s", "");
3118 if (opts
->committer_date_is_author_date
)
3119 write_file(rebase_path_cdate_is_adate(), "%s", "");
3120 if (opts
->ignore_date
)
3121 write_file(rebase_path_ignore_date(), "%s", "");
3122 if (opts
->reschedule_failed_exec
)
3123 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
3125 write_file(rebase_path_no_reschedule_failed_exec(), "%s", "");
3130 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
3131 struct replay_opts
*opts
)
3133 enum todo_command command
= opts
->action
== REPLAY_PICK
?
3134 TODO_PICK
: TODO_REVERT
;
3135 const char *command_string
= todo_command_info
[command
].str
;
3136 const char *encoding
;
3137 struct commit
*commit
;
3139 if (prepare_revs(opts
))
3142 encoding
= get_log_output_encoding();
3144 while ((commit
= get_revision(opts
->revs
))) {
3145 struct todo_item
*item
= append_new_todo(todo_list
);
3146 const char *commit_buffer
= repo_logmsg_reencode(the_repository
,
3149 const char *subject
;
3152 item
->command
= command
;
3153 item
->commit
= commit
;
3154 item
->arg_offset
= 0;
3156 item
->offset_in_buf
= todo_list
->buf
.len
;
3157 subject_len
= find_commit_subject(commit_buffer
, &subject
);
3158 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
3159 short_commit_name(commit
), subject_len
, subject
);
3160 repo_unuse_commit_buffer(the_repository
, commit
,
3165 return error(_("empty commit set passed"));
3170 static int create_seq_dir(struct repository
*r
)
3172 enum replay_action action
;
3173 const char *in_progress_error
= NULL
;
3174 const char *in_progress_advice
= NULL
;
3175 unsigned int advise_skip
=
3176 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD") ||
3177 refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD");
3179 if (!sequencer_get_last_command(r
, &action
)) {
3182 in_progress_error
= _("revert is already in progress");
3183 in_progress_advice
=
3184 _("try \"git revert (--continue | %s--abort | --quit)\"");
3187 in_progress_error
= _("cherry-pick is already in progress");
3188 in_progress_advice
=
3189 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
3192 BUG("unexpected action in create_seq_dir");
3195 if (in_progress_error
) {
3196 error("%s", in_progress_error
);
3197 if (advice_enabled(ADVICE_SEQUENCER_IN_USE
))
3198 advise(in_progress_advice
,
3199 advise_skip
? "--skip | " : "");
3202 if (mkdir(git_path_seq_dir(), 0777) < 0)
3203 return error_errno(_("could not create sequencer directory '%s'"),
3204 git_path_seq_dir());
3209 static int save_head(const char *head
)
3211 return write_message(head
, strlen(head
), git_path_head_file(), 1);
3214 static int rollback_is_safe(void)
3216 struct strbuf sb
= STRBUF_INIT
;
3217 struct object_id expected_head
, actual_head
;
3219 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
3221 if (get_oid_hex(sb
.buf
, &expected_head
)) {
3222 strbuf_release(&sb
);
3223 die(_("could not parse %s"), git_path_abort_safety_file());
3225 strbuf_release(&sb
);
3227 else if (errno
== ENOENT
)
3228 oidclr(&expected_head
);
3230 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
3232 if (repo_get_oid(the_repository
, "HEAD", &actual_head
))
3233 oidclr(&actual_head
);
3235 return oideq(&actual_head
, &expected_head
);
3238 static int reset_merge(const struct object_id
*oid
)
3240 struct child_process cmd
= CHILD_PROCESS_INIT
;
3243 strvec_pushl(&cmd
.args
, "reset", "--merge", NULL
);
3245 if (!is_null_oid(oid
))
3246 strvec_push(&cmd
.args
, oid_to_hex(oid
));
3248 return run_command(&cmd
);
3251 static int rollback_single_pick(struct repository
*r
)
3253 struct object_id head_oid
;
3255 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
3256 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
3257 return error(_("no cherry-pick or revert in progress"));
3258 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
3259 return error(_("cannot resolve HEAD"));
3260 if (is_null_oid(&head_oid
))
3261 return error(_("cannot abort from a branch yet to be born"));
3262 return reset_merge(&head_oid
);
3265 static int skip_single_pick(void)
3267 struct object_id head
;
3269 if (read_ref_full("HEAD", 0, &head
, NULL
))
3270 return error(_("cannot resolve HEAD"));
3271 return reset_merge(&head
);
3274 int sequencer_rollback(struct repository
*r
, struct replay_opts
*opts
)
3277 struct object_id oid
;
3278 struct strbuf buf
= STRBUF_INIT
;
3281 f
= fopen(git_path_head_file(), "r");
3282 if (!f
&& errno
== ENOENT
) {
3284 * There is no multiple-cherry-pick in progress.
3285 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
3286 * a single-cherry-pick in progress, abort that.
3288 return rollback_single_pick(r
);
3291 return error_errno(_("cannot open '%s'"), git_path_head_file());
3292 if (strbuf_getline_lf(&buf
, f
)) {
3293 error(_("cannot read '%s': %s"), git_path_head_file(),
3294 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
3299 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
3300 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
3301 git_path_head_file());
3304 if (is_null_oid(&oid
)) {
3305 error(_("cannot abort from a branch yet to be born"));
3309 if (!rollback_is_safe()) {
3310 /* Do not error, just do not rollback */
3311 warning(_("You seem to have moved HEAD. "
3312 "Not rewinding, check your HEAD!"));
3314 if (reset_merge(&oid
))
3316 strbuf_release(&buf
);
3317 return sequencer_remove_state(opts
);
3319 strbuf_release(&buf
);
3323 int sequencer_skip(struct repository
*r
, struct replay_opts
*opts
)
3325 enum replay_action action
= -1;
3326 sequencer_get_last_command(r
, &action
);
3329 * Check whether the subcommand requested to skip the commit is actually
3330 * in progress and that it's safe to skip the commit.
3332 * opts->action tells us which subcommand requested to skip the commit.
3333 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
3334 * action is in progress and we can skip the commit.
3336 * Otherwise we check that the last instruction was related to the
3337 * particular subcommand we're trying to execute and barf if that's not
3340 * Finally we check that the rollback is "safe", i.e., has the HEAD
3341 * moved? In this case, it doesn't make sense to "reset the merge" and
3342 * "skip the commit" as the user already handled this by committing. But
3343 * we'd not want to barf here, instead give advice on how to proceed. We
3344 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
3345 * it gets removed when the user commits, so if it still exists we're
3346 * sure the user can't have committed before.
3348 switch (opts
->action
) {
3350 if (!refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
3351 if (action
!= REPLAY_REVERT
)
3352 return error(_("no revert in progress"));
3353 if (!rollback_is_safe())
3358 if (!refs_ref_exists(get_main_ref_store(r
),
3359 "CHERRY_PICK_HEAD")) {
3360 if (action
!= REPLAY_PICK
)
3361 return error(_("no cherry-pick in progress"));
3362 if (!rollback_is_safe())
3367 BUG("unexpected action in sequencer_skip");
3370 if (skip_single_pick())
3371 return error(_("failed to skip the commit"));
3372 if (!is_directory(git_path_seq_dir()))
3375 return sequencer_continue(r
, opts
);
3378 error(_("there is nothing to skip"));
3380 if (advice_enabled(ADVICE_RESOLVE_CONFLICT
)) {
3381 advise(_("have you committed already?\n"
3382 "try \"git %s --continue\""),
3383 action
== REPLAY_REVERT
? "revert" : "cherry-pick");
3388 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
3390 struct lock_file todo_lock
= LOCK_INIT
;
3391 const char *todo_path
= get_todo_path(opts
);
3392 int next
= todo_list
->current
, offset
, fd
;
3395 * rebase -i writes "git-rebase-todo" without the currently executing
3396 * command, appending it to "done" instead.
3398 if (is_rebase_i(opts
))
3401 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
3403 return error_errno(_("could not lock '%s'"), todo_path
);
3404 offset
= get_item_line_offset(todo_list
, next
);
3405 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
3406 todo_list
->buf
.len
- offset
) < 0)
3407 return error_errno(_("could not write to '%s'"), todo_path
);
3408 if (commit_lock_file(&todo_lock
) < 0)
3409 return error(_("failed to finalize '%s'"), todo_path
);
3411 if (is_rebase_i(opts
) && next
> 0) {
3412 const char *done
= rebase_path_done();
3413 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
3418 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
3419 get_item_line_length(todo_list
, next
- 1))
3421 ret
= error_errno(_("could not write to '%s'"), done
);
3423 ret
= error_errno(_("failed to finalize '%s'"), done
);
3429 static int save_opts(struct replay_opts
*opts
)
3431 const char *opts_file
= git_path_opts_file();
3434 if (opts
->no_commit
)
3435 res
|= git_config_set_in_file_gently(opts_file
,
3436 "options.no-commit", "true");
3437 if (opts
->edit
>= 0)
3438 res
|= git_config_set_in_file_gently(opts_file
, "options.edit",
3439 opts
->edit
? "true" : "false");
3440 if (opts
->allow_empty
)
3441 res
|= git_config_set_in_file_gently(opts_file
,
3442 "options.allow-empty", "true");
3443 if (opts
->allow_empty_message
)
3444 res
|= git_config_set_in_file_gently(opts_file
,
3445 "options.allow-empty-message", "true");
3446 if (opts
->keep_redundant_commits
)
3447 res
|= git_config_set_in_file_gently(opts_file
,
3448 "options.keep-redundant-commits", "true");
3450 res
|= git_config_set_in_file_gently(opts_file
,
3451 "options.signoff", "true");
3452 if (opts
->record_origin
)
3453 res
|= git_config_set_in_file_gently(opts_file
,
3454 "options.record-origin", "true");
3456 res
|= git_config_set_in_file_gently(opts_file
,
3457 "options.allow-ff", "true");
3458 if (opts
->mainline
) {
3459 struct strbuf buf
= STRBUF_INIT
;
3460 strbuf_addf(&buf
, "%d", opts
->mainline
);
3461 res
|= git_config_set_in_file_gently(opts_file
,
3462 "options.mainline", buf
.buf
);
3463 strbuf_release(&buf
);
3466 res
|= git_config_set_in_file_gently(opts_file
,
3467 "options.strategy", opts
->strategy
);
3469 res
|= git_config_set_in_file_gently(opts_file
,
3470 "options.gpg-sign", opts
->gpg_sign
);
3471 for (size_t i
= 0; i
< opts
->xopts
.nr
; i
++)
3472 res
|= git_config_set_multivar_in_file_gently(opts_file
,
3473 "options.strategy-option",
3474 opts
->xopts
.v
[i
], "^$", 0);
3475 if (opts
->allow_rerere_auto
)
3476 res
|= git_config_set_in_file_gently(opts_file
,
3477 "options.allow-rerere-auto",
3478 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
3481 if (opts
->explicit_cleanup
)
3482 res
|= git_config_set_in_file_gently(opts_file
,
3483 "options.default-msg-cleanup",
3484 describe_cleanup_mode(opts
->default_msg_cleanup
));
3488 static int make_patch(struct repository
*r
,
3489 struct commit
*commit
,
3490 struct replay_opts
*opts
)
3492 struct strbuf buf
= STRBUF_INIT
;
3493 struct rev_info log_tree_opt
;
3494 const char *subject
;
3495 char hex
[GIT_MAX_HEXSZ
+ 1];
3498 oid_to_hex_r(hex
, &commit
->object
.oid
);
3499 if (write_message(hex
, strlen(hex
), rebase_path_stopped_sha(), 1) < 0)
3501 res
|= write_rebase_head(&commit
->object
.oid
);
3503 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
3504 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3505 repo_init_revisions(r
, &log_tree_opt
, NULL
);
3506 log_tree_opt
.abbrev
= 0;
3507 log_tree_opt
.diff
= 1;
3508 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
3509 log_tree_opt
.disable_stdin
= 1;
3510 log_tree_opt
.no_commit_id
= 1;
3511 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
3512 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
3513 if (!log_tree_opt
.diffopt
.file
)
3514 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
3516 res
|= log_tree_commit(&log_tree_opt
, commit
);
3517 fclose(log_tree_opt
.diffopt
.file
);
3521 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
3522 if (!file_exists(buf
.buf
)) {
3523 const char *encoding
= get_commit_output_encoding();
3524 const char *commit_buffer
= repo_logmsg_reencode(r
,
3527 find_commit_subject(commit_buffer
, &subject
);
3528 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
3529 repo_unuse_commit_buffer(r
, commit
,
3532 strbuf_release(&buf
);
3533 release_revisions(&log_tree_opt
);
3538 static int intend_to_amend(void)
3540 struct object_id head
;
3543 if (repo_get_oid(the_repository
, "HEAD", &head
))
3544 return error(_("cannot read HEAD"));
3546 p
= oid_to_hex(&head
);
3547 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
3550 static int error_with_patch(struct repository
*r
,
3551 struct commit
*commit
,
3552 const char *subject
, int subject_len
,
3553 struct replay_opts
*opts
,
3554 int exit_code
, int to_amend
)
3557 if (make_patch(r
, commit
, opts
))
3559 } else if (copy_file(rebase_path_message(),
3560 git_path_merge_msg(r
), 0666))
3561 return error(_("unable to copy '%s' to '%s'"),
3562 git_path_merge_msg(r
), rebase_path_message());
3565 if (intend_to_amend())
3569 _("You can amend the commit now, with\n"
3571 " git commit --amend %s\n"
3573 "Once you are satisfied with your changes, run\n"
3575 " git rebase --continue\n"),
3576 gpg_sign_opt_quoted(opts
));
3577 } else if (exit_code
) {
3579 fprintf_ln(stderr
, _("Could not apply %s... %.*s"),
3580 short_commit_name(commit
), subject_len
, subject
);
3583 * We don't have the hash of the parent so
3584 * just print the line from the todo file.
3586 fprintf_ln(stderr
, _("Could not merge %.*s"),
3587 subject_len
, subject
);
3593 static int error_failed_squash(struct repository
*r
,
3594 struct commit
*commit
,
3595 struct replay_opts
*opts
,
3597 const char *subject
)
3599 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3600 return error(_("could not copy '%s' to '%s'"),
3601 rebase_path_squash_msg(), rebase_path_message());
3602 unlink(git_path_merge_msg(r
));
3603 if (copy_file(git_path_merge_msg(r
), rebase_path_message(), 0666))
3604 return error(_("could not copy '%s' to '%s'"),
3605 rebase_path_message(),
3606 git_path_merge_msg(r
));
3607 return error_with_patch(r
, commit
, subject
, subject_len
, opts
, 1, 0);
3610 static int do_exec(struct repository
*r
, const char *command_line
)
3612 struct child_process cmd
= CHILD_PROCESS_INIT
;
3615 fprintf(stderr
, _("Executing: %s\n"), command_line
);
3617 strvec_push(&cmd
.args
, command_line
);
3618 status
= run_command(&cmd
);
3620 /* force re-reading of the cache */
3621 discard_index(r
->index
);
3622 if (repo_read_index(r
) < 0)
3623 return error(_("could not read index"));
3625 dirty
= require_clean_work_tree(r
, "rebase", NULL
, 1, 1);
3628 warning(_("execution failed: %s\n%s"
3629 "You can fix the problem, and then run\n"
3631 " git rebase --continue\n"
3634 dirty
? _("and made changes to the index and/or the "
3635 "working tree.\n") : "");
3637 /* command not found */
3640 warning(_("execution succeeded: %s\nbut "
3641 "left changes to the index and/or the working tree.\n"
3642 "Commit or stash your changes, and then run\n"
3644 " git rebase --continue\n"
3645 "\n"), command_line
);
3652 __attribute__((format (printf
, 2, 3)))
3653 static int safe_append(const char *filename
, const char *fmt
, ...)
3656 struct lock_file lock
= LOCK_INIT
;
3657 int fd
= hold_lock_file_for_update(&lock
, filename
,
3658 LOCK_REPORT_ON_ERROR
);
3659 struct strbuf buf
= STRBUF_INIT
;
3664 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
3665 error_errno(_("could not read '%s'"), filename
);
3666 rollback_lock_file(&lock
);
3669 strbuf_complete(&buf
, '\n');
3671 strbuf_vaddf(&buf
, fmt
, ap
);
3674 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
3675 error_errno(_("could not write to '%s'"), filename
);
3676 strbuf_release(&buf
);
3677 rollback_lock_file(&lock
);
3680 if (commit_lock_file(&lock
) < 0) {
3681 strbuf_release(&buf
);
3682 return error(_("failed to finalize '%s'"), filename
);
3685 strbuf_release(&buf
);
3689 static int do_label(struct repository
*r
, const char *name
, int len
)
3691 struct ref_store
*refs
= get_main_ref_store(r
);
3692 struct ref_transaction
*transaction
;
3693 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
3694 struct strbuf msg
= STRBUF_INIT
;
3696 struct object_id head_oid
;
3698 if (len
== 1 && *name
== '#')
3699 return error(_("illegal label name: '%.*s'"), len
, name
);
3701 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3702 strbuf_addf(&msg
, "rebase (label) '%.*s'", len
, name
);
3704 transaction
= ref_store_transaction_begin(refs
, &err
);
3706 error("%s", err
.buf
);
3708 } else if (repo_get_oid(r
, "HEAD", &head_oid
)) {
3709 error(_("could not read HEAD"));
3711 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
3712 NULL
, 0, msg
.buf
, &err
) < 0 ||
3713 ref_transaction_commit(transaction
, &err
)) {
3714 error("%s", err
.buf
);
3717 ref_transaction_free(transaction
);
3718 strbuf_release(&err
);
3719 strbuf_release(&msg
);
3722 ret
= safe_append(rebase_path_refs_to_delete(),
3723 "%s\n", ref_name
.buf
);
3724 strbuf_release(&ref_name
);
3729 static const char *sequencer_reflog_action(struct replay_opts
*opts
)
3731 if (!opts
->reflog_action
) {
3732 opts
->reflog_action
= getenv(GIT_REFLOG_ACTION
);
3733 opts
->reflog_action
=
3734 xstrdup(opts
->reflog_action
? opts
->reflog_action
3735 : action_name(opts
));
3738 return opts
->reflog_action
;
3741 __attribute__((format (printf
, 3, 4)))
3742 static const char *reflog_message(struct replay_opts
*opts
,
3743 const char *sub_action
, const char *fmt
, ...)
3746 static struct strbuf buf
= STRBUF_INIT
;
3750 strbuf_addstr(&buf
, sequencer_reflog_action(opts
));
3752 strbuf_addf(&buf
, " (%s)", sub_action
);
3754 strbuf_addstr(&buf
, ": ");
3755 strbuf_vaddf(&buf
, fmt
, ap
);
3762 static struct commit
*lookup_label(struct repository
*r
, const char *label
,
3763 int len
, struct strbuf
*buf
)
3765 struct commit
*commit
;
3766 struct object_id oid
;
3769 strbuf_addf(buf
, "refs/rewritten/%.*s", len
, label
);
3770 if (!read_ref(buf
->buf
, &oid
)) {
3771 commit
= lookup_commit_object(r
, &oid
);
3773 /* fall back to non-rewritten ref or commit */
3774 strbuf_splice(buf
, 0, strlen("refs/rewritten/"), "", 0);
3775 commit
= lookup_commit_reference_by_name(buf
->buf
);
3779 error(_("could not resolve '%s'"), buf
->buf
);
3784 static int do_reset(struct repository
*r
,
3785 const char *name
, int len
,
3786 struct replay_opts
*opts
)
3788 struct strbuf ref_name
= STRBUF_INIT
;
3789 struct object_id oid
;
3790 struct lock_file lock
= LOCK_INIT
;
3791 struct tree_desc desc
= { 0 };
3793 struct unpack_trees_options unpack_tree_opts
= { 0 };
3796 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0)
3799 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
3800 if (!opts
->have_squash_onto
) {
3802 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
3803 NULL
, &opts
->squash_onto
,
3805 return error(_("writing fake root commit"));
3806 opts
->have_squash_onto
= 1;
3807 hex
= oid_to_hex(&opts
->squash_onto
);
3808 if (write_message(hex
, strlen(hex
),
3809 rebase_path_squash_onto(), 0))
3810 return error(_("writing squash-onto"));
3812 oidcpy(&oid
, &opts
->squash_onto
);
3815 struct commit
*commit
;
3817 /* Determine the length of the label */
3818 for (i
= 0; i
< len
; i
++)
3819 if (isspace(name
[i
]))
3823 commit
= lookup_label(r
, name
, len
, &ref_name
);
3828 oid
= commit
->object
.oid
;
3831 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
3832 unpack_tree_opts
.head_idx
= 1;
3833 unpack_tree_opts
.src_index
= r
->index
;
3834 unpack_tree_opts
.dst_index
= r
->index
;
3835 unpack_tree_opts
.fn
= oneway_merge
;
3836 unpack_tree_opts
.merge
= 1;
3837 unpack_tree_opts
.update
= 1;
3838 unpack_tree_opts
.preserve_ignored
= 0; /* FIXME: !overwrite_ignore */
3839 unpack_tree_opts
.skip_cache_tree_update
= 1;
3840 init_checkout_metadata(&unpack_tree_opts
.meta
, name
, &oid
, NULL
);
3842 if (repo_read_index_unmerged(r
)) {
3843 ret
= error_resolve_conflict(action_name(opts
));
3847 if (!fill_tree_descriptor(r
, &desc
, &oid
)) {
3848 ret
= error(_("failed to find tree of %s"), oid_to_hex(&oid
));
3852 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
3857 tree
= parse_tree_indirect(&oid
);
3858 prime_cache_tree(r
, r
->index
, tree
);
3860 if (write_locked_index(r
->index
, &lock
, COMMIT_LOCK
) < 0)
3861 ret
= error(_("could not write index"));
3864 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
3865 len
, name
), "HEAD", &oid
,
3866 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3868 free((void *)desc
.buffer
);
3870 rollback_lock_file(&lock
);
3871 strbuf_release(&ref_name
);
3872 clear_unpack_trees_porcelain(&unpack_tree_opts
);
3876 static int do_merge(struct repository
*r
,
3877 struct commit
*commit
,
3878 const char *arg
, int arg_len
,
3879 int flags
, int *check_todo
, struct replay_opts
*opts
)
3881 int run_commit_flags
= 0;
3882 struct strbuf ref_name
= STRBUF_INIT
;
3883 struct commit
*head_commit
, *merge_commit
, *i
;
3884 struct commit_list
*bases
, *j
;
3885 struct commit_list
*to_merge
= NULL
, **tail
= &to_merge
;
3886 const char *strategy
= !opts
->xopts
.nr
&&
3888 !strcmp(opts
->strategy
, "recursive") ||
3889 !strcmp(opts
->strategy
, "ort")) ?
3890 NULL
: opts
->strategy
;
3891 struct merge_options o
;
3892 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
, k
;
3893 static struct lock_file lock
;
3896 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0) {
3901 head_commit
= lookup_commit_reference_by_name("HEAD");
3903 ret
= error(_("cannot merge without a current revision"));
3908 * For octopus merges, the arg starts with the list of revisions to be
3909 * merged. The list is optionally followed by '#' and the oneline.
3911 merge_arg_len
= oneline_offset
= arg_len
;
3912 for (p
= arg
; p
- arg
< arg_len
; p
+= strspn(p
, " \t\n")) {
3915 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
3916 p
+= 1 + strspn(p
+ 1, " \t\n");
3917 oneline_offset
= p
- arg
;
3920 k
= strcspn(p
, " \t\n");
3923 merge_commit
= lookup_label(r
, p
, k
, &ref_name
);
3924 if (!merge_commit
) {
3925 ret
= error(_("unable to parse '%.*s'"), k
, p
);
3928 tail
= &commit_list_insert(merge_commit
, tail
)->next
;
3930 merge_arg_len
= p
- arg
;
3934 ret
= error(_("nothing to merge: '%.*s'"), arg_len
, arg
);
3938 if (opts
->have_squash_onto
&&
3939 oideq(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
3941 * When the user tells us to "merge" something into a
3942 * "[new root]", let's simply fast-forward to the merge head.
3944 rollback_lock_file(&lock
);
3946 ret
= error(_("octopus merge cannot be executed on "
3947 "top of a [new root]"));
3949 ret
= fast_forward_to(r
, &to_merge
->item
->object
.oid
,
3950 &head_commit
->object
.oid
, 0,
3956 * If HEAD is not identical to the first parent of the original merge
3957 * commit, we cannot fast-forward.
3959 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
3960 oideq(&commit
->parents
->item
->object
.oid
,
3961 &head_commit
->object
.oid
);
3964 * If any merge head is different from the original one, we cannot
3967 if (can_fast_forward
) {
3968 struct commit_list
*p
= commit
->parents
->next
;
3970 for (j
= to_merge
; j
&& p
; j
= j
->next
, p
= p
->next
)
3971 if (!oideq(&j
->item
->object
.oid
,
3972 &p
->item
->object
.oid
)) {
3973 can_fast_forward
= 0;
3977 * If the number of merge heads differs from the original merge
3978 * commit, we cannot fast-forward.
3981 can_fast_forward
= 0;
3984 if (can_fast_forward
) {
3985 rollback_lock_file(&lock
);
3986 ret
= fast_forward_to(r
, &commit
->object
.oid
,
3987 &head_commit
->object
.oid
, 0, opts
);
3988 if (flags
& TODO_EDIT_MERGE_MSG
)
3989 goto fast_forward_edit
;
3995 const char *encoding
= get_commit_output_encoding();
3996 const char *message
= repo_logmsg_reencode(r
, commit
, NULL
,
4002 ret
= error(_("could not get commit message of '%s'"),
4003 oid_to_hex(&commit
->object
.oid
));
4006 write_author_script(message
);
4007 find_commit_subject(message
, &body
);
4009 ret
= write_message(body
, len
, git_path_merge_msg(r
), 0);
4010 repo_unuse_commit_buffer(r
, commit
, message
);
4012 error_errno(_("could not write '%s'"),
4013 git_path_merge_msg(r
));
4017 struct strbuf buf
= STRBUF_INIT
;
4020 strbuf_addf(&buf
, "author %s", git_author_info(0));
4021 write_author_script(buf
.buf
);
4024 if (oneline_offset
< arg_len
) {
4025 p
= arg
+ oneline_offset
;
4026 len
= arg_len
- oneline_offset
;
4028 strbuf_addf(&buf
, "Merge %s '%.*s'",
4029 to_merge
->next
? "branches" : "branch",
4030 merge_arg_len
, arg
);
4035 ret
= write_message(p
, len
, git_path_merge_msg(r
), 0);
4036 strbuf_release(&buf
);
4038 error_errno(_("could not write '%s'"),
4039 git_path_merge_msg(r
));
4044 if (strategy
|| to_merge
->next
) {
4046 struct child_process cmd
= CHILD_PROCESS_INIT
;
4048 if (read_env_script(&cmd
.env
)) {
4049 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
4051 ret
= error(_(staged_changes_advice
), gpg_opt
, gpg_opt
);
4055 if (opts
->committer_date_is_author_date
)
4056 strvec_pushf(&cmd
.env
, "GIT_COMMITTER_DATE=%s",
4059 author_date_from_env(&cmd
.env
));
4060 if (opts
->ignore_date
)
4061 strvec_push(&cmd
.env
, "GIT_AUTHOR_DATE=");
4064 strvec_push(&cmd
.args
, "merge");
4065 strvec_push(&cmd
.args
, "-s");
4067 strvec_push(&cmd
.args
, "octopus");
4069 strvec_push(&cmd
.args
, strategy
);
4070 for (k
= 0; k
< opts
->xopts
.nr
; k
++)
4071 strvec_pushf(&cmd
.args
,
4072 "-X%s", opts
->xopts
.v
[k
]);
4074 if (!(flags
& TODO_EDIT_MERGE_MSG
))
4075 strvec_push(&cmd
.args
, "--no-edit");
4077 strvec_push(&cmd
.args
, "--edit");
4078 strvec_push(&cmd
.args
, "--no-ff");
4079 strvec_push(&cmd
.args
, "--no-log");
4080 strvec_push(&cmd
.args
, "--no-stat");
4081 strvec_push(&cmd
.args
, "-F");
4082 strvec_push(&cmd
.args
, git_path_merge_msg(r
));
4084 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
4086 strvec_push(&cmd
.args
, "--no-gpg-sign");
4088 /* Add the tips to be merged */
4089 for (j
= to_merge
; j
; j
= j
->next
)
4090 strvec_push(&cmd
.args
,
4091 oid_to_hex(&j
->item
->object
.oid
));
4093 strbuf_release(&ref_name
);
4094 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
4096 rollback_lock_file(&lock
);
4098 ret
= run_command(&cmd
);
4100 /* force re-reading of the cache */
4102 discard_index(r
->index
);
4103 if (repo_read_index(r
) < 0)
4104 ret
= error(_("could not read index"));
4109 merge_commit
= to_merge
->item
;
4110 bases
= repo_get_merge_bases(r
, head_commit
, merge_commit
);
4111 if (bases
&& oideq(&merge_commit
->object
.oid
,
4112 &bases
->item
->object
.oid
)) {
4114 /* skip merging an ancestor of HEAD */
4118 write_message(oid_to_hex(&merge_commit
->object
.oid
), the_hash_algo
->hexsz
,
4119 git_path_merge_head(r
), 0);
4120 write_message("no-ff", 5, git_path_merge_mode(r
), 0);
4122 bases
= reverse_commit_list(bases
);
4125 init_merge_options(&o
, r
);
4127 o
.branch2
= ref_name
.buf
;
4128 o
.buffer_output
= 2;
4130 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
4132 * TODO: Should use merge_incore_recursive() and
4133 * merge_switch_to_result(), skipping the call to
4134 * merge_switch_to_result() when we don't actually need to
4135 * update the index and working copy immediately.
4137 ret
= merge_ort_recursive(&o
,
4138 head_commit
, merge_commit
, bases
,
4141 ret
= merge_recursive(&o
, head_commit
, merge_commit
, bases
,
4145 fputs(o
.obuf
.buf
, stdout
);
4146 strbuf_release(&o
.obuf
);
4148 error(_("could not even attempt to merge '%.*s'"),
4149 merge_arg_len
, arg
);
4153 * The return value of merge_recursive() is 1 on clean, and 0 on
4156 * Let's reverse that, so that do_merge() returns 0 upon success and
4157 * 1 upon failed merge (keeping the return value -1 for the cases where
4158 * we will want to reschedule the `merge` command).
4162 if (r
->index
->cache_changed
&&
4163 write_locked_index(r
->index
, &lock
, COMMIT_LOCK
)) {
4164 ret
= error(_("merge: Unable to write new index file"));
4168 rollback_lock_file(&lock
);
4170 repo_rerere(r
, opts
->allow_rerere_auto
);
4173 * In case of problems, we now want to return a positive
4174 * value (a negative one would indicate that the `merge`
4175 * command needs to be rescheduled).
4177 ret
= !!run_git_commit(git_path_merge_msg(r
), opts
,
4180 if (!ret
&& flags
& TODO_EDIT_MERGE_MSG
) {
4183 run_commit_flags
|= AMEND_MSG
| EDIT_MSG
| VERIFY_MSG
;
4184 ret
= !!run_git_commit(NULL
, opts
, run_commit_flags
);
4189 strbuf_release(&ref_name
);
4190 rollback_lock_file(&lock
);
4191 free_commit_list(to_merge
);
4195 static int write_update_refs_state(struct string_list
*refs_to_oids
)
4198 struct lock_file lock
= LOCK_INIT
;
4200 struct string_list_item
*item
;
4203 path
= rebase_path_update_refs(the_repository
->gitdir
);
4205 if (!refs_to_oids
->nr
) {
4206 if (unlink(path
) && errno
!= ENOENT
)
4207 result
= error_errno(_("could not unlink: %s"), path
);
4211 if (safe_create_leading_directories(path
)) {
4212 result
= error(_("unable to create leading directories of %s"),
4217 if (hold_lock_file_for_update(&lock
, path
, 0) < 0) {
4218 result
= error(_("another 'rebase' process appears to be running; "
4219 "'%s.lock' already exists"),
4224 fp
= fdopen_lock_file(&lock
, "w");
4226 result
= error_errno(_("could not open '%s' for writing"), path
);
4227 rollback_lock_file(&lock
);
4231 for_each_string_list_item(item
, refs_to_oids
) {
4232 struct update_ref_record
*rec
= item
->util
;
4233 fprintf(fp
, "%s\n%s\n%s\n", item
->string
,
4234 oid_to_hex(&rec
->before
), oid_to_hex(&rec
->after
));
4237 result
= commit_lock_file(&lock
);
4245 * Parse the update-refs file for the current rebase, then remove the
4246 * refs that do not appear in the todo_list (and have not had updated
4247 * values stored) and add refs that are in the todo_list but not
4248 * represented in the update-refs file.
4250 * If there are changes to the update-refs list, then write the new state
4253 void todo_list_filter_update_refs(struct repository
*r
,
4254 struct todo_list
*todo_list
)
4258 struct string_list update_refs
= STRING_LIST_INIT_DUP
;
4260 sequencer_get_update_refs_state(r
->gitdir
, &update_refs
);
4263 * For each item in the update_refs list, if it has no updated
4264 * value and does not appear in the todo_list, then remove it
4265 * from the update_refs list.
4267 for (i
= 0; i
< update_refs
.nr
; i
++) {
4270 const char *ref
= update_refs
.items
[i
].string
;
4271 size_t reflen
= strlen(ref
);
4272 struct update_ref_record
*rec
= update_refs
.items
[i
].util
;
4274 /* OID already stored as updated. */
4275 if (!is_null_oid(&rec
->after
))
4278 for (j
= 0; !found
&& j
< todo_list
->nr
; j
++) {
4279 struct todo_item
*item
= &todo_list
->items
[j
];
4280 const char *arg
= todo_list
->buf
.buf
+ item
->arg_offset
;
4282 if (item
->command
!= TODO_UPDATE_REF
)
4285 if (item
->arg_len
!= reflen
||
4286 strncmp(arg
, ref
, reflen
))
4293 free(update_refs
.items
[i
].string
);
4294 free(update_refs
.items
[i
].util
);
4297 MOVE_ARRAY(update_refs
.items
+ i
, update_refs
.items
+ i
+ 1, update_refs
.nr
- i
);
4305 * For each todo_item, check if its ref is in the update_refs list.
4306 * If not, then add it as an un-updated ref.
4308 for (i
= 0; i
< todo_list
->nr
; i
++) {
4309 struct todo_item
*item
= &todo_list
->items
[i
];
4310 const char *arg
= todo_list
->buf
.buf
+ item
->arg_offset
;
4313 if (item
->command
!= TODO_UPDATE_REF
)
4316 for (j
= 0; !found
&& j
< update_refs
.nr
; j
++) {
4317 const char *ref
= update_refs
.items
[j
].string
;
4319 found
= strlen(ref
) == item
->arg_len
&&
4320 !strncmp(ref
, arg
, item
->arg_len
);
4324 struct string_list_item
*inserted
;
4325 struct strbuf argref
= STRBUF_INIT
;
4327 strbuf_add(&argref
, arg
, item
->arg_len
);
4328 inserted
= string_list_insert(&update_refs
, argref
.buf
);
4329 inserted
->util
= init_update_ref_record(argref
.buf
);
4330 strbuf_release(&argref
);
4336 write_update_refs_state(&update_refs
);
4337 string_list_clear(&update_refs
, 1);
4340 static int do_update_ref(struct repository
*r
, const char *refname
)
4342 struct string_list_item
*item
;
4343 struct string_list list
= STRING_LIST_INIT_DUP
;
4345 if (sequencer_get_update_refs_state(r
->gitdir
, &list
))
4348 for_each_string_list_item(item
, &list
) {
4349 if (!strcmp(item
->string
, refname
)) {
4350 struct update_ref_record
*rec
= item
->util
;
4351 if (read_ref("HEAD", &rec
->after
))
4357 write_update_refs_state(&list
);
4358 string_list_clear(&list
, 1);
4362 static int do_update_refs(struct repository
*r
, int quiet
)
4365 struct string_list_item
*item
;
4366 struct string_list refs_to_oids
= STRING_LIST_INIT_DUP
;
4367 struct ref_store
*refs
= get_main_ref_store(r
);
4368 struct strbuf update_msg
= STRBUF_INIT
;
4369 struct strbuf error_msg
= STRBUF_INIT
;
4371 if ((res
= sequencer_get_update_refs_state(r
->gitdir
, &refs_to_oids
)))
4374 for_each_string_list_item(item
, &refs_to_oids
) {
4375 struct update_ref_record
*rec
= item
->util
;
4378 loop_res
= refs_update_ref(refs
, "rewritten during rebase",
4380 &rec
->after
, &rec
->before
,
4381 0, UPDATE_REFS_MSG_ON_ERR
);
4388 strbuf_addf(&error_msg
, "\t%s\n", item
->string
);
4390 strbuf_addf(&update_msg
, "\t%s\n", item
->string
);
4394 (update_msg
.len
|| error_msg
.len
)) {
4396 _("Updated the following refs with %s:\n%s"),
4402 _("Failed to update the following refs with %s:\n%s"),
4407 string_list_clear(&refs_to_oids
, 1);
4408 strbuf_release(&update_msg
);
4409 strbuf_release(&error_msg
);
4413 static int is_final_fixup(struct todo_list
*todo_list
)
4415 int i
= todo_list
->current
;
4417 if (!is_fixup(todo_list
->items
[i
].command
))
4420 while (++i
< todo_list
->nr
)
4421 if (is_fixup(todo_list
->items
[i
].command
))
4423 else if (!is_noop(todo_list
->items
[i
].command
))
4428 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
4432 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
4433 if (!is_noop(todo_list
->items
[i
].command
))
4434 return todo_list
->items
[i
].command
;
4439 void create_autostash(struct repository
*r
, const char *path
)
4441 struct strbuf buf
= STRBUF_INIT
;
4442 struct lock_file lock_file
= LOCK_INIT
;
4445 fd
= repo_hold_locked_index(r
, &lock_file
, 0);
4446 refresh_index(r
->index
, REFRESH_QUIET
, NULL
, NULL
, NULL
);
4448 repo_update_index_if_able(r
, &lock_file
);
4449 rollback_lock_file(&lock_file
);
4451 if (has_unstaged_changes(r
, 1) ||
4452 has_uncommitted_changes(r
, 1)) {
4453 struct child_process stash
= CHILD_PROCESS_INIT
;
4454 struct reset_head_opts ropts
= { .flags
= RESET_HEAD_HARD
};
4455 struct object_id oid
;
4457 strvec_pushl(&stash
.args
,
4458 "stash", "create", "autostash", NULL
);
4462 if (capture_command(&stash
, &buf
, GIT_MAX_HEXSZ
))
4463 die(_("Cannot autostash"));
4464 strbuf_trim_trailing_newline(&buf
);
4465 if (repo_get_oid(r
, buf
.buf
, &oid
))
4466 die(_("Unexpected stash response: '%s'"),
4469 strbuf_add_unique_abbrev(&buf
, &oid
, DEFAULT_ABBREV
);
4471 if (safe_create_leading_directories_const(path
))
4472 die(_("Could not create directory for '%s'"),
4474 write_file(path
, "%s", oid_to_hex(&oid
));
4475 printf(_("Created autostash: %s\n"), buf
.buf
);
4476 if (reset_head(r
, &ropts
) < 0)
4477 die(_("could not reset --hard"));
4478 discard_index(r
->index
);
4479 if (repo_read_index(r
) < 0)
4480 die(_("could not read index"));
4482 strbuf_release(&buf
);
4485 static int apply_save_autostash_oid(const char *stash_oid
, int attempt_apply
)
4487 struct child_process child
= CHILD_PROCESS_INIT
;
4490 if (attempt_apply
) {
4492 child
.no_stdout
= 1;
4493 child
.no_stderr
= 1;
4494 strvec_push(&child
.args
, "stash");
4495 strvec_push(&child
.args
, "apply");
4496 strvec_push(&child
.args
, stash_oid
);
4497 ret
= run_command(&child
);
4500 if (attempt_apply
&& !ret
)
4501 fprintf(stderr
, _("Applied autostash.\n"));
4503 struct child_process store
= CHILD_PROCESS_INIT
;
4506 strvec_push(&store
.args
, "stash");
4507 strvec_push(&store
.args
, "store");
4508 strvec_push(&store
.args
, "-m");
4509 strvec_push(&store
.args
, "autostash");
4510 strvec_push(&store
.args
, "-q");
4511 strvec_push(&store
.args
, stash_oid
);
4512 if (run_command(&store
))
4513 ret
= error(_("cannot store %s"), stash_oid
);
4517 "Your changes are safe in the stash.\n"
4518 "You can run \"git stash pop\" or"
4519 " \"git stash drop\" at any time.\n"),
4521 _("Applying autostash resulted in conflicts.") :
4522 _("Autostash exists; creating a new stash entry."));
4528 static int apply_save_autostash(const char *path
, int attempt_apply
)
4530 struct strbuf stash_oid
= STRBUF_INIT
;
4533 if (!read_oneliner(&stash_oid
, path
,
4534 READ_ONELINER_SKIP_IF_EMPTY
)) {
4535 strbuf_release(&stash_oid
);
4538 strbuf_trim(&stash_oid
);
4540 ret
= apply_save_autostash_oid(stash_oid
.buf
, attempt_apply
);
4543 strbuf_release(&stash_oid
);
4547 int save_autostash(const char *path
)
4549 return apply_save_autostash(path
, 0);
4552 int apply_autostash(const char *path
)
4554 return apply_save_autostash(path
, 1);
4557 int apply_autostash_oid(const char *stash_oid
)
4559 return apply_save_autostash_oid(stash_oid
, 1);
4562 static int checkout_onto(struct repository
*r
, struct replay_opts
*opts
,
4563 const char *onto_name
, const struct object_id
*onto
,
4564 const struct object_id
*orig_head
)
4566 struct reset_head_opts ropts
= {
4568 .orig_head
= orig_head
,
4569 .flags
= RESET_HEAD_DETACH
| RESET_ORIG_HEAD
|
4570 RESET_HEAD_RUN_POST_CHECKOUT_HOOK
,
4571 .head_msg
= reflog_message(opts
, "start", "checkout %s",
4573 .default_reflog_action
= sequencer_reflog_action(opts
)
4575 if (reset_head(r
, &ropts
)) {
4576 apply_autostash(rebase_path_autostash());
4577 sequencer_remove_state(opts
);
4578 return error(_("could not detach HEAD"));
4584 static int stopped_at_head(struct repository
*r
)
4586 struct object_id head
;
4587 struct commit
*commit
;
4588 struct commit_message message
;
4590 if (repo_get_oid(r
, "HEAD", &head
) ||
4591 !(commit
= lookup_commit(r
, &head
)) ||
4592 repo_parse_commit(r
, commit
) || get_message(commit
, &message
))
4593 fprintf(stderr
, _("Stopped at HEAD\n"));
4595 fprintf(stderr
, _("Stopped at %s\n"), message
.label
);
4596 free_message(commit
, &message
);
4602 static int reread_todo_if_changed(struct repository
*r
,
4603 struct todo_list
*todo_list
,
4604 struct replay_opts
*opts
)
4607 struct strbuf buf
= STRBUF_INIT
;
4609 if (strbuf_read_file_or_whine(&buf
, get_todo_path(opts
)) < 0)
4611 offset
= get_item_line_offset(todo_list
, todo_list
->current
+ 1);
4612 if (buf
.len
!= todo_list
->buf
.len
- offset
||
4613 memcmp(buf
.buf
, todo_list
->buf
.buf
+ offset
, buf
.len
)) {
4614 /* Reread the todo file if it has changed. */
4615 todo_list_release(todo_list
);
4616 if (read_populate_todo(r
, todo_list
, opts
))
4617 return -1; /* message was printed */
4618 /* `current` will be incremented on return */
4619 todo_list
->current
= -1;
4621 strbuf_release(&buf
);
4626 static const char rescheduled_advice
[] =
4627 N_("Could not execute the todo command\n"
4631 "It has been rescheduled; To edit the command before continuing, please\n"
4632 "edit the todo list first:\n"
4634 " git rebase --edit-todo\n"
4635 " git rebase --continue\n");
4637 static int pick_commits(struct repository
*r
,
4638 struct todo_list
*todo_list
,
4639 struct replay_opts
*opts
)
4641 int res
= 0, reschedule
= 0;
4643 opts
->reflog_message
= sequencer_reflog_action(opts
);
4645 assert(!(opts
->signoff
|| opts
->no_commit
||
4646 opts
->record_origin
|| should_edit(opts
) ||
4647 opts
->committer_date_is_author_date
||
4648 opts
->ignore_date
));
4649 if (read_and_refresh_cache(r
, opts
))
4652 while (todo_list
->current
< todo_list
->nr
) {
4653 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
4654 const char *arg
= todo_item_get_arg(todo_list
, item
);
4657 if (save_todo(todo_list
, opts
))
4659 if (is_rebase_i(opts
)) {
4660 if (item
->command
!= TODO_COMMENT
) {
4661 FILE *f
= fopen(rebase_path_msgnum(), "w");
4663 todo_list
->done_nr
++;
4666 fprintf(f
, "%d\n", todo_list
->done_nr
);
4670 fprintf(stderr
, _("Rebasing (%d/%d)%s"),
4672 todo_list
->total_nr
,
4673 opts
->verbose
? "\n" : "\r");
4675 unlink(rebase_path_message());
4676 unlink(rebase_path_author_script());
4677 unlink(rebase_path_stopped_sha());
4678 unlink(rebase_path_amend());
4679 unlink(git_path_merge_head(r
));
4680 unlink(git_path_auto_merge(r
));
4681 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
4683 if (item
->command
== TODO_BREAK
) {
4686 return stopped_at_head(r
);
4689 if (item
->command
<= TODO_SQUASH
) {
4690 if (is_rebase_i(opts
))
4691 opts
->reflog_message
= reflog_message(opts
,
4692 command_to_string(item
->command
), NULL
);
4694 res
= do_pick_commit(r
, item
, opts
,
4695 is_final_fixup(todo_list
),
4697 if (is_rebase_i(opts
) && res
< 0) {
4699 advise(_(rescheduled_advice
),
4700 get_item_line_length(todo_list
,
4701 todo_list
->current
),
4702 get_item_line(todo_list
,
4703 todo_list
->current
));
4704 todo_list
->current
--;
4705 if (save_todo(todo_list
, opts
))
4708 if (item
->command
== TODO_EDIT
) {
4709 struct commit
*commit
= item
->commit
;
4714 _("Stopped at %s... %.*s\n"),
4715 short_commit_name(commit
),
4716 item
->arg_len
, arg
);
4718 return error_with_patch(r
, commit
,
4719 arg
, item
->arg_len
, opts
, res
, !res
);
4721 if (is_rebase_i(opts
) && !res
)
4722 record_in_rewritten(&item
->commit
->object
.oid
,
4723 peek_command(todo_list
, 1));
4724 if (res
&& is_fixup(item
->command
)) {
4727 return error_failed_squash(r
, item
->commit
, opts
,
4728 item
->arg_len
, arg
);
4729 } else if (res
&& is_rebase_i(opts
) && item
->commit
) {
4731 struct object_id oid
;
4734 * If we are rewording and have either
4735 * fast-forwarded already, or are about to
4736 * create a new root commit, we want to amend,
4737 * otherwise we do not.
4739 if (item
->command
== TODO_REWORD
&&
4740 !repo_get_oid(r
, "HEAD", &oid
) &&
4741 (oideq(&item
->commit
->object
.oid
, &oid
) ||
4742 (opts
->have_squash_onto
&&
4743 oideq(&opts
->squash_onto
, &oid
))))
4746 return res
| error_with_patch(r
, item
->commit
,
4747 arg
, item
->arg_len
, opts
,
4750 } else if (item
->command
== TODO_EXEC
) {
4751 char *end_of_arg
= (char *)(arg
+ item
->arg_len
);
4752 int saved
= *end_of_arg
;
4757 res
= do_exec(r
, arg
);
4758 *end_of_arg
= saved
;
4761 if (opts
->reschedule_failed_exec
)
4765 } else if (item
->command
== TODO_LABEL
) {
4766 if ((res
= do_label(r
, arg
, item
->arg_len
)))
4768 } else if (item
->command
== TODO_RESET
) {
4769 if ((res
= do_reset(r
, arg
, item
->arg_len
, opts
)))
4771 } else if (item
->command
== TODO_MERGE
) {
4772 if ((res
= do_merge(r
, item
->commit
, arg
, item
->arg_len
,
4773 item
->flags
, &check_todo
, opts
)) < 0)
4775 else if (item
->commit
)
4776 record_in_rewritten(&item
->commit
->object
.oid
,
4777 peek_command(todo_list
, 1));
4779 /* failed with merge conflicts */
4780 return error_with_patch(r
, item
->commit
,
4783 } else if (item
->command
== TODO_UPDATE_REF
) {
4784 struct strbuf ref
= STRBUF_INIT
;
4785 strbuf_add(&ref
, arg
, item
->arg_len
);
4786 if ((res
= do_update_ref(r
, ref
.buf
)))
4788 strbuf_release(&ref
);
4789 } else if (!is_noop(item
->command
))
4790 return error(_("unknown command %d"), item
->command
);
4793 advise(_(rescheduled_advice
),
4794 get_item_line_length(todo_list
,
4795 todo_list
->current
),
4796 get_item_line(todo_list
, todo_list
->current
));
4797 todo_list
->current
--;
4798 if (save_todo(todo_list
, opts
))
4801 return error_with_patch(r
,
4805 } else if (is_rebase_i(opts
) && check_todo
&& !res
&&
4806 reread_todo_if_changed(r
, todo_list
, opts
)) {
4810 todo_list
->current
++;
4815 if (is_rebase_i(opts
)) {
4816 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
4819 /* Stopped in the middle, as planned? */
4820 if (todo_list
->current
< todo_list
->nr
)
4823 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
4824 starts_with(head_ref
.buf
, "refs/")) {
4826 struct object_id head
, orig
;
4829 if (repo_get_oid(r
, "HEAD", &head
)) {
4830 res
= error(_("cannot read HEAD"));
4832 strbuf_release(&head_ref
);
4833 strbuf_release(&buf
);
4836 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
4837 get_oid_hex(buf
.buf
, &orig
)) {
4838 res
= error(_("could not read orig-head"));
4839 goto cleanup_head_ref
;
4842 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
4843 res
= error(_("could not read 'onto'"));
4844 goto cleanup_head_ref
;
4846 msg
= reflog_message(opts
, "finish", "%s onto %s",
4847 head_ref
.buf
, buf
.buf
);
4848 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
4849 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
4850 res
= error(_("could not update %s"),
4852 goto cleanup_head_ref
;
4854 msg
= reflog_message(opts
, "finish", "returning to %s",
4856 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
4857 res
= error(_("could not update HEAD to %s"),
4859 goto cleanup_head_ref
;
4864 if (opts
->verbose
) {
4865 struct rev_info log_tree_opt
;
4866 struct object_id orig
, head
;
4868 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
4869 repo_init_revisions(r
, &log_tree_opt
, NULL
);
4870 log_tree_opt
.diff
= 1;
4871 log_tree_opt
.diffopt
.output_format
=
4872 DIFF_FORMAT_DIFFSTAT
;
4873 log_tree_opt
.disable_stdin
= 1;
4875 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
4876 !repo_get_oid(r
, buf
.buf
, &orig
) &&
4877 !repo_get_oid(r
, "HEAD", &head
)) {
4878 diff_tree_oid(&orig
, &head
, "",
4879 &log_tree_opt
.diffopt
);
4880 log_tree_diff_flush(&log_tree_opt
);
4882 release_revisions(&log_tree_opt
);
4884 flush_rewritten_pending();
4885 if (!stat(rebase_path_rewritten_list(), &st
) &&
4887 struct child_process child
= CHILD_PROCESS_INIT
;
4888 struct run_hooks_opt hook_opt
= RUN_HOOKS_OPT_INIT
;
4890 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
4892 strvec_push(&child
.args
, "notes");
4893 strvec_push(&child
.args
, "copy");
4894 strvec_push(&child
.args
, "--for-rewrite=rebase");
4895 /* we don't care if this copying failed */
4896 run_command(&child
);
4898 hook_opt
.path_to_stdin
= rebase_path_rewritten_list();
4899 strvec_push(&hook_opt
.args
, "rebase");
4900 run_hooks_opt("post-rewrite", &hook_opt
);
4902 apply_autostash(rebase_path_autostash());
4908 _("Successfully rebased and updated %s.\n"),
4912 strbuf_release(&buf
);
4913 strbuf_release(&head_ref
);
4915 if (do_update_refs(r
, opts
->quiet
))
4920 * Sequence of picks finished successfully; cleanup by
4921 * removing the .git/sequencer directory
4923 return sequencer_remove_state(opts
);
4926 static int continue_single_pick(struct repository
*r
, struct replay_opts
*opts
)
4928 struct child_process cmd
= CHILD_PROCESS_INIT
;
4930 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
4931 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
4932 return error(_("no cherry-pick or revert in progress"));
4935 strvec_push(&cmd
.args
, "commit");
4938 * continue_single_pick() handles the case of recovering from a
4939 * conflict. should_edit() doesn't handle that case; for a conflict,
4940 * we want to edit if the user asked for it, or if they didn't specify
4941 * and stdin is a tty.
4943 if (!opts
->edit
|| (opts
->edit
< 0 && !isatty(0)))
4945 * Include --cleanup=strip as well because we don't want the
4946 * "# Conflicts:" messages.
4948 strvec_pushl(&cmd
.args
, "--no-edit", "--cleanup=strip", NULL
);
4950 return run_command(&cmd
);
4953 static int commit_staged_changes(struct repository
*r
,
4954 struct replay_opts
*opts
,
4955 struct todo_list
*todo_list
)
4957 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
4958 unsigned int final_fixup
= 0, is_clean
;
4960 if (has_unstaged_changes(r
, 1))
4961 return error(_("cannot rebase: You have unstaged changes."));
4963 is_clean
= !has_uncommitted_changes(r
, 0);
4965 if (file_exists(rebase_path_amend())) {
4966 struct strbuf rev
= STRBUF_INIT
;
4967 struct object_id head
, to_amend
;
4969 if (repo_get_oid(r
, "HEAD", &head
))
4970 return error(_("cannot amend non-existing commit"));
4971 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
4972 return error(_("invalid file: '%s'"), rebase_path_amend());
4973 if (get_oid_hex(rev
.buf
, &to_amend
))
4974 return error(_("invalid contents: '%s'"),
4975 rebase_path_amend());
4976 if (!is_clean
&& !oideq(&head
, &to_amend
))
4977 return error(_("\nYou have uncommitted changes in your "
4978 "working tree. Please, commit them\n"
4979 "first and then run 'git rebase "
4980 "--continue' again."));
4982 * When skipping a failed fixup/squash, we need to edit the
4983 * commit message, the current fixup list and count, and if it
4984 * was the last fixup/squash in the chain, we need to clean up
4985 * the commit message and if there was a squash, let the user
4988 if (!is_clean
|| !opts
->current_fixup_count
)
4989 ; /* this is not the final fixup */
4990 else if (!oideq(&head
, &to_amend
) ||
4991 !file_exists(rebase_path_stopped_sha())) {
4992 /* was a final fixup or squash done manually? */
4993 if (!is_fixup(peek_command(todo_list
, 0))) {
4994 unlink(rebase_path_fixup_msg());
4995 unlink(rebase_path_squash_msg());
4996 unlink(rebase_path_current_fixups());
4997 strbuf_reset(&opts
->current_fixups
);
4998 opts
->current_fixup_count
= 0;
5001 /* we are in a fixup/squash chain */
5002 const char *p
= opts
->current_fixups
.buf
;
5003 int len
= opts
->current_fixups
.len
;
5005 opts
->current_fixup_count
--;
5007 BUG("Incorrect current_fixups:\n%s", p
);
5008 while (len
&& p
[len
- 1] != '\n')
5010 strbuf_setlen(&opts
->current_fixups
, len
);
5011 if (write_message(p
, len
, rebase_path_current_fixups(),
5013 return error(_("could not write file: '%s'"),
5014 rebase_path_current_fixups());
5017 * If a fixup/squash in a fixup/squash chain failed, the
5018 * commit message is already correct, no need to commit
5021 * Only if it is the final command in the fixup/squash
5022 * chain, and only if the chain is longer than a single
5023 * fixup/squash command (which was just skipped), do we
5024 * actually need to re-commit with a cleaned up commit
5027 if (opts
->current_fixup_count
> 0 &&
5028 !is_fixup(peek_command(todo_list
, 0))) {
5031 * If there was not a single "squash" in the
5032 * chain, we only need to clean up the commit
5033 * message, no need to bother the user with
5034 * opening the commit message in the editor.
5036 if (!starts_with(p
, "squash ") &&
5037 !strstr(p
, "\nsquash "))
5038 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
5039 } else if (is_fixup(peek_command(todo_list
, 0))) {
5041 * We need to update the squash message to skip
5042 * the latest commit message.
5044 struct commit
*commit
;
5045 const char *path
= rebase_path_squash_msg();
5046 const char *encoding
= get_commit_output_encoding();
5048 if (parse_head(r
, &commit
) ||
5049 !(p
= repo_logmsg_reencode(r
, commit
, NULL
, encoding
)) ||
5050 write_message(p
, strlen(p
), path
, 0)) {
5051 repo_unuse_commit_buffer(r
, commit
, p
);
5052 return error(_("could not write file: "
5055 repo_unuse_commit_buffer(r
,
5060 strbuf_release(&rev
);
5065 if (refs_ref_exists(get_main_ref_store(r
),
5066 "CHERRY_PICK_HEAD") &&
5067 refs_delete_ref(get_main_ref_store(r
), "",
5068 "CHERRY_PICK_HEAD", NULL
, 0))
5069 return error(_("could not remove CHERRY_PICK_HEAD"));
5070 if (unlink(git_path_merge_msg(r
)) && errno
!= ENOENT
)
5071 return error_errno(_("could not remove '%s'"),
5072 git_path_merge_msg(r
));
5077 if (run_git_commit(final_fixup
? NULL
: rebase_path_message(),
5079 return error(_("could not commit staged changes."));
5080 unlink(rebase_path_amend());
5081 unlink(git_path_merge_head(r
));
5082 unlink(git_path_auto_merge(r
));
5084 unlink(rebase_path_fixup_msg());
5085 unlink(rebase_path_squash_msg());
5087 if (opts
->current_fixup_count
> 0) {
5089 * Whether final fixup or not, we just cleaned up the commit
5092 unlink(rebase_path_current_fixups());
5093 strbuf_reset(&opts
->current_fixups
);
5094 opts
->current_fixup_count
= 0;
5099 int sequencer_continue(struct repository
*r
, struct replay_opts
*opts
)
5101 struct todo_list todo_list
= TODO_LIST_INIT
;
5104 if (read_and_refresh_cache(r
, opts
))
5107 if (read_populate_opts(opts
))
5109 if (is_rebase_i(opts
)) {
5110 if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
5111 goto release_todo_list
;
5113 if (file_exists(rebase_path_dropped())) {
5114 if ((res
= todo_list_check_against_backup(r
, &todo_list
)))
5115 goto release_todo_list
;
5117 unlink(rebase_path_dropped());
5120 opts
->reflog_message
= reflog_message(opts
, "continue", NULL
);
5121 if (commit_staged_changes(r
, opts
, &todo_list
)) {
5123 goto release_todo_list
;
5125 } else if (!file_exists(get_todo_path(opts
)))
5126 return continue_single_pick(r
, opts
);
5127 else if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
5128 goto release_todo_list
;
5130 if (!is_rebase_i(opts
)) {
5131 /* Verify that the conflict has been resolved */
5132 if (refs_ref_exists(get_main_ref_store(r
),
5133 "CHERRY_PICK_HEAD") ||
5134 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
5135 res
= continue_single_pick(r
, opts
);
5137 goto release_todo_list
;
5139 if (index_differs_from(r
, "HEAD", NULL
, 0)) {
5140 res
= error_dirty_index(r
, opts
);
5141 goto release_todo_list
;
5143 todo_list
.current
++;
5144 } else if (file_exists(rebase_path_stopped_sha())) {
5145 struct strbuf buf
= STRBUF_INIT
;
5146 struct object_id oid
;
5148 if (read_oneliner(&buf
, rebase_path_stopped_sha(),
5149 READ_ONELINER_SKIP_IF_EMPTY
) &&
5150 !get_oid_hex(buf
.buf
, &oid
))
5151 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
5152 strbuf_release(&buf
);
5155 res
= pick_commits(r
, &todo_list
, opts
);
5157 todo_list_release(&todo_list
);
5161 static int single_pick(struct repository
*r
,
5162 struct commit
*cmit
,
5163 struct replay_opts
*opts
)
5166 struct todo_item item
;
5168 item
.command
= opts
->action
== REPLAY_PICK
?
5169 TODO_PICK
: TODO_REVERT
;
5172 opts
->reflog_message
= sequencer_reflog_action(opts
);
5173 return do_pick_commit(r
, &item
, opts
, 0, &check_todo
);
5176 int sequencer_pick_revisions(struct repository
*r
,
5177 struct replay_opts
*opts
)
5179 struct todo_list todo_list
= TODO_LIST_INIT
;
5180 struct object_id oid
;
5184 if (read_and_refresh_cache(r
, opts
))
5187 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
5188 struct object_id oid
;
5189 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
5191 /* This happens when using --stdin. */
5195 if (!repo_get_oid(r
, name
, &oid
)) {
5196 if (!lookup_commit_reference_gently(r
, &oid
, 1)) {
5197 enum object_type type
= oid_object_info(r
,
5200 return error(_("%s: can't cherry-pick a %s"),
5201 name
, type_name(type
));
5204 return error(_("%s: bad revision"), name
);
5208 * If we were called as "git cherry-pick <commit>", just
5209 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
5210 * REVERT_HEAD, and don't touch the sequencer state.
5211 * This means it is possible to cherry-pick in the middle
5212 * of a cherry-pick sequence.
5214 if (opts
->revs
->cmdline
.nr
== 1 &&
5215 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
5216 opts
->revs
->no_walk
&&
5217 !opts
->revs
->cmdline
.rev
->flags
) {
5218 struct commit
*cmit
;
5219 if (prepare_revision_walk(opts
->revs
))
5220 return error(_("revision walk setup failed"));
5221 cmit
= get_revision(opts
->revs
);
5223 return error(_("empty commit set passed"));
5224 if (get_revision(opts
->revs
))
5225 BUG("unexpected extra commit from walk");
5226 return single_pick(r
, cmit
, opts
);
5230 * Start a new cherry-pick/ revert sequence; but
5231 * first, make sure that an existing one isn't in
5235 if (walk_revs_populate_todo(&todo_list
, opts
) ||
5236 create_seq_dir(r
) < 0)
5238 if (repo_get_oid(r
, "HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
5239 return error(_("can't revert as initial commit"));
5240 if (save_head(oid_to_hex(&oid
)))
5242 if (save_opts(opts
))
5244 update_abort_safety_file();
5245 res
= pick_commits(r
, &todo_list
, opts
);
5246 todo_list_release(&todo_list
);
5250 void append_signoff(struct strbuf
*msgbuf
, size_t ignore_footer
, unsigned flag
)
5252 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
5253 struct strbuf sob
= STRBUF_INIT
;
5256 strbuf_addstr(&sob
, sign_off_header
);
5257 strbuf_addstr(&sob
, fmt_name(WANT_COMMITTER_IDENT
));
5258 strbuf_addch(&sob
, '\n');
5261 strbuf_complete_line(msgbuf
);
5264 * If the whole message buffer is equal to the sob, pretend that we
5265 * found a conforming footer with a matching sob
5267 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
5268 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
5271 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
5274 const char *append_newlines
= NULL
;
5275 size_t len
= msgbuf
->len
- ignore_footer
;
5279 * The buffer is completely empty. Leave foom for
5280 * the title and body to be filled in by the user.
5282 append_newlines
= "\n\n";
5283 } else if (len
== 1) {
5285 * Buffer contains a single newline. Add another
5286 * so that we leave room for the title and body.
5288 append_newlines
= "\n";
5289 } else if (msgbuf
->buf
[len
- 2] != '\n') {
5291 * Buffer ends with a single newline. Add another
5292 * so that there is an empty line between the message
5295 append_newlines
= "\n";
5296 } /* else, the buffer already ends with two newlines. */
5298 if (append_newlines
)
5299 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
5300 append_newlines
, strlen(append_newlines
));
5303 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
5304 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
5307 strbuf_release(&sob
);
5310 struct labels_entry
{
5311 struct hashmap_entry entry
;
5312 char label
[FLEX_ARRAY
];
5315 static int labels_cmp(const void *fndata UNUSED
,
5316 const struct hashmap_entry
*eptr
,
5317 const struct hashmap_entry
*entry_or_key
, const void *key
)
5319 const struct labels_entry
*a
, *b
;
5321 a
= container_of(eptr
, const struct labels_entry
, entry
);
5322 b
= container_of(entry_or_key
, const struct labels_entry
, entry
);
5324 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
5327 struct string_entry
{
5328 struct oidmap_entry entry
;
5329 char string
[FLEX_ARRAY
];
5332 struct label_state
{
5333 struct oidmap commit2label
;
5334 struct hashmap labels
;
5338 static const char *label_oid(struct object_id
*oid
, const char *label
,
5339 struct label_state
*state
)
5341 struct labels_entry
*labels_entry
;
5342 struct string_entry
*string_entry
;
5343 struct object_id dummy
;
5346 string_entry
= oidmap_get(&state
->commit2label
, oid
);
5348 return string_entry
->string
;
5351 * For "uninteresting" commits, i.e. commits that are not to be
5352 * rebased, and which can therefore not be labeled, we use a unique
5353 * abbreviation of the commit name. This is slightly more complicated
5354 * than calling repo_find_unique_abbrev() because we also need to make
5355 * sure that the abbreviation does not conflict with any other
5358 * We disallow "interesting" commits to be labeled by a string that
5359 * is a valid full-length hash, to ensure that we always can find an
5360 * abbreviation for any uninteresting commit's names that does not
5361 * clash with any other label.
5363 strbuf_reset(&state
->buf
);
5367 strbuf_grow(&state
->buf
, GIT_MAX_HEXSZ
);
5368 label
= p
= state
->buf
.buf
;
5370 repo_find_unique_abbrev_r(the_repository
, p
, oid
,
5374 * We may need to extend the abbreviated hash so that there is
5375 * no conflicting label.
5377 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
5378 size_t i
= strlen(p
) + 1;
5380 oid_to_hex_r(p
, oid
);
5381 for (; i
< the_hash_algo
->hexsz
; i
++) {
5384 if (!hashmap_get_from_hash(&state
->labels
,
5391 struct strbuf
*buf
= &state
->buf
;
5394 * Sanitize labels by replacing non-alpha-numeric characters
5395 * (including white-space ones) by dashes, as they might be
5396 * illegal in file names (and hence in ref names).
5398 * Note that we retain non-ASCII UTF-8 characters (identified
5399 * via the most significant bit). They should be all acceptable
5400 * in file names. We do not validate the UTF-8 here, that's not
5401 * the job of this function.
5403 for (; *label
; label
++)
5404 if ((*label
& 0x80) || isalnum(*label
))
5405 strbuf_addch(buf
, *label
);
5406 /* avoid leading dash and double-dashes */
5407 else if (buf
->len
&& buf
->buf
[buf
->len
- 1] != '-')
5408 strbuf_addch(buf
, '-');
5410 strbuf_addstr(buf
, "rev-");
5411 strbuf_add_unique_abbrev(buf
, oid
, default_abbrev
);
5415 if ((buf
->len
== the_hash_algo
->hexsz
&&
5416 !get_oid_hex(label
, &dummy
)) ||
5417 (buf
->len
== 1 && *label
== '#') ||
5418 hashmap_get_from_hash(&state
->labels
,
5419 strihash(label
), label
)) {
5421 * If the label already exists, or if the label is a
5422 * valid full OID, or the label is a '#' (which we use
5423 * as a separator between merge heads and oneline), we
5424 * append a dash and a number to make it unique.
5426 size_t len
= buf
->len
;
5428 for (i
= 2; ; i
++) {
5429 strbuf_setlen(buf
, len
);
5430 strbuf_addf(buf
, "-%d", i
);
5431 if (!hashmap_get_from_hash(&state
->labels
,
5441 FLEX_ALLOC_STR(labels_entry
, label
, label
);
5442 hashmap_entry_init(&labels_entry
->entry
, strihash(label
));
5443 hashmap_add(&state
->labels
, &labels_entry
->entry
);
5445 FLEX_ALLOC_STR(string_entry
, string
, label
);
5446 oidcpy(&string_entry
->entry
.oid
, oid
);
5447 oidmap_put(&state
->commit2label
, string_entry
);
5449 return string_entry
->string
;
5452 static int make_script_with_merges(struct pretty_print_context
*pp
,
5453 struct rev_info
*revs
, struct strbuf
*out
,
5456 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5457 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
5458 int root_with_onto
= flags
& TODO_LIST_ROOT_WITH_ONTO
;
5459 int skipped_commit
= 0;
5460 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
5461 struct strbuf label
= STRBUF_INIT
;
5462 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
5463 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
5464 struct commit
*commit
;
5465 struct oidmap commit2todo
= OIDMAP_INIT
;
5466 struct string_entry
*entry
;
5467 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
5468 shown
= OIDSET_INIT
;
5469 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
5471 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
5472 const char *cmd_pick
= abbr
? "p" : "pick",
5473 *cmd_label
= abbr
? "l" : "label",
5474 *cmd_reset
= abbr
? "t" : "reset",
5475 *cmd_merge
= abbr
? "m" : "merge";
5477 oidmap_init(&commit2todo
, 0);
5478 oidmap_init(&state
.commit2label
, 0);
5479 hashmap_init(&state
.labels
, labels_cmp
, NULL
, 0);
5480 strbuf_init(&state
.buf
, 32);
5482 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
5483 struct labels_entry
*onto_label_entry
;
5484 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
5485 FLEX_ALLOC_STR(entry
, string
, "onto");
5486 oidcpy(&entry
->entry
.oid
, oid
);
5487 oidmap_put(&state
.commit2label
, entry
);
5489 FLEX_ALLOC_STR(onto_label_entry
, label
, "onto");
5490 hashmap_entry_init(&onto_label_entry
->entry
, strihash("onto"));
5491 hashmap_add(&state
.labels
, &onto_label_entry
->entry
);
5496 * - get onelines for all commits
5497 * - gather all branch tips (i.e. 2nd or later parents of merges)
5498 * - label all branch tips
5500 while ((commit
= get_revision(revs
))) {
5501 struct commit_list
*to_merge
;
5502 const char *p1
, *p2
;
5503 struct object_id
*oid
;
5506 tail
= &commit_list_insert(commit
, tail
)->next
;
5507 oidset_insert(&interesting
, &commit
->object
.oid
);
5509 is_empty
= is_original_commit_empty(commit
);
5510 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5511 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5512 warning(_("skipped previously applied commit %s"),
5513 short_commit_name(commit
));
5517 if (is_empty
&& !keep_empty
)
5520 strbuf_reset(&oneline
);
5521 pretty_print_commit(pp
, commit
, &oneline
);
5523 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
5525 /* non-merge commit: easy case */
5527 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
5528 oid_to_hex(&commit
->object
.oid
),
5531 strbuf_addf(&buf
, " %c empty",
5534 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5535 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5536 oidmap_put(&commit2todo
, entry
);
5541 /* Create a label */
5542 strbuf_reset(&label
);
5543 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
5544 (p1
= strchr(p1
, '\'')) &&
5545 (p2
= strchr(++p1
, '\'')))
5546 strbuf_add(&label
, p1
, p2
- p1
);
5547 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
5549 (p1
= strstr(p1
, " from ")))
5550 strbuf_addstr(&label
, p1
+ strlen(" from "));
5552 strbuf_addbuf(&label
, &oneline
);
5555 strbuf_addf(&buf
, "%s -C %s",
5556 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
5558 /* label the tips of merged branches */
5559 for (; to_merge
; to_merge
= to_merge
->next
) {
5560 oid
= &to_merge
->item
->object
.oid
;
5561 strbuf_addch(&buf
, ' ');
5563 if (!oidset_contains(&interesting
, oid
)) {
5564 strbuf_addstr(&buf
, label_oid(oid
, NULL
,
5569 tips_tail
= &commit_list_insert(to_merge
->item
,
5572 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
5574 strbuf_addf(&buf
, " # %s", oneline
.buf
);
5576 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5577 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5578 oidmap_put(&commit2todo
, entry
);
5581 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5582 _("use --reapply-cherry-picks to include skipped commits"));
5586 * - label branch points
5587 * - add HEAD to the branch tips
5589 for (iter
= commits
; iter
; iter
= iter
->next
) {
5590 struct commit_list
*parent
= iter
->item
->parents
;
5591 for (; parent
; parent
= parent
->next
) {
5592 struct object_id
*oid
= &parent
->item
->object
.oid
;
5593 if (!oidset_contains(&interesting
, oid
))
5595 if (oidset_insert(&child_seen
, oid
))
5596 label_oid(oid
, "branch-point", &state
);
5599 /* Add HEAD as implicit "tip of branch" */
5601 tips_tail
= &commit_list_insert(iter
->item
,
5606 * Third phase: output the todo list. This is a bit tricky, as we
5607 * want to avoid jumping back and forth between revisions. To
5608 * accomplish that goal, we walk backwards from the branch tips,
5609 * gathering commits not yet shown, reversing the list on the fly,
5610 * then outputting that list (labeling revisions as needed).
5612 strbuf_addf(out
, "%s onto\n", cmd_label
);
5613 for (iter
= tips
; iter
; iter
= iter
->next
) {
5614 struct commit_list
*list
= NULL
, *iter2
;
5616 commit
= iter
->item
;
5617 if (oidset_contains(&shown
, &commit
->object
.oid
))
5619 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
5622 strbuf_addf(out
, "\n%c Branch %s\n", comment_line_char
, entry
->string
);
5624 strbuf_addch(out
, '\n');
5626 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
5627 !oidset_contains(&shown
, &commit
->object
.oid
)) {
5628 commit_list_insert(commit
, &list
);
5629 if (!commit
->parents
) {
5633 commit
= commit
->parents
->item
;
5637 strbuf_addf(out
, "%s %s\n", cmd_reset
,
5638 rebase_cousins
|| root_with_onto
?
5639 "onto" : "[new root]");
5641 const char *to
= NULL
;
5643 entry
= oidmap_get(&state
.commit2label
,
5644 &commit
->object
.oid
);
5647 else if (!rebase_cousins
)
5648 to
= label_oid(&commit
->object
.oid
, NULL
,
5651 if (!to
|| !strcmp(to
, "onto"))
5652 strbuf_addf(out
, "%s onto\n", cmd_reset
);
5654 strbuf_reset(&oneline
);
5655 pretty_print_commit(pp
, commit
, &oneline
);
5656 strbuf_addf(out
, "%s %s # %s\n",
5657 cmd_reset
, to
, oneline
.buf
);
5661 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
5662 struct object_id
*oid
= &iter2
->item
->object
.oid
;
5663 entry
= oidmap_get(&commit2todo
, oid
);
5664 /* only show if not already upstream */
5666 strbuf_addf(out
, "%s\n", entry
->string
);
5667 entry
= oidmap_get(&state
.commit2label
, oid
);
5669 strbuf_addf(out
, "%s %s\n",
5670 cmd_label
, entry
->string
);
5671 oidset_insert(&shown
, oid
);
5674 free_commit_list(list
);
5677 free_commit_list(commits
);
5678 free_commit_list(tips
);
5680 strbuf_release(&label
);
5681 strbuf_release(&oneline
);
5682 strbuf_release(&buf
);
5684 oidmap_free(&commit2todo
, 1);
5685 oidmap_free(&state
.commit2label
, 1);
5686 hashmap_clear_and_free(&state
.labels
, struct labels_entry
, entry
);
5687 strbuf_release(&state
.buf
);
5692 int sequencer_make_script(struct repository
*r
, struct strbuf
*out
, int argc
,
5693 const char **argv
, unsigned flags
)
5695 char *format
= NULL
;
5696 struct pretty_print_context pp
= {0};
5697 struct rev_info revs
;
5698 struct commit
*commit
;
5699 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5700 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
5701 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
5702 int reapply_cherry_picks
= flags
& TODO_LIST_REAPPLY_CHERRY_PICKS
;
5703 int skipped_commit
= 0;
5706 repo_init_revisions(r
, &revs
, NULL
);
5707 revs
.verbose_header
= 1;
5709 revs
.max_parents
= 1;
5710 revs
.cherry_mark
= !reapply_cherry_picks
;
5713 revs
.right_only
= 1;
5714 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
5715 revs
.topo_order
= 1;
5717 revs
.pretty_given
= 1;
5718 git_config_get_string("rebase.instructionFormat", &format
);
5719 if (!format
|| !*format
) {
5721 format
= xstrdup("%s");
5723 get_commit_format(format
, &revs
);
5725 pp
.fmt
= revs
.commit_format
;
5726 pp
.output_encoding
= get_log_output_encoding();
5728 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1) {
5729 ret
= error(_("make_script: unhandled options"));
5733 if (prepare_revision_walk(&revs
) < 0) {
5734 ret
= error(_("make_script: error preparing revisions"));
5738 if (rebase_merges
) {
5739 ret
= make_script_with_merges(&pp
, &revs
, out
, flags
);
5743 while ((commit
= get_revision(&revs
))) {
5744 int is_empty
= is_original_commit_empty(commit
);
5746 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5747 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5748 warning(_("skipped previously applied commit %s"),
5749 short_commit_name(commit
));
5753 if (is_empty
&& !keep_empty
)
5755 strbuf_addf(out
, "%s %s ", insn
,
5756 oid_to_hex(&commit
->object
.oid
));
5757 pretty_print_commit(&pp
, commit
, out
);
5759 strbuf_addf(out
, " %c empty", comment_line_char
);
5760 strbuf_addch(out
, '\n');
5763 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5764 _("use --reapply-cherry-picks to include skipped commits"));
5766 release_revisions(&revs
);
5771 * Add commands after pick and (series of) squash/fixup commands
5774 static void todo_list_add_exec_commands(struct todo_list
*todo_list
,
5775 struct string_list
*commands
)
5777 struct strbuf
*buf
= &todo_list
->buf
;
5778 size_t base_offset
= buf
->len
;
5779 int i
, insert
, nr
= 0, alloc
= 0;
5780 struct todo_item
*items
= NULL
, *base_items
= NULL
;
5782 CALLOC_ARRAY(base_items
, commands
->nr
);
5783 for (i
= 0; i
< commands
->nr
; i
++) {
5784 size_t command_len
= strlen(commands
->items
[i
].string
);
5786 strbuf_addstr(buf
, commands
->items
[i
].string
);
5787 strbuf_addch(buf
, '\n');
5789 base_items
[i
].command
= TODO_EXEC
;
5790 base_items
[i
].offset_in_buf
= base_offset
;
5791 base_items
[i
].arg_offset
= base_offset
;
5792 base_items
[i
].arg_len
= command_len
;
5794 base_offset
+= command_len
+ 1;
5798 * Insert <commands> after every pick. Here, fixup/squash chains
5799 * are considered part of the pick, so we insert the commands *after*
5800 * those chains if there are any.
5802 * As we insert the exec commands immediately after rearranging
5803 * any fixups and before the user edits the list, a fixup chain
5804 * can never contain comments (any comments are empty picks that
5805 * have been commented out because the user did not specify
5806 * --keep-empty). So, it is safe to insert an exec command
5807 * without looking at the command following a comment.
5810 for (i
= 0; i
< todo_list
->nr
; i
++) {
5811 enum todo_command command
= todo_list
->items
[i
].command
;
5812 if (insert
&& !is_fixup(command
)) {
5813 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5814 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5820 ALLOC_GROW(items
, nr
+ 1, alloc
);
5821 items
[nr
++] = todo_list
->items
[i
];
5823 if (command
== TODO_PICK
|| command
== TODO_MERGE
)
5827 /* insert or append final <commands> */
5829 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5830 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5835 FREE_AND_NULL(todo_list
->items
);
5836 todo_list
->items
= items
;
5838 todo_list
->alloc
= alloc
;
5841 static void todo_list_to_strbuf(struct repository
*r
, struct todo_list
*todo_list
,
5842 struct strbuf
*buf
, int num
, unsigned flags
)
5844 struct todo_item
*item
;
5845 int i
, max
= todo_list
->nr
;
5847 if (num
> 0 && num
< max
)
5850 for (item
= todo_list
->items
, i
= 0; i
< max
; i
++, item
++) {
5853 /* if the item is not a command write it and continue */
5854 if (item
->command
>= TODO_COMMENT
) {
5855 strbuf_addf(buf
, "%.*s\n", item
->arg_len
,
5856 todo_item_get_arg(todo_list
, item
));
5860 /* add command to the buffer */
5861 cmd
= command_to_char(item
->command
);
5862 if ((flags
& TODO_LIST_ABBREVIATE_CMDS
) && cmd
)
5863 strbuf_addch(buf
, cmd
);
5865 strbuf_addstr(buf
, command_to_string(item
->command
));
5869 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
5870 short_commit_name(item
->commit
) :
5871 oid_to_hex(&item
->commit
->object
.oid
);
5873 if (item
->command
== TODO_FIXUP
) {
5874 if (item
->flags
& TODO_EDIT_FIXUP_MSG
)
5875 strbuf_addstr(buf
, " -c");
5876 else if (item
->flags
& TODO_REPLACE_FIXUP_MSG
) {
5877 strbuf_addstr(buf
, " -C");
5881 if (item
->command
== TODO_MERGE
) {
5882 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
5883 strbuf_addstr(buf
, " -c");
5885 strbuf_addstr(buf
, " -C");
5888 strbuf_addf(buf
, " %s", oid
);
5891 /* add all the rest */
5893 strbuf_addch(buf
, '\n');
5895 strbuf_addf(buf
, " %.*s\n", item
->arg_len
,
5896 todo_item_get_arg(todo_list
, item
));
5900 int todo_list_write_to_file(struct repository
*r
, struct todo_list
*todo_list
,
5901 const char *file
, const char *shortrevisions
,
5902 const char *shortonto
, int num
, unsigned flags
)
5905 struct strbuf buf
= STRBUF_INIT
;
5907 todo_list_to_strbuf(r
, todo_list
, &buf
, num
, flags
);
5908 if (flags
& TODO_LIST_APPEND_TODO_HELP
)
5909 append_todo_help(count_commands(todo_list
),
5910 shortrevisions
, shortonto
, &buf
);
5912 res
= write_message(buf
.buf
, buf
.len
, file
, 0);
5913 strbuf_release(&buf
);
5918 /* skip picking commits whose parents are unchanged */
5919 static int skip_unnecessary_picks(struct repository
*r
,
5920 struct todo_list
*todo_list
,
5921 struct object_id
*base_oid
)
5923 struct object_id
*parent_oid
;
5926 for (i
= 0; i
< todo_list
->nr
; i
++) {
5927 struct todo_item
*item
= todo_list
->items
+ i
;
5929 if (item
->command
>= TODO_NOOP
)
5931 if (item
->command
!= TODO_PICK
)
5933 if (repo_parse_commit(r
, item
->commit
)) {
5934 return error(_("could not parse commit '%s'"),
5935 oid_to_hex(&item
->commit
->object
.oid
));
5937 if (!item
->commit
->parents
)
5938 break; /* root commit */
5939 if (item
->commit
->parents
->next
)
5940 break; /* merge commit */
5941 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
5942 if (!oideq(parent_oid
, base_oid
))
5944 oidcpy(base_oid
, &item
->commit
->object
.oid
);
5947 const char *done_path
= rebase_path_done();
5949 if (todo_list_write_to_file(r
, todo_list
, done_path
, NULL
, NULL
, i
, 0)) {
5950 error_errno(_("could not write to '%s'"), done_path
);
5954 MOVE_ARRAY(todo_list
->items
, todo_list
->items
+ i
, todo_list
->nr
- i
);
5956 todo_list
->current
= 0;
5957 todo_list
->done_nr
+= i
;
5959 if (is_fixup(peek_command(todo_list
, 0)))
5960 record_in_rewritten(base_oid
, peek_command(todo_list
, 0));
5966 struct todo_add_branch_context
{
5967 struct todo_item
*items
;
5971 struct commit
*commit
;
5972 struct string_list refs_to_oids
;
5975 static int add_decorations_to_list(const struct commit
*commit
,
5976 struct todo_add_branch_context
*ctx
)
5978 const struct name_decoration
*decoration
= get_name_decoration(&commit
->object
);
5979 const char *head_ref
= resolve_ref_unsafe("HEAD",
5980 RESOLVE_REF_READING
,
5984 while (decoration
) {
5985 struct todo_item
*item
;
5987 size_t base_offset
= ctx
->buf
->len
;
5990 * If the branch is the current HEAD, then it will be
5991 * updated by the default rebase behavior.
5993 if (head_ref
&& !strcmp(head_ref
, decoration
->name
)) {
5994 decoration
= decoration
->next
;
5998 ALLOC_GROW(ctx
->items
,
6001 item
= &ctx
->items
[ctx
->items_nr
];
6002 memset(item
, 0, sizeof(*item
));
6004 /* If the branch is checked out, then leave a comment instead. */
6005 if ((path
= branch_checked_out(decoration
->name
))) {
6006 item
->command
= TODO_COMMENT
;
6007 strbuf_addf(ctx
->buf
, "# Ref %s checked out at '%s'\n",
6008 decoration
->name
, path
);
6010 struct string_list_item
*sti
;
6011 item
->command
= TODO_UPDATE_REF
;
6012 strbuf_addf(ctx
->buf
, "%s\n", decoration
->name
);
6014 sti
= string_list_insert(&ctx
->refs_to_oids
,
6016 sti
->util
= init_update_ref_record(decoration
->name
);
6019 item
->offset_in_buf
= base_offset
;
6020 item
->arg_offset
= base_offset
;
6021 item
->arg_len
= ctx
->buf
->len
- base_offset
;
6024 decoration
= decoration
->next
;
6031 * For each 'pick' command, find out if the commit has a decoration in
6032 * refs/heads/. If so, then add a 'label for-update-refs/' command.
6034 static int todo_list_add_update_ref_commands(struct todo_list
*todo_list
)
6037 static struct string_list decorate_refs_exclude
= STRING_LIST_INIT_NODUP
;
6038 static struct string_list decorate_refs_exclude_config
= STRING_LIST_INIT_NODUP
;
6039 static struct string_list decorate_refs_include
= STRING_LIST_INIT_NODUP
;
6040 struct decoration_filter decoration_filter
= {
6041 .include_ref_pattern
= &decorate_refs_include
,
6042 .exclude_ref_pattern
= &decorate_refs_exclude
,
6043 .exclude_ref_config_pattern
= &decorate_refs_exclude_config
,
6045 struct todo_add_branch_context ctx
= {
6046 .buf
= &todo_list
->buf
,
6047 .refs_to_oids
= STRING_LIST_INIT_DUP
,
6050 ctx
.items_alloc
= 2 * todo_list
->nr
+ 1;
6051 ALLOC_ARRAY(ctx
.items
, ctx
.items_alloc
);
6053 string_list_append(&decorate_refs_include
, "refs/heads/");
6054 load_ref_decorations(&decoration_filter
, 0);
6056 for (i
= 0; i
< todo_list
->nr
; ) {
6057 struct todo_item
*item
= &todo_list
->items
[i
];
6059 /* insert ith item into new list */
6060 ALLOC_GROW(ctx
.items
,
6064 ctx
.items
[ctx
.items_nr
++] = todo_list
->items
[i
++];
6067 ctx
.commit
= item
->commit
;
6068 add_decorations_to_list(item
->commit
, &ctx
);
6072 res
= write_update_refs_state(&ctx
.refs_to_oids
);
6074 string_list_clear(&ctx
.refs_to_oids
, 1);
6077 /* we failed, so clean up the new list. */
6082 free(todo_list
->items
);
6083 todo_list
->items
= ctx
.items
;
6084 todo_list
->nr
= ctx
.items_nr
;
6085 todo_list
->alloc
= ctx
.items_alloc
;
6090 int complete_action(struct repository
*r
, struct replay_opts
*opts
, unsigned flags
,
6091 const char *shortrevisions
, const char *onto_name
,
6092 struct commit
*onto
, const struct object_id
*orig_head
,
6093 struct string_list
*commands
, unsigned autosquash
,
6094 unsigned update_refs
,
6095 struct todo_list
*todo_list
)
6097 char shortonto
[GIT_MAX_HEXSZ
+ 1];
6098 const char *todo_file
= rebase_path_todo();
6099 struct todo_list new_todo
= TODO_LIST_INIT
;
6100 struct strbuf
*buf
= &todo_list
->buf
, buf2
= STRBUF_INIT
;
6101 struct object_id oid
= onto
->object
.oid
;
6104 repo_find_unique_abbrev_r(r
, shortonto
, &oid
,
6107 if (buf
->len
== 0) {
6108 struct todo_item
*item
= append_new_todo(todo_list
);
6109 item
->command
= TODO_NOOP
;
6110 item
->commit
= NULL
;
6111 item
->arg_len
= item
->arg_offset
= item
->flags
= item
->offset_in_buf
= 0;
6114 if (update_refs
&& todo_list_add_update_ref_commands(todo_list
))
6117 if (autosquash
&& todo_list_rearrange_squash(todo_list
))
6121 todo_list_add_exec_commands(todo_list
, commands
);
6123 if (count_commands(todo_list
) == 0) {
6124 apply_autostash(rebase_path_autostash());
6125 sequencer_remove_state(opts
);
6127 return error(_("nothing to do"));
6130 res
= edit_todo_list(r
, todo_list
, &new_todo
, shortrevisions
,
6134 else if (res
== -2) {
6135 apply_autostash(rebase_path_autostash());
6136 sequencer_remove_state(opts
);
6139 } else if (res
== -3) {
6140 apply_autostash(rebase_path_autostash());
6141 sequencer_remove_state(opts
);
6142 todo_list_release(&new_todo
);
6144 return error(_("nothing to do"));
6145 } else if (res
== -4) {
6146 checkout_onto(r
, opts
, onto_name
, &onto
->object
.oid
, orig_head
);
6147 todo_list_release(&new_todo
);
6152 /* Expand the commit IDs */
6153 todo_list_to_strbuf(r
, &new_todo
, &buf2
, -1, 0);
6154 strbuf_swap(&new_todo
.buf
, &buf2
);
6155 strbuf_release(&buf2
);
6156 /* Nothing is done yet, and we're reparsing, so let's reset the count */
6157 new_todo
.total_nr
= 0;
6158 if (todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
) < 0)
6159 BUG("invalid todo list after expanding IDs:\n%s",
6162 if (opts
->allow_ff
&& skip_unnecessary_picks(r
, &new_todo
, &oid
)) {
6163 todo_list_release(&new_todo
);
6164 return error(_("could not skip unnecessary pick commands"));
6167 if (todo_list_write_to_file(r
, &new_todo
, todo_file
, NULL
, NULL
, -1,
6168 flags
& ~(TODO_LIST_SHORTEN_IDS
))) {
6169 todo_list_release(&new_todo
);
6170 return error_errno(_("could not write '%s'"), todo_file
);
6175 if (checkout_onto(r
, opts
, onto_name
, &oid
, orig_head
))
6178 if (require_clean_work_tree(r
, "rebase", "", 1, 1))
6181 todo_list_write_total_nr(&new_todo
);
6182 res
= pick_commits(r
, &new_todo
, opts
);
6185 todo_list_release(&new_todo
);
6190 struct subject2item_entry
{
6191 struct hashmap_entry entry
;
6193 char subject
[FLEX_ARRAY
];
6196 static int subject2item_cmp(const void *fndata UNUSED
,
6197 const struct hashmap_entry
*eptr
,
6198 const struct hashmap_entry
*entry_or_key
,
6201 const struct subject2item_entry
*a
, *b
;
6203 a
= container_of(eptr
, const struct subject2item_entry
, entry
);
6204 b
= container_of(entry_or_key
, const struct subject2item_entry
, entry
);
6206 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
6209 define_commit_slab(commit_todo_item
, struct todo_item
*);
6211 static int skip_fixupish(const char *subject
, const char **p
) {
6212 return skip_prefix(subject
, "fixup! ", p
) ||
6213 skip_prefix(subject
, "amend! ", p
) ||
6214 skip_prefix(subject
, "squash! ", p
);
6218 * Rearrange the todo list that has both "pick commit-id msg" and "pick
6219 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
6220 * after the former, and change "pick" to "fixup"/"squash".
6222 * Note that if the config has specified a custom instruction format, each log
6223 * message will have to be retrieved from the commit (as the oneline in the
6224 * script cannot be trusted) in order to normalize the autosquash arrangement.
6226 int todo_list_rearrange_squash(struct todo_list
*todo_list
)
6228 struct hashmap subject2item
;
6229 int rearranged
= 0, *next
, *tail
, i
, nr
= 0, alloc
= 0;
6231 struct commit_todo_item commit_todo
;
6232 struct todo_item
*items
= NULL
;
6234 init_commit_todo_item(&commit_todo
);
6236 * The hashmap maps onelines to the respective todo list index.
6238 * If any items need to be rearranged, the next[i] value will indicate
6239 * which item was moved directly after the i'th.
6241 * In that case, last[i] will indicate the index of the latest item to
6242 * be moved to appear after the i'th.
6244 hashmap_init(&subject2item
, subject2item_cmp
, NULL
, todo_list
->nr
);
6245 ALLOC_ARRAY(next
, todo_list
->nr
);
6246 ALLOC_ARRAY(tail
, todo_list
->nr
);
6247 ALLOC_ARRAY(subjects
, todo_list
->nr
);
6248 for (i
= 0; i
< todo_list
->nr
; i
++) {
6249 struct strbuf buf
= STRBUF_INIT
;
6250 struct todo_item
*item
= todo_list
->items
+ i
;
6251 const char *commit_buffer
, *subject
, *p
;
6254 struct subject2item_entry
*entry
;
6256 next
[i
] = tail
[i
] = -1;
6257 if (!item
->commit
|| item
->command
== TODO_DROP
) {
6262 if (is_fixup(item
->command
)) {
6263 clear_commit_todo_item(&commit_todo
);
6264 return error(_("the script was already rearranged."));
6267 repo_parse_commit(the_repository
, item
->commit
);
6268 commit_buffer
= repo_logmsg_reencode(the_repository
,
6271 find_commit_subject(commit_buffer
, &subject
);
6272 format_subject(&buf
, subject
, " ");
6273 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
6274 repo_unuse_commit_buffer(the_repository
, item
->commit
,
6276 if (skip_fixupish(subject
, &p
)) {
6277 struct commit
*commit2
;
6282 if (!skip_fixupish(p
, &p
))
6286 entry
= hashmap_get_entry_from_hash(&subject2item
,
6288 struct subject2item_entry
,
6291 /* found by title */
6293 else if (!strchr(p
, ' ') &&
6295 lookup_commit_reference_by_name(p
)) &&
6296 *commit_todo_item_at(&commit_todo
, commit2
))
6297 /* found by commit name */
6298 i2
= *commit_todo_item_at(&commit_todo
, commit2
)
6301 /* copy can be a prefix of the commit subject */
6302 for (i2
= 0; i2
< i
; i2
++)
6304 starts_with(subjects
[i2
], p
))
6312 if (starts_with(subject
, "fixup!")) {
6313 todo_list
->items
[i
].command
= TODO_FIXUP
;
6314 } else if (starts_with(subject
, "amend!")) {
6315 todo_list
->items
[i
].command
= TODO_FIXUP
;
6316 todo_list
->items
[i
].flags
= TODO_REPLACE_FIXUP_MSG
;
6318 todo_list
->items
[i
].command
= TODO_SQUASH
;
6324 next
[i
] = next
[tail
[i2
]];
6328 } else if (!hashmap_get_from_hash(&subject2item
,
6329 strhash(subject
), subject
)) {
6330 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
6332 hashmap_entry_init(&entry
->entry
,
6333 strhash(entry
->subject
));
6334 hashmap_put(&subject2item
, &entry
->entry
);
6337 *commit_todo_item_at(&commit_todo
, item
->commit
) = item
;
6341 for (i
= 0; i
< todo_list
->nr
; i
++) {
6342 enum todo_command command
= todo_list
->items
[i
].command
;
6346 * Initially, all commands are 'pick's. If it is a
6347 * fixup or a squash now, we have rearranged it.
6349 if (is_fixup(command
))
6353 ALLOC_GROW(items
, nr
+ 1, alloc
);
6354 items
[nr
++] = todo_list
->items
[cur
];
6359 FREE_AND_NULL(todo_list
->items
);
6360 todo_list
->items
= items
;
6362 todo_list
->alloc
= alloc
;
6367 for (i
= 0; i
< todo_list
->nr
; i
++)
6370 hashmap_clear_and_free(&subject2item
, struct subject2item_entry
, entry
);
6372 clear_commit_todo_item(&commit_todo
);
6377 int sequencer_determine_whence(struct repository
*r
, enum commit_whence
*whence
)
6379 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
6380 struct object_id cherry_pick_head
, rebase_head
;
6382 if (file_exists(git_path_seq_dir()))
6383 *whence
= FROM_CHERRY_PICK_MULTI
;
6384 if (file_exists(rebase_path()) &&
6385 !repo_get_oid(r
, "REBASE_HEAD", &rebase_head
) &&
6386 !repo_get_oid(r
, "CHERRY_PICK_HEAD", &cherry_pick_head
) &&
6387 oideq(&rebase_head
, &cherry_pick_head
))
6388 *whence
= FROM_REBASE_PICK
;
6390 *whence
= FROM_CHERRY_PICK_SINGLE
;
6398 int sequencer_get_update_refs_state(const char *wt_dir
,
6399 struct string_list
*refs
)
6403 struct strbuf ref
= STRBUF_INIT
;
6404 struct strbuf hash
= STRBUF_INIT
;
6405 struct update_ref_record
*rec
= NULL
;
6407 char *path
= rebase_path_update_refs(wt_dir
);
6409 fp
= fopen(path
, "r");
6413 while (strbuf_getline(&ref
, fp
) != EOF
) {
6414 struct string_list_item
*item
;
6416 CALLOC_ARRAY(rec
, 1);
6418 if (strbuf_getline(&hash
, fp
) == EOF
||
6419 get_oid_hex(hash
.buf
, &rec
->before
)) {
6420 warning(_("update-refs file at '%s' is invalid"),
6426 if (strbuf_getline(&hash
, fp
) == EOF
||
6427 get_oid_hex(hash
.buf
, &rec
->after
)) {
6428 warning(_("update-refs file at '%s' is invalid"),
6434 item
= string_list_insert(refs
, ref
.buf
);
6444 strbuf_release(&ref
);
6445 strbuf_release(&hash
);