5 #include "object-store.h"
10 #include "run-command.h"
14 #include "cache-tree.h"
18 #include "merge-ort.h"
19 #include "merge-ort-wrappers.h"
25 #include "wt-status.h"
27 #include "notes-utils.h"
29 #include "unpack-trees.h"
33 #include "commit-slab.h"
35 #include "commit-reach.h"
36 #include "rebase-interactive.h"
41 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
43 static const char sign_off_header
[] = "Signed-off-by: ";
44 static const char cherry_picked_prefix
[] = "(cherry picked from commit ";
46 GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
48 static GIT_PATH_FUNC(git_path_seq_dir
, "sequencer")
50 static GIT_PATH_FUNC(git_path_todo_file
, "sequencer/todo")
51 static GIT_PATH_FUNC(git_path_opts_file
, "sequencer/opts")
52 static GIT_PATH_FUNC(git_path_head_file
, "sequencer/head")
53 static GIT_PATH_FUNC(git_path_abort_safety_file
, "sequencer/abort-safety")
55 static GIT_PATH_FUNC(rebase_path
, "rebase-merge")
57 * The file containing rebase commands, comments, and empty lines.
58 * This file is created by "git rebase -i" then edited by the user. As
59 * the lines are processed, they are removed from the front of this
60 * file and written to the tail of 'done'.
62 GIT_PATH_FUNC(rebase_path_todo
, "rebase-merge/git-rebase-todo")
63 GIT_PATH_FUNC(rebase_path_todo_backup
, "rebase-merge/git-rebase-todo.backup")
65 GIT_PATH_FUNC(rebase_path_dropped
, "rebase-merge/dropped")
68 * The rebase command lines that have already been processed. A line
69 * is moved here when it is first handled, before any associated user
72 static GIT_PATH_FUNC(rebase_path_done
, "rebase-merge/done")
74 * The file to keep track of how many commands were already processed (e.g.
77 static GIT_PATH_FUNC(rebase_path_msgnum
, "rebase-merge/msgnum")
79 * The file to keep track of how many commands are to be processed in total
80 * (e.g. for the prompt).
82 static GIT_PATH_FUNC(rebase_path_msgtotal
, "rebase-merge/end")
84 * The commit message that is planned to be used for any changes that
85 * need to be committed following a user interaction.
87 static GIT_PATH_FUNC(rebase_path_message
, "rebase-merge/message")
89 * The file into which is accumulated the suggested commit message for
90 * squash/fixup commands. When the first of a series of squash/fixups
91 * is seen, the file is created and the commit message from the
92 * previous commit and from the first squash/fixup commit are written
93 * to it. The commit message for each subsequent squash/fixup commit
94 * is appended to the file as it is processed.
96 static GIT_PATH_FUNC(rebase_path_squash_msg
, "rebase-merge/message-squash")
98 * If the current series of squash/fixups has not yet included a squash
99 * command, then this file exists and holds the commit message of the
100 * original "pick" commit. (If the series ends without a "squash"
101 * command, then this can be used as the commit message of the combined
102 * commit without opening the editor.)
104 static GIT_PATH_FUNC(rebase_path_fixup_msg
, "rebase-merge/message-fixup")
106 * This file contains the list fixup/squash commands that have been
107 * accumulated into message-fixup or message-squash so far.
109 static GIT_PATH_FUNC(rebase_path_current_fixups
, "rebase-merge/current-fixups")
111 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
112 * GIT_AUTHOR_DATE that will be used for the commit that is currently
115 static GIT_PATH_FUNC(rebase_path_author_script
, "rebase-merge/author-script")
117 * When an "edit" rebase command is being processed, the SHA1 of the
118 * commit to be edited is recorded in this file. When "git rebase
119 * --continue" is executed, if there are any staged changes then they
120 * will be amended to the HEAD commit, but only provided the HEAD
121 * commit is still the commit to be edited. When any other rebase
122 * command is processed, this file is deleted.
124 static GIT_PATH_FUNC(rebase_path_amend
, "rebase-merge/amend")
126 * When we stop at a given patch via the "edit" command, this file contains
127 * the commit object name of the corresponding patch.
129 static GIT_PATH_FUNC(rebase_path_stopped_sha
, "rebase-merge/stopped-sha")
131 * For the post-rewrite hook, we make a list of rewritten commits and
132 * their new sha1s. The rewritten-pending list keeps the sha1s of
133 * commits that have been processed, but not committed yet,
134 * e.g. because they are waiting for a 'squash' command.
136 static GIT_PATH_FUNC(rebase_path_rewritten_list
, "rebase-merge/rewritten-list")
137 static GIT_PATH_FUNC(rebase_path_rewritten_pending
,
138 "rebase-merge/rewritten-pending")
141 * The path of the file containing the OID of the "squash onto" commit, i.e.
142 * the dummy commit used for `reset [new root]`.
144 static GIT_PATH_FUNC(rebase_path_squash_onto
, "rebase-merge/squash-onto")
147 * The path of the file listing refs that need to be deleted after the rebase
148 * finishes. This is used by the `label` command to record the need for cleanup.
150 static GIT_PATH_FUNC(rebase_path_refs_to_delete
, "rebase-merge/refs-to-delete")
153 * The update-refs file stores a list of refs that will be updated at the end
154 * of the rebase sequence. The 'update-ref <ref>' commands in the todo file
155 * update the OIDs for the refs in this file, but the refs are not updated
156 * until the end of the rebase sequence.
158 * rebase_path_update_refs() returns the path to this file for a given
159 * worktree directory. For the current worktree, pass the_repository->gitdir.
161 static char *rebase_path_update_refs(const char *wt_git_dir
)
163 return xstrfmt("%s/rebase-merge/update-refs", wt_git_dir
);
167 * The following files are written by git-rebase just after parsing the
170 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt
, "rebase-merge/gpg_sign_opt")
171 static GIT_PATH_FUNC(rebase_path_cdate_is_adate
, "rebase-merge/cdate_is_adate")
172 static GIT_PATH_FUNC(rebase_path_ignore_date
, "rebase-merge/ignore_date")
173 static GIT_PATH_FUNC(rebase_path_orig_head
, "rebase-merge/orig-head")
174 static GIT_PATH_FUNC(rebase_path_verbose
, "rebase-merge/verbose")
175 static GIT_PATH_FUNC(rebase_path_quiet
, "rebase-merge/quiet")
176 static GIT_PATH_FUNC(rebase_path_signoff
, "rebase-merge/signoff")
177 static GIT_PATH_FUNC(rebase_path_head_name
, "rebase-merge/head-name")
178 static GIT_PATH_FUNC(rebase_path_onto
, "rebase-merge/onto")
179 static GIT_PATH_FUNC(rebase_path_autostash
, "rebase-merge/autostash")
180 static GIT_PATH_FUNC(rebase_path_strategy
, "rebase-merge/strategy")
181 static GIT_PATH_FUNC(rebase_path_strategy_opts
, "rebase-merge/strategy_opts")
182 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate
, "rebase-merge/allow_rerere_autoupdate")
183 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec
, "rebase-merge/reschedule-failed-exec")
184 static GIT_PATH_FUNC(rebase_path_no_reschedule_failed_exec
, "rebase-merge/no-reschedule-failed-exec")
185 static GIT_PATH_FUNC(rebase_path_drop_redundant_commits
, "rebase-merge/drop_redundant_commits")
186 static GIT_PATH_FUNC(rebase_path_keep_redundant_commits
, "rebase-merge/keep_redundant_commits")
189 * A 'struct update_refs_record' represents a value in the update-refs
190 * list. We use a string_list to map refs to these (before, after) pairs.
192 struct update_ref_record
{
193 struct object_id before
;
194 struct object_id after
;
197 static struct update_ref_record
*init_update_ref_record(const char *ref
)
199 struct update_ref_record
*rec
;
201 CALLOC_ARRAY(rec
, 1);
203 oidcpy(&rec
->before
, null_oid());
204 oidcpy(&rec
->after
, null_oid());
206 /* This may fail, but that's fine, we will keep the null OID. */
207 read_ref(ref
, &rec
->before
);
212 static int git_sequencer_config(const char *k
, const char *v
, void *cb
)
214 struct replay_opts
*opts
= cb
;
217 if (!strcmp(k
, "commit.cleanup")) {
220 status
= git_config_string(&s
, k
, v
);
224 if (!strcmp(s
, "verbatim")) {
225 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
226 opts
->explicit_cleanup
= 1;
227 } else if (!strcmp(s
, "whitespace")) {
228 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
229 opts
->explicit_cleanup
= 1;
230 } else if (!strcmp(s
, "strip")) {
231 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_ALL
;
232 opts
->explicit_cleanup
= 1;
233 } else if (!strcmp(s
, "scissors")) {
234 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_SCISSORS
;
235 opts
->explicit_cleanup
= 1;
237 warning(_("invalid commit message cleanup mode '%s'"),
245 if (!strcmp(k
, "commit.gpgsign")) {
246 opts
->gpg_sign
= git_config_bool(k
, v
) ? xstrdup("") : NULL
;
250 if (!opts
->default_strategy
&& !strcmp(k
, "pull.twohead")) {
251 int ret
= git_config_string((const char**)&opts
->default_strategy
, k
, v
);
254 * pull.twohead is allowed to be multi-valued; we only
255 * care about the first value.
257 char *tmp
= strchr(opts
->default_strategy
, ' ');
264 if (opts
->action
== REPLAY_REVERT
&& !strcmp(k
, "revert.reference"))
265 opts
->commit_use_reference
= git_config_bool(k
, v
);
267 status
= git_gpg_config(k
, v
, NULL
);
271 return git_diff_basic_config(k
, v
, NULL
);
274 void sequencer_init_config(struct replay_opts
*opts
)
276 opts
->default_msg_cleanup
= COMMIT_MSG_CLEANUP_NONE
;
277 git_config(git_sequencer_config
, opts
);
280 static inline int is_rebase_i(const struct replay_opts
*opts
)
282 return opts
->action
== REPLAY_INTERACTIVE_REBASE
;
285 static const char *get_dir(const struct replay_opts
*opts
)
287 if (is_rebase_i(opts
))
288 return rebase_path();
289 return git_path_seq_dir();
292 static const char *get_todo_path(const struct replay_opts
*opts
)
294 if (is_rebase_i(opts
))
295 return rebase_path_todo();
296 return git_path_todo_file();
300 * Returns 0 for non-conforming footer
301 * Returns 1 for conforming footer
302 * Returns 2 when sob exists within conforming footer
303 * Returns 3 when sob exists within conforming footer as last entry
305 static int has_conforming_footer(struct strbuf
*sb
, struct strbuf
*sob
,
306 size_t ignore_footer
)
308 struct process_trailer_options opts
= PROCESS_TRAILER_OPTIONS_INIT
;
309 struct trailer_info info
;
311 int found_sob
= 0, found_sob_last
= 0;
317 saved_char
= sb
->buf
[sb
->len
- ignore_footer
];
318 sb
->buf
[sb
->len
- ignore_footer
] = '\0';
321 trailer_info_get(&info
, sb
->buf
, &opts
);
324 sb
->buf
[sb
->len
- ignore_footer
] = saved_char
;
326 if (info
.trailer_start
== info
.trailer_end
)
329 for (i
= 0; i
< info
.trailer_nr
; i
++)
330 if (sob
&& !strncmp(info
.trailers
[i
], sob
->buf
, sob
->len
)) {
332 if (i
== info
.trailer_nr
- 1)
336 trailer_info_release(&info
);
345 static const char *gpg_sign_opt_quoted(struct replay_opts
*opts
)
347 static struct strbuf buf
= STRBUF_INIT
;
351 sq_quotef(&buf
, "-S%s", opts
->gpg_sign
);
355 int sequencer_remove_state(struct replay_opts
*opts
)
357 struct strbuf buf
= STRBUF_INIT
;
360 if (is_rebase_i(opts
) &&
361 strbuf_read_file(&buf
, rebase_path_refs_to_delete(), 0) > 0) {
364 char *eol
= strchr(p
, '\n');
367 if (delete_ref("(rebase) cleanup", p
, NULL
, 0) < 0) {
368 warning(_("could not delete '%s'"), p
);
377 free(opts
->gpg_sign
);
378 free(opts
->default_strategy
);
379 free(opts
->strategy
);
380 for (i
= 0; i
< opts
->xopts_nr
; i
++)
381 free(opts
->xopts
[i
]);
383 strbuf_release(&opts
->current_fixups
);
386 strbuf_addstr(&buf
, get_dir(opts
));
387 if (remove_dir_recursively(&buf
, 0))
388 ret
= error(_("could not remove '%s'"), buf
.buf
);
389 strbuf_release(&buf
);
394 static const char *action_name(const struct replay_opts
*opts
)
396 switch (opts
->action
) {
400 return N_("cherry-pick");
401 case REPLAY_INTERACTIVE_REBASE
:
404 die(_("unknown action: %d"), opts
->action
);
407 struct commit_message
{
414 static const char *short_commit_name(struct commit
*commit
)
416 return find_unique_abbrev(&commit
->object
.oid
, DEFAULT_ABBREV
);
419 static int get_message(struct commit
*commit
, struct commit_message
*out
)
421 const char *abbrev
, *subject
;
424 out
->message
= logmsg_reencode(commit
, NULL
, get_commit_output_encoding());
425 abbrev
= short_commit_name(commit
);
427 subject_len
= find_commit_subject(out
->message
, &subject
);
429 out
->subject
= xmemdupz(subject
, subject_len
);
430 out
->label
= xstrfmt("%s (%s)", abbrev
, out
->subject
);
431 out
->parent_label
= xstrfmt("parent of %s", out
->label
);
436 static void free_message(struct commit
*commit
, struct commit_message
*msg
)
438 free(msg
->parent_label
);
441 unuse_commit_buffer(commit
, msg
->message
);
444 static void print_advice(struct repository
*r
, int show_hint
,
445 struct replay_opts
*opts
)
447 char *msg
= getenv("GIT_CHERRY_PICK_HELP");
452 * A conflict has occurred but the porcelain
453 * (typically rebase --interactive) wants to take care
454 * of the commit itself so remove CHERRY_PICK_HEAD
456 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
463 advise(_("after resolving the conflicts, mark the corrected paths\n"
464 "with 'git add <paths>' or 'git rm <paths>'"));
465 else if (opts
->action
== REPLAY_PICK
)
466 advise(_("After resolving the conflicts, mark them with\n"
467 "\"git add/rm <pathspec>\", then run\n"
468 "\"git cherry-pick --continue\".\n"
469 "You can instead skip this commit with \"git cherry-pick --skip\".\n"
470 "To abort and get back to the state before \"git cherry-pick\",\n"
471 "run \"git cherry-pick --abort\"."));
472 else if (opts
->action
== REPLAY_REVERT
)
473 advise(_("After resolving the conflicts, mark them with\n"
474 "\"git add/rm <pathspec>\", then run\n"
475 "\"git revert --continue\".\n"
476 "You can instead skip this commit with \"git revert --skip\".\n"
477 "To abort and get back to the state before \"git revert\",\n"
478 "run \"git revert --abort\"."));
480 BUG("unexpected pick action in print_advice()");
484 static int write_message(const void *buf
, size_t len
, const char *filename
,
487 struct lock_file msg_file
= LOCK_INIT
;
489 int msg_fd
= hold_lock_file_for_update(&msg_file
, filename
, 0);
491 return error_errno(_("could not lock '%s'"), filename
);
492 if (write_in_full(msg_fd
, buf
, len
) < 0) {
493 error_errno(_("could not write to '%s'"), filename
);
494 rollback_lock_file(&msg_file
);
497 if (append_eol
&& write(msg_fd
, "\n", 1) < 0) {
498 error_errno(_("could not write eol to '%s'"), filename
);
499 rollback_lock_file(&msg_file
);
502 if (commit_lock_file(&msg_file
) < 0)
503 return error(_("failed to finalize '%s'"), filename
);
508 int read_oneliner(struct strbuf
*buf
,
509 const char *path
, unsigned flags
)
511 int orig_len
= buf
->len
;
513 if (strbuf_read_file(buf
, path
, 0) < 0) {
514 if ((flags
& READ_ONELINER_WARN_MISSING
) ||
515 (errno
!= ENOENT
&& errno
!= ENOTDIR
))
516 warning_errno(_("could not read '%s'"), path
);
520 if (buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\n') {
521 if (--buf
->len
> orig_len
&& buf
->buf
[buf
->len
- 1] == '\r')
523 buf
->buf
[buf
->len
] = '\0';
526 if ((flags
& READ_ONELINER_SKIP_IF_EMPTY
) && buf
->len
== orig_len
)
532 static struct tree
*empty_tree(struct repository
*r
)
534 return lookup_tree(r
, the_hash_algo
->empty_tree
);
537 static int error_dirty_index(struct repository
*repo
, struct replay_opts
*opts
)
539 if (repo_read_index_unmerged(repo
))
540 return error_resolve_conflict(action_name(opts
));
542 error(_("your local changes would be overwritten by %s."),
543 _(action_name(opts
)));
545 if (advice_enabled(ADVICE_COMMIT_BEFORE_MERGE
))
546 advise(_("commit your changes or stash them to proceed."));
550 static void update_abort_safety_file(void)
552 struct object_id head
;
554 /* Do nothing on a single-pick */
555 if (!file_exists(git_path_seq_dir()))
558 if (!get_oid("HEAD", &head
))
559 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head
));
561 write_file(git_path_abort_safety_file(), "%s", "");
564 static int fast_forward_to(struct repository
*r
,
565 const struct object_id
*to
,
566 const struct object_id
*from
,
568 struct replay_opts
*opts
)
570 struct ref_transaction
*transaction
;
571 struct strbuf sb
= STRBUF_INIT
;
572 struct strbuf err
= STRBUF_INIT
;
575 if (checkout_fast_forward(r
, from
, to
, 1))
576 return -1; /* the callee should have complained already */
578 strbuf_addf(&sb
, "%s: fast-forward", action_name(opts
));
580 transaction
= ref_transaction_begin(&err
);
582 ref_transaction_update(transaction
, "HEAD",
583 to
, unborn
&& !is_rebase_i(opts
) ?
586 ref_transaction_commit(transaction
, &err
)) {
587 ref_transaction_free(transaction
);
588 error("%s", err
.buf
);
590 strbuf_release(&err
);
595 strbuf_release(&err
);
596 ref_transaction_free(transaction
);
597 update_abort_safety_file();
601 enum commit_msg_cleanup_mode
get_cleanup_mode(const char *cleanup_arg
,
604 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
605 return use_editor
? COMMIT_MSG_CLEANUP_ALL
:
606 COMMIT_MSG_CLEANUP_SPACE
;
607 else if (!strcmp(cleanup_arg
, "verbatim"))
608 return COMMIT_MSG_CLEANUP_NONE
;
609 else if (!strcmp(cleanup_arg
, "whitespace"))
610 return COMMIT_MSG_CLEANUP_SPACE
;
611 else if (!strcmp(cleanup_arg
, "strip"))
612 return COMMIT_MSG_CLEANUP_ALL
;
613 else if (!strcmp(cleanup_arg
, "scissors"))
614 return use_editor
? COMMIT_MSG_CLEANUP_SCISSORS
:
615 COMMIT_MSG_CLEANUP_SPACE
;
617 die(_("Invalid cleanup mode %s"), cleanup_arg
);
621 * NB using int rather than enum cleanup_mode to stop clang's
622 * -Wtautological-constant-out-of-range-compare complaining that the comparison
625 static const char *describe_cleanup_mode(int cleanup_mode
)
627 static const char *modes
[] = { "whitespace",
632 if (cleanup_mode
< ARRAY_SIZE(modes
))
633 return modes
[cleanup_mode
];
635 BUG("invalid cleanup_mode provided (%d)", cleanup_mode
);
638 void append_conflicts_hint(struct index_state
*istate
,
639 struct strbuf
*msgbuf
, enum commit_msg_cleanup_mode cleanup_mode
)
643 if (cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
) {
644 strbuf_addch(msgbuf
, '\n');
645 wt_status_append_cut_line(msgbuf
);
646 strbuf_addch(msgbuf
, comment_line_char
);
649 strbuf_addch(msgbuf
, '\n');
650 strbuf_commented_addf(msgbuf
, "Conflicts:\n");
651 for (i
= 0; i
< istate
->cache_nr
;) {
652 const struct cache_entry
*ce
= istate
->cache
[i
++];
654 strbuf_commented_addf(msgbuf
, "\t%s\n", ce
->name
);
655 while (i
< istate
->cache_nr
&&
656 !strcmp(ce
->name
, istate
->cache
[i
]->name
))
662 static int do_recursive_merge(struct repository
*r
,
663 struct commit
*base
, struct commit
*next
,
664 const char *base_label
, const char *next_label
,
665 struct object_id
*head
, struct strbuf
*msgbuf
,
666 struct replay_opts
*opts
)
668 struct merge_options o
;
669 struct merge_result result
;
670 struct tree
*next_tree
, *base_tree
, *head_tree
;
671 int clean
, show_output
;
673 struct lock_file index_lock
= LOCK_INIT
;
675 if (repo_hold_locked_index(r
, &index_lock
, LOCK_REPORT_ON_ERROR
) < 0)
680 init_merge_options(&o
, r
);
681 o
.ancestor
= base
? base_label
: "(empty tree)";
683 o
.branch2
= next
? next_label
: "(empty tree)";
684 if (is_rebase_i(opts
))
686 o
.show_rename_progress
= 1;
688 head_tree
= parse_tree_indirect(head
);
689 next_tree
= next
? get_commit_tree(next
) : empty_tree(r
);
690 base_tree
= base
? get_commit_tree(base
) : empty_tree(r
);
692 for (i
= 0; i
< opts
->xopts_nr
; i
++)
693 parse_merge_opt(&o
, opts
->xopts
[i
]);
695 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
696 memset(&result
, 0, sizeof(result
));
697 merge_incore_nonrecursive(&o
, base_tree
, head_tree
, next_tree
,
699 show_output
= !is_rebase_i(opts
) || !result
.clean
;
701 * TODO: merge_switch_to_result will update index/working tree;
702 * we only really want to do that if !result.clean || this is
703 * the final patch to be picked. But determining this is the
704 * final patch would take some work, and "head_tree" would need
705 * to be replace with the tree the index matched before we
706 * started doing any picks.
708 merge_switch_to_result(&o
, head_tree
, &result
, 1, show_output
);
709 clean
= result
.clean
;
711 ensure_full_index(r
->index
);
712 clean
= merge_trees(&o
, head_tree
, next_tree
, base_tree
);
713 if (is_rebase_i(opts
) && clean
<= 0)
714 fputs(o
.obuf
.buf
, stdout
);
715 strbuf_release(&o
.obuf
);
718 rollback_lock_file(&index_lock
);
722 if (write_locked_index(r
->index
, &index_lock
,
723 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
725 * TRANSLATORS: %s will be "revert", "cherry-pick" or
728 return error(_("%s: Unable to write new index file"),
729 _(action_name(opts
)));
732 append_conflicts_hint(r
->index
, msgbuf
,
733 opts
->default_msg_cleanup
);
738 static struct object_id
*get_cache_tree_oid(struct index_state
*istate
)
740 if (!cache_tree_fully_valid(istate
->cache_tree
))
741 if (cache_tree_update(istate
, 0)) {
742 error(_("unable to update cache tree"));
746 return &istate
->cache_tree
->oid
;
749 static int is_index_unchanged(struct repository
*r
)
751 struct object_id head_oid
, *cache_tree_oid
;
752 struct commit
*head_commit
;
753 struct index_state
*istate
= r
->index
;
755 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING
, &head_oid
, NULL
))
756 return error(_("could not resolve HEAD commit"));
758 head_commit
= lookup_commit(r
, &head_oid
);
761 * If head_commit is NULL, check_commit, called from
762 * lookup_commit, would have indicated that head_commit is not
763 * a commit object already. parse_commit() will return failure
764 * without further complaints in such a case. Otherwise, if
765 * the commit is invalid, parse_commit() will complain. So
766 * there is nothing for us to say here. Just return failure.
768 if (parse_commit(head_commit
))
771 if (!(cache_tree_oid
= get_cache_tree_oid(istate
)))
774 return oideq(cache_tree_oid
, get_commit_tree_oid(head_commit
));
777 static int write_author_script(const char *message
)
779 struct strbuf buf
= STRBUF_INIT
;
784 if (!*message
|| starts_with(message
, "\n")) {
786 /* Missing 'author' line? */
787 unlink(rebase_path_author_script());
789 } else if (skip_prefix(message
, "author ", &message
))
791 else if ((eol
= strchr(message
, '\n')))
796 strbuf_addstr(&buf
, "GIT_AUTHOR_NAME='");
797 while (*message
&& *message
!= '\n' && *message
!= '\r')
798 if (skip_prefix(message
, " <", &message
))
800 else if (*message
!= '\'')
801 strbuf_addch(&buf
, *(message
++));
803 strbuf_addf(&buf
, "'\\%c'", *(message
++));
804 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_EMAIL='");
805 while (*message
&& *message
!= '\n' && *message
!= '\r')
806 if (skip_prefix(message
, "> ", &message
))
808 else if (*message
!= '\'')
809 strbuf_addch(&buf
, *(message
++));
811 strbuf_addf(&buf
, "'\\%c'", *(message
++));
812 strbuf_addstr(&buf
, "'\nGIT_AUTHOR_DATE='@");
813 while (*message
&& *message
!= '\n' && *message
!= '\r')
814 if (*message
!= '\'')
815 strbuf_addch(&buf
, *(message
++));
817 strbuf_addf(&buf
, "'\\%c'", *(message
++));
818 strbuf_addch(&buf
, '\'');
819 res
= write_message(buf
.buf
, buf
.len
, rebase_path_author_script(), 1);
820 strbuf_release(&buf
);
825 * Take a series of KEY='VALUE' lines where VALUE part is
826 * sq-quoted, and append <KEY, VALUE> at the end of the string list
828 static int parse_key_value_squoted(char *buf
, struct string_list
*list
)
831 struct string_list_item
*item
;
833 char *cp
= strchr(buf
, '=');
835 np
= strchrnul(buf
, '\n');
836 return error(_("no key present in '%.*s'"),
837 (int) (np
- buf
), buf
);
839 np
= strchrnul(cp
, '\n');
841 item
= string_list_append(list
, buf
);
843 buf
= np
+ (*np
== '\n');
847 return error(_("unable to dequote value of '%s'"),
849 item
->util
= xstrdup(cp
);
855 * Reads and parses the state directory's "author-script" file, and sets name,
856 * email and date accordingly.
857 * Returns 0 on success, -1 if the file could not be parsed.
859 * The author script is of the format:
861 * GIT_AUTHOR_NAME='$author_name'
862 * GIT_AUTHOR_EMAIL='$author_email'
863 * GIT_AUTHOR_DATE='$author_date'
865 * where $author_name, $author_email and $author_date are quoted. We are strict
866 * with our parsing, as the file was meant to be eval'd in the now-removed
867 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
868 * from what this function expects, it is better to bail out than to do
869 * something that the user does not expect.
871 int read_author_script(const char *path
, char **name
, char **email
, char **date
,
874 struct strbuf buf
= STRBUF_INIT
;
875 struct string_list kv
= STRING_LIST_INIT_DUP
;
876 int retval
= -1; /* assume failure */
877 int i
, name_i
= -2, email_i
= -2, date_i
= -2, err
= 0;
879 if (strbuf_read_file(&buf
, path
, 256) <= 0) {
880 strbuf_release(&buf
);
881 if (errno
== ENOENT
&& allow_missing
)
884 return error_errno(_("could not open '%s' for reading"),
888 if (parse_key_value_squoted(buf
.buf
, &kv
))
891 for (i
= 0; i
< kv
.nr
; i
++) {
892 if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_NAME")) {
894 name_i
= error(_("'GIT_AUTHOR_NAME' already given"));
897 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_EMAIL")) {
899 email_i
= error(_("'GIT_AUTHOR_EMAIL' already given"));
902 } else if (!strcmp(kv
.items
[i
].string
, "GIT_AUTHOR_DATE")) {
904 date_i
= error(_("'GIT_AUTHOR_DATE' already given"));
908 err
= error(_("unknown variable '%s'"),
913 error(_("missing 'GIT_AUTHOR_NAME'"));
915 error(_("missing 'GIT_AUTHOR_EMAIL'"));
917 error(_("missing 'GIT_AUTHOR_DATE'"));
918 if (name_i
< 0 || email_i
< 0 || date_i
< 0 || err
)
920 *name
= kv
.items
[name_i
].util
;
921 *email
= kv
.items
[email_i
].util
;
922 *date
= kv
.items
[date_i
].util
;
925 string_list_clear(&kv
, !!retval
);
926 strbuf_release(&buf
);
931 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
932 * file with shell quoting into struct strvec. Returns -1 on
933 * error, 0 otherwise.
935 static int read_env_script(struct strvec
*env
)
937 char *name
, *email
, *date
;
939 if (read_author_script(rebase_path_author_script(),
940 &name
, &email
, &date
, 0))
943 strvec_pushf(env
, "GIT_AUTHOR_NAME=%s", name
);
944 strvec_pushf(env
, "GIT_AUTHOR_EMAIL=%s", email
);
945 strvec_pushf(env
, "GIT_AUTHOR_DATE=%s", date
);
953 static char *get_author(const char *message
)
958 a
= find_commit_header(message
, "author", &len
);
960 return xmemdupz(a
, len
);
965 static const char *author_date_from_env(const struct strvec
*env
)
970 for (i
= 0; i
< env
->nr
; i
++)
971 if (skip_prefix(env
->v
[i
],
972 "GIT_AUTHOR_DATE=", &date
))
975 * If GIT_AUTHOR_DATE is missing we should have already errored out when
978 BUG("GIT_AUTHOR_DATE missing from author script");
981 static const char staged_changes_advice
[] =
982 N_("you have staged changes in your working tree\n"
983 "If these changes are meant to be squashed into the previous commit, run:\n"
985 " git commit --amend %s\n"
987 "If they are meant to go into a new commit, run:\n"
991 "In both cases, once you're done, continue with:\n"
993 " git rebase --continue\n");
995 #define ALLOW_EMPTY (1<<0)
996 #define EDIT_MSG (1<<1)
997 #define AMEND_MSG (1<<2)
998 #define CLEANUP_MSG (1<<3)
999 #define VERIFY_MSG (1<<4)
1000 #define CREATE_ROOT_COMMIT (1<<5)
1001 #define VERBATIM_MSG (1<<6)
1003 static int run_command_silent_on_success(struct child_process
*cmd
)
1005 struct strbuf buf
= STRBUF_INIT
;
1008 cmd
->stdout_to_stderr
= 1;
1009 rc
= pipe_command(cmd
,
1015 fputs(buf
.buf
, stderr
);
1016 strbuf_release(&buf
);
1021 * If we are cherry-pick, and if the merge did not result in
1022 * hand-editing, we will hit this commit and inherit the original
1023 * author date and name.
1025 * If we are revert, or if our cherry-pick results in a hand merge,
1026 * we had better say that the current user is responsible for that.
1028 * An exception is when run_git_commit() is called during an
1029 * interactive rebase: in that case, we will want to retain the
1032 static int run_git_commit(const char *defmsg
,
1033 struct replay_opts
*opts
,
1036 struct child_process cmd
= CHILD_PROCESS_INIT
;
1038 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1039 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1043 if (is_rebase_i(opts
) &&
1044 ((opts
->committer_date_is_author_date
&& !opts
->ignore_date
) ||
1045 !(!defmsg
&& (flags
& AMEND_MSG
))) &&
1046 read_env_script(&cmd
.env
)) {
1047 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
1049 return error(_(staged_changes_advice
),
1053 if (opts
->committer_date_is_author_date
)
1054 strvec_pushf(&cmd
.env
, "GIT_COMMITTER_DATE=%s",
1057 author_date_from_env(&cmd
.env
));
1058 if (opts
->ignore_date
)
1059 strvec_push(&cmd
.env
, "GIT_AUTHOR_DATE=");
1061 strvec_push(&cmd
.args
, "commit");
1063 if (!(flags
& VERIFY_MSG
))
1064 strvec_push(&cmd
.args
, "-n");
1065 if ((flags
& AMEND_MSG
))
1066 strvec_push(&cmd
.args
, "--amend");
1068 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
1070 strvec_push(&cmd
.args
, "--no-gpg-sign");
1072 strvec_pushl(&cmd
.args
, "-F", defmsg
, NULL
);
1073 else if (!(flags
& EDIT_MSG
))
1074 strvec_pushl(&cmd
.args
, "-C", "HEAD", NULL
);
1075 if ((flags
& CLEANUP_MSG
))
1076 strvec_push(&cmd
.args
, "--cleanup=strip");
1077 if ((flags
& VERBATIM_MSG
))
1078 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1079 if ((flags
& EDIT_MSG
))
1080 strvec_push(&cmd
.args
, "-e");
1081 else if (!(flags
& CLEANUP_MSG
) &&
1082 !opts
->signoff
&& !opts
->record_origin
&&
1083 !opts
->explicit_cleanup
)
1084 strvec_push(&cmd
.args
, "--cleanup=verbatim");
1086 if ((flags
& ALLOW_EMPTY
))
1087 strvec_push(&cmd
.args
, "--allow-empty");
1089 if (!(flags
& EDIT_MSG
))
1090 strvec_push(&cmd
.args
, "--allow-empty-message");
1092 if (is_rebase_i(opts
) && !(flags
& EDIT_MSG
))
1093 return run_command_silent_on_success(&cmd
);
1095 return run_command(&cmd
);
1098 static int rest_is_empty(const struct strbuf
*sb
, int start
)
1103 /* Check if the rest is just whitespace and Signed-off-by's. */
1104 for (i
= start
; i
< sb
->len
; i
++) {
1105 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1111 if (strlen(sign_off_header
) <= eol
- i
&&
1112 starts_with(sb
->buf
+ i
, sign_off_header
)) {
1117 if (!isspace(sb
->buf
[i
++]))
1124 void cleanup_message(struct strbuf
*msgbuf
,
1125 enum commit_msg_cleanup_mode cleanup_mode
, int verbose
)
1127 if (verbose
|| /* Truncate the message just before the diff, if any. */
1128 cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
1129 strbuf_setlen(msgbuf
, wt_status_locate_end(msgbuf
->buf
, msgbuf
->len
));
1130 if (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
)
1131 strbuf_stripspace(msgbuf
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1135 * Find out if the message in the strbuf contains only whitespace and
1136 * Signed-off-by lines.
1138 int message_is_empty(const struct strbuf
*sb
,
1139 enum commit_msg_cleanup_mode cleanup_mode
)
1141 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1143 return rest_is_empty(sb
, 0);
1147 * See if the user edited the message in the editor or left what
1148 * was in the template intact
1150 int template_untouched(const struct strbuf
*sb
, const char *template_file
,
1151 enum commit_msg_cleanup_mode cleanup_mode
)
1153 struct strbuf tmpl
= STRBUF_INIT
;
1156 if (cleanup_mode
== COMMIT_MSG_CLEANUP_NONE
&& sb
->len
)
1159 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
1162 strbuf_stripspace(&tmpl
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1163 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
1165 strbuf_release(&tmpl
);
1166 return rest_is_empty(sb
, start
- sb
->buf
);
1169 int update_head_with_reflog(const struct commit
*old_head
,
1170 const struct object_id
*new_head
,
1171 const char *action
, const struct strbuf
*msg
,
1174 struct ref_transaction
*transaction
;
1175 struct strbuf sb
= STRBUF_INIT
;
1180 strbuf_addstr(&sb
, action
);
1181 strbuf_addstr(&sb
, ": ");
1184 nl
= strchr(msg
->buf
, '\n');
1186 strbuf_add(&sb
, msg
->buf
, nl
+ 1 - msg
->buf
);
1188 strbuf_addbuf(&sb
, msg
);
1189 strbuf_addch(&sb
, '\n');
1192 transaction
= ref_transaction_begin(err
);
1194 ref_transaction_update(transaction
, "HEAD", new_head
,
1195 old_head
? &old_head
->object
.oid
: null_oid(),
1197 ref_transaction_commit(transaction
, err
)) {
1200 ref_transaction_free(transaction
);
1201 strbuf_release(&sb
);
1206 static int run_rewrite_hook(const struct object_id
*oldoid
,
1207 const struct object_id
*newoid
)
1209 struct child_process proc
= CHILD_PROCESS_INIT
;
1211 struct strbuf sb
= STRBUF_INIT
;
1212 const char *hook_path
= find_hook("post-rewrite");
1217 strvec_pushl(&proc
.args
, hook_path
, "amend", NULL
);
1219 proc
.stdout_to_stderr
= 1;
1220 proc
.trace2_hook_name
= "post-rewrite";
1222 code
= start_command(&proc
);
1225 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
1226 sigchain_push(SIGPIPE
, SIG_IGN
);
1227 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
1229 strbuf_release(&sb
);
1230 sigchain_pop(SIGPIPE
);
1231 return finish_command(&proc
);
1234 void commit_post_rewrite(struct repository
*r
,
1235 const struct commit
*old_head
,
1236 const struct object_id
*new_head
)
1238 struct notes_rewrite_cfg
*cfg
;
1240 cfg
= init_copy_notes_for_rewrite("amend");
1242 /* we are amending, so old_head is not NULL */
1243 copy_note_for_rewrite(cfg
, &old_head
->object
.oid
, new_head
);
1244 finish_copy_notes_for_rewrite(r
, cfg
, "Notes added by 'git commit --amend'");
1246 run_rewrite_hook(&old_head
->object
.oid
, new_head
);
1249 static int run_prepare_commit_msg_hook(struct repository
*r
,
1254 const char *name
, *arg1
= NULL
, *arg2
= NULL
;
1256 name
= git_path_commit_editmsg();
1257 if (write_message(msg
->buf
, msg
->len
, name
, 0))
1266 if (run_commit_hook(0, r
->index_file
, NULL
, "prepare-commit-msg", name
,
1268 ret
= error(_("'prepare-commit-msg' hook failed"));
1273 static const char implicit_ident_advice_noconfig
[] =
1274 N_("Your name and email address were configured automatically based\n"
1275 "on your username and hostname. Please check that they are accurate.\n"
1276 "You can suppress this message by setting them explicitly. Run the\n"
1277 "following command and follow the instructions in your editor to edit\n"
1278 "your configuration file:\n"
1280 " git config --global --edit\n"
1282 "After doing this, you may fix the identity used for this commit with:\n"
1284 " git commit --amend --reset-author\n");
1286 static const char implicit_ident_advice_config
[] =
1287 N_("Your name and email address were configured automatically based\n"
1288 "on your username and hostname. Please check that they are accurate.\n"
1289 "You can suppress this message by setting them explicitly:\n"
1291 " git config --global user.name \"Your Name\"\n"
1292 " git config --global user.email you@example.com\n"
1294 "After doing this, you may fix the identity used for this commit with:\n"
1296 " git commit --amend --reset-author\n");
1298 static const char *implicit_ident_advice(void)
1300 char *user_config
= interpolate_path("~/.gitconfig", 0);
1301 char *xdg_config
= xdg_config_home("config");
1302 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1308 return _(implicit_ident_advice_config
);
1310 return _(implicit_ident_advice_noconfig
);
1314 void print_commit_summary(struct repository
*r
,
1316 const struct object_id
*oid
,
1319 struct rev_info rev
;
1320 struct commit
*commit
;
1321 struct strbuf format
= STRBUF_INIT
;
1323 struct pretty_print_context pctx
= {0};
1324 struct strbuf author_ident
= STRBUF_INIT
;
1325 struct strbuf committer_ident
= STRBUF_INIT
;
1326 struct ref_store
*refs
;
1328 commit
= lookup_commit(r
, oid
);
1330 die(_("couldn't look up newly created commit"));
1331 if (parse_commit(commit
))
1332 die(_("could not parse newly created commit"));
1334 strbuf_addstr(&format
, "format:%h] %s");
1336 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1337 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1338 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1339 strbuf_addstr(&format
, "\n Author: ");
1340 strbuf_addbuf_percentquote(&format
, &author_ident
);
1342 if (flags
& SUMMARY_SHOW_AUTHOR_DATE
) {
1343 struct strbuf date
= STRBUF_INIT
;
1345 format_commit_message(commit
, "%ad", &date
, &pctx
);
1346 strbuf_addstr(&format
, "\n Date: ");
1347 strbuf_addbuf_percentquote(&format
, &date
);
1348 strbuf_release(&date
);
1350 if (!committer_ident_sufficiently_given()) {
1351 strbuf_addstr(&format
, "\n Committer: ");
1352 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1353 if (advice_enabled(ADVICE_IMPLICIT_IDENTITY
)) {
1354 strbuf_addch(&format
, '\n');
1355 strbuf_addstr(&format
, implicit_ident_advice());
1358 strbuf_release(&author_ident
);
1359 strbuf_release(&committer_ident
);
1361 repo_init_revisions(r
, &rev
, prefix
);
1362 setup_revisions(0, NULL
, &rev
, NULL
);
1365 rev
.diffopt
.output_format
=
1366 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1368 rev
.verbose_header
= 1;
1369 rev
.show_root_diff
= 1;
1370 get_commit_format(format
.buf
, &rev
);
1371 rev
.always_show_header
= 0;
1372 rev
.diffopt
.detect_rename
= DIFF_DETECT_RENAME
;
1373 diff_setup_done(&rev
.diffopt
);
1375 refs
= get_main_ref_store(the_repository
);
1376 head
= refs_resolve_ref_unsafe(refs
, "HEAD", 0, NULL
, NULL
);
1378 die(_("unable to resolve HEAD after creating commit"));
1379 if (!strcmp(head
, "HEAD"))
1380 head
= _("detached HEAD");
1382 skip_prefix(head
, "refs/heads/", &head
);
1383 printf("[%s%s ", head
, (flags
& SUMMARY_INITIAL_COMMIT
) ?
1384 _(" (root-commit)") : "");
1386 if (!log_tree_commit(&rev
, commit
)) {
1387 rev
.always_show_header
= 1;
1388 rev
.use_terminator
= 1;
1389 log_tree_commit(&rev
, commit
);
1392 release_revisions(&rev
);
1393 strbuf_release(&format
);
1396 static int parse_head(struct repository
*r
, struct commit
**head
)
1398 struct commit
*current_head
;
1399 struct object_id oid
;
1401 if (get_oid("HEAD", &oid
)) {
1402 current_head
= NULL
;
1404 current_head
= lookup_commit_reference(r
, &oid
);
1406 return error(_("could not parse HEAD"));
1407 if (!oideq(&oid
, ¤t_head
->object
.oid
)) {
1408 warning(_("HEAD %s is not a commit!"),
1411 if (parse_commit(current_head
))
1412 return error(_("could not parse HEAD commit"));
1414 *head
= current_head
;
1420 * Try to commit without forking 'git commit'. In some cases we need
1421 * to run 'git commit' to display an error message
1424 * -1 - error unable to commit
1426 * 1 - run 'git commit'
1428 static int try_to_commit(struct repository
*r
,
1429 struct strbuf
*msg
, const char *author
,
1430 struct replay_opts
*opts
, unsigned int flags
,
1431 struct object_id
*oid
)
1433 struct object_id tree
;
1434 struct commit
*current_head
= NULL
;
1435 struct commit_list
*parents
= NULL
;
1436 struct commit_extra_header
*extra
= NULL
;
1437 struct strbuf err
= STRBUF_INIT
;
1438 struct strbuf commit_msg
= STRBUF_INIT
;
1439 char *amend_author
= NULL
;
1440 const char *committer
= NULL
;
1441 const char *hook_commit
= NULL
;
1442 enum commit_msg_cleanup_mode cleanup
;
1445 if ((flags
& CLEANUP_MSG
) && (flags
& VERBATIM_MSG
))
1446 BUG("CLEANUP_MSG and VERBATIM_MSG are mutually exclusive");
1448 if (parse_head(r
, ¤t_head
))
1451 if (flags
& AMEND_MSG
) {
1452 const char *exclude_gpgsig
[] = { "gpgsig", "gpgsig-sha256", NULL
};
1453 const char *out_enc
= get_commit_output_encoding();
1454 const char *message
= logmsg_reencode(current_head
, NULL
,
1458 const char *orig_message
= NULL
;
1460 find_commit_subject(message
, &orig_message
);
1462 strbuf_addstr(msg
, orig_message
);
1463 hook_commit
= "HEAD";
1465 author
= amend_author
= get_author(message
);
1466 unuse_commit_buffer(current_head
, message
);
1468 res
= error(_("unable to parse commit author"));
1471 parents
= copy_commit_list(current_head
->parents
);
1472 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1473 } else if (current_head
&&
1474 (!(flags
& CREATE_ROOT_COMMIT
) || (flags
& AMEND_MSG
))) {
1475 commit_list_insert(current_head
, &parents
);
1478 if (write_index_as_tree(&tree
, r
->index
, r
->index_file
, 0, NULL
)) {
1479 res
= error(_("git write-tree failed to write a tree"));
1483 if (!(flags
& ALLOW_EMPTY
)) {
1484 struct commit
*first_parent
= current_head
;
1486 if (flags
& AMEND_MSG
) {
1487 if (current_head
->parents
) {
1488 first_parent
= current_head
->parents
->item
;
1489 if (repo_parse_commit(r
, first_parent
)) {
1490 res
= error(_("could not parse HEAD commit"));
1494 first_parent
= NULL
;
1497 if (oideq(first_parent
1498 ? get_commit_tree_oid(first_parent
)
1499 : the_hash_algo
->empty_tree
,
1501 res
= 1; /* run 'git commit' to display error message */
1506 if (hook_exists("prepare-commit-msg")) {
1507 res
= run_prepare_commit_msg_hook(r
, msg
, hook_commit
);
1510 if (strbuf_read_file(&commit_msg
, git_path_commit_editmsg(),
1512 res
= error_errno(_("unable to read commit message "
1514 git_path_commit_editmsg());
1520 if (flags
& CLEANUP_MSG
)
1521 cleanup
= COMMIT_MSG_CLEANUP_ALL
;
1522 else if (flags
& VERBATIM_MSG
)
1523 cleanup
= COMMIT_MSG_CLEANUP_NONE
;
1524 else if ((opts
->signoff
|| opts
->record_origin
) &&
1525 !opts
->explicit_cleanup
)
1526 cleanup
= COMMIT_MSG_CLEANUP_SPACE
;
1528 cleanup
= opts
->default_msg_cleanup
;
1530 if (cleanup
!= COMMIT_MSG_CLEANUP_NONE
)
1531 strbuf_stripspace(msg
, cleanup
== COMMIT_MSG_CLEANUP_ALL
);
1532 if ((flags
& EDIT_MSG
) && message_is_empty(msg
, cleanup
)) {
1533 res
= 1; /* run 'git commit' to display error message */
1537 if (opts
->committer_date_is_author_date
) {
1538 struct ident_split id
;
1539 struct strbuf date
= STRBUF_INIT
;
1541 if (!opts
->ignore_date
) {
1542 if (split_ident_line(&id
, author
, (int)strlen(author
)) < 0) {
1543 res
= error(_("invalid author identity '%s'"),
1547 if (!id
.date_begin
) {
1549 "corrupt author: missing date information"));
1552 strbuf_addf(&date
, "@%.*s %.*s",
1553 (int)(id
.date_end
- id
.date_begin
),
1555 (int)(id
.tz_end
- id
.tz_begin
),
1560 committer
= fmt_ident(getenv("GIT_COMMITTER_NAME"),
1561 getenv("GIT_COMMITTER_EMAIL"),
1562 WANT_COMMITTER_IDENT
,
1563 opts
->ignore_date
? NULL
: date
.buf
,
1565 strbuf_release(&date
);
1570 if (opts
->ignore_date
) {
1571 struct ident_split id
;
1574 if (split_ident_line(&id
, author
, strlen(author
)) < 0) {
1575 error(_("invalid author identity '%s'"), author
);
1578 name
= xmemdupz(id
.name_begin
, id
.name_end
- id
.name_begin
);
1579 email
= xmemdupz(id
.mail_begin
, id
.mail_end
- id
.mail_begin
);
1580 author
= fmt_ident(name
, email
, WANT_AUTHOR_IDENT
, NULL
,
1586 if (commit_tree_extended(msg
->buf
, msg
->len
, &tree
, parents
, oid
,
1587 author
, committer
, opts
->gpg_sign
, extra
)) {
1588 res
= error(_("failed to write commit object"));
1592 if (update_head_with_reflog(current_head
, oid
,
1593 getenv("GIT_REFLOG_ACTION"), msg
, &err
)) {
1594 res
= error("%s", err
.buf
);
1598 run_commit_hook(0, r
->index_file
, NULL
, "post-commit", NULL
);
1599 if (flags
& AMEND_MSG
)
1600 commit_post_rewrite(r
, current_head
, oid
);
1603 free_commit_extra_headers(extra
);
1604 strbuf_release(&err
);
1605 strbuf_release(&commit_msg
);
1611 static int write_rebase_head(struct object_id
*oid
)
1613 if (update_ref("rebase", "REBASE_HEAD", oid
,
1614 NULL
, REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
1615 return error(_("could not update %s"), "REBASE_HEAD");
1620 static int do_commit(struct repository
*r
,
1621 const char *msg_file
, const char *author
,
1622 struct replay_opts
*opts
, unsigned int flags
,
1623 struct object_id
*oid
)
1627 if (!(flags
& EDIT_MSG
) && !(flags
& VERIFY_MSG
)) {
1628 struct object_id oid
;
1629 struct strbuf sb
= STRBUF_INIT
;
1631 if (msg_file
&& strbuf_read_file(&sb
, msg_file
, 2048) < 0)
1632 return error_errno(_("unable to read commit message "
1636 res
= try_to_commit(r
, msg_file
? &sb
: NULL
,
1637 author
, opts
, flags
, &oid
);
1638 strbuf_release(&sb
);
1640 refs_delete_ref(get_main_ref_store(r
), "",
1641 "CHERRY_PICK_HEAD", NULL
, 0);
1642 unlink(git_path_merge_msg(r
));
1643 if (!is_rebase_i(opts
))
1644 print_commit_summary(r
, NULL
, &oid
,
1645 SUMMARY_SHOW_AUTHOR_DATE
);
1650 if (is_rebase_i(opts
) && oid
)
1651 if (write_rebase_head(oid
))
1653 return run_git_commit(msg_file
, opts
, flags
);
1659 static int is_original_commit_empty(struct commit
*commit
)
1661 const struct object_id
*ptree_oid
;
1663 if (parse_commit(commit
))
1664 return error(_("could not parse commit %s"),
1665 oid_to_hex(&commit
->object
.oid
));
1666 if (commit
->parents
) {
1667 struct commit
*parent
= commit
->parents
->item
;
1668 if (parse_commit(parent
))
1669 return error(_("could not parse parent commit %s"),
1670 oid_to_hex(&parent
->object
.oid
));
1671 ptree_oid
= get_commit_tree_oid(parent
);
1673 ptree_oid
= the_hash_algo
->empty_tree
; /* commit is root */
1676 return oideq(ptree_oid
, get_commit_tree_oid(commit
));
1680 * Should empty commits be allowed? Return status:
1681 * <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)
1682 * 0: Halt on empty commit
1683 * 1: Allow empty commit
1684 * 2: Drop empty commit
1686 static int allow_empty(struct repository
*r
,
1687 struct replay_opts
*opts
,
1688 struct commit
*commit
)
1690 int index_unchanged
, originally_empty
;
1695 * (1) we do not allow empty at all and error out.
1697 * (2) we allow ones that were initially empty, and
1698 * just drop the ones that become empty
1700 * (3) we allow ones that were initially empty, but
1701 * halt for the ones that become empty;
1703 * (4) we allow both.
1705 if (!opts
->allow_empty
)
1706 return 0; /* let "git commit" barf as necessary */
1708 index_unchanged
= is_index_unchanged(r
);
1709 if (index_unchanged
< 0)
1710 return index_unchanged
;
1711 if (!index_unchanged
)
1712 return 0; /* we do not have to say --allow-empty */
1714 if (opts
->keep_redundant_commits
)
1717 originally_empty
= is_original_commit_empty(commit
);
1718 if (originally_empty
< 0)
1719 return originally_empty
;
1720 if (originally_empty
)
1722 else if (opts
->drop_redundant_commits
)
1731 } todo_command_info
[] = {
1732 [TODO_PICK
] = { 'p', "pick" },
1733 [TODO_REVERT
] = { 0, "revert" },
1734 [TODO_EDIT
] = { 'e', "edit" },
1735 [TODO_REWORD
] = { 'r', "reword" },
1736 [TODO_FIXUP
] = { 'f', "fixup" },
1737 [TODO_SQUASH
] = { 's', "squash" },
1738 [TODO_EXEC
] = { 'x', "exec" },
1739 [TODO_BREAK
] = { 'b', "break" },
1740 [TODO_LABEL
] = { 'l', "label" },
1741 [TODO_RESET
] = { 't', "reset" },
1742 [TODO_MERGE
] = { 'm', "merge" },
1743 [TODO_UPDATE_REF
] = { 'u', "update-ref" },
1744 [TODO_NOOP
] = { 0, "noop" },
1745 [TODO_DROP
] = { 'd', "drop" },
1746 [TODO_COMMENT
] = { 0, NULL
},
1749 static const char *command_to_string(const enum todo_command command
)
1751 if (command
< TODO_COMMENT
)
1752 return todo_command_info
[command
].str
;
1753 die(_("unknown command: %d"), command
);
1756 static char command_to_char(const enum todo_command command
)
1758 if (command
< TODO_COMMENT
)
1759 return todo_command_info
[command
].c
;
1760 return comment_line_char
;
1763 static int is_noop(const enum todo_command command
)
1765 return TODO_NOOP
<= command
;
1768 static int is_fixup(enum todo_command command
)
1770 return command
== TODO_FIXUP
|| command
== TODO_SQUASH
;
1773 /* Does this command create a (non-merge) commit? */
1774 static int is_pick_or_similar(enum todo_command command
)
1789 enum todo_item_flags
{
1790 TODO_EDIT_MERGE_MSG
= (1 << 0),
1791 TODO_REPLACE_FIXUP_MSG
= (1 << 1),
1792 TODO_EDIT_FIXUP_MSG
= (1 << 2),
1795 static const char first_commit_msg_str
[] = N_("This is the 1st commit message:");
1796 static const char nth_commit_msg_fmt
[] = N_("This is the commit message #%d:");
1797 static const char skip_first_commit_msg_str
[] = N_("The 1st commit message will be skipped:");
1798 static const char skip_nth_commit_msg_fmt
[] = N_("The commit message #%d will be skipped:");
1799 static const char combined_commit_msg_fmt
[] = N_("This is a combination of %d commits.");
1801 static int is_fixup_flag(enum todo_command command
, unsigned flag
)
1803 return command
== TODO_FIXUP
&& ((flag
& TODO_REPLACE_FIXUP_MSG
) ||
1804 (flag
& TODO_EDIT_FIXUP_MSG
));
1808 * Wrapper around strbuf_add_commented_lines() which avoids double
1809 * commenting commit subjects.
1811 static void add_commented_lines(struct strbuf
*buf
, const void *str
, size_t len
)
1813 const char *s
= str
;
1814 while (len
> 0 && s
[0] == comment_line_char
) {
1816 const char *n
= memchr(s
, '\n', len
);
1821 strbuf_add(buf
, s
, count
);
1825 strbuf_add_commented_lines(buf
, s
, len
);
1828 /* Does the current fixup chain contain a squash command? */
1829 static int seen_squash(struct replay_opts
*opts
)
1831 return starts_with(opts
->current_fixups
.buf
, "squash") ||
1832 strstr(opts
->current_fixups
.buf
, "\nsquash");
1835 static void update_comment_bufs(struct strbuf
*buf1
, struct strbuf
*buf2
, int n
)
1837 strbuf_setlen(buf1
, 2);
1838 strbuf_addf(buf1
, _(nth_commit_msg_fmt
), n
);
1839 strbuf_addch(buf1
, '\n');
1840 strbuf_setlen(buf2
, 2);
1841 strbuf_addf(buf2
, _(skip_nth_commit_msg_fmt
), n
);
1842 strbuf_addch(buf2
, '\n');
1846 * Comment out any un-commented commit messages, updating the message comments
1847 * to say they will be skipped but do not comment out the empty lines that
1848 * surround commit messages and their comments.
1850 static void update_squash_message_for_fixup(struct strbuf
*msg
)
1852 void (*copy_lines
)(struct strbuf
*, const void *, size_t) = strbuf_add
;
1853 struct strbuf buf1
= STRBUF_INIT
, buf2
= STRBUF_INIT
;
1854 const char *s
, *start
;
1856 size_t orig_msg_len
;
1859 strbuf_addf(&buf1
, "# %s\n", _(first_commit_msg_str
));
1860 strbuf_addf(&buf2
, "# %s\n", _(skip_first_commit_msg_str
));
1861 s
= start
= orig_msg
= strbuf_detach(msg
, &orig_msg_len
);
1865 if (skip_prefix(s
, buf1
.buf
, &next
)) {
1867 * Copy the last message, preserving the blank line
1868 * preceding the current line
1870 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1871 copy_lines(msg
, start
, s
- start
- off
);
1873 strbuf_addch(msg
, '\n');
1875 * The next message needs to be commented out but the
1876 * message header is already commented out so just copy
1877 * it and the blank line that follows it.
1879 strbuf_addbuf(msg
, &buf2
);
1881 strbuf_addch(msg
, *next
++);
1883 copy_lines
= add_commented_lines
;
1884 update_comment_bufs(&buf1
, &buf2
, ++i
);
1885 } else if (skip_prefix(s
, buf2
.buf
, &next
)) {
1886 off
= (s
> start
+ 1 && s
[-2] == '\n') ? 1 : 0;
1887 copy_lines(msg
, start
, s
- start
- off
);
1890 copy_lines
= strbuf_add
;
1891 update_comment_bufs(&buf1
, &buf2
, ++i
);
1893 s
= strchr(s
, '\n');
1898 copy_lines(msg
, start
, orig_msg_len
- (start
- orig_msg
));
1900 strbuf_release(&buf1
);
1901 strbuf_release(&buf2
);
1904 static int append_squash_message(struct strbuf
*buf
, const char *body
,
1905 enum todo_command command
, struct replay_opts
*opts
,
1908 const char *fixup_msg
;
1909 size_t commented_len
= 0, fixup_off
;
1911 * amend is non-interactive and not normally used with fixup!
1912 * or squash! commits, so only comment out those subjects when
1913 * squashing commit messages.
1915 if (starts_with(body
, "amend!") ||
1916 ((command
== TODO_SQUASH
|| seen_squash(opts
)) &&
1917 (starts_with(body
, "squash!") || starts_with(body
, "fixup!"))))
1918 commented_len
= commit_subject_length(body
);
1920 strbuf_addf(buf
, "\n%c ", comment_line_char
);
1921 strbuf_addf(buf
, _(nth_commit_msg_fmt
),
1922 ++opts
->current_fixup_count
+ 1);
1923 strbuf_addstr(buf
, "\n\n");
1924 strbuf_add_commented_lines(buf
, body
, commented_len
);
1925 /* buf->buf may be reallocated so store an offset into the buffer */
1926 fixup_off
= buf
->len
;
1927 strbuf_addstr(buf
, body
+ commented_len
);
1929 /* fixup -C after squash behaves like squash */
1930 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
)) {
1932 * We're replacing the commit message so we need to
1933 * append the Signed-off-by: trailer if the user
1934 * requested '--signoff'.
1937 append_signoff(buf
, 0, 0);
1939 if ((command
== TODO_FIXUP
) &&
1940 (flag
& TODO_REPLACE_FIXUP_MSG
) &&
1941 (file_exists(rebase_path_fixup_msg()) ||
1942 !file_exists(rebase_path_squash_msg()))) {
1943 fixup_msg
= skip_blank_lines(buf
->buf
+ fixup_off
);
1944 if (write_message(fixup_msg
, strlen(fixup_msg
),
1945 rebase_path_fixup_msg(), 0) < 0)
1946 return error(_("cannot write '%s'"),
1947 rebase_path_fixup_msg());
1949 unlink(rebase_path_fixup_msg());
1952 unlink(rebase_path_fixup_msg());
1958 static int update_squash_messages(struct repository
*r
,
1959 enum todo_command command
,
1960 struct commit
*commit
,
1961 struct replay_opts
*opts
,
1964 struct strbuf buf
= STRBUF_INIT
;
1966 const char *message
, *body
;
1967 const char *encoding
= get_commit_output_encoding();
1969 if (opts
->current_fixup_count
> 0) {
1970 struct strbuf header
= STRBUF_INIT
;
1973 if (strbuf_read_file(&buf
, rebase_path_squash_msg(), 9) <= 0)
1974 return error(_("could not read '%s'"),
1975 rebase_path_squash_msg());
1977 eol
= buf
.buf
[0] != comment_line_char
?
1978 buf
.buf
: strchrnul(buf
.buf
, '\n');
1980 strbuf_addf(&header
, "%c ", comment_line_char
);
1981 strbuf_addf(&header
, _(combined_commit_msg_fmt
),
1982 opts
->current_fixup_count
+ 2);
1983 strbuf_splice(&buf
, 0, eol
- buf
.buf
, header
.buf
, header
.len
);
1984 strbuf_release(&header
);
1985 if (is_fixup_flag(command
, flag
) && !seen_squash(opts
))
1986 update_squash_message_for_fixup(&buf
);
1988 struct object_id head
;
1989 struct commit
*head_commit
;
1990 const char *head_message
, *body
;
1992 if (get_oid("HEAD", &head
))
1993 return error(_("need a HEAD to fixup"));
1994 if (!(head_commit
= lookup_commit_reference(r
, &head
)))
1995 return error(_("could not read HEAD"));
1996 if (!(head_message
= logmsg_reencode(head_commit
, NULL
, encoding
)))
1997 return error(_("could not read HEAD's commit message"));
1999 find_commit_subject(head_message
, &body
);
2000 if (command
== TODO_FIXUP
&& !flag
&& write_message(body
, strlen(body
),
2001 rebase_path_fixup_msg(), 0) < 0) {
2002 unuse_commit_buffer(head_commit
, head_message
);
2003 return error(_("cannot write '%s'"), rebase_path_fixup_msg());
2005 strbuf_addf(&buf
, "%c ", comment_line_char
);
2006 strbuf_addf(&buf
, _(combined_commit_msg_fmt
), 2);
2007 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
2008 strbuf_addstr(&buf
, is_fixup_flag(command
, flag
) ?
2009 _(skip_first_commit_msg_str
) :
2010 _(first_commit_msg_str
));
2011 strbuf_addstr(&buf
, "\n\n");
2012 if (is_fixup_flag(command
, flag
))
2013 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
2015 strbuf_addstr(&buf
, body
);
2017 unuse_commit_buffer(head_commit
, head_message
);
2020 if (!(message
= logmsg_reencode(commit
, NULL
, encoding
)))
2021 return error(_("could not read commit message of %s"),
2022 oid_to_hex(&commit
->object
.oid
));
2023 find_commit_subject(message
, &body
);
2025 if (command
== TODO_SQUASH
|| is_fixup_flag(command
, flag
)) {
2026 res
= append_squash_message(&buf
, body
, command
, opts
, flag
);
2027 } else if (command
== TODO_FIXUP
) {
2028 strbuf_addf(&buf
, "\n%c ", comment_line_char
);
2029 strbuf_addf(&buf
, _(skip_nth_commit_msg_fmt
),
2030 ++opts
->current_fixup_count
+ 1);
2031 strbuf_addstr(&buf
, "\n\n");
2032 strbuf_add_commented_lines(&buf
, body
, strlen(body
));
2034 return error(_("unknown command: %d"), command
);
2035 unuse_commit_buffer(commit
, message
);
2038 res
= write_message(buf
.buf
, buf
.len
, rebase_path_squash_msg(),
2040 strbuf_release(&buf
);
2043 strbuf_addf(&opts
->current_fixups
, "%s%s %s",
2044 opts
->current_fixups
.len
? "\n" : "",
2045 command_to_string(command
),
2046 oid_to_hex(&commit
->object
.oid
));
2047 res
= write_message(opts
->current_fixups
.buf
,
2048 opts
->current_fixups
.len
,
2049 rebase_path_current_fixups(), 0);
2055 static void flush_rewritten_pending(void)
2057 struct strbuf buf
= STRBUF_INIT
;
2058 struct object_id newoid
;
2061 if (strbuf_read_file(&buf
, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ
+ 1) * 2) > 0 &&
2062 !get_oid("HEAD", &newoid
) &&
2063 (out
= fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
2064 char *bol
= buf
.buf
, *eol
;
2067 eol
= strchrnul(bol
, '\n');
2068 fprintf(out
, "%.*s %s\n", (int)(eol
- bol
),
2069 bol
, oid_to_hex(&newoid
));
2075 unlink(rebase_path_rewritten_pending());
2077 strbuf_release(&buf
);
2080 static void record_in_rewritten(struct object_id
*oid
,
2081 enum todo_command next_command
)
2083 FILE *out
= fopen_or_warn(rebase_path_rewritten_pending(), "a");
2088 fprintf(out
, "%s\n", oid_to_hex(oid
));
2091 if (!is_fixup(next_command
))
2092 flush_rewritten_pending();
2095 static int should_edit(struct replay_opts
*opts
) {
2098 * Note that we only handle the case of non-conflicted
2099 * commits; continue_single_pick() handles the conflicted
2100 * commits itself instead of calling this function.
2102 return (opts
->action
== REPLAY_REVERT
&& isatty(0)) ? 1 : 0;
2106 static void refer_to_commit(struct replay_opts
*opts
,
2107 struct strbuf
*msgbuf
, struct commit
*commit
)
2109 if (opts
->commit_use_reference
) {
2110 struct pretty_print_context ctx
= {
2111 .abbrev
= DEFAULT_ABBREV
,
2112 .date_mode
.type
= DATE_SHORT
,
2114 format_commit_message(commit
, "%h (%s, %ad)", msgbuf
, &ctx
);
2116 strbuf_addstr(msgbuf
, oid_to_hex(&commit
->object
.oid
));
2120 static int do_pick_commit(struct repository
*r
,
2121 struct todo_item
*item
,
2122 struct replay_opts
*opts
,
2123 int final_fixup
, int *check_todo
)
2125 unsigned int flags
= should_edit(opts
) ? EDIT_MSG
: 0;
2126 const char *msg_file
= should_edit(opts
) ? NULL
: git_path_merge_msg(r
);
2127 struct object_id head
;
2128 struct commit
*base
, *next
, *parent
;
2129 const char *base_label
, *next_label
;
2130 char *author
= NULL
;
2131 struct commit_message msg
= { NULL
, NULL
, NULL
, NULL
};
2132 struct strbuf msgbuf
= STRBUF_INIT
;
2133 int res
, unborn
= 0, reword
= 0, allow
, drop_commit
;
2134 enum todo_command command
= item
->command
;
2135 struct commit
*commit
= item
->commit
;
2137 if (opts
->no_commit
) {
2139 * We do not intend to commit immediately. We just want to
2140 * merge the differences in, so let's compute the tree
2141 * that represents the "current" state for the merge machinery
2144 if (write_index_as_tree(&head
, r
->index
, r
->index_file
, 0, NULL
))
2145 return error(_("your index file is unmerged."));
2147 unborn
= get_oid("HEAD", &head
);
2148 /* Do we want to generate a root commit? */
2149 if (is_pick_or_similar(command
) && opts
->have_squash_onto
&&
2150 oideq(&head
, &opts
->squash_onto
)) {
2151 if (is_fixup(command
))
2152 return error(_("cannot fixup root commit"));
2153 flags
|= CREATE_ROOT_COMMIT
;
2156 oidcpy(&head
, the_hash_algo
->empty_tree
);
2157 if (index_differs_from(r
, unborn
? empty_tree_oid_hex() : "HEAD",
2159 return error_dirty_index(r
, opts
);
2161 discard_index(r
->index
);
2163 if (!commit
->parents
)
2165 else if (commit
->parents
->next
) {
2166 /* Reverting or cherry-picking a merge commit */
2168 struct commit_list
*p
;
2170 if (!opts
->mainline
)
2171 return error(_("commit %s is a merge but no -m option was given."),
2172 oid_to_hex(&commit
->object
.oid
));
2174 for (cnt
= 1, p
= commit
->parents
;
2175 cnt
!= opts
->mainline
&& p
;
2178 if (cnt
!= opts
->mainline
|| !p
)
2179 return error(_("commit %s does not have parent %d"),
2180 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2182 } else if (1 < opts
->mainline
)
2184 * Non-first parent explicitly specified as mainline for
2187 return error(_("commit %s does not have parent %d"),
2188 oid_to_hex(&commit
->object
.oid
), opts
->mainline
);
2190 parent
= commit
->parents
->item
;
2192 if (get_message(commit
, &msg
) != 0)
2193 return error(_("cannot get commit message for %s"),
2194 oid_to_hex(&commit
->object
.oid
));
2196 if (opts
->allow_ff
&& !is_fixup(command
) &&
2197 ((parent
&& oideq(&parent
->object
.oid
, &head
)) ||
2198 (!parent
&& unborn
))) {
2199 if (is_rebase_i(opts
))
2200 write_author_script(msg
.message
);
2201 res
= fast_forward_to(r
, &commit
->object
.oid
, &head
, unborn
,
2203 if (res
|| command
!= TODO_REWORD
)
2207 goto fast_forward_edit
;
2209 if (parent
&& parse_commit(parent
) < 0)
2210 /* TRANSLATORS: The first %s will be a "todo" command like
2211 "revert" or "pick", the second %s a SHA1. */
2212 return error(_("%s: cannot parse parent commit %s"),
2213 command_to_string(command
),
2214 oid_to_hex(&parent
->object
.oid
));
2217 * "commit" is an existing commit. We would want to apply
2218 * the difference it introduces since its first parent "prev"
2219 * on top of the current HEAD if we are cherry-pick. Or the
2220 * reverse of it if we are revert.
2223 if (command
== TODO_REVERT
) {
2225 base_label
= msg
.label
;
2227 next_label
= msg
.parent_label
;
2228 if (opts
->commit_use_reference
) {
2229 strbuf_addstr(&msgbuf
,
2230 "# *** SAY WHY WE ARE REVERTING ON THE TITLE LINE ***");
2232 strbuf_addstr(&msgbuf
, "Revert \"");
2233 strbuf_addstr(&msgbuf
, msg
.subject
);
2234 strbuf_addstr(&msgbuf
, "\"");
2236 strbuf_addstr(&msgbuf
, "\n\nThis reverts commit ");
2237 refer_to_commit(opts
, &msgbuf
, commit
);
2239 if (commit
->parents
&& commit
->parents
->next
) {
2240 strbuf_addstr(&msgbuf
, ", reversing\nchanges made to ");
2241 refer_to_commit(opts
, &msgbuf
, parent
);
2243 strbuf_addstr(&msgbuf
, ".\n");
2248 base_label
= msg
.parent_label
;
2250 next_label
= msg
.label
;
2252 /* Append the commit log message to msgbuf. */
2253 if (find_commit_subject(msg
.message
, &p
))
2254 strbuf_addstr(&msgbuf
, p
);
2256 if (opts
->record_origin
) {
2257 strbuf_complete_line(&msgbuf
);
2258 if (!has_conforming_footer(&msgbuf
, NULL
, 0))
2259 strbuf_addch(&msgbuf
, '\n');
2260 strbuf_addstr(&msgbuf
, cherry_picked_prefix
);
2261 strbuf_addstr(&msgbuf
, oid_to_hex(&commit
->object
.oid
));
2262 strbuf_addstr(&msgbuf
, ")\n");
2264 if (!is_fixup(command
))
2265 author
= get_author(msg
.message
);
2268 if (command
== TODO_REWORD
)
2270 else if (is_fixup(command
)) {
2271 if (update_squash_messages(r
, command
, commit
,
2276 msg_file
= rebase_path_squash_msg();
2277 else if (file_exists(rebase_path_fixup_msg())) {
2278 flags
|= VERBATIM_MSG
;
2279 msg_file
= rebase_path_fixup_msg();
2281 const char *dest
= git_path_squash_msg(r
);
2283 if (copy_file(dest
, rebase_path_squash_msg(), 0666))
2284 return error(_("could not rename '%s' to '%s'"),
2285 rebase_path_squash_msg(), dest
);
2286 unlink(git_path_merge_msg(r
));
2292 if (opts
->signoff
&& !is_fixup(command
))
2293 append_signoff(&msgbuf
, 0, 0);
2295 if (is_rebase_i(opts
) && write_author_script(msg
.message
) < 0)
2297 else if (!opts
->strategy
||
2298 !strcmp(opts
->strategy
, "recursive") ||
2299 !strcmp(opts
->strategy
, "ort") ||
2300 command
== TODO_REVERT
) {
2301 res
= do_recursive_merge(r
, base
, next
, base_label
, next_label
,
2302 &head
, &msgbuf
, opts
);
2306 res
|= write_message(msgbuf
.buf
, msgbuf
.len
,
2307 git_path_merge_msg(r
), 0);
2309 struct commit_list
*common
= NULL
;
2310 struct commit_list
*remotes
= NULL
;
2312 res
= write_message(msgbuf
.buf
, msgbuf
.len
,
2313 git_path_merge_msg(r
), 0);
2315 commit_list_insert(base
, &common
);
2316 commit_list_insert(next
, &remotes
);
2317 res
|= try_merge_command(r
, opts
->strategy
,
2318 opts
->xopts_nr
, (const char **)opts
->xopts
,
2319 common
, oid_to_hex(&head
), remotes
);
2320 free_commit_list(common
);
2321 free_commit_list(remotes
);
2323 strbuf_release(&msgbuf
);
2326 * If the merge was clean or if it failed due to conflict, we write
2327 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
2328 * However, if the merge did not even start, then we don't want to
2331 if ((command
== TODO_PICK
|| command
== TODO_REWORD
||
2332 command
== TODO_EDIT
) && !opts
->no_commit
&&
2333 (res
== 0 || res
== 1) &&
2334 update_ref(NULL
, "CHERRY_PICK_HEAD", &commit
->object
.oid
, NULL
,
2335 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2337 if (command
== TODO_REVERT
&& ((opts
->no_commit
&& res
== 0) || res
== 1) &&
2338 update_ref(NULL
, "REVERT_HEAD", &commit
->object
.oid
, NULL
,
2339 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
))
2343 error(command
== TODO_REVERT
2344 ? _("could not revert %s... %s")
2345 : _("could not apply %s... %s"),
2346 short_commit_name(commit
), msg
.subject
);
2347 print_advice(r
, res
== 1, opts
);
2348 repo_rerere(r
, opts
->allow_rerere_auto
);
2353 allow
= allow_empty(r
, opts
, commit
);
2357 } else if (allow
== 1) {
2358 flags
|= ALLOW_EMPTY
;
2359 } else if (allow
== 2) {
2361 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
2363 unlink(git_path_merge_msg(r
));
2364 unlink(git_path_auto_merge(r
));
2366 _("dropping %s %s -- patch contents already upstream\n"),
2367 oid_to_hex(&commit
->object
.oid
), msg
.subject
);
2368 } /* else allow == 0 and there's nothing special to do */
2369 if (!opts
->no_commit
&& !drop_commit
) {
2370 if (author
|| command
== TODO_REVERT
|| (flags
& AMEND_MSG
))
2371 res
= do_commit(r
, msg_file
, author
, opts
, flags
,
2372 commit
? &commit
->object
.oid
: NULL
);
2374 res
= error(_("unable to parse commit author"));
2375 *check_todo
= !!(flags
& EDIT_MSG
);
2376 if (!res
&& reword
) {
2378 res
= run_git_commit(NULL
, opts
, EDIT_MSG
|
2379 VERIFY_MSG
| AMEND_MSG
|
2380 (flags
& ALLOW_EMPTY
));
2386 if (!res
&& final_fixup
) {
2387 unlink(rebase_path_fixup_msg());
2388 unlink(rebase_path_squash_msg());
2389 unlink(rebase_path_current_fixups());
2390 strbuf_reset(&opts
->current_fixups
);
2391 opts
->current_fixup_count
= 0;
2395 free_message(commit
, &msg
);
2397 update_abort_safety_file();
2402 static int prepare_revs(struct replay_opts
*opts
)
2405 * picking (but not reverting) ranges (but not individual revisions)
2406 * should be done in reverse
2408 if (opts
->action
== REPLAY_PICK
&& !opts
->revs
->no_walk
)
2409 opts
->revs
->reverse
^= 1;
2411 if (prepare_revision_walk(opts
->revs
))
2412 return error(_("revision walk setup failed"));
2417 static int read_and_refresh_cache(struct repository
*r
,
2418 struct replay_opts
*opts
)
2420 struct lock_file index_lock
= LOCK_INIT
;
2421 int index_fd
= repo_hold_locked_index(r
, &index_lock
, 0);
2422 if (repo_read_index(r
) < 0) {
2423 rollback_lock_file(&index_lock
);
2424 return error(_("git %s: failed to read the index"),
2427 refresh_index(r
->index
, REFRESH_QUIET
|REFRESH_UNMERGED
, NULL
, NULL
, NULL
);
2429 if (index_fd
>= 0) {
2430 if (write_locked_index(r
->index
, &index_lock
,
2431 COMMIT_LOCK
| SKIP_IF_UNCHANGED
)) {
2432 return error(_("git %s: failed to refresh the index"),
2438 * If we are resolving merges in any way other than "ort", then
2439 * expand the sparse index.
2441 if (opts
->strategy
&& strcmp(opts
->strategy
, "ort"))
2442 ensure_full_index(r
->index
);
2446 void todo_list_release(struct todo_list
*todo_list
)
2448 strbuf_release(&todo_list
->buf
);
2449 FREE_AND_NULL(todo_list
->items
);
2450 todo_list
->nr
= todo_list
->alloc
= 0;
2453 static struct todo_item
*append_new_todo(struct todo_list
*todo_list
)
2455 ALLOC_GROW(todo_list
->items
, todo_list
->nr
+ 1, todo_list
->alloc
);
2456 return todo_list
->items
+ todo_list
->nr
++;
2459 const char *todo_item_get_arg(struct todo_list
*todo_list
,
2460 struct todo_item
*item
)
2462 return todo_list
->buf
.buf
+ item
->arg_offset
;
2465 static int is_command(enum todo_command command
, const char **bol
)
2467 const char *str
= todo_command_info
[command
].str
;
2468 const char nick
= todo_command_info
[command
].c
;
2469 const char *p
= *bol
+ 1;
2471 return skip_prefix(*bol
, str
, bol
) ||
2472 ((nick
&& **bol
== nick
) &&
2473 (*p
== ' ' || *p
== '\t' || *p
== '\n' || *p
== '\r' || !*p
) &&
2477 static int parse_insn_line(struct repository
*r
, struct todo_item
*item
,
2478 const char *buf
, const char *bol
, char *eol
)
2480 struct object_id commit_oid
;
2481 char *end_of_object_name
;
2482 int i
, saved
, status
, padding
;
2487 bol
+= strspn(bol
, " \t");
2489 if (bol
== eol
|| *bol
== '\r' || *bol
== comment_line_char
) {
2490 item
->command
= TODO_COMMENT
;
2491 item
->commit
= NULL
;
2492 item
->arg_offset
= bol
- buf
;
2493 item
->arg_len
= eol
- bol
;
2497 for (i
= 0; i
< TODO_COMMENT
; i
++)
2498 if (is_command(i
, &bol
)) {
2502 if (i
>= TODO_COMMENT
)
2505 /* Eat up extra spaces/ tabs before object name */
2506 padding
= strspn(bol
, " \t");
2509 if (item
->command
== TODO_NOOP
|| item
->command
== TODO_BREAK
) {
2511 return error(_("%s does not accept arguments: '%s'"),
2512 command_to_string(item
->command
), bol
);
2513 item
->commit
= NULL
;
2514 item
->arg_offset
= bol
- buf
;
2515 item
->arg_len
= eol
- bol
;
2520 return error(_("missing arguments for %s"),
2521 command_to_string(item
->command
));
2523 if (item
->command
== TODO_EXEC
|| item
->command
== TODO_LABEL
||
2524 item
->command
== TODO_RESET
|| item
->command
== TODO_UPDATE_REF
) {
2525 item
->commit
= NULL
;
2526 item
->arg_offset
= bol
- buf
;
2527 item
->arg_len
= (int)(eol
- bol
);
2531 if (item
->command
== TODO_FIXUP
) {
2532 if (skip_prefix(bol
, "-C", &bol
) &&
2533 (*bol
== ' ' || *bol
== '\t')) {
2534 bol
+= strspn(bol
, " \t");
2535 item
->flags
|= TODO_REPLACE_FIXUP_MSG
;
2536 } else if (skip_prefix(bol
, "-c", &bol
) &&
2537 (*bol
== ' ' || *bol
== '\t')) {
2538 bol
+= strspn(bol
, " \t");
2539 item
->flags
|= TODO_EDIT_FIXUP_MSG
;
2543 if (item
->command
== TODO_MERGE
) {
2544 if (skip_prefix(bol
, "-C", &bol
))
2545 bol
+= strspn(bol
, " \t");
2546 else if (skip_prefix(bol
, "-c", &bol
)) {
2547 bol
+= strspn(bol
, " \t");
2548 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2550 item
->flags
|= TODO_EDIT_MERGE_MSG
;
2551 item
->commit
= NULL
;
2552 item
->arg_offset
= bol
- buf
;
2553 item
->arg_len
= (int)(eol
- bol
);
2558 end_of_object_name
= (char *) bol
+ strcspn(bol
, " \t\n");
2559 saved
= *end_of_object_name
;
2560 *end_of_object_name
= '\0';
2561 status
= get_oid(bol
, &commit_oid
);
2563 error(_("could not parse '%s'"), bol
); /* return later */
2564 *end_of_object_name
= saved
;
2566 bol
= end_of_object_name
+ strspn(end_of_object_name
, " \t");
2567 item
->arg_offset
= bol
- buf
;
2568 item
->arg_len
= (int)(eol
- bol
);
2573 item
->commit
= lookup_commit_reference(r
, &commit_oid
);
2574 return item
->commit
? 0 : -1;
2577 int sequencer_get_last_command(struct repository
*r
, enum replay_action
*action
)
2579 const char *todo_file
, *bol
;
2580 struct strbuf buf
= STRBUF_INIT
;
2583 todo_file
= git_path_todo_file();
2584 if (strbuf_read_file(&buf
, todo_file
, 0) < 0) {
2585 if (errno
== ENOENT
|| errno
== ENOTDIR
)
2588 return error_errno("unable to open '%s'", todo_file
);
2590 bol
= buf
.buf
+ strspn(buf
.buf
, " \t\r\n");
2591 if (is_command(TODO_PICK
, &bol
) && (*bol
== ' ' || *bol
== '\t'))
2592 *action
= REPLAY_PICK
;
2593 else if (is_command(TODO_REVERT
, &bol
) &&
2594 (*bol
== ' ' || *bol
== '\t'))
2595 *action
= REPLAY_REVERT
;
2599 strbuf_release(&buf
);
2604 int todo_list_parse_insn_buffer(struct repository
*r
, char *buf
,
2605 struct todo_list
*todo_list
)
2607 struct todo_item
*item
;
2608 char *p
= buf
, *next_p
;
2609 int i
, res
= 0, fixup_okay
= file_exists(rebase_path_done());
2611 todo_list
->current
= todo_list
->nr
= todo_list
->total_nr
= 0;
2613 for (i
= 1; *p
; i
++, p
= next_p
) {
2614 char *eol
= strchrnul(p
, '\n');
2616 next_p
= *eol
? eol
+ 1 /* skip LF */ : eol
;
2618 if (p
!= eol
&& eol
[-1] == '\r')
2619 eol
--; /* strip Carriage Return */
2621 item
= append_new_todo(todo_list
);
2622 item
->offset_in_buf
= p
- todo_list
->buf
.buf
;
2623 if (parse_insn_line(r
, item
, buf
, p
, eol
)) {
2624 res
= error(_("invalid line %d: %.*s"),
2625 i
, (int)(eol
- p
), p
);
2626 item
->command
= TODO_COMMENT
+ 1;
2627 item
->arg_offset
= p
- buf
;
2628 item
->arg_len
= (int)(eol
- p
);
2629 item
->commit
= NULL
;
2632 if (item
->command
!= TODO_COMMENT
)
2633 todo_list
->total_nr
++;
2637 else if (is_fixup(item
->command
))
2638 return error(_("cannot '%s' without a previous commit"),
2639 command_to_string(item
->command
));
2640 else if (!is_noop(item
->command
))
2647 static int count_commands(struct todo_list
*todo_list
)
2651 for (i
= 0; i
< todo_list
->nr
; i
++)
2652 if (todo_list
->items
[i
].command
!= TODO_COMMENT
)
2658 static int get_item_line_offset(struct todo_list
*todo_list
, int index
)
2660 return index
< todo_list
->nr
?
2661 todo_list
->items
[index
].offset_in_buf
: todo_list
->buf
.len
;
2664 static const char *get_item_line(struct todo_list
*todo_list
, int index
)
2666 return todo_list
->buf
.buf
+ get_item_line_offset(todo_list
, index
);
2669 static int get_item_line_length(struct todo_list
*todo_list
, int index
)
2671 return get_item_line_offset(todo_list
, index
+ 1)
2672 - get_item_line_offset(todo_list
, index
);
2675 static ssize_t
strbuf_read_file_or_whine(struct strbuf
*sb
, const char *path
)
2680 fd
= open(path
, O_RDONLY
);
2682 return error_errno(_("could not open '%s'"), path
);
2683 len
= strbuf_read(sb
, fd
, 0);
2686 return error(_("could not read '%s'."), path
);
2690 static int have_finished_the_last_pick(void)
2692 struct strbuf buf
= STRBUF_INIT
;
2694 const char *todo_path
= git_path_todo_file();
2697 if (strbuf_read_file(&buf
, todo_path
, 0) < 0) {
2698 if (errno
== ENOENT
) {
2701 error_errno("unable to open '%s'", todo_path
);
2705 /* If there is only one line then we are done */
2706 eol
= strchr(buf
.buf
, '\n');
2707 if (!eol
|| !eol
[1])
2710 strbuf_release(&buf
);
2715 void sequencer_post_commit_cleanup(struct repository
*r
, int verbose
)
2717 struct replay_opts opts
= REPLAY_OPTS_INIT
;
2718 int need_cleanup
= 0;
2720 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
2721 if (!refs_delete_ref(get_main_ref_store(r
), "",
2722 "CHERRY_PICK_HEAD", NULL
, 0) &&
2724 warning(_("cancelling a cherry picking in progress"));
2725 opts
.action
= REPLAY_PICK
;
2729 if (refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
2730 if (!refs_delete_ref(get_main_ref_store(r
), "", "REVERT_HEAD",
2733 warning(_("cancelling a revert in progress"));
2734 opts
.action
= REPLAY_REVERT
;
2738 unlink(git_path_auto_merge(r
));
2743 if (!have_finished_the_last_pick())
2746 sequencer_remove_state(&opts
);
2749 static void todo_list_write_total_nr(struct todo_list
*todo_list
)
2751 FILE *f
= fopen_or_warn(rebase_path_msgtotal(), "w");
2754 fprintf(f
, "%d\n", todo_list
->total_nr
);
2759 static int read_populate_todo(struct repository
*r
,
2760 struct todo_list
*todo_list
,
2761 struct replay_opts
*opts
)
2763 const char *todo_file
= get_todo_path(opts
);
2766 strbuf_reset(&todo_list
->buf
);
2767 if (strbuf_read_file_or_whine(&todo_list
->buf
, todo_file
) < 0)
2770 res
= todo_list_parse_insn_buffer(r
, todo_list
->buf
.buf
, todo_list
);
2772 if (is_rebase_i(opts
))
2773 return error(_("please fix this using "
2774 "'git rebase --edit-todo'."));
2775 return error(_("unusable instruction sheet: '%s'"), todo_file
);
2778 if (!todo_list
->nr
&&
2779 (!is_rebase_i(opts
) || !file_exists(rebase_path_done())))
2780 return error(_("no commits parsed."));
2782 if (!is_rebase_i(opts
)) {
2783 enum todo_command valid
=
2784 opts
->action
== REPLAY_PICK
? TODO_PICK
: TODO_REVERT
;
2787 for (i
= 0; i
< todo_list
->nr
; i
++)
2788 if (valid
== todo_list
->items
[i
].command
)
2790 else if (valid
== TODO_PICK
)
2791 return error(_("cannot cherry-pick during a revert."));
2793 return error(_("cannot revert during a cherry-pick."));
2796 if (is_rebase_i(opts
)) {
2797 struct todo_list done
= TODO_LIST_INIT
;
2799 if (strbuf_read_file(&done
.buf
, rebase_path_done(), 0) > 0 &&
2800 !todo_list_parse_insn_buffer(r
, done
.buf
.buf
, &done
))
2801 todo_list
->done_nr
= count_commands(&done
);
2803 todo_list
->done_nr
= 0;
2805 todo_list
->total_nr
= todo_list
->done_nr
2806 + count_commands(todo_list
);
2807 todo_list_release(&done
);
2809 todo_list_write_total_nr(todo_list
);
2815 static int git_config_string_dup(char **dest
,
2816 const char *var
, const char *value
)
2819 return config_error_nonbool(var
);
2821 *dest
= xstrdup(value
);
2825 static int populate_opts_cb(const char *key
, const char *value
, void *data
)
2827 struct replay_opts
*opts
= data
;
2832 else if (!strcmp(key
, "options.no-commit"))
2833 opts
->no_commit
= git_config_bool_or_int(key
, value
, &error_flag
);
2834 else if (!strcmp(key
, "options.edit"))
2835 opts
->edit
= git_config_bool_or_int(key
, value
, &error_flag
);
2836 else if (!strcmp(key
, "options.allow-empty"))
2838 git_config_bool_or_int(key
, value
, &error_flag
);
2839 else if (!strcmp(key
, "options.allow-empty-message"))
2840 opts
->allow_empty_message
=
2841 git_config_bool_or_int(key
, value
, &error_flag
);
2842 else if (!strcmp(key
, "options.keep-redundant-commits"))
2843 opts
->keep_redundant_commits
=
2844 git_config_bool_or_int(key
, value
, &error_flag
);
2845 else if (!strcmp(key
, "options.signoff"))
2846 opts
->signoff
= git_config_bool_or_int(key
, value
, &error_flag
);
2847 else if (!strcmp(key
, "options.record-origin"))
2848 opts
->record_origin
= git_config_bool_or_int(key
, value
, &error_flag
);
2849 else if (!strcmp(key
, "options.allow-ff"))
2850 opts
->allow_ff
= git_config_bool_or_int(key
, value
, &error_flag
);
2851 else if (!strcmp(key
, "options.mainline"))
2852 opts
->mainline
= git_config_int(key
, value
);
2853 else if (!strcmp(key
, "options.strategy"))
2854 git_config_string_dup(&opts
->strategy
, key
, value
);
2855 else if (!strcmp(key
, "options.gpg-sign"))
2856 git_config_string_dup(&opts
->gpg_sign
, key
, value
);
2857 else if (!strcmp(key
, "options.strategy-option")) {
2858 ALLOC_GROW(opts
->xopts
, opts
->xopts_nr
+ 1, opts
->xopts_alloc
);
2859 opts
->xopts
[opts
->xopts_nr
++] = xstrdup(value
);
2860 } else if (!strcmp(key
, "options.allow-rerere-auto"))
2861 opts
->allow_rerere_auto
=
2862 git_config_bool_or_int(key
, value
, &error_flag
) ?
2863 RERERE_AUTOUPDATE
: RERERE_NOAUTOUPDATE
;
2864 else if (!strcmp(key
, "options.default-msg-cleanup")) {
2865 opts
->explicit_cleanup
= 1;
2866 opts
->default_msg_cleanup
= get_cleanup_mode(value
, 1);
2868 return error(_("invalid key: %s"), key
);
2871 return error(_("invalid value for '%s': '%s'"), key
, value
);
2876 void parse_strategy_opts(struct replay_opts
*opts
, char *raw_opts
)
2879 char *strategy_opts_string
= raw_opts
;
2881 if (*strategy_opts_string
== ' ')
2882 strategy_opts_string
++;
2884 opts
->xopts_nr
= split_cmdline(strategy_opts_string
,
2885 (const char ***)&opts
->xopts
);
2886 for (i
= 0; i
< opts
->xopts_nr
; i
++) {
2887 const char *arg
= opts
->xopts
[i
];
2889 skip_prefix(arg
, "--", &arg
);
2890 opts
->xopts
[i
] = xstrdup(arg
);
2894 static void read_strategy_opts(struct replay_opts
*opts
, struct strbuf
*buf
)
2897 if (!read_oneliner(buf
, rebase_path_strategy(), 0))
2899 opts
->strategy
= strbuf_detach(buf
, NULL
);
2900 if (!read_oneliner(buf
, rebase_path_strategy_opts(), 0))
2903 parse_strategy_opts(opts
, buf
->buf
);
2906 static int read_populate_opts(struct replay_opts
*opts
)
2908 if (is_rebase_i(opts
)) {
2909 struct strbuf buf
= STRBUF_INIT
;
2912 if (read_oneliner(&buf
, rebase_path_gpg_sign_opt(),
2913 READ_ONELINER_SKIP_IF_EMPTY
)) {
2914 if (!starts_with(buf
.buf
, "-S"))
2917 free(opts
->gpg_sign
);
2918 opts
->gpg_sign
= xstrdup(buf
.buf
+ 2);
2923 if (read_oneliner(&buf
, rebase_path_allow_rerere_autoupdate(),
2924 READ_ONELINER_SKIP_IF_EMPTY
)) {
2925 if (!strcmp(buf
.buf
, "--rerere-autoupdate"))
2926 opts
->allow_rerere_auto
= RERERE_AUTOUPDATE
;
2927 else if (!strcmp(buf
.buf
, "--no-rerere-autoupdate"))
2928 opts
->allow_rerere_auto
= RERERE_NOAUTOUPDATE
;
2932 if (file_exists(rebase_path_verbose()))
2935 if (file_exists(rebase_path_quiet()))
2938 if (file_exists(rebase_path_signoff())) {
2943 if (file_exists(rebase_path_cdate_is_adate())) {
2945 opts
->committer_date_is_author_date
= 1;
2948 if (file_exists(rebase_path_ignore_date())) {
2950 opts
->ignore_date
= 1;
2953 if (file_exists(rebase_path_reschedule_failed_exec()))
2954 opts
->reschedule_failed_exec
= 1;
2955 else if (file_exists(rebase_path_no_reschedule_failed_exec()))
2956 opts
->reschedule_failed_exec
= 0;
2958 if (file_exists(rebase_path_drop_redundant_commits()))
2959 opts
->drop_redundant_commits
= 1;
2961 if (file_exists(rebase_path_keep_redundant_commits()))
2962 opts
->keep_redundant_commits
= 1;
2964 read_strategy_opts(opts
, &buf
);
2967 if (read_oneliner(&opts
->current_fixups
,
2968 rebase_path_current_fixups(),
2969 READ_ONELINER_SKIP_IF_EMPTY
)) {
2970 const char *p
= opts
->current_fixups
.buf
;
2971 opts
->current_fixup_count
= 1;
2972 while ((p
= strchr(p
, '\n'))) {
2973 opts
->current_fixup_count
++;
2978 if (read_oneliner(&buf
, rebase_path_squash_onto(), 0)) {
2979 if (get_oid_committish(buf
.buf
, &opts
->squash_onto
) < 0) {
2980 ret
= error(_("unusable squash-onto"));
2983 opts
->have_squash_onto
= 1;
2987 strbuf_release(&buf
);
2991 if (!file_exists(git_path_opts_file()))
2994 * The function git_parse_source(), called from git_config_from_file(),
2995 * may die() in case of a syntactically incorrect file. We do not care
2996 * about this case, though, because we wrote that file ourselves, so we
2997 * are pretty certain that it is syntactically correct.
2999 if (git_config_from_file(populate_opts_cb
, git_path_opts_file(), opts
) < 0)
3000 return error(_("malformed options sheet: '%s'"),
3001 git_path_opts_file());
3005 static void write_strategy_opts(struct replay_opts
*opts
)
3008 struct strbuf buf
= STRBUF_INIT
;
3010 for (i
= 0; i
< opts
->xopts_nr
; ++i
)
3011 strbuf_addf(&buf
, " --%s", opts
->xopts
[i
]);
3013 write_file(rebase_path_strategy_opts(), "%s\n", buf
.buf
);
3014 strbuf_release(&buf
);
3017 int write_basic_state(struct replay_opts
*opts
, const char *head_name
,
3018 struct commit
*onto
, const struct object_id
*orig_head
)
3021 write_file(rebase_path_head_name(), "%s\n", head_name
);
3023 write_file(rebase_path_onto(), "%s\n",
3024 oid_to_hex(&onto
->object
.oid
));
3026 write_file(rebase_path_orig_head(), "%s\n",
3027 oid_to_hex(orig_head
));
3030 write_file(rebase_path_quiet(), "%s", "");
3032 write_file(rebase_path_verbose(), "%s", "");
3034 write_file(rebase_path_strategy(), "%s\n", opts
->strategy
);
3035 if (opts
->xopts_nr
> 0)
3036 write_strategy_opts(opts
);
3038 if (opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
)
3039 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
3040 else if (opts
->allow_rerere_auto
== RERERE_NOAUTOUPDATE
)
3041 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
3044 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts
->gpg_sign
);
3046 write_file(rebase_path_signoff(), "--signoff\n");
3047 if (opts
->drop_redundant_commits
)
3048 write_file(rebase_path_drop_redundant_commits(), "%s", "");
3049 if (opts
->keep_redundant_commits
)
3050 write_file(rebase_path_keep_redundant_commits(), "%s", "");
3051 if (opts
->committer_date_is_author_date
)
3052 write_file(rebase_path_cdate_is_adate(), "%s", "");
3053 if (opts
->ignore_date
)
3054 write_file(rebase_path_ignore_date(), "%s", "");
3055 if (opts
->reschedule_failed_exec
)
3056 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
3058 write_file(rebase_path_no_reschedule_failed_exec(), "%s", "");
3063 static int walk_revs_populate_todo(struct todo_list
*todo_list
,
3064 struct replay_opts
*opts
)
3066 enum todo_command command
= opts
->action
== REPLAY_PICK
?
3067 TODO_PICK
: TODO_REVERT
;
3068 const char *command_string
= todo_command_info
[command
].str
;
3069 const char *encoding
;
3070 struct commit
*commit
;
3072 if (prepare_revs(opts
))
3075 encoding
= get_log_output_encoding();
3077 while ((commit
= get_revision(opts
->revs
))) {
3078 struct todo_item
*item
= append_new_todo(todo_list
);
3079 const char *commit_buffer
= logmsg_reencode(commit
, NULL
, encoding
);
3080 const char *subject
;
3083 item
->command
= command
;
3084 item
->commit
= commit
;
3085 item
->arg_offset
= 0;
3087 item
->offset_in_buf
= todo_list
->buf
.len
;
3088 subject_len
= find_commit_subject(commit_buffer
, &subject
);
3089 strbuf_addf(&todo_list
->buf
, "%s %s %.*s\n", command_string
,
3090 short_commit_name(commit
), subject_len
, subject
);
3091 unuse_commit_buffer(commit
, commit_buffer
);
3095 return error(_("empty commit set passed"));
3100 static int create_seq_dir(struct repository
*r
)
3102 enum replay_action action
;
3103 const char *in_progress_error
= NULL
;
3104 const char *in_progress_advice
= NULL
;
3105 unsigned int advise_skip
=
3106 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD") ||
3107 refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD");
3109 if (!sequencer_get_last_command(r
, &action
)) {
3112 in_progress_error
= _("revert is already in progress");
3113 in_progress_advice
=
3114 _("try \"git revert (--continue | %s--abort | --quit)\"");
3117 in_progress_error
= _("cherry-pick is already in progress");
3118 in_progress_advice
=
3119 _("try \"git cherry-pick (--continue | %s--abort | --quit)\"");
3122 BUG("unexpected action in create_seq_dir");
3125 if (in_progress_error
) {
3126 error("%s", in_progress_error
);
3127 if (advice_enabled(ADVICE_SEQUENCER_IN_USE
))
3128 advise(in_progress_advice
,
3129 advise_skip
? "--skip | " : "");
3132 if (mkdir(git_path_seq_dir(), 0777) < 0)
3133 return error_errno(_("could not create sequencer directory '%s'"),
3134 git_path_seq_dir());
3139 static int save_head(const char *head
)
3141 struct lock_file head_lock
= LOCK_INIT
;
3142 struct strbuf buf
= STRBUF_INIT
;
3146 fd
= hold_lock_file_for_update(&head_lock
, git_path_head_file(), 0);
3148 return error_errno(_("could not lock HEAD"));
3149 strbuf_addf(&buf
, "%s\n", head
);
3150 written
= write_in_full(fd
, buf
.buf
, buf
.len
);
3151 strbuf_release(&buf
);
3153 error_errno(_("could not write to '%s'"), git_path_head_file());
3154 rollback_lock_file(&head_lock
);
3157 if (commit_lock_file(&head_lock
) < 0)
3158 return error(_("failed to finalize '%s'"), git_path_head_file());
3162 static int rollback_is_safe(void)
3164 struct strbuf sb
= STRBUF_INIT
;
3165 struct object_id expected_head
, actual_head
;
3167 if (strbuf_read_file(&sb
, git_path_abort_safety_file(), 0) >= 0) {
3169 if (get_oid_hex(sb
.buf
, &expected_head
)) {
3170 strbuf_release(&sb
);
3171 die(_("could not parse %s"), git_path_abort_safety_file());
3173 strbuf_release(&sb
);
3175 else if (errno
== ENOENT
)
3176 oidclr(&expected_head
);
3178 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
3180 if (get_oid("HEAD", &actual_head
))
3181 oidclr(&actual_head
);
3183 return oideq(&actual_head
, &expected_head
);
3186 static int reset_merge(const struct object_id
*oid
)
3189 struct strvec argv
= STRVEC_INIT
;
3191 strvec_pushl(&argv
, "reset", "--merge", NULL
);
3193 if (!is_null_oid(oid
))
3194 strvec_push(&argv
, oid_to_hex(oid
));
3196 ret
= run_command_v_opt(argv
.v
, RUN_GIT_CMD
);
3197 strvec_clear(&argv
);
3202 static int rollback_single_pick(struct repository
*r
)
3204 struct object_id head_oid
;
3206 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
3207 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
3208 return error(_("no cherry-pick or revert in progress"));
3209 if (read_ref_full("HEAD", 0, &head_oid
, NULL
))
3210 return error(_("cannot resolve HEAD"));
3211 if (is_null_oid(&head_oid
))
3212 return error(_("cannot abort from a branch yet to be born"));
3213 return reset_merge(&head_oid
);
3216 static int skip_single_pick(void)
3218 struct object_id head
;
3220 if (read_ref_full("HEAD", 0, &head
, NULL
))
3221 return error(_("cannot resolve HEAD"));
3222 return reset_merge(&head
);
3225 int sequencer_rollback(struct repository
*r
, struct replay_opts
*opts
)
3228 struct object_id oid
;
3229 struct strbuf buf
= STRBUF_INIT
;
3232 f
= fopen(git_path_head_file(), "r");
3233 if (!f
&& errno
== ENOENT
) {
3235 * There is no multiple-cherry-pick in progress.
3236 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
3237 * a single-cherry-pick in progress, abort that.
3239 return rollback_single_pick(r
);
3242 return error_errno(_("cannot open '%s'"), git_path_head_file());
3243 if (strbuf_getline_lf(&buf
, f
)) {
3244 error(_("cannot read '%s': %s"), git_path_head_file(),
3245 ferror(f
) ? strerror(errno
) : _("unexpected end of file"));
3250 if (parse_oid_hex(buf
.buf
, &oid
, &p
) || *p
!= '\0') {
3251 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
3252 git_path_head_file());
3255 if (is_null_oid(&oid
)) {
3256 error(_("cannot abort from a branch yet to be born"));
3260 if (!rollback_is_safe()) {
3261 /* Do not error, just do not rollback */
3262 warning(_("You seem to have moved HEAD. "
3263 "Not rewinding, check your HEAD!"));
3265 if (reset_merge(&oid
))
3267 strbuf_release(&buf
);
3268 return sequencer_remove_state(opts
);
3270 strbuf_release(&buf
);
3274 int sequencer_skip(struct repository
*r
, struct replay_opts
*opts
)
3276 enum replay_action action
= -1;
3277 sequencer_get_last_command(r
, &action
);
3280 * Check whether the subcommand requested to skip the commit is actually
3281 * in progress and that it's safe to skip the commit.
3283 * opts->action tells us which subcommand requested to skip the commit.
3284 * If the corresponding .git/<ACTION>_HEAD exists, we know that the
3285 * action is in progress and we can skip the commit.
3287 * Otherwise we check that the last instruction was related to the
3288 * particular subcommand we're trying to execute and barf if that's not
3291 * Finally we check that the rollback is "safe", i.e., has the HEAD
3292 * moved? In this case, it doesn't make sense to "reset the merge" and
3293 * "skip the commit" as the user already handled this by committing. But
3294 * we'd not want to barf here, instead give advice on how to proceed. We
3295 * only need to check that when .git/<ACTION>_HEAD doesn't exist because
3296 * it gets removed when the user commits, so if it still exists we're
3297 * sure the user can't have committed before.
3299 switch (opts
->action
) {
3301 if (!refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
3302 if (action
!= REPLAY_REVERT
)
3303 return error(_("no revert in progress"));
3304 if (!rollback_is_safe())
3309 if (!refs_ref_exists(get_main_ref_store(r
),
3310 "CHERRY_PICK_HEAD")) {
3311 if (action
!= REPLAY_PICK
)
3312 return error(_("no cherry-pick in progress"));
3313 if (!rollback_is_safe())
3318 BUG("unexpected action in sequencer_skip");
3321 if (skip_single_pick())
3322 return error(_("failed to skip the commit"));
3323 if (!is_directory(git_path_seq_dir()))
3326 return sequencer_continue(r
, opts
);
3329 error(_("there is nothing to skip"));
3331 if (advice_enabled(ADVICE_RESOLVE_CONFLICT
)) {
3332 advise(_("have you committed already?\n"
3333 "try \"git %s --continue\""),
3334 action
== REPLAY_REVERT
? "revert" : "cherry-pick");
3339 static int save_todo(struct todo_list
*todo_list
, struct replay_opts
*opts
)
3341 struct lock_file todo_lock
= LOCK_INIT
;
3342 const char *todo_path
= get_todo_path(opts
);
3343 int next
= todo_list
->current
, offset
, fd
;
3346 * rebase -i writes "git-rebase-todo" without the currently executing
3347 * command, appending it to "done" instead.
3349 if (is_rebase_i(opts
))
3352 fd
= hold_lock_file_for_update(&todo_lock
, todo_path
, 0);
3354 return error_errno(_("could not lock '%s'"), todo_path
);
3355 offset
= get_item_line_offset(todo_list
, next
);
3356 if (write_in_full(fd
, todo_list
->buf
.buf
+ offset
,
3357 todo_list
->buf
.len
- offset
) < 0)
3358 return error_errno(_("could not write to '%s'"), todo_path
);
3359 if (commit_lock_file(&todo_lock
) < 0)
3360 return error(_("failed to finalize '%s'"), todo_path
);
3362 if (is_rebase_i(opts
) && next
> 0) {
3363 const char *done
= rebase_path_done();
3364 int fd
= open(done
, O_CREAT
| O_WRONLY
| O_APPEND
, 0666);
3369 if (write_in_full(fd
, get_item_line(todo_list
, next
- 1),
3370 get_item_line_length(todo_list
, next
- 1))
3372 ret
= error_errno(_("could not write to '%s'"), done
);
3374 ret
= error_errno(_("failed to finalize '%s'"), done
);
3380 static int save_opts(struct replay_opts
*opts
)
3382 const char *opts_file
= git_path_opts_file();
3385 if (opts
->no_commit
)
3386 res
|= git_config_set_in_file_gently(opts_file
,
3387 "options.no-commit", "true");
3388 if (opts
->edit
>= 0)
3389 res
|= git_config_set_in_file_gently(opts_file
, "options.edit",
3390 opts
->edit
? "true" : "false");
3391 if (opts
->allow_empty
)
3392 res
|= git_config_set_in_file_gently(opts_file
,
3393 "options.allow-empty", "true");
3394 if (opts
->allow_empty_message
)
3395 res
|= git_config_set_in_file_gently(opts_file
,
3396 "options.allow-empty-message", "true");
3397 if (opts
->keep_redundant_commits
)
3398 res
|= git_config_set_in_file_gently(opts_file
,
3399 "options.keep-redundant-commits", "true");
3401 res
|= git_config_set_in_file_gently(opts_file
,
3402 "options.signoff", "true");
3403 if (opts
->record_origin
)
3404 res
|= git_config_set_in_file_gently(opts_file
,
3405 "options.record-origin", "true");
3407 res
|= git_config_set_in_file_gently(opts_file
,
3408 "options.allow-ff", "true");
3409 if (opts
->mainline
) {
3410 struct strbuf buf
= STRBUF_INIT
;
3411 strbuf_addf(&buf
, "%d", opts
->mainline
);
3412 res
|= git_config_set_in_file_gently(opts_file
,
3413 "options.mainline", buf
.buf
);
3414 strbuf_release(&buf
);
3417 res
|= git_config_set_in_file_gently(opts_file
,
3418 "options.strategy", opts
->strategy
);
3420 res
|= git_config_set_in_file_gently(opts_file
,
3421 "options.gpg-sign", opts
->gpg_sign
);
3424 for (i
= 0; i
< opts
->xopts_nr
; i
++)
3425 res
|= git_config_set_multivar_in_file_gently(opts_file
,
3426 "options.strategy-option",
3427 opts
->xopts
[i
], "^$", 0);
3429 if (opts
->allow_rerere_auto
)
3430 res
|= git_config_set_in_file_gently(opts_file
,
3431 "options.allow-rerere-auto",
3432 opts
->allow_rerere_auto
== RERERE_AUTOUPDATE
?
3435 if (opts
->explicit_cleanup
)
3436 res
|= git_config_set_in_file_gently(opts_file
,
3437 "options.default-msg-cleanup",
3438 describe_cleanup_mode(opts
->default_msg_cleanup
));
3442 static int make_patch(struct repository
*r
,
3443 struct commit
*commit
,
3444 struct replay_opts
*opts
)
3446 struct strbuf buf
= STRBUF_INIT
;
3447 struct rev_info log_tree_opt
;
3448 const char *subject
;
3449 char hex
[GIT_MAX_HEXSZ
+ 1];
3452 oid_to_hex_r(hex
, &commit
->object
.oid
);
3453 if (write_message(hex
, strlen(hex
), rebase_path_stopped_sha(), 1) < 0)
3455 res
|= write_rebase_head(&commit
->object
.oid
);
3457 strbuf_addf(&buf
, "%s/patch", get_dir(opts
));
3458 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
3459 repo_init_revisions(r
, &log_tree_opt
, NULL
);
3460 log_tree_opt
.abbrev
= 0;
3461 log_tree_opt
.diff
= 1;
3462 log_tree_opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
3463 log_tree_opt
.disable_stdin
= 1;
3464 log_tree_opt
.no_commit_id
= 1;
3465 log_tree_opt
.diffopt
.file
= fopen(buf
.buf
, "w");
3466 log_tree_opt
.diffopt
.use_color
= GIT_COLOR_NEVER
;
3467 if (!log_tree_opt
.diffopt
.file
)
3468 res
|= error_errno(_("could not open '%s'"), buf
.buf
);
3470 res
|= log_tree_commit(&log_tree_opt
, commit
);
3471 fclose(log_tree_opt
.diffopt
.file
);
3475 strbuf_addf(&buf
, "%s/message", get_dir(opts
));
3476 if (!file_exists(buf
.buf
)) {
3477 const char *encoding
= get_commit_output_encoding();
3478 const char *commit_buffer
= logmsg_reencode(commit
, NULL
, encoding
);
3479 find_commit_subject(commit_buffer
, &subject
);
3480 res
|= write_message(subject
, strlen(subject
), buf
.buf
, 1);
3481 unuse_commit_buffer(commit
, commit_buffer
);
3483 strbuf_release(&buf
);
3484 release_revisions(&log_tree_opt
);
3489 static int intend_to_amend(void)
3491 struct object_id head
;
3494 if (get_oid("HEAD", &head
))
3495 return error(_("cannot read HEAD"));
3497 p
= oid_to_hex(&head
);
3498 return write_message(p
, strlen(p
), rebase_path_amend(), 1);
3501 static int error_with_patch(struct repository
*r
,
3502 struct commit
*commit
,
3503 const char *subject
, int subject_len
,
3504 struct replay_opts
*opts
,
3505 int exit_code
, int to_amend
)
3508 if (make_patch(r
, commit
, opts
))
3510 } else if (copy_file(rebase_path_message(),
3511 git_path_merge_msg(r
), 0666))
3512 return error(_("unable to copy '%s' to '%s'"),
3513 git_path_merge_msg(r
), rebase_path_message());
3516 if (intend_to_amend())
3520 _("You can amend the commit now, with\n"
3522 " git commit --amend %s\n"
3524 "Once you are satisfied with your changes, run\n"
3526 " git rebase --continue\n"),
3527 gpg_sign_opt_quoted(opts
));
3528 } else if (exit_code
) {
3530 fprintf_ln(stderr
, _("Could not apply %s... %.*s"),
3531 short_commit_name(commit
), subject_len
, subject
);
3534 * We don't have the hash of the parent so
3535 * just print the line from the todo file.
3537 fprintf_ln(stderr
, _("Could not merge %.*s"),
3538 subject_len
, subject
);
3544 static int error_failed_squash(struct repository
*r
,
3545 struct commit
*commit
,
3546 struct replay_opts
*opts
,
3548 const char *subject
)
3550 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
3551 return error(_("could not copy '%s' to '%s'"),
3552 rebase_path_squash_msg(), rebase_path_message());
3553 unlink(git_path_merge_msg(r
));
3554 if (copy_file(git_path_merge_msg(r
), rebase_path_message(), 0666))
3555 return error(_("could not copy '%s' to '%s'"),
3556 rebase_path_message(),
3557 git_path_merge_msg(r
));
3558 return error_with_patch(r
, commit
, subject
, subject_len
, opts
, 1, 0);
3561 static int do_exec(struct repository
*r
, const char *command_line
)
3563 const char *child_argv
[] = { NULL
, NULL
};
3566 fprintf(stderr
, _("Executing: %s\n"), command_line
);
3567 child_argv
[0] = command_line
;
3568 status
= run_command_v_opt(child_argv
, RUN_USING_SHELL
);
3570 /* force re-reading of the cache */
3571 if (discard_index(r
->index
) < 0 || repo_read_index(r
) < 0)
3572 return error(_("could not read index"));
3574 dirty
= require_clean_work_tree(r
, "rebase", NULL
, 1, 1);
3577 warning(_("execution failed: %s\n%s"
3578 "You can fix the problem, and then run\n"
3580 " git rebase --continue\n"
3583 dirty
? N_("and made changes to the index and/or the "
3584 "working tree\n") : "");
3586 /* command not found */
3589 warning(_("execution succeeded: %s\nbut "
3590 "left changes to the index and/or the working tree\n"
3591 "Commit or stash your changes, and then run\n"
3593 " git rebase --continue\n"
3594 "\n"), command_line
);
3601 __attribute__((format (printf
, 2, 3)))
3602 static int safe_append(const char *filename
, const char *fmt
, ...)
3605 struct lock_file lock
= LOCK_INIT
;
3606 int fd
= hold_lock_file_for_update(&lock
, filename
,
3607 LOCK_REPORT_ON_ERROR
);
3608 struct strbuf buf
= STRBUF_INIT
;
3613 if (strbuf_read_file(&buf
, filename
, 0) < 0 && errno
!= ENOENT
) {
3614 error_errno(_("could not read '%s'"), filename
);
3615 rollback_lock_file(&lock
);
3618 strbuf_complete(&buf
, '\n');
3620 strbuf_vaddf(&buf
, fmt
, ap
);
3623 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
3624 error_errno(_("could not write to '%s'"), filename
);
3625 strbuf_release(&buf
);
3626 rollback_lock_file(&lock
);
3629 if (commit_lock_file(&lock
) < 0) {
3630 strbuf_release(&buf
);
3631 rollback_lock_file(&lock
);
3632 return error(_("failed to finalize '%s'"), filename
);
3635 strbuf_release(&buf
);
3639 static int do_label(struct repository
*r
, const char *name
, int len
)
3641 struct ref_store
*refs
= get_main_ref_store(r
);
3642 struct ref_transaction
*transaction
;
3643 struct strbuf ref_name
= STRBUF_INIT
, err
= STRBUF_INIT
;
3644 struct strbuf msg
= STRBUF_INIT
;
3646 struct object_id head_oid
;
3648 if (len
== 1 && *name
== '#')
3649 return error(_("illegal label name: '%.*s'"), len
, name
);
3651 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3652 strbuf_addf(&msg
, "rebase (label) '%.*s'", len
, name
);
3654 transaction
= ref_store_transaction_begin(refs
, &err
);
3656 error("%s", err
.buf
);
3658 } else if (get_oid("HEAD", &head_oid
)) {
3659 error(_("could not read HEAD"));
3661 } else if (ref_transaction_update(transaction
, ref_name
.buf
, &head_oid
,
3662 NULL
, 0, msg
.buf
, &err
) < 0 ||
3663 ref_transaction_commit(transaction
, &err
)) {
3664 error("%s", err
.buf
);
3667 ref_transaction_free(transaction
);
3668 strbuf_release(&err
);
3669 strbuf_release(&msg
);
3672 ret
= safe_append(rebase_path_refs_to_delete(),
3673 "%s\n", ref_name
.buf
);
3674 strbuf_release(&ref_name
);
3679 __attribute__((format (printf
, 3, 4)))
3680 static const char *reflog_message(struct replay_opts
*opts
,
3681 const char *sub_action
, const char *fmt
, ...)
3684 static struct strbuf buf
= STRBUF_INIT
;
3685 char *reflog_action
= getenv(GIT_REFLOG_ACTION
);
3689 strbuf_addstr(&buf
, reflog_action
? reflog_action
: action_name(opts
));
3691 strbuf_addf(&buf
, " (%s)", sub_action
);
3693 strbuf_addstr(&buf
, ": ");
3694 strbuf_vaddf(&buf
, fmt
, ap
);
3701 static int do_reset(struct repository
*r
,
3702 const char *name
, int len
,
3703 struct replay_opts
*opts
)
3705 struct strbuf ref_name
= STRBUF_INIT
;
3706 struct object_id oid
;
3707 struct lock_file lock
= LOCK_INIT
;
3708 struct tree_desc desc
= { 0 };
3710 struct unpack_trees_options unpack_tree_opts
= { 0 };
3713 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0)
3716 if (len
== 10 && !strncmp("[new root]", name
, len
)) {
3717 if (!opts
->have_squash_onto
) {
3719 if (commit_tree("", 0, the_hash_algo
->empty_tree
,
3720 NULL
, &opts
->squash_onto
,
3722 return error(_("writing fake root commit"));
3723 opts
->have_squash_onto
= 1;
3724 hex
= oid_to_hex(&opts
->squash_onto
);
3725 if (write_message(hex
, strlen(hex
),
3726 rebase_path_squash_onto(), 0))
3727 return error(_("writing squash-onto"));
3729 oidcpy(&oid
, &opts
->squash_onto
);
3733 /* Determine the length of the label */
3734 for (i
= 0; i
< len
; i
++)
3735 if (isspace(name
[i
]))
3739 strbuf_addf(&ref_name
, "refs/rewritten/%.*s", len
, name
);
3740 if (get_oid(ref_name
.buf
, &oid
) &&
3741 get_oid(ref_name
.buf
+ strlen("refs/rewritten/"), &oid
)) {
3742 ret
= error(_("could not read '%s'"), ref_name
.buf
);
3747 setup_unpack_trees_porcelain(&unpack_tree_opts
, "reset");
3748 unpack_tree_opts
.head_idx
= 1;
3749 unpack_tree_opts
.src_index
= r
->index
;
3750 unpack_tree_opts
.dst_index
= r
->index
;
3751 unpack_tree_opts
.fn
= oneway_merge
;
3752 unpack_tree_opts
.merge
= 1;
3753 unpack_tree_opts
.update
= 1;
3754 unpack_tree_opts
.preserve_ignored
= 0; /* FIXME: !overwrite_ignore */
3755 init_checkout_metadata(&unpack_tree_opts
.meta
, name
, &oid
, NULL
);
3757 if (repo_read_index_unmerged(r
)) {
3758 ret
= error_resolve_conflict(action_name(opts
));
3762 if (!fill_tree_descriptor(r
, &desc
, &oid
)) {
3763 ret
= error(_("failed to find tree of %s"), oid_to_hex(&oid
));
3767 if (unpack_trees(1, &desc
, &unpack_tree_opts
)) {
3772 tree
= parse_tree_indirect(&oid
);
3773 prime_cache_tree(r
, r
->index
, tree
);
3775 if (write_locked_index(r
->index
, &lock
, COMMIT_LOCK
) < 0)
3776 ret
= error(_("could not write index"));
3779 ret
= update_ref(reflog_message(opts
, "reset", "'%.*s'",
3780 len
, name
), "HEAD", &oid
,
3781 NULL
, 0, UPDATE_REFS_MSG_ON_ERR
);
3783 free((void *)desc
.buffer
);
3785 rollback_lock_file(&lock
);
3786 strbuf_release(&ref_name
);
3787 clear_unpack_trees_porcelain(&unpack_tree_opts
);
3791 static struct commit
*lookup_label(const char *label
, int len
,
3794 struct commit
*commit
;
3797 strbuf_addf(buf
, "refs/rewritten/%.*s", len
, label
);
3798 commit
= lookup_commit_reference_by_name(buf
->buf
);
3800 /* fall back to non-rewritten ref or commit */
3801 strbuf_splice(buf
, 0, strlen("refs/rewritten/"), "", 0);
3802 commit
= lookup_commit_reference_by_name(buf
->buf
);
3806 error(_("could not resolve '%s'"), buf
->buf
);
3811 static int do_merge(struct repository
*r
,
3812 struct commit
*commit
,
3813 const char *arg
, int arg_len
,
3814 int flags
, int *check_todo
, struct replay_opts
*opts
)
3816 int run_commit_flags
= 0;
3817 struct strbuf ref_name
= STRBUF_INIT
;
3818 struct commit
*head_commit
, *merge_commit
, *i
;
3819 struct commit_list
*bases
, *j
;
3820 struct commit_list
*to_merge
= NULL
, **tail
= &to_merge
;
3821 const char *strategy
= !opts
->xopts_nr
&&
3823 !strcmp(opts
->strategy
, "recursive") ||
3824 !strcmp(opts
->strategy
, "ort")) ?
3825 NULL
: opts
->strategy
;
3826 struct merge_options o
;
3827 int merge_arg_len
, oneline_offset
, can_fast_forward
, ret
, k
;
3828 static struct lock_file lock
;
3831 if (repo_hold_locked_index(r
, &lock
, LOCK_REPORT_ON_ERROR
) < 0) {
3836 head_commit
= lookup_commit_reference_by_name("HEAD");
3838 ret
= error(_("cannot merge without a current revision"));
3843 * For octopus merges, the arg starts with the list of revisions to be
3844 * merged. The list is optionally followed by '#' and the oneline.
3846 merge_arg_len
= oneline_offset
= arg_len
;
3847 for (p
= arg
; p
- arg
< arg_len
; p
+= strspn(p
, " \t\n")) {
3850 if (*p
== '#' && (!p
[1] || isspace(p
[1]))) {
3851 p
+= 1 + strspn(p
+ 1, " \t\n");
3852 oneline_offset
= p
- arg
;
3855 k
= strcspn(p
, " \t\n");
3858 merge_commit
= lookup_label(p
, k
, &ref_name
);
3859 if (!merge_commit
) {
3860 ret
= error(_("unable to parse '%.*s'"), k
, p
);
3863 tail
= &commit_list_insert(merge_commit
, tail
)->next
;
3865 merge_arg_len
= p
- arg
;
3869 ret
= error(_("nothing to merge: '%.*s'"), arg_len
, arg
);
3873 if (opts
->have_squash_onto
&&
3874 oideq(&head_commit
->object
.oid
, &opts
->squash_onto
)) {
3876 * When the user tells us to "merge" something into a
3877 * "[new root]", let's simply fast-forward to the merge head.
3879 rollback_lock_file(&lock
);
3881 ret
= error(_("octopus merge cannot be executed on "
3882 "top of a [new root]"));
3884 ret
= fast_forward_to(r
, &to_merge
->item
->object
.oid
,
3885 &head_commit
->object
.oid
, 0,
3891 * If HEAD is not identical to the first parent of the original merge
3892 * commit, we cannot fast-forward.
3894 can_fast_forward
= opts
->allow_ff
&& commit
&& commit
->parents
&&
3895 oideq(&commit
->parents
->item
->object
.oid
,
3896 &head_commit
->object
.oid
);
3899 * If any merge head is different from the original one, we cannot
3902 if (can_fast_forward
) {
3903 struct commit_list
*p
= commit
->parents
->next
;
3905 for (j
= to_merge
; j
&& p
; j
= j
->next
, p
= p
->next
)
3906 if (!oideq(&j
->item
->object
.oid
,
3907 &p
->item
->object
.oid
)) {
3908 can_fast_forward
= 0;
3912 * If the number of merge heads differs from the original merge
3913 * commit, we cannot fast-forward.
3916 can_fast_forward
= 0;
3919 if (can_fast_forward
) {
3920 rollback_lock_file(&lock
);
3921 ret
= fast_forward_to(r
, &commit
->object
.oid
,
3922 &head_commit
->object
.oid
, 0, opts
);
3923 if (flags
& TODO_EDIT_MERGE_MSG
)
3924 goto fast_forward_edit
;
3930 const char *encoding
= get_commit_output_encoding();
3931 const char *message
= logmsg_reencode(commit
, NULL
, encoding
);
3936 ret
= error(_("could not get commit message of '%s'"),
3937 oid_to_hex(&commit
->object
.oid
));
3940 write_author_script(message
);
3941 find_commit_subject(message
, &body
);
3943 ret
= write_message(body
, len
, git_path_merge_msg(r
), 0);
3944 unuse_commit_buffer(commit
, message
);
3946 error_errno(_("could not write '%s'"),
3947 git_path_merge_msg(r
));
3951 struct strbuf buf
= STRBUF_INIT
;
3954 strbuf_addf(&buf
, "author %s", git_author_info(0));
3955 write_author_script(buf
.buf
);
3958 if (oneline_offset
< arg_len
) {
3959 p
= arg
+ oneline_offset
;
3960 len
= arg_len
- oneline_offset
;
3962 strbuf_addf(&buf
, "Merge %s '%.*s'",
3963 to_merge
->next
? "branches" : "branch",
3964 merge_arg_len
, arg
);
3969 ret
= write_message(p
, len
, git_path_merge_msg(r
), 0);
3970 strbuf_release(&buf
);
3972 error_errno(_("could not write '%s'"),
3973 git_path_merge_msg(r
));
3978 if (strategy
|| to_merge
->next
) {
3980 struct child_process cmd
= CHILD_PROCESS_INIT
;
3982 if (read_env_script(&cmd
.env
)) {
3983 const char *gpg_opt
= gpg_sign_opt_quoted(opts
);
3985 ret
= error(_(staged_changes_advice
), gpg_opt
, gpg_opt
);
3989 if (opts
->committer_date_is_author_date
)
3990 strvec_pushf(&cmd
.env
, "GIT_COMMITTER_DATE=%s",
3993 author_date_from_env(&cmd
.env
));
3994 if (opts
->ignore_date
)
3995 strvec_push(&cmd
.env
, "GIT_AUTHOR_DATE=");
3998 strvec_push(&cmd
.args
, "merge");
3999 strvec_push(&cmd
.args
, "-s");
4001 strvec_push(&cmd
.args
, "octopus");
4003 strvec_push(&cmd
.args
, strategy
);
4004 for (k
= 0; k
< opts
->xopts_nr
; k
++)
4005 strvec_pushf(&cmd
.args
,
4006 "-X%s", opts
->xopts
[k
]);
4008 if (!(flags
& TODO_EDIT_MERGE_MSG
))
4009 strvec_push(&cmd
.args
, "--no-edit");
4011 strvec_push(&cmd
.args
, "--edit");
4012 strvec_push(&cmd
.args
, "--no-ff");
4013 strvec_push(&cmd
.args
, "--no-log");
4014 strvec_push(&cmd
.args
, "--no-stat");
4015 strvec_push(&cmd
.args
, "-F");
4016 strvec_push(&cmd
.args
, git_path_merge_msg(r
));
4018 strvec_pushf(&cmd
.args
, "-S%s", opts
->gpg_sign
);
4020 strvec_push(&cmd
.args
, "--no-gpg-sign");
4022 /* Add the tips to be merged */
4023 for (j
= to_merge
; j
; j
= j
->next
)
4024 strvec_push(&cmd
.args
,
4025 oid_to_hex(&j
->item
->object
.oid
));
4027 strbuf_release(&ref_name
);
4028 refs_delete_ref(get_main_ref_store(r
), "", "CHERRY_PICK_HEAD",
4030 rollback_lock_file(&lock
);
4032 ret
= run_command(&cmd
);
4034 /* force re-reading of the cache */
4035 if (!ret
&& (discard_index(r
->index
) < 0 ||
4036 repo_read_index(r
) < 0))
4037 ret
= error(_("could not read index"));
4041 merge_commit
= to_merge
->item
;
4042 bases
= get_merge_bases(head_commit
, merge_commit
);
4043 if (bases
&& oideq(&merge_commit
->object
.oid
,
4044 &bases
->item
->object
.oid
)) {
4046 /* skip merging an ancestor of HEAD */
4050 write_message(oid_to_hex(&merge_commit
->object
.oid
), the_hash_algo
->hexsz
,
4051 git_path_merge_head(r
), 0);
4052 write_message("no-ff", 5, git_path_merge_mode(r
), 0);
4054 bases
= reverse_commit_list(bases
);
4057 init_merge_options(&o
, r
);
4059 o
.branch2
= ref_name
.buf
;
4060 o
.buffer_output
= 2;
4062 if (!opts
->strategy
|| !strcmp(opts
->strategy
, "ort")) {
4064 * TODO: Should use merge_incore_recursive() and
4065 * merge_switch_to_result(), skipping the call to
4066 * merge_switch_to_result() when we don't actually need to
4067 * update the index and working copy immediately.
4069 ret
= merge_ort_recursive(&o
,
4070 head_commit
, merge_commit
, bases
,
4073 ret
= merge_recursive(&o
, head_commit
, merge_commit
, bases
,
4077 fputs(o
.obuf
.buf
, stdout
);
4078 strbuf_release(&o
.obuf
);
4080 error(_("could not even attempt to merge '%.*s'"),
4081 merge_arg_len
, arg
);
4085 * The return value of merge_recursive() is 1 on clean, and 0 on
4088 * Let's reverse that, so that do_merge() returns 0 upon success and
4089 * 1 upon failed merge (keeping the return value -1 for the cases where
4090 * we will want to reschedule the `merge` command).
4094 if (r
->index
->cache_changed
&&
4095 write_locked_index(r
->index
, &lock
, COMMIT_LOCK
)) {
4096 ret
= error(_("merge: Unable to write new index file"));
4100 rollback_lock_file(&lock
);
4102 repo_rerere(r
, opts
->allow_rerere_auto
);
4105 * In case of problems, we now want to return a positive
4106 * value (a negative one would indicate that the `merge`
4107 * command needs to be rescheduled).
4109 ret
= !!run_git_commit(git_path_merge_msg(r
), opts
,
4112 if (!ret
&& flags
& TODO_EDIT_MERGE_MSG
) {
4115 run_commit_flags
|= AMEND_MSG
| EDIT_MSG
| VERIFY_MSG
;
4116 ret
= !!run_git_commit(NULL
, opts
, run_commit_flags
);
4121 strbuf_release(&ref_name
);
4122 rollback_lock_file(&lock
);
4123 free_commit_list(to_merge
);
4127 static int write_update_refs_state(struct string_list
*refs_to_oids
)
4130 struct lock_file lock
= LOCK_INIT
;
4132 struct string_list_item
*item
;
4135 path
= rebase_path_update_refs(the_repository
->gitdir
);
4137 if (!refs_to_oids
->nr
) {
4138 if (unlink(path
) && errno
!= ENOENT
)
4139 result
= error_errno(_("could not unlink: %s"), path
);
4143 if (safe_create_leading_directories(path
)) {
4144 result
= error(_("unable to create leading directories of %s"),
4149 if (hold_lock_file_for_update(&lock
, path
, 0) < 0) {
4150 result
= error(_("another 'rebase' process appears to be running; "
4151 "'%s.lock' already exists"),
4156 fp
= fdopen_lock_file(&lock
, "w");
4158 result
= error_errno(_("could not open '%s' for writing"), path
);
4159 rollback_lock_file(&lock
);
4163 for_each_string_list_item(item
, refs_to_oids
) {
4164 struct update_ref_record
*rec
= item
->util
;
4165 fprintf(fp
, "%s\n%s\n%s\n", item
->string
,
4166 oid_to_hex(&rec
->before
), oid_to_hex(&rec
->after
));
4169 result
= commit_lock_file(&lock
);
4177 * Parse the update-refs file for the current rebase, then remove the
4178 * refs that do not appear in the todo_list (and have not had updated
4179 * values stored) and add refs that are in the todo_list but not
4180 * represented in the update-refs file.
4182 * If there are changes to the update-refs list, then write the new state
4185 void todo_list_filter_update_refs(struct repository
*r
,
4186 struct todo_list
*todo_list
)
4190 struct string_list update_refs
= STRING_LIST_INIT_DUP
;
4192 sequencer_get_update_refs_state(r
->gitdir
, &update_refs
);
4195 * For each item in the update_refs list, if it has no updated
4196 * value and does not appear in the todo_list, then remove it
4197 * from the update_refs list.
4199 for (i
= 0; i
< update_refs
.nr
; i
++) {
4202 const char *ref
= update_refs
.items
[i
].string
;
4203 size_t reflen
= strlen(ref
);
4204 struct update_ref_record
*rec
= update_refs
.items
[i
].util
;
4206 /* OID already stored as updated. */
4207 if (!is_null_oid(&rec
->after
))
4210 for (j
= 0; !found
&& j
< todo_list
->nr
; j
++) {
4211 struct todo_item
*item
= &todo_list
->items
[j
];
4212 const char *arg
= todo_list
->buf
.buf
+ item
->arg_offset
;
4214 if (item
->command
!= TODO_UPDATE_REF
)
4217 if (item
->arg_len
!= reflen
||
4218 strncmp(arg
, ref
, reflen
))
4225 free(update_refs
.items
[i
].string
);
4226 free(update_refs
.items
[i
].util
);
4229 MOVE_ARRAY(update_refs
.items
+ i
, update_refs
.items
+ i
+ 1, update_refs
.nr
- i
);
4237 * For each todo_item, check if its ref is in the update_refs list.
4238 * If not, then add it as an un-updated ref.
4240 for (i
= 0; i
< todo_list
->nr
; i
++) {
4241 struct todo_item
*item
= &todo_list
->items
[i
];
4242 const char *arg
= todo_list
->buf
.buf
+ item
->arg_offset
;
4245 if (item
->command
!= TODO_UPDATE_REF
)
4248 for (j
= 0; !found
&& j
< update_refs
.nr
; j
++) {
4249 const char *ref
= update_refs
.items
[j
].string
;
4251 found
= strlen(ref
) == item
->arg_len
&&
4252 !strncmp(ref
, arg
, item
->arg_len
);
4256 struct string_list_item
*inserted
;
4257 struct strbuf argref
= STRBUF_INIT
;
4259 strbuf_add(&argref
, arg
, item
->arg_len
);
4260 inserted
= string_list_insert(&update_refs
, argref
.buf
);
4261 inserted
->util
= init_update_ref_record(argref
.buf
);
4262 strbuf_release(&argref
);
4268 write_update_refs_state(&update_refs
);
4269 string_list_clear(&update_refs
, 1);
4272 static int do_update_ref(struct repository
*r
, const char *refname
)
4274 struct string_list_item
*item
;
4275 struct string_list list
= STRING_LIST_INIT_DUP
;
4277 if (sequencer_get_update_refs_state(r
->gitdir
, &list
))
4280 for_each_string_list_item(item
, &list
) {
4281 if (!strcmp(item
->string
, refname
)) {
4282 struct update_ref_record
*rec
= item
->util
;
4283 if (read_ref("HEAD", &rec
->after
))
4289 write_update_refs_state(&list
);
4290 string_list_clear(&list
, 1);
4294 static int do_update_refs(struct repository
*r
, int quiet
)
4297 struct string_list_item
*item
;
4298 struct string_list refs_to_oids
= STRING_LIST_INIT_DUP
;
4299 struct ref_store
*refs
= get_main_ref_store(r
);
4300 struct strbuf update_msg
= STRBUF_INIT
;
4301 struct strbuf error_msg
= STRBUF_INIT
;
4303 if ((res
= sequencer_get_update_refs_state(r
->gitdir
, &refs_to_oids
)))
4306 for_each_string_list_item(item
, &refs_to_oids
) {
4307 struct update_ref_record
*rec
= item
->util
;
4310 loop_res
= refs_update_ref(refs
, "rewritten during rebase",
4312 &rec
->after
, &rec
->before
,
4313 0, UPDATE_REFS_MSG_ON_ERR
);
4320 strbuf_addf(&error_msg
, "\t%s\n", item
->string
);
4322 strbuf_addf(&update_msg
, "\t%s\n", item
->string
);
4326 (update_msg
.len
|| error_msg
.len
)) {
4328 _("Updated the following refs with %s:\n%s"),
4334 _("Failed to update the following refs with %s:\n%s"),
4339 string_list_clear(&refs_to_oids
, 1);
4340 strbuf_release(&update_msg
);
4341 strbuf_release(&error_msg
);
4345 static int is_final_fixup(struct todo_list
*todo_list
)
4347 int i
= todo_list
->current
;
4349 if (!is_fixup(todo_list
->items
[i
].command
))
4352 while (++i
< todo_list
->nr
)
4353 if (is_fixup(todo_list
->items
[i
].command
))
4355 else if (!is_noop(todo_list
->items
[i
].command
))
4360 static enum todo_command
peek_command(struct todo_list
*todo_list
, int offset
)
4364 for (i
= todo_list
->current
+ offset
; i
< todo_list
->nr
; i
++)
4365 if (!is_noop(todo_list
->items
[i
].command
))
4366 return todo_list
->items
[i
].command
;
4371 void create_autostash(struct repository
*r
, const char *path
)
4373 struct strbuf buf
= STRBUF_INIT
;
4374 struct lock_file lock_file
= LOCK_INIT
;
4377 fd
= repo_hold_locked_index(r
, &lock_file
, 0);
4378 refresh_index(r
->index
, REFRESH_QUIET
, NULL
, NULL
, NULL
);
4380 repo_update_index_if_able(r
, &lock_file
);
4381 rollback_lock_file(&lock_file
);
4383 if (has_unstaged_changes(r
, 1) ||
4384 has_uncommitted_changes(r
, 1)) {
4385 struct child_process stash
= CHILD_PROCESS_INIT
;
4386 struct reset_head_opts ropts
= { .flags
= RESET_HEAD_HARD
};
4387 struct object_id oid
;
4389 strvec_pushl(&stash
.args
,
4390 "stash", "create", "autostash", NULL
);
4394 if (capture_command(&stash
, &buf
, GIT_MAX_HEXSZ
))
4395 die(_("Cannot autostash"));
4396 strbuf_trim_trailing_newline(&buf
);
4397 if (get_oid(buf
.buf
, &oid
))
4398 die(_("Unexpected stash response: '%s'"),
4401 strbuf_add_unique_abbrev(&buf
, &oid
, DEFAULT_ABBREV
);
4403 if (safe_create_leading_directories_const(path
))
4404 die(_("Could not create directory for '%s'"),
4406 write_file(path
, "%s", oid_to_hex(&oid
));
4407 printf(_("Created autostash: %s\n"), buf
.buf
);
4408 if (reset_head(r
, &ropts
) < 0)
4409 die(_("could not reset --hard"));
4410 if (discard_index(r
->index
) < 0 ||
4411 repo_read_index(r
) < 0)
4412 die(_("could not read index"));
4414 strbuf_release(&buf
);
4417 static int apply_save_autostash_oid(const char *stash_oid
, int attempt_apply
)
4419 struct child_process child
= CHILD_PROCESS_INIT
;
4422 if (attempt_apply
) {
4424 child
.no_stdout
= 1;
4425 child
.no_stderr
= 1;
4426 strvec_push(&child
.args
, "stash");
4427 strvec_push(&child
.args
, "apply");
4428 strvec_push(&child
.args
, stash_oid
);
4429 ret
= run_command(&child
);
4432 if (attempt_apply
&& !ret
)
4433 fprintf(stderr
, _("Applied autostash.\n"));
4435 struct child_process store
= CHILD_PROCESS_INIT
;
4438 strvec_push(&store
.args
, "stash");
4439 strvec_push(&store
.args
, "store");
4440 strvec_push(&store
.args
, "-m");
4441 strvec_push(&store
.args
, "autostash");
4442 strvec_push(&store
.args
, "-q");
4443 strvec_push(&store
.args
, stash_oid
);
4444 if (run_command(&store
))
4445 ret
= error(_("cannot store %s"), stash_oid
);
4449 "Your changes are safe in the stash.\n"
4450 "You can run \"git stash pop\" or"
4451 " \"git stash drop\" at any time.\n"),
4453 _("Applying autostash resulted in conflicts.") :
4454 _("Autostash exists; creating a new stash entry."));
4460 static int apply_save_autostash(const char *path
, int attempt_apply
)
4462 struct strbuf stash_oid
= STRBUF_INIT
;
4465 if (!read_oneliner(&stash_oid
, path
,
4466 READ_ONELINER_SKIP_IF_EMPTY
)) {
4467 strbuf_release(&stash_oid
);
4470 strbuf_trim(&stash_oid
);
4472 ret
= apply_save_autostash_oid(stash_oid
.buf
, attempt_apply
);
4475 strbuf_release(&stash_oid
);
4479 int save_autostash(const char *path
)
4481 return apply_save_autostash(path
, 0);
4484 int apply_autostash(const char *path
)
4486 return apply_save_autostash(path
, 1);
4489 int apply_autostash_oid(const char *stash_oid
)
4491 return apply_save_autostash_oid(stash_oid
, 1);
4494 static int checkout_onto(struct repository
*r
, struct replay_opts
*opts
,
4495 const char *onto_name
, const struct object_id
*onto
,
4496 const struct object_id
*orig_head
)
4498 struct reset_head_opts ropts
= {
4500 .orig_head
= orig_head
,
4501 .flags
= RESET_HEAD_DETACH
| RESET_ORIG_HEAD
|
4502 RESET_HEAD_RUN_POST_CHECKOUT_HOOK
,
4503 .head_msg
= reflog_message(opts
, "start", "checkout %s",
4505 .default_reflog_action
= "rebase"
4507 if (reset_head(r
, &ropts
)) {
4508 apply_autostash(rebase_path_autostash());
4509 sequencer_remove_state(opts
);
4510 return error(_("could not detach HEAD"));
4516 static int stopped_at_head(struct repository
*r
)
4518 struct object_id head
;
4519 struct commit
*commit
;
4520 struct commit_message message
;
4522 if (get_oid("HEAD", &head
) ||
4523 !(commit
= lookup_commit(r
, &head
)) ||
4524 parse_commit(commit
) || get_message(commit
, &message
))
4525 fprintf(stderr
, _("Stopped at HEAD\n"));
4527 fprintf(stderr
, _("Stopped at %s\n"), message
.label
);
4528 free_message(commit
, &message
);
4534 static int reread_todo_if_changed(struct repository
*r
,
4535 struct todo_list
*todo_list
,
4536 struct replay_opts
*opts
)
4539 struct strbuf buf
= STRBUF_INIT
;
4541 if (strbuf_read_file_or_whine(&buf
, get_todo_path(opts
)) < 0)
4543 offset
= get_item_line_offset(todo_list
, todo_list
->current
+ 1);
4544 if (buf
.len
!= todo_list
->buf
.len
- offset
||
4545 memcmp(buf
.buf
, todo_list
->buf
.buf
+ offset
, buf
.len
)) {
4546 /* Reread the todo file if it has changed. */
4547 todo_list_release(todo_list
);
4548 if (read_populate_todo(r
, todo_list
, opts
))
4549 return -1; /* message was printed */
4550 /* `current` will be incremented on return */
4551 todo_list
->current
= -1;
4553 strbuf_release(&buf
);
4558 static const char rescheduled_advice
[] =
4559 N_("Could not execute the todo command\n"
4563 "It has been rescheduled; To edit the command before continuing, please\n"
4564 "edit the todo list first:\n"
4566 " git rebase --edit-todo\n"
4567 " git rebase --continue\n");
4569 static int pick_commits(struct repository
*r
,
4570 struct todo_list
*todo_list
,
4571 struct replay_opts
*opts
)
4573 int res
= 0, reschedule
= 0;
4574 char *prev_reflog_action
;
4576 /* Note that 0 for 3rd parameter of setenv means set only if not set */
4577 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
4578 prev_reflog_action
= xstrdup(getenv(GIT_REFLOG_ACTION
));
4580 assert(!(opts
->signoff
|| opts
->no_commit
||
4581 opts
->record_origin
|| should_edit(opts
) ||
4582 opts
->committer_date_is_author_date
||
4583 opts
->ignore_date
));
4584 if (read_and_refresh_cache(r
, opts
))
4587 while (todo_list
->current
< todo_list
->nr
) {
4588 struct todo_item
*item
= todo_list
->items
+ todo_list
->current
;
4589 const char *arg
= todo_item_get_arg(todo_list
, item
);
4592 if (save_todo(todo_list
, opts
))
4594 if (is_rebase_i(opts
)) {
4595 if (item
->command
!= TODO_COMMENT
) {
4596 FILE *f
= fopen(rebase_path_msgnum(), "w");
4598 todo_list
->done_nr
++;
4601 fprintf(f
, "%d\n", todo_list
->done_nr
);
4605 fprintf(stderr
, _("Rebasing (%d/%d)%s"),
4607 todo_list
->total_nr
,
4608 opts
->verbose
? "\n" : "\r");
4610 unlink(rebase_path_message());
4611 unlink(rebase_path_author_script());
4612 unlink(rebase_path_stopped_sha());
4613 unlink(rebase_path_amend());
4614 unlink(git_path_merge_head(r
));
4615 unlink(git_path_auto_merge(r
));
4616 delete_ref(NULL
, "REBASE_HEAD", NULL
, REF_NO_DEREF
);
4618 if (item
->command
== TODO_BREAK
) {
4621 return stopped_at_head(r
);
4624 if (item
->command
<= TODO_SQUASH
) {
4625 if (is_rebase_i(opts
))
4626 setenv(GIT_REFLOG_ACTION
, reflog_message(opts
,
4627 command_to_string(item
->command
), NULL
),
4629 res
= do_pick_commit(r
, item
, opts
,
4630 is_final_fixup(todo_list
),
4632 if (is_rebase_i(opts
))
4633 setenv(GIT_REFLOG_ACTION
, prev_reflog_action
, 1);
4634 if (is_rebase_i(opts
) && res
< 0) {
4636 advise(_(rescheduled_advice
),
4637 get_item_line_length(todo_list
,
4638 todo_list
->current
),
4639 get_item_line(todo_list
,
4640 todo_list
->current
));
4641 todo_list
->current
--;
4642 if (save_todo(todo_list
, opts
))
4645 if (item
->command
== TODO_EDIT
) {
4646 struct commit
*commit
= item
->commit
;
4651 _("Stopped at %s... %.*s\n"),
4652 short_commit_name(commit
),
4653 item
->arg_len
, arg
);
4655 return error_with_patch(r
, commit
,
4656 arg
, item
->arg_len
, opts
, res
, !res
);
4658 if (is_rebase_i(opts
) && !res
)
4659 record_in_rewritten(&item
->commit
->object
.oid
,
4660 peek_command(todo_list
, 1));
4661 if (res
&& is_fixup(item
->command
)) {
4664 return error_failed_squash(r
, item
->commit
, opts
,
4665 item
->arg_len
, arg
);
4666 } else if (res
&& is_rebase_i(opts
) && item
->commit
) {
4668 struct object_id oid
;
4671 * If we are rewording and have either
4672 * fast-forwarded already, or are about to
4673 * create a new root commit, we want to amend,
4674 * otherwise we do not.
4676 if (item
->command
== TODO_REWORD
&&
4677 !get_oid("HEAD", &oid
) &&
4678 (oideq(&item
->commit
->object
.oid
, &oid
) ||
4679 (opts
->have_squash_onto
&&
4680 oideq(&opts
->squash_onto
, &oid
))))
4683 return res
| error_with_patch(r
, item
->commit
,
4684 arg
, item
->arg_len
, opts
,
4687 } else if (item
->command
== TODO_EXEC
) {
4688 char *end_of_arg
= (char *)(arg
+ item
->arg_len
);
4689 int saved
= *end_of_arg
;
4694 res
= do_exec(r
, arg
);
4695 *end_of_arg
= saved
;
4698 if (opts
->reschedule_failed_exec
)
4702 } else if (item
->command
== TODO_LABEL
) {
4703 if ((res
= do_label(r
, arg
, item
->arg_len
)))
4705 } else if (item
->command
== TODO_RESET
) {
4706 if ((res
= do_reset(r
, arg
, item
->arg_len
, opts
)))
4708 } else if (item
->command
== TODO_MERGE
) {
4709 if ((res
= do_merge(r
, item
->commit
, arg
, item
->arg_len
,
4710 item
->flags
, &check_todo
, opts
)) < 0)
4712 else if (item
->commit
)
4713 record_in_rewritten(&item
->commit
->object
.oid
,
4714 peek_command(todo_list
, 1));
4716 /* failed with merge conflicts */
4717 return error_with_patch(r
, item
->commit
,
4720 } else if (item
->command
== TODO_UPDATE_REF
) {
4721 struct strbuf ref
= STRBUF_INIT
;
4722 strbuf_add(&ref
, arg
, item
->arg_len
);
4723 if ((res
= do_update_ref(r
, ref
.buf
)))
4725 strbuf_release(&ref
);
4726 } else if (!is_noop(item
->command
))
4727 return error(_("unknown command %d"), item
->command
);
4730 advise(_(rescheduled_advice
),
4731 get_item_line_length(todo_list
,
4732 todo_list
->current
),
4733 get_item_line(todo_list
, todo_list
->current
));
4734 todo_list
->current
--;
4735 if (save_todo(todo_list
, opts
))
4738 return error_with_patch(r
,
4742 } else if (is_rebase_i(opts
) && check_todo
&& !res
&&
4743 reread_todo_if_changed(r
, todo_list
, opts
)) {
4747 todo_list
->current
++;
4752 if (is_rebase_i(opts
)) {
4753 struct strbuf head_ref
= STRBUF_INIT
, buf
= STRBUF_INIT
;
4756 /* Stopped in the middle, as planned? */
4757 if (todo_list
->current
< todo_list
->nr
)
4760 if (read_oneliner(&head_ref
, rebase_path_head_name(), 0) &&
4761 starts_with(head_ref
.buf
, "refs/")) {
4763 struct object_id head
, orig
;
4766 if (get_oid("HEAD", &head
)) {
4767 res
= error(_("cannot read HEAD"));
4769 strbuf_release(&head_ref
);
4770 strbuf_release(&buf
);
4773 if (!read_oneliner(&buf
, rebase_path_orig_head(), 0) ||
4774 get_oid_hex(buf
.buf
, &orig
)) {
4775 res
= error(_("could not read orig-head"));
4776 goto cleanup_head_ref
;
4779 if (!read_oneliner(&buf
, rebase_path_onto(), 0)) {
4780 res
= error(_("could not read 'onto'"));
4781 goto cleanup_head_ref
;
4783 msg
= reflog_message(opts
, "finish", "%s onto %s",
4784 head_ref
.buf
, buf
.buf
);
4785 if (update_ref(msg
, head_ref
.buf
, &head
, &orig
,
4786 REF_NO_DEREF
, UPDATE_REFS_MSG_ON_ERR
)) {
4787 res
= error(_("could not update %s"),
4789 goto cleanup_head_ref
;
4791 msg
= reflog_message(opts
, "finish", "returning to %s",
4793 if (create_symref("HEAD", head_ref
.buf
, msg
)) {
4794 res
= error(_("could not update HEAD to %s"),
4796 goto cleanup_head_ref
;
4801 if (opts
->verbose
) {
4802 struct rev_info log_tree_opt
;
4803 struct object_id orig
, head
;
4805 memset(&log_tree_opt
, 0, sizeof(log_tree_opt
));
4806 repo_init_revisions(r
, &log_tree_opt
, NULL
);
4807 log_tree_opt
.diff
= 1;
4808 log_tree_opt
.diffopt
.output_format
=
4809 DIFF_FORMAT_DIFFSTAT
;
4810 log_tree_opt
.disable_stdin
= 1;
4812 if (read_oneliner(&buf
, rebase_path_orig_head(), 0) &&
4813 !get_oid(buf
.buf
, &orig
) &&
4814 !get_oid("HEAD", &head
)) {
4815 diff_tree_oid(&orig
, &head
, "",
4816 &log_tree_opt
.diffopt
);
4817 log_tree_diff_flush(&log_tree_opt
);
4819 release_revisions(&log_tree_opt
);
4821 flush_rewritten_pending();
4822 if (!stat(rebase_path_rewritten_list(), &st
) &&
4824 struct child_process child
= CHILD_PROCESS_INIT
;
4825 const char *post_rewrite_hook
=
4826 find_hook("post-rewrite");
4828 child
.in
= open(rebase_path_rewritten_list(), O_RDONLY
);
4830 strvec_push(&child
.args
, "notes");
4831 strvec_push(&child
.args
, "copy");
4832 strvec_push(&child
.args
, "--for-rewrite=rebase");
4833 /* we don't care if this copying failed */
4834 run_command(&child
);
4836 if (post_rewrite_hook
) {
4837 struct child_process hook
= CHILD_PROCESS_INIT
;
4839 hook
.in
= open(rebase_path_rewritten_list(),
4841 hook
.stdout_to_stderr
= 1;
4842 hook
.trace2_hook_name
= "post-rewrite";
4843 strvec_push(&hook
.args
, post_rewrite_hook
);
4844 strvec_push(&hook
.args
, "rebase");
4845 /* we don't care if this hook failed */
4849 apply_autostash(rebase_path_autostash());
4855 _("Successfully rebased and updated %s.\n"),
4859 strbuf_release(&buf
);
4860 strbuf_release(&head_ref
);
4862 if (do_update_refs(r
, opts
->quiet
))
4867 * Sequence of picks finished successfully; cleanup by
4868 * removing the .git/sequencer directory
4870 return sequencer_remove_state(opts
);
4873 static int continue_single_pick(struct repository
*r
, struct replay_opts
*opts
)
4875 struct strvec argv
= STRVEC_INIT
;
4878 if (!refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD") &&
4879 !refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD"))
4880 return error(_("no cherry-pick or revert in progress"));
4882 strvec_push(&argv
, "commit");
4885 * continue_single_pick() handles the case of recovering from a
4886 * conflict. should_edit() doesn't handle that case; for a conflict,
4887 * we want to edit if the user asked for it, or if they didn't specify
4888 * and stdin is a tty.
4890 if (!opts
->edit
|| (opts
->edit
< 0 && !isatty(0)))
4892 * Include --cleanup=strip as well because we don't want the
4893 * "# Conflicts:" messages.
4895 strvec_pushl(&argv
, "--no-edit", "--cleanup=strip", NULL
);
4897 ret
= run_command_v_opt(argv
.v
, RUN_GIT_CMD
);
4898 strvec_clear(&argv
);
4902 static int commit_staged_changes(struct repository
*r
,
4903 struct replay_opts
*opts
,
4904 struct todo_list
*todo_list
)
4906 unsigned int flags
= ALLOW_EMPTY
| EDIT_MSG
;
4907 unsigned int final_fixup
= 0, is_clean
;
4909 if (has_unstaged_changes(r
, 1))
4910 return error(_("cannot rebase: You have unstaged changes."));
4912 is_clean
= !has_uncommitted_changes(r
, 0);
4914 if (file_exists(rebase_path_amend())) {
4915 struct strbuf rev
= STRBUF_INIT
;
4916 struct object_id head
, to_amend
;
4918 if (get_oid("HEAD", &head
))
4919 return error(_("cannot amend non-existing commit"));
4920 if (!read_oneliner(&rev
, rebase_path_amend(), 0))
4921 return error(_("invalid file: '%s'"), rebase_path_amend());
4922 if (get_oid_hex(rev
.buf
, &to_amend
))
4923 return error(_("invalid contents: '%s'"),
4924 rebase_path_amend());
4925 if (!is_clean
&& !oideq(&head
, &to_amend
))
4926 return error(_("\nYou have uncommitted changes in your "
4927 "working tree. Please, commit them\n"
4928 "first and then run 'git rebase "
4929 "--continue' again."));
4931 * When skipping a failed fixup/squash, we need to edit the
4932 * commit message, the current fixup list and count, and if it
4933 * was the last fixup/squash in the chain, we need to clean up
4934 * the commit message and if there was a squash, let the user
4937 if (!is_clean
|| !opts
->current_fixup_count
)
4938 ; /* this is not the final fixup */
4939 else if (!oideq(&head
, &to_amend
) ||
4940 !file_exists(rebase_path_stopped_sha())) {
4941 /* was a final fixup or squash done manually? */
4942 if (!is_fixup(peek_command(todo_list
, 0))) {
4943 unlink(rebase_path_fixup_msg());
4944 unlink(rebase_path_squash_msg());
4945 unlink(rebase_path_current_fixups());
4946 strbuf_reset(&opts
->current_fixups
);
4947 opts
->current_fixup_count
= 0;
4950 /* we are in a fixup/squash chain */
4951 const char *p
= opts
->current_fixups
.buf
;
4952 int len
= opts
->current_fixups
.len
;
4954 opts
->current_fixup_count
--;
4956 BUG("Incorrect current_fixups:\n%s", p
);
4957 while (len
&& p
[len
- 1] != '\n')
4959 strbuf_setlen(&opts
->current_fixups
, len
);
4960 if (write_message(p
, len
, rebase_path_current_fixups(),
4962 return error(_("could not write file: '%s'"),
4963 rebase_path_current_fixups());
4966 * If a fixup/squash in a fixup/squash chain failed, the
4967 * commit message is already correct, no need to commit
4970 * Only if it is the final command in the fixup/squash
4971 * chain, and only if the chain is longer than a single
4972 * fixup/squash command (which was just skipped), do we
4973 * actually need to re-commit with a cleaned up commit
4976 if (opts
->current_fixup_count
> 0 &&
4977 !is_fixup(peek_command(todo_list
, 0))) {
4980 * If there was not a single "squash" in the
4981 * chain, we only need to clean up the commit
4982 * message, no need to bother the user with
4983 * opening the commit message in the editor.
4985 if (!starts_with(p
, "squash ") &&
4986 !strstr(p
, "\nsquash "))
4987 flags
= (flags
& ~EDIT_MSG
) | CLEANUP_MSG
;
4988 } else if (is_fixup(peek_command(todo_list
, 0))) {
4990 * We need to update the squash message to skip
4991 * the latest commit message.
4993 struct commit
*commit
;
4994 const char *path
= rebase_path_squash_msg();
4995 const char *encoding
= get_commit_output_encoding();
4997 if (parse_head(r
, &commit
) ||
4998 !(p
= logmsg_reencode(commit
, NULL
, encoding
)) ||
4999 write_message(p
, strlen(p
), path
, 0)) {
5000 unuse_commit_buffer(commit
, p
);
5001 return error(_("could not write file: "
5004 unuse_commit_buffer(commit
, p
);
5008 strbuf_release(&rev
);
5013 if (refs_ref_exists(get_main_ref_store(r
),
5014 "CHERRY_PICK_HEAD") &&
5015 refs_delete_ref(get_main_ref_store(r
), "",
5016 "CHERRY_PICK_HEAD", NULL
, 0))
5017 return error(_("could not remove CHERRY_PICK_HEAD"));
5018 if (unlink(git_path_merge_msg(r
)) && errno
!= ENOENT
)
5019 return error_errno(_("could not remove '%s'"),
5020 git_path_merge_msg(r
));
5025 if (run_git_commit(final_fixup
? NULL
: rebase_path_message(),
5027 return error(_("could not commit staged changes."));
5028 unlink(rebase_path_amend());
5029 unlink(git_path_merge_head(r
));
5030 unlink(git_path_auto_merge(r
));
5032 unlink(rebase_path_fixup_msg());
5033 unlink(rebase_path_squash_msg());
5035 if (opts
->current_fixup_count
> 0) {
5037 * Whether final fixup or not, we just cleaned up the commit
5040 unlink(rebase_path_current_fixups());
5041 strbuf_reset(&opts
->current_fixups
);
5042 opts
->current_fixup_count
= 0;
5047 int sequencer_continue(struct repository
*r
, struct replay_opts
*opts
)
5049 struct todo_list todo_list
= TODO_LIST_INIT
;
5052 if (read_and_refresh_cache(r
, opts
))
5055 if (read_populate_opts(opts
))
5057 if (is_rebase_i(opts
)) {
5058 if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
5059 goto release_todo_list
;
5061 if (file_exists(rebase_path_dropped())) {
5062 if ((res
= todo_list_check_against_backup(r
, &todo_list
)))
5063 goto release_todo_list
;
5065 unlink(rebase_path_dropped());
5068 if (commit_staged_changes(r
, opts
, &todo_list
)) {
5070 goto release_todo_list
;
5072 } else if (!file_exists(get_todo_path(opts
)))
5073 return continue_single_pick(r
, opts
);
5074 else if ((res
= read_populate_todo(r
, &todo_list
, opts
)))
5075 goto release_todo_list
;
5077 if (!is_rebase_i(opts
)) {
5078 /* Verify that the conflict has been resolved */
5079 if (refs_ref_exists(get_main_ref_store(r
),
5080 "CHERRY_PICK_HEAD") ||
5081 refs_ref_exists(get_main_ref_store(r
), "REVERT_HEAD")) {
5082 res
= continue_single_pick(r
, opts
);
5084 goto release_todo_list
;
5086 if (index_differs_from(r
, "HEAD", NULL
, 0)) {
5087 res
= error_dirty_index(r
, opts
);
5088 goto release_todo_list
;
5090 todo_list
.current
++;
5091 } else if (file_exists(rebase_path_stopped_sha())) {
5092 struct strbuf buf
= STRBUF_INIT
;
5093 struct object_id oid
;
5095 if (read_oneliner(&buf
, rebase_path_stopped_sha(),
5096 READ_ONELINER_SKIP_IF_EMPTY
) &&
5097 !get_oid_hex(buf
.buf
, &oid
))
5098 record_in_rewritten(&oid
, peek_command(&todo_list
, 0));
5099 strbuf_release(&buf
);
5102 res
= pick_commits(r
, &todo_list
, opts
);
5104 todo_list_release(&todo_list
);
5108 static int single_pick(struct repository
*r
,
5109 struct commit
*cmit
,
5110 struct replay_opts
*opts
)
5113 struct todo_item item
;
5115 item
.command
= opts
->action
== REPLAY_PICK
?
5116 TODO_PICK
: TODO_REVERT
;
5119 setenv(GIT_REFLOG_ACTION
, action_name(opts
), 0);
5120 return do_pick_commit(r
, &item
, opts
, 0, &check_todo
);
5123 int sequencer_pick_revisions(struct repository
*r
,
5124 struct replay_opts
*opts
)
5126 struct todo_list todo_list
= TODO_LIST_INIT
;
5127 struct object_id oid
;
5131 if (read_and_refresh_cache(r
, opts
))
5134 for (i
= 0; i
< opts
->revs
->pending
.nr
; i
++) {
5135 struct object_id oid
;
5136 const char *name
= opts
->revs
->pending
.objects
[i
].name
;
5138 /* This happens when using --stdin. */
5142 if (!get_oid(name
, &oid
)) {
5143 if (!lookup_commit_reference_gently(r
, &oid
, 1)) {
5144 enum object_type type
= oid_object_info(r
,
5147 return error(_("%s: can't cherry-pick a %s"),
5148 name
, type_name(type
));
5151 return error(_("%s: bad revision"), name
);
5155 * If we were called as "git cherry-pick <commit>", just
5156 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
5157 * REVERT_HEAD, and don't touch the sequencer state.
5158 * This means it is possible to cherry-pick in the middle
5159 * of a cherry-pick sequence.
5161 if (opts
->revs
->cmdline
.nr
== 1 &&
5162 opts
->revs
->cmdline
.rev
->whence
== REV_CMD_REV
&&
5163 opts
->revs
->no_walk
&&
5164 !opts
->revs
->cmdline
.rev
->flags
) {
5165 struct commit
*cmit
;
5166 if (prepare_revision_walk(opts
->revs
))
5167 return error(_("revision walk setup failed"));
5168 cmit
= get_revision(opts
->revs
);
5170 return error(_("empty commit set passed"));
5171 if (get_revision(opts
->revs
))
5172 BUG("unexpected extra commit from walk");
5173 return single_pick(r
, cmit
, opts
);
5177 * Start a new cherry-pick/ revert sequence; but
5178 * first, make sure that an existing one isn't in
5182 if (walk_revs_populate_todo(&todo_list
, opts
) ||
5183 create_seq_dir(r
) < 0)
5185 if (get_oid("HEAD", &oid
) && (opts
->action
== REPLAY_REVERT
))
5186 return error(_("can't revert as initial commit"));
5187 if (save_head(oid_to_hex(&oid
)))
5189 if (save_opts(opts
))
5191 update_abort_safety_file();
5192 res
= pick_commits(r
, &todo_list
, opts
);
5193 todo_list_release(&todo_list
);
5197 void append_signoff(struct strbuf
*msgbuf
, size_t ignore_footer
, unsigned flag
)
5199 unsigned no_dup_sob
= flag
& APPEND_SIGNOFF_DEDUP
;
5200 struct strbuf sob
= STRBUF_INIT
;
5203 strbuf_addstr(&sob
, sign_off_header
);
5204 strbuf_addstr(&sob
, fmt_name(WANT_COMMITTER_IDENT
));
5205 strbuf_addch(&sob
, '\n');
5208 strbuf_complete_line(msgbuf
);
5211 * If the whole message buffer is equal to the sob, pretend that we
5212 * found a conforming footer with a matching sob
5214 if (msgbuf
->len
- ignore_footer
== sob
.len
&&
5215 !strncmp(msgbuf
->buf
, sob
.buf
, sob
.len
))
5218 has_footer
= has_conforming_footer(msgbuf
, &sob
, ignore_footer
);
5221 const char *append_newlines
= NULL
;
5222 size_t len
= msgbuf
->len
- ignore_footer
;
5226 * The buffer is completely empty. Leave foom for
5227 * the title and body to be filled in by the user.
5229 append_newlines
= "\n\n";
5230 } else if (len
== 1) {
5232 * Buffer contains a single newline. Add another
5233 * so that we leave room for the title and body.
5235 append_newlines
= "\n";
5236 } else if (msgbuf
->buf
[len
- 2] != '\n') {
5238 * Buffer ends with a single newline. Add another
5239 * so that there is an empty line between the message
5242 append_newlines
= "\n";
5243 } /* else, the buffer already ends with two newlines. */
5245 if (append_newlines
)
5246 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
5247 append_newlines
, strlen(append_newlines
));
5250 if (has_footer
!= 3 && (!no_dup_sob
|| has_footer
!= 2))
5251 strbuf_splice(msgbuf
, msgbuf
->len
- ignore_footer
, 0,
5254 strbuf_release(&sob
);
5257 struct labels_entry
{
5258 struct hashmap_entry entry
;
5259 char label
[FLEX_ARRAY
];
5262 static int labels_cmp(const void *fndata UNUSED
,
5263 const struct hashmap_entry
*eptr
,
5264 const struct hashmap_entry
*entry_or_key
, const void *key
)
5266 const struct labels_entry
*a
, *b
;
5268 a
= container_of(eptr
, const struct labels_entry
, entry
);
5269 b
= container_of(entry_or_key
, const struct labels_entry
, entry
);
5271 return key
? strcmp(a
->label
, key
) : strcmp(a
->label
, b
->label
);
5274 struct string_entry
{
5275 struct oidmap_entry entry
;
5276 char string
[FLEX_ARRAY
];
5279 struct label_state
{
5280 struct oidmap commit2label
;
5281 struct hashmap labels
;
5285 static const char *label_oid(struct object_id
*oid
, const char *label
,
5286 struct label_state
*state
)
5288 struct labels_entry
*labels_entry
;
5289 struct string_entry
*string_entry
;
5290 struct object_id dummy
;
5293 string_entry
= oidmap_get(&state
->commit2label
, oid
);
5295 return string_entry
->string
;
5298 * For "uninteresting" commits, i.e. commits that are not to be
5299 * rebased, and which can therefore not be labeled, we use a unique
5300 * abbreviation of the commit name. This is slightly more complicated
5301 * than calling find_unique_abbrev() because we also need to make
5302 * sure that the abbreviation does not conflict with any other
5305 * We disallow "interesting" commits to be labeled by a string that
5306 * is a valid full-length hash, to ensure that we always can find an
5307 * abbreviation for any uninteresting commit's names that does not
5308 * clash with any other label.
5310 strbuf_reset(&state
->buf
);
5314 strbuf_grow(&state
->buf
, GIT_MAX_HEXSZ
);
5315 label
= p
= state
->buf
.buf
;
5317 find_unique_abbrev_r(p
, oid
, default_abbrev
);
5320 * We may need to extend the abbreviated hash so that there is
5321 * no conflicting label.
5323 if (hashmap_get_from_hash(&state
->labels
, strihash(p
), p
)) {
5324 size_t i
= strlen(p
) + 1;
5326 oid_to_hex_r(p
, oid
);
5327 for (; i
< the_hash_algo
->hexsz
; i
++) {
5330 if (!hashmap_get_from_hash(&state
->labels
,
5337 struct strbuf
*buf
= &state
->buf
;
5340 * Sanitize labels by replacing non-alpha-numeric characters
5341 * (including white-space ones) by dashes, as they might be
5342 * illegal in file names (and hence in ref names).
5344 * Note that we retain non-ASCII UTF-8 characters (identified
5345 * via the most significant bit). They should be all acceptable
5346 * in file names. We do not validate the UTF-8 here, that's not
5347 * the job of this function.
5349 for (; *label
; label
++)
5350 if ((*label
& 0x80) || isalnum(*label
))
5351 strbuf_addch(buf
, *label
);
5352 /* avoid leading dash and double-dashes */
5353 else if (buf
->len
&& buf
->buf
[buf
->len
- 1] != '-')
5354 strbuf_addch(buf
, '-');
5356 strbuf_addstr(buf
, "rev-");
5357 strbuf_add_unique_abbrev(buf
, oid
, default_abbrev
);
5361 if ((buf
->len
== the_hash_algo
->hexsz
&&
5362 !get_oid_hex(label
, &dummy
)) ||
5363 (buf
->len
== 1 && *label
== '#') ||
5364 hashmap_get_from_hash(&state
->labels
,
5365 strihash(label
), label
)) {
5367 * If the label already exists, or if the label is a
5368 * valid full OID, or the label is a '#' (which we use
5369 * as a separator between merge heads and oneline), we
5370 * append a dash and a number to make it unique.
5372 size_t len
= buf
->len
;
5374 for (i
= 2; ; i
++) {
5375 strbuf_setlen(buf
, len
);
5376 strbuf_addf(buf
, "-%d", i
);
5377 if (!hashmap_get_from_hash(&state
->labels
,
5387 FLEX_ALLOC_STR(labels_entry
, label
, label
);
5388 hashmap_entry_init(&labels_entry
->entry
, strihash(label
));
5389 hashmap_add(&state
->labels
, &labels_entry
->entry
);
5391 FLEX_ALLOC_STR(string_entry
, string
, label
);
5392 oidcpy(&string_entry
->entry
.oid
, oid
);
5393 oidmap_put(&state
->commit2label
, string_entry
);
5395 return string_entry
->string
;
5398 static int make_script_with_merges(struct pretty_print_context
*pp
,
5399 struct rev_info
*revs
, struct strbuf
*out
,
5402 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5403 int rebase_cousins
= flags
& TODO_LIST_REBASE_COUSINS
;
5404 int root_with_onto
= flags
& TODO_LIST_ROOT_WITH_ONTO
;
5405 int skipped_commit
= 0;
5406 struct strbuf buf
= STRBUF_INIT
, oneline
= STRBUF_INIT
;
5407 struct strbuf label
= STRBUF_INIT
;
5408 struct commit_list
*commits
= NULL
, **tail
= &commits
, *iter
;
5409 struct commit_list
*tips
= NULL
, **tips_tail
= &tips
;
5410 struct commit
*commit
;
5411 struct oidmap commit2todo
= OIDMAP_INIT
;
5412 struct string_entry
*entry
;
5413 struct oidset interesting
= OIDSET_INIT
, child_seen
= OIDSET_INIT
,
5414 shown
= OIDSET_INIT
;
5415 struct label_state state
= { OIDMAP_INIT
, { NULL
}, STRBUF_INIT
};
5417 int abbr
= flags
& TODO_LIST_ABBREVIATE_CMDS
;
5418 const char *cmd_pick
= abbr
? "p" : "pick",
5419 *cmd_label
= abbr
? "l" : "label",
5420 *cmd_reset
= abbr
? "t" : "reset",
5421 *cmd_merge
= abbr
? "m" : "merge";
5423 oidmap_init(&commit2todo
, 0);
5424 oidmap_init(&state
.commit2label
, 0);
5425 hashmap_init(&state
.labels
, labels_cmp
, NULL
, 0);
5426 strbuf_init(&state
.buf
, 32);
5428 if (revs
->cmdline
.nr
&& (revs
->cmdline
.rev
[0].flags
& BOTTOM
)) {
5429 struct labels_entry
*onto_label_entry
;
5430 struct object_id
*oid
= &revs
->cmdline
.rev
[0].item
->oid
;
5431 FLEX_ALLOC_STR(entry
, string
, "onto");
5432 oidcpy(&entry
->entry
.oid
, oid
);
5433 oidmap_put(&state
.commit2label
, entry
);
5435 FLEX_ALLOC_STR(onto_label_entry
, label
, "onto");
5436 hashmap_entry_init(&onto_label_entry
->entry
, strihash("onto"));
5437 hashmap_add(&state
.labels
, &onto_label_entry
->entry
);
5442 * - get onelines for all commits
5443 * - gather all branch tips (i.e. 2nd or later parents of merges)
5444 * - label all branch tips
5446 while ((commit
= get_revision(revs
))) {
5447 struct commit_list
*to_merge
;
5448 const char *p1
, *p2
;
5449 struct object_id
*oid
;
5452 tail
= &commit_list_insert(commit
, tail
)->next
;
5453 oidset_insert(&interesting
, &commit
->object
.oid
);
5455 is_empty
= is_original_commit_empty(commit
);
5456 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5457 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5458 warning(_("skipped previously applied commit %s"),
5459 short_commit_name(commit
));
5463 if (is_empty
&& !keep_empty
)
5466 strbuf_reset(&oneline
);
5467 pretty_print_commit(pp
, commit
, &oneline
);
5469 to_merge
= commit
->parents
? commit
->parents
->next
: NULL
;
5471 /* non-merge commit: easy case */
5473 strbuf_addf(&buf
, "%s %s %s", cmd_pick
,
5474 oid_to_hex(&commit
->object
.oid
),
5477 strbuf_addf(&buf
, " %c empty",
5480 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5481 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5482 oidmap_put(&commit2todo
, entry
);
5487 /* Create a label */
5488 strbuf_reset(&label
);
5489 if (skip_prefix(oneline
.buf
, "Merge ", &p1
) &&
5490 (p1
= strchr(p1
, '\'')) &&
5491 (p2
= strchr(++p1
, '\'')))
5492 strbuf_add(&label
, p1
, p2
- p1
);
5493 else if (skip_prefix(oneline
.buf
, "Merge pull request ",
5495 (p1
= strstr(p1
, " from ")))
5496 strbuf_addstr(&label
, p1
+ strlen(" from "));
5498 strbuf_addbuf(&label
, &oneline
);
5501 strbuf_addf(&buf
, "%s -C %s",
5502 cmd_merge
, oid_to_hex(&commit
->object
.oid
));
5504 /* label the tips of merged branches */
5505 for (; to_merge
; to_merge
= to_merge
->next
) {
5506 oid
= &to_merge
->item
->object
.oid
;
5507 strbuf_addch(&buf
, ' ');
5509 if (!oidset_contains(&interesting
, oid
)) {
5510 strbuf_addstr(&buf
, label_oid(oid
, NULL
,
5515 tips_tail
= &commit_list_insert(to_merge
->item
,
5518 strbuf_addstr(&buf
, label_oid(oid
, label
.buf
, &state
));
5520 strbuf_addf(&buf
, " # %s", oneline
.buf
);
5522 FLEX_ALLOC_STR(entry
, string
, buf
.buf
);
5523 oidcpy(&entry
->entry
.oid
, &commit
->object
.oid
);
5524 oidmap_put(&commit2todo
, entry
);
5527 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5528 _("use --reapply-cherry-picks to include skipped commits"));
5532 * - label branch points
5533 * - add HEAD to the branch tips
5535 for (iter
= commits
; iter
; iter
= iter
->next
) {
5536 struct commit_list
*parent
= iter
->item
->parents
;
5537 for (; parent
; parent
= parent
->next
) {
5538 struct object_id
*oid
= &parent
->item
->object
.oid
;
5539 if (!oidset_contains(&interesting
, oid
))
5541 if (oidset_insert(&child_seen
, oid
))
5542 label_oid(oid
, "branch-point", &state
);
5545 /* Add HEAD as implicit "tip of branch" */
5547 tips_tail
= &commit_list_insert(iter
->item
,
5552 * Third phase: output the todo list. This is a bit tricky, as we
5553 * want to avoid jumping back and forth between revisions. To
5554 * accomplish that goal, we walk backwards from the branch tips,
5555 * gathering commits not yet shown, reversing the list on the fly,
5556 * then outputting that list (labeling revisions as needed).
5558 strbuf_addf(out
, "%s onto\n", cmd_label
);
5559 for (iter
= tips
; iter
; iter
= iter
->next
) {
5560 struct commit_list
*list
= NULL
, *iter2
;
5562 commit
= iter
->item
;
5563 if (oidset_contains(&shown
, &commit
->object
.oid
))
5565 entry
= oidmap_get(&state
.commit2label
, &commit
->object
.oid
);
5568 strbuf_addf(out
, "\n%c Branch %s\n", comment_line_char
, entry
->string
);
5570 strbuf_addch(out
, '\n');
5572 while (oidset_contains(&interesting
, &commit
->object
.oid
) &&
5573 !oidset_contains(&shown
, &commit
->object
.oid
)) {
5574 commit_list_insert(commit
, &list
);
5575 if (!commit
->parents
) {
5579 commit
= commit
->parents
->item
;
5583 strbuf_addf(out
, "%s %s\n", cmd_reset
,
5584 rebase_cousins
|| root_with_onto
?
5585 "onto" : "[new root]");
5587 const char *to
= NULL
;
5589 entry
= oidmap_get(&state
.commit2label
,
5590 &commit
->object
.oid
);
5593 else if (!rebase_cousins
)
5594 to
= label_oid(&commit
->object
.oid
, NULL
,
5597 if (!to
|| !strcmp(to
, "onto"))
5598 strbuf_addf(out
, "%s onto\n", cmd_reset
);
5600 strbuf_reset(&oneline
);
5601 pretty_print_commit(pp
, commit
, &oneline
);
5602 strbuf_addf(out
, "%s %s # %s\n",
5603 cmd_reset
, to
, oneline
.buf
);
5607 for (iter2
= list
; iter2
; iter2
= iter2
->next
) {
5608 struct object_id
*oid
= &iter2
->item
->object
.oid
;
5609 entry
= oidmap_get(&commit2todo
, oid
);
5610 /* only show if not already upstream */
5612 strbuf_addf(out
, "%s\n", entry
->string
);
5613 entry
= oidmap_get(&state
.commit2label
, oid
);
5615 strbuf_addf(out
, "%s %s\n",
5616 cmd_label
, entry
->string
);
5617 oidset_insert(&shown
, oid
);
5620 free_commit_list(list
);
5623 free_commit_list(commits
);
5624 free_commit_list(tips
);
5626 strbuf_release(&label
);
5627 strbuf_release(&oneline
);
5628 strbuf_release(&buf
);
5630 oidmap_free(&commit2todo
, 1);
5631 oidmap_free(&state
.commit2label
, 1);
5632 hashmap_clear_and_free(&state
.labels
, struct labels_entry
, entry
);
5633 strbuf_release(&state
.buf
);
5638 int sequencer_make_script(struct repository
*r
, struct strbuf
*out
, int argc
,
5639 const char **argv
, unsigned flags
)
5641 char *format
= NULL
;
5642 struct pretty_print_context pp
= {0};
5643 struct rev_info revs
;
5644 struct commit
*commit
;
5645 int keep_empty
= flags
& TODO_LIST_KEEP_EMPTY
;
5646 const char *insn
= flags
& TODO_LIST_ABBREVIATE_CMDS
? "p" : "pick";
5647 int rebase_merges
= flags
& TODO_LIST_REBASE_MERGES
;
5648 int reapply_cherry_picks
= flags
& TODO_LIST_REAPPLY_CHERRY_PICKS
;
5649 int skipped_commit
= 0;
5652 repo_init_revisions(r
, &revs
, NULL
);
5653 revs
.verbose_header
= 1;
5655 revs
.max_parents
= 1;
5656 revs
.cherry_mark
= !reapply_cherry_picks
;
5659 revs
.right_only
= 1;
5660 revs
.sort_order
= REV_SORT_IN_GRAPH_ORDER
;
5661 revs
.topo_order
= 1;
5663 revs
.pretty_given
= 1;
5664 git_config_get_string("rebase.instructionFormat", &format
);
5665 if (!format
|| !*format
) {
5667 format
= xstrdup("%s");
5669 get_commit_format(format
, &revs
);
5671 pp
.fmt
= revs
.commit_format
;
5672 pp
.output_encoding
= get_log_output_encoding();
5674 if (setup_revisions(argc
, argv
, &revs
, NULL
) > 1) {
5675 ret
= error(_("make_script: unhandled options"));
5679 if (prepare_revision_walk(&revs
) < 0) {
5680 ret
= error(_("make_script: error preparing revisions"));
5684 if (rebase_merges
) {
5685 ret
= make_script_with_merges(&pp
, &revs
, out
, flags
);
5689 while ((commit
= get_revision(&revs
))) {
5690 int is_empty
= is_original_commit_empty(commit
);
5692 if (!is_empty
&& (commit
->object
.flags
& PATCHSAME
)) {
5693 if (flags
& TODO_LIST_WARN_SKIPPED_CHERRY_PICKS
)
5694 warning(_("skipped previously applied commit %s"),
5695 short_commit_name(commit
));
5699 if (is_empty
&& !keep_empty
)
5701 strbuf_addf(out
, "%s %s ", insn
,
5702 oid_to_hex(&commit
->object
.oid
));
5703 pretty_print_commit(&pp
, commit
, out
);
5705 strbuf_addf(out
, " %c empty", comment_line_char
);
5706 strbuf_addch(out
, '\n');
5709 advise_if_enabled(ADVICE_SKIPPED_CHERRY_PICKS
,
5710 _("use --reapply-cherry-picks to include skipped commits"));
5712 release_revisions(&revs
);
5717 * Add commands after pick and (series of) squash/fixup commands
5720 static void todo_list_add_exec_commands(struct todo_list
*todo_list
,
5721 struct string_list
*commands
)
5723 struct strbuf
*buf
= &todo_list
->buf
;
5724 size_t base_offset
= buf
->len
;
5725 int i
, insert
, nr
= 0, alloc
= 0;
5726 struct todo_item
*items
= NULL
, *base_items
= NULL
;
5728 CALLOC_ARRAY(base_items
, commands
->nr
);
5729 for (i
= 0; i
< commands
->nr
; i
++) {
5730 size_t command_len
= strlen(commands
->items
[i
].string
);
5732 strbuf_addstr(buf
, commands
->items
[i
].string
);
5733 strbuf_addch(buf
, '\n');
5735 base_items
[i
].command
= TODO_EXEC
;
5736 base_items
[i
].offset_in_buf
= base_offset
;
5737 base_items
[i
].arg_offset
= base_offset
+ strlen("exec ");
5738 base_items
[i
].arg_len
= command_len
- strlen("exec ");
5740 base_offset
+= command_len
+ 1;
5744 * Insert <commands> after every pick. Here, fixup/squash chains
5745 * are considered part of the pick, so we insert the commands *after*
5746 * those chains if there are any.
5748 * As we insert the exec commands immediately after rearranging
5749 * any fixups and before the user edits the list, a fixup chain
5750 * can never contain comments (any comments are empty picks that
5751 * have been commented out because the user did not specify
5752 * --keep-empty). So, it is safe to insert an exec command
5753 * without looking at the command following a comment.
5756 for (i
= 0; i
< todo_list
->nr
; i
++) {
5757 enum todo_command command
= todo_list
->items
[i
].command
;
5758 if (insert
&& !is_fixup(command
)) {
5759 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5760 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5766 ALLOC_GROW(items
, nr
+ 1, alloc
);
5767 items
[nr
++] = todo_list
->items
[i
];
5769 if (command
== TODO_PICK
|| command
== TODO_MERGE
)
5773 /* insert or append final <commands> */
5775 ALLOC_GROW(items
, nr
+ commands
->nr
, alloc
);
5776 COPY_ARRAY(items
+ nr
, base_items
, commands
->nr
);
5781 FREE_AND_NULL(todo_list
->items
);
5782 todo_list
->items
= items
;
5784 todo_list
->alloc
= alloc
;
5787 static void todo_list_to_strbuf(struct repository
*r
, struct todo_list
*todo_list
,
5788 struct strbuf
*buf
, int num
, unsigned flags
)
5790 struct todo_item
*item
;
5791 int i
, max
= todo_list
->nr
;
5793 if (num
> 0 && num
< max
)
5796 for (item
= todo_list
->items
, i
= 0; i
< max
; i
++, item
++) {
5799 /* if the item is not a command write it and continue */
5800 if (item
->command
>= TODO_COMMENT
) {
5801 strbuf_addf(buf
, "%.*s\n", item
->arg_len
,
5802 todo_item_get_arg(todo_list
, item
));
5806 /* add command to the buffer */
5807 cmd
= command_to_char(item
->command
);
5808 if ((flags
& TODO_LIST_ABBREVIATE_CMDS
) && cmd
)
5809 strbuf_addch(buf
, cmd
);
5811 strbuf_addstr(buf
, command_to_string(item
->command
));
5815 const char *oid
= flags
& TODO_LIST_SHORTEN_IDS
?
5816 short_commit_name(item
->commit
) :
5817 oid_to_hex(&item
->commit
->object
.oid
);
5819 if (item
->command
== TODO_FIXUP
) {
5820 if (item
->flags
& TODO_EDIT_FIXUP_MSG
)
5821 strbuf_addstr(buf
, " -c");
5822 else if (item
->flags
& TODO_REPLACE_FIXUP_MSG
) {
5823 strbuf_addstr(buf
, " -C");
5827 if (item
->command
== TODO_MERGE
) {
5828 if (item
->flags
& TODO_EDIT_MERGE_MSG
)
5829 strbuf_addstr(buf
, " -c");
5831 strbuf_addstr(buf
, " -C");
5834 strbuf_addf(buf
, " %s", oid
);
5837 /* add all the rest */
5839 strbuf_addch(buf
, '\n');
5841 strbuf_addf(buf
, " %.*s\n", item
->arg_len
,
5842 todo_item_get_arg(todo_list
, item
));
5846 int todo_list_write_to_file(struct repository
*r
, struct todo_list
*todo_list
,
5847 const char *file
, const char *shortrevisions
,
5848 const char *shortonto
, int num
, unsigned flags
)
5851 struct strbuf buf
= STRBUF_INIT
;
5853 todo_list_to_strbuf(r
, todo_list
, &buf
, num
, flags
);
5854 if (flags
& TODO_LIST_APPEND_TODO_HELP
)
5855 append_todo_help(count_commands(todo_list
),
5856 shortrevisions
, shortonto
, &buf
);
5858 res
= write_message(buf
.buf
, buf
.len
, file
, 0);
5859 strbuf_release(&buf
);
5864 /* skip picking commits whose parents are unchanged */
5865 static int skip_unnecessary_picks(struct repository
*r
,
5866 struct todo_list
*todo_list
,
5867 struct object_id
*base_oid
)
5869 struct object_id
*parent_oid
;
5872 for (i
= 0; i
< todo_list
->nr
; i
++) {
5873 struct todo_item
*item
= todo_list
->items
+ i
;
5875 if (item
->command
>= TODO_NOOP
)
5877 if (item
->command
!= TODO_PICK
)
5879 if (parse_commit(item
->commit
)) {
5880 return error(_("could not parse commit '%s'"),
5881 oid_to_hex(&item
->commit
->object
.oid
));
5883 if (!item
->commit
->parents
)
5884 break; /* root commit */
5885 if (item
->commit
->parents
->next
)
5886 break; /* merge commit */
5887 parent_oid
= &item
->commit
->parents
->item
->object
.oid
;
5888 if (!oideq(parent_oid
, base_oid
))
5890 oidcpy(base_oid
, &item
->commit
->object
.oid
);
5893 const char *done_path
= rebase_path_done();
5895 if (todo_list_write_to_file(r
, todo_list
, done_path
, NULL
, NULL
, i
, 0)) {
5896 error_errno(_("could not write to '%s'"), done_path
);
5900 MOVE_ARRAY(todo_list
->items
, todo_list
->items
+ i
, todo_list
->nr
- i
);
5902 todo_list
->current
= 0;
5903 todo_list
->done_nr
+= i
;
5905 if (is_fixup(peek_command(todo_list
, 0)))
5906 record_in_rewritten(base_oid
, peek_command(todo_list
, 0));
5912 struct todo_add_branch_context
{
5913 struct todo_item
*items
;
5917 struct commit
*commit
;
5918 struct string_list refs_to_oids
;
5921 static int add_decorations_to_list(const struct commit
*commit
,
5922 struct todo_add_branch_context
*ctx
)
5924 const struct name_decoration
*decoration
= get_name_decoration(&commit
->object
);
5925 const char *head_ref
= resolve_ref_unsafe("HEAD",
5926 RESOLVE_REF_READING
,
5930 while (decoration
) {
5931 struct todo_item
*item
;
5933 size_t base_offset
= ctx
->buf
->len
;
5936 * If the branch is the current HEAD, then it will be
5937 * updated by the default rebase behavior.
5939 if (head_ref
&& !strcmp(head_ref
, decoration
->name
)) {
5940 decoration
= decoration
->next
;
5944 ALLOC_GROW(ctx
->items
,
5947 item
= &ctx
->items
[ctx
->items_nr
];
5948 memset(item
, 0, sizeof(*item
));
5950 /* If the branch is checked out, then leave a comment instead. */
5951 if ((path
= branch_checked_out(decoration
->name
))) {
5952 item
->command
= TODO_COMMENT
;
5953 strbuf_addf(ctx
->buf
, "# Ref %s checked out at '%s'\n",
5954 decoration
->name
, path
);
5956 struct string_list_item
*sti
;
5957 item
->command
= TODO_UPDATE_REF
;
5958 strbuf_addf(ctx
->buf
, "%s\n", decoration
->name
);
5960 sti
= string_list_insert(&ctx
->refs_to_oids
,
5962 sti
->util
= init_update_ref_record(decoration
->name
);
5965 item
->offset_in_buf
= base_offset
;
5966 item
->arg_offset
= base_offset
;
5967 item
->arg_len
= ctx
->buf
->len
- base_offset
;
5970 decoration
= decoration
->next
;
5977 * For each 'pick' command, find out if the commit has a decoration in
5978 * refs/heads/. If so, then add a 'label for-update-refs/' command.
5980 static int todo_list_add_update_ref_commands(struct todo_list
*todo_list
)
5983 static struct string_list decorate_refs_exclude
= STRING_LIST_INIT_NODUP
;
5984 static struct string_list decorate_refs_exclude_config
= STRING_LIST_INIT_NODUP
;
5985 static struct string_list decorate_refs_include
= STRING_LIST_INIT_NODUP
;
5986 struct decoration_filter decoration_filter
= {
5987 .include_ref_pattern
= &decorate_refs_include
,
5988 .exclude_ref_pattern
= &decorate_refs_exclude
,
5989 .exclude_ref_config_pattern
= &decorate_refs_exclude_config
,
5991 struct todo_add_branch_context ctx
= {
5992 .buf
= &todo_list
->buf
,
5993 .refs_to_oids
= STRING_LIST_INIT_DUP
,
5996 ctx
.items_alloc
= 2 * todo_list
->nr
+ 1;
5997 ALLOC_ARRAY(ctx
.items
, ctx
.items_alloc
);
5999 string_list_append(&decorate_refs_include
, "refs/heads/");
6000 load_ref_decorations(&decoration_filter
, 0);
6002 for (i
= 0; i
< todo_list
->nr
; ) {
6003 struct todo_item
*item
= &todo_list
->items
[i
];
6005 /* insert ith item into new list */
6006 ALLOC_GROW(ctx
.items
,
6010 ctx
.items
[ctx
.items_nr
++] = todo_list
->items
[i
++];
6013 ctx
.commit
= item
->commit
;
6014 add_decorations_to_list(item
->commit
, &ctx
);
6018 res
= write_update_refs_state(&ctx
.refs_to_oids
);
6020 string_list_clear(&ctx
.refs_to_oids
, 1);
6023 /* we failed, so clean up the new list. */
6028 free(todo_list
->items
);
6029 todo_list
->items
= ctx
.items
;
6030 todo_list
->nr
= ctx
.items_nr
;
6031 todo_list
->alloc
= ctx
.items_alloc
;
6036 int complete_action(struct repository
*r
, struct replay_opts
*opts
, unsigned flags
,
6037 const char *shortrevisions
, const char *onto_name
,
6038 struct commit
*onto
, const struct object_id
*orig_head
,
6039 struct string_list
*commands
, unsigned autosquash
,
6040 unsigned update_refs
,
6041 struct todo_list
*todo_list
)
6043 char shortonto
[GIT_MAX_HEXSZ
+ 1];
6044 const char *todo_file
= rebase_path_todo();
6045 struct todo_list new_todo
= TODO_LIST_INIT
;
6046 struct strbuf
*buf
= &todo_list
->buf
, buf2
= STRBUF_INIT
;
6047 struct object_id oid
= onto
->object
.oid
;
6050 find_unique_abbrev_r(shortonto
, &oid
, DEFAULT_ABBREV
);
6052 if (buf
->len
== 0) {
6053 struct todo_item
*item
= append_new_todo(todo_list
);
6054 item
->command
= TODO_NOOP
;
6055 item
->commit
= NULL
;
6056 item
->arg_len
= item
->arg_offset
= item
->flags
= item
->offset_in_buf
= 0;
6059 if (update_refs
&& todo_list_add_update_ref_commands(todo_list
))
6062 if (autosquash
&& todo_list_rearrange_squash(todo_list
))
6066 todo_list_add_exec_commands(todo_list
, commands
);
6068 if (count_commands(todo_list
) == 0) {
6069 apply_autostash(rebase_path_autostash());
6070 sequencer_remove_state(opts
);
6072 return error(_("nothing to do"));
6075 res
= edit_todo_list(r
, todo_list
, &new_todo
, shortrevisions
,
6079 else if (res
== -2) {
6080 apply_autostash(rebase_path_autostash());
6081 sequencer_remove_state(opts
);
6084 } else if (res
== -3) {
6085 apply_autostash(rebase_path_autostash());
6086 sequencer_remove_state(opts
);
6087 todo_list_release(&new_todo
);
6089 return error(_("nothing to do"));
6090 } else if (res
== -4) {
6091 checkout_onto(r
, opts
, onto_name
, &onto
->object
.oid
, orig_head
);
6092 todo_list_release(&new_todo
);
6097 /* Expand the commit IDs */
6098 todo_list_to_strbuf(r
, &new_todo
, &buf2
, -1, 0);
6099 strbuf_swap(&new_todo
.buf
, &buf2
);
6100 strbuf_release(&buf2
);
6101 /* Nothing is done yet, and we're reparsing, so let's reset the count */
6102 new_todo
.total_nr
= 0;
6103 if (todo_list_parse_insn_buffer(r
, new_todo
.buf
.buf
, &new_todo
) < 0)
6104 BUG("invalid todo list after expanding IDs:\n%s",
6107 if (opts
->allow_ff
&& skip_unnecessary_picks(r
, &new_todo
, &oid
)) {
6108 todo_list_release(&new_todo
);
6109 return error(_("could not skip unnecessary pick commands"));
6112 if (todo_list_write_to_file(r
, &new_todo
, todo_file
, NULL
, NULL
, -1,
6113 flags
& ~(TODO_LIST_SHORTEN_IDS
))) {
6114 todo_list_release(&new_todo
);
6115 return error_errno(_("could not write '%s'"), todo_file
);
6120 if (checkout_onto(r
, opts
, onto_name
, &oid
, orig_head
))
6123 if (require_clean_work_tree(r
, "rebase", "", 1, 1))
6126 todo_list_write_total_nr(&new_todo
);
6127 res
= pick_commits(r
, &new_todo
, opts
);
6130 todo_list_release(&new_todo
);
6135 struct subject2item_entry
{
6136 struct hashmap_entry entry
;
6138 char subject
[FLEX_ARRAY
];
6141 static int subject2item_cmp(const void *fndata UNUSED
,
6142 const struct hashmap_entry
*eptr
,
6143 const struct hashmap_entry
*entry_or_key
,
6146 const struct subject2item_entry
*a
, *b
;
6148 a
= container_of(eptr
, const struct subject2item_entry
, entry
);
6149 b
= container_of(entry_or_key
, const struct subject2item_entry
, entry
);
6151 return key
? strcmp(a
->subject
, key
) : strcmp(a
->subject
, b
->subject
);
6154 define_commit_slab(commit_todo_item
, struct todo_item
*);
6156 static int skip_fixupish(const char *subject
, const char **p
) {
6157 return skip_prefix(subject
, "fixup! ", p
) ||
6158 skip_prefix(subject
, "amend! ", p
) ||
6159 skip_prefix(subject
, "squash! ", p
);
6163 * Rearrange the todo list that has both "pick commit-id msg" and "pick
6164 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
6165 * after the former, and change "pick" to "fixup"/"squash".
6167 * Note that if the config has specified a custom instruction format, each log
6168 * message will have to be retrieved from the commit (as the oneline in the
6169 * script cannot be trusted) in order to normalize the autosquash arrangement.
6171 int todo_list_rearrange_squash(struct todo_list
*todo_list
)
6173 struct hashmap subject2item
;
6174 int rearranged
= 0, *next
, *tail
, i
, nr
= 0, alloc
= 0;
6176 struct commit_todo_item commit_todo
;
6177 struct todo_item
*items
= NULL
;
6179 init_commit_todo_item(&commit_todo
);
6181 * The hashmap maps onelines to the respective todo list index.
6183 * If any items need to be rearranged, the next[i] value will indicate
6184 * which item was moved directly after the i'th.
6186 * In that case, last[i] will indicate the index of the latest item to
6187 * be moved to appear after the i'th.
6189 hashmap_init(&subject2item
, subject2item_cmp
, NULL
, todo_list
->nr
);
6190 ALLOC_ARRAY(next
, todo_list
->nr
);
6191 ALLOC_ARRAY(tail
, todo_list
->nr
);
6192 ALLOC_ARRAY(subjects
, todo_list
->nr
);
6193 for (i
= 0; i
< todo_list
->nr
; i
++) {
6194 struct strbuf buf
= STRBUF_INIT
;
6195 struct todo_item
*item
= todo_list
->items
+ i
;
6196 const char *commit_buffer
, *subject
, *p
;
6199 struct subject2item_entry
*entry
;
6201 next
[i
] = tail
[i
] = -1;
6202 if (!item
->commit
|| item
->command
== TODO_DROP
) {
6207 if (is_fixup(item
->command
)) {
6208 clear_commit_todo_item(&commit_todo
);
6209 return error(_("the script was already rearranged."));
6212 parse_commit(item
->commit
);
6213 commit_buffer
= logmsg_reencode(item
->commit
, NULL
, "UTF-8");
6214 find_commit_subject(commit_buffer
, &subject
);
6215 format_subject(&buf
, subject
, " ");
6216 subject
= subjects
[i
] = strbuf_detach(&buf
, &subject_len
);
6217 unuse_commit_buffer(item
->commit
, commit_buffer
);
6218 if (skip_fixupish(subject
, &p
)) {
6219 struct commit
*commit2
;
6224 if (!skip_fixupish(p
, &p
))
6228 entry
= hashmap_get_entry_from_hash(&subject2item
,
6230 struct subject2item_entry
,
6233 /* found by title */
6235 else if (!strchr(p
, ' ') &&
6237 lookup_commit_reference_by_name(p
)) &&
6238 *commit_todo_item_at(&commit_todo
, commit2
))
6239 /* found by commit name */
6240 i2
= *commit_todo_item_at(&commit_todo
, commit2
)
6243 /* copy can be a prefix of the commit subject */
6244 for (i2
= 0; i2
< i
; i2
++)
6246 starts_with(subjects
[i2
], p
))
6254 if (starts_with(subject
, "fixup!")) {
6255 todo_list
->items
[i
].command
= TODO_FIXUP
;
6256 } else if (starts_with(subject
, "amend!")) {
6257 todo_list
->items
[i
].command
= TODO_FIXUP
;
6258 todo_list
->items
[i
].flags
= TODO_REPLACE_FIXUP_MSG
;
6260 todo_list
->items
[i
].command
= TODO_SQUASH
;
6266 next
[i
] = next
[tail
[i2
]];
6270 } else if (!hashmap_get_from_hash(&subject2item
,
6271 strhash(subject
), subject
)) {
6272 FLEX_ALLOC_MEM(entry
, subject
, subject
, subject_len
);
6274 hashmap_entry_init(&entry
->entry
,
6275 strhash(entry
->subject
));
6276 hashmap_put(&subject2item
, &entry
->entry
);
6279 *commit_todo_item_at(&commit_todo
, item
->commit
) = item
;
6283 for (i
= 0; i
< todo_list
->nr
; i
++) {
6284 enum todo_command command
= todo_list
->items
[i
].command
;
6288 * Initially, all commands are 'pick's. If it is a
6289 * fixup or a squash now, we have rearranged it.
6291 if (is_fixup(command
))
6295 ALLOC_GROW(items
, nr
+ 1, alloc
);
6296 items
[nr
++] = todo_list
->items
[cur
];
6301 FREE_AND_NULL(todo_list
->items
);
6302 todo_list
->items
= items
;
6304 todo_list
->alloc
= alloc
;
6309 for (i
= 0; i
< todo_list
->nr
; i
++)
6312 hashmap_clear_and_free(&subject2item
, struct subject2item_entry
, entry
);
6314 clear_commit_todo_item(&commit_todo
);
6319 int sequencer_determine_whence(struct repository
*r
, enum commit_whence
*whence
)
6321 if (refs_ref_exists(get_main_ref_store(r
), "CHERRY_PICK_HEAD")) {
6322 struct object_id cherry_pick_head
, rebase_head
;
6324 if (file_exists(git_path_seq_dir()))
6325 *whence
= FROM_CHERRY_PICK_MULTI
;
6326 if (file_exists(rebase_path()) &&
6327 !get_oid("REBASE_HEAD", &rebase_head
) &&
6328 !get_oid("CHERRY_PICK_HEAD", &cherry_pick_head
) &&
6329 oideq(&rebase_head
, &cherry_pick_head
))
6330 *whence
= FROM_REBASE_PICK
;
6332 *whence
= FROM_CHERRY_PICK_SINGLE
;
6340 int sequencer_get_update_refs_state(const char *wt_dir
,
6341 struct string_list
*refs
)
6345 struct strbuf ref
= STRBUF_INIT
;
6346 struct strbuf hash
= STRBUF_INIT
;
6347 struct update_ref_record
*rec
= NULL
;
6349 char *path
= rebase_path_update_refs(wt_dir
);
6351 fp
= fopen(path
, "r");
6355 while (strbuf_getline(&ref
, fp
) != EOF
) {
6356 struct string_list_item
*item
;
6358 CALLOC_ARRAY(rec
, 1);
6360 if (strbuf_getline(&hash
, fp
) == EOF
||
6361 get_oid_hex(hash
.buf
, &rec
->before
)) {
6362 warning(_("update-refs file at '%s' is invalid"),
6368 if (strbuf_getline(&hash
, fp
) == EOF
||
6369 get_oid_hex(hash
.buf
, &rec
->after
)) {
6370 warning(_("update-refs file at '%s' is invalid"),
6376 item
= string_list_insert(refs
, ref
.buf
);
6386 strbuf_release(&ref
);
6387 strbuf_release(&hash
);