f88a97fb10a322c21062ec8c102482677cfd0feb
1#include "cache.h"
2#include "config.h"
3#include "lockfile.h"
4#include "dir.h"
5#include "object-store.h"
6#include "object.h"
7#include "commit.h"
8#include "sequencer.h"
9#include "tag.h"
10#include "run-command.h"
11#include "exec-cmd.h"
12#include "utf8.h"
13#include "cache-tree.h"
14#include "diff.h"
15#include "revision.h"
16#include "rerere.h"
17#include "merge-recursive.h"
18#include "refs.h"
19#include "argv-array.h"
20#include "quote.h"
21#include "trailer.h"
22#include "log-tree.h"
23#include "wt-status.h"
24#include "hashmap.h"
25#include "notes-utils.h"
26#include "sigchain.h"
27#include "unpack-trees.h"
28#include "worktree.h"
29#include "oidmap.h"
30#include "oidset.h"
31#include "commit-slab.h"
32#include "alias.h"
33#include "commit-reach.h"
34#include "rebase-interactive.h"
35
36#define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
37
38static const char sign_off_header[] = "Signed-off-by: ";
39static const char cherry_picked_prefix[] = "(cherry picked from commit ";
40
41GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
42
43GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
44
45static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
46static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
47static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
48static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
49
50static GIT_PATH_FUNC(rebase_path, "rebase-merge")
51/*
52 * The file containing rebase commands, comments, and empty lines.
53 * This file is created by "git rebase -i" then edited by the user. As
54 * the lines are processed, they are removed from the front of this
55 * file and written to the tail of 'done'.
56 */
57GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
58GIT_PATH_FUNC(rebase_path_todo_backup, "rebase-merge/git-rebase-todo.backup")
59
60/*
61 * The rebase command lines that have already been processed. A line
62 * is moved here when it is first handled, before any associated user
63 * actions.
64 */
65static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
66/*
67 * The file to keep track of how many commands were already processed (e.g.
68 * for the prompt).
69 */
70static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum")
71/*
72 * The file to keep track of how many commands are to be processed in total
73 * (e.g. for the prompt).
74 */
75static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end")
76/*
77 * The commit message that is planned to be used for any changes that
78 * need to be committed following a user interaction.
79 */
80static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
81/*
82 * The file into which is accumulated the suggested commit message for
83 * squash/fixup commands. When the first of a series of squash/fixups
84 * is seen, the file is created and the commit message from the
85 * previous commit and from the first squash/fixup commit are written
86 * to it. The commit message for each subsequent squash/fixup commit
87 * is appended to the file as it is processed.
88 */
89static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
90/*
91 * If the current series of squash/fixups has not yet included a squash
92 * command, then this file exists and holds the commit message of the
93 * original "pick" commit. (If the series ends without a "squash"
94 * command, then this can be used as the commit message of the combined
95 * commit without opening the editor.)
96 */
97static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
98/*
99 * This file contains the list fixup/squash commands that have been
100 * accumulated into message-fixup or message-squash so far.
101 */
102static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")
103/*
104 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
105 * GIT_AUTHOR_DATE that will be used for the commit that is currently
106 * being rebased.
107 */
108static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
109/*
110 * When an "edit" rebase command is being processed, the SHA1 of the
111 * commit to be edited is recorded in this file. When "git rebase
112 * --continue" is executed, if there are any staged changes then they
113 * will be amended to the HEAD commit, but only provided the HEAD
114 * commit is still the commit to be edited. When any other rebase
115 * command is processed, this file is deleted.
116 */
117static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
118/*
119 * When we stop at a given patch via the "edit" command, this file contains
120 * the abbreviated commit name of the corresponding patch.
121 */
122static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
123/*
124 * For the post-rewrite hook, we make a list of rewritten commits and
125 * their new sha1s. The rewritten-pending list keeps the sha1s of
126 * commits that have been processed, but not committed yet,
127 * e.g. because they are waiting for a 'squash' command.
128 */
129static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
130static GIT_PATH_FUNC(rebase_path_rewritten_pending,
131 "rebase-merge/rewritten-pending")
132
133/*
134 * The path of the file containig the OID of the "squash onto" commit, i.e.
135 * the dummy commit used for `reset [new root]`.
136 */
137static GIT_PATH_FUNC(rebase_path_squash_onto, "rebase-merge/squash-onto")
138
139/*
140 * The path of the file listing refs that need to be deleted after the rebase
141 * finishes. This is used by the `label` command to record the need for cleanup.
142 */
143static GIT_PATH_FUNC(rebase_path_refs_to_delete, "rebase-merge/refs-to-delete")
144
145/*
146 * The following files are written by git-rebase just after parsing the
147 * command-line.
148 */
149static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
150static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
151static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
152static GIT_PATH_FUNC(rebase_path_quiet, "rebase-merge/quiet")
153static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")
154static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
155static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
156static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
157static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
158static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
159static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
160static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec, "rebase-merge/reschedule-failed-exec")
161
162static int git_sequencer_config(const char *k, const char *v, void *cb)
163{
164 struct replay_opts *opts = cb;
165 int status;
166
167 if (!strcmp(k, "commit.cleanup")) {
168 const char *s;
169
170 status = git_config_string(&s, k, v);
171 if (status)
172 return status;
173
174 if (!strcmp(s, "verbatim")) {
175 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
176 opts->explicit_cleanup = 1;
177 } else if (!strcmp(s, "whitespace")) {
178 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
179 opts->explicit_cleanup = 1;
180 } else if (!strcmp(s, "strip")) {
181 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
182 opts->explicit_cleanup = 1;
183 } else if (!strcmp(s, "scissors")) {
184 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SCISSORS;
185 opts->explicit_cleanup = 1;
186 } else {
187 warning(_("invalid commit message cleanup mode '%s'"),
188 s);
189 }
190
191 free((char *)s);
192 return status;
193 }
194
195 if (!strcmp(k, "commit.gpgsign")) {
196 opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
197 return 0;
198 }
199
200 status = git_gpg_config(k, v, NULL);
201 if (status)
202 return status;
203
204 return git_diff_basic_config(k, v, NULL);
205}
206
207void sequencer_init_config(struct replay_opts *opts)
208{
209 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
210 git_config(git_sequencer_config, opts);
211}
212
213static inline int is_rebase_i(const struct replay_opts *opts)
214{
215 return opts->action == REPLAY_INTERACTIVE_REBASE;
216}
217
218static const char *get_dir(const struct replay_opts *opts)
219{
220 if (is_rebase_i(opts))
221 return rebase_path();
222 return git_path_seq_dir();
223}
224
225static const char *get_todo_path(const struct replay_opts *opts)
226{
227 if (is_rebase_i(opts))
228 return rebase_path_todo();
229 return git_path_todo_file();
230}
231
232/*
233 * Returns 0 for non-conforming footer
234 * Returns 1 for conforming footer
235 * Returns 2 when sob exists within conforming footer
236 * Returns 3 when sob exists within conforming footer as last entry
237 */
238static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
239 size_t ignore_footer)
240{
241 struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
242 struct trailer_info info;
243 size_t i;
244 int found_sob = 0, found_sob_last = 0;
245
246 opts.no_divider = 1;
247
248 trailer_info_get(&info, sb->buf, &opts);
249
250 if (info.trailer_start == info.trailer_end)
251 return 0;
252
253 for (i = 0; i < info.trailer_nr; i++)
254 if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
255 found_sob = 1;
256 if (i == info.trailer_nr - 1)
257 found_sob_last = 1;
258 }
259
260 trailer_info_release(&info);
261
262 if (found_sob_last)
263 return 3;
264 if (found_sob)
265 return 2;
266 return 1;
267}
268
269static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
270{
271 static struct strbuf buf = STRBUF_INIT;
272
273 strbuf_reset(&buf);
274 if (opts->gpg_sign)
275 sq_quotef(&buf, "-S%s", opts->gpg_sign);
276 return buf.buf;
277}
278
279int sequencer_remove_state(struct replay_opts *opts)
280{
281 struct strbuf buf = STRBUF_INIT;
282 int i;
283
284 if (is_rebase_i(opts) &&
285 strbuf_read_file(&buf, rebase_path_refs_to_delete(), 0) > 0) {
286 char *p = buf.buf;
287 while (*p) {
288 char *eol = strchr(p, '\n');
289 if (eol)
290 *eol = '\0';
291 if (delete_ref("(rebase -i) cleanup", p, NULL, 0) < 0)
292 warning(_("could not delete '%s'"), p);
293 if (!eol)
294 break;
295 p = eol + 1;
296 }
297 }
298
299 free(opts->gpg_sign);
300 free(opts->strategy);
301 for (i = 0; i < opts->xopts_nr; i++)
302 free(opts->xopts[i]);
303 free(opts->xopts);
304 strbuf_release(&opts->current_fixups);
305
306 strbuf_reset(&buf);
307 strbuf_addstr(&buf, get_dir(opts));
308 remove_dir_recursively(&buf, 0);
309 strbuf_release(&buf);
310
311 return 0;
312}
313
314static const char *action_name(const struct replay_opts *opts)
315{
316 switch (opts->action) {
317 case REPLAY_REVERT:
318 return N_("revert");
319 case REPLAY_PICK:
320 return N_("cherry-pick");
321 case REPLAY_INTERACTIVE_REBASE:
322 return N_("rebase -i");
323 }
324 die(_("unknown action: %d"), opts->action);
325}
326
327struct commit_message {
328 char *parent_label;
329 char *label;
330 char *subject;
331 const char *message;
332};
333
334static const char *short_commit_name(struct commit *commit)
335{
336 return find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV);
337}
338
339static int get_message(struct commit *commit, struct commit_message *out)
340{
341 const char *abbrev, *subject;
342 int subject_len;
343
344 out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
345 abbrev = short_commit_name(commit);
346
347 subject_len = find_commit_subject(out->message, &subject);
348
349 out->subject = xmemdupz(subject, subject_len);
350 out->label = xstrfmt("%s... %s", abbrev, out->subject);
351 out->parent_label = xstrfmt("parent of %s", out->label);
352
353 return 0;
354}
355
356static void free_message(struct commit *commit, struct commit_message *msg)
357{
358 free(msg->parent_label);
359 free(msg->label);
360 free(msg->subject);
361 unuse_commit_buffer(commit, msg->message);
362}
363
364static void print_advice(struct repository *r, int show_hint,
365 struct replay_opts *opts)
366{
367 char *msg = getenv("GIT_CHERRY_PICK_HELP");
368
369 if (msg) {
370 fprintf(stderr, "%s\n", msg);
371 /*
372 * A conflict has occurred but the porcelain
373 * (typically rebase --interactive) wants to take care
374 * of the commit itself so remove CHERRY_PICK_HEAD
375 */
376 unlink(git_path_cherry_pick_head(r));
377 return;
378 }
379
380 if (show_hint) {
381 if (opts->no_commit)
382 advise(_("after resolving the conflicts, mark the corrected paths\n"
383 "with 'git add <paths>' or 'git rm <paths>'"));
384 else
385 advise(_("after resolving the conflicts, mark the corrected paths\n"
386 "with 'git add <paths>' or 'git rm <paths>'\n"
387 "and commit the result with 'git commit'"));
388 }
389}
390
391static int write_message(const void *buf, size_t len, const char *filename,
392 int append_eol)
393{
394 struct lock_file msg_file = LOCK_INIT;
395
396 int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
397 if (msg_fd < 0)
398 return error_errno(_("could not lock '%s'"), filename);
399 if (write_in_full(msg_fd, buf, len) < 0) {
400 error_errno(_("could not write to '%s'"), filename);
401 rollback_lock_file(&msg_file);
402 return -1;
403 }
404 if (append_eol && write(msg_fd, "\n", 1) < 0) {
405 error_errno(_("could not write eol to '%s'"), filename);
406 rollback_lock_file(&msg_file);
407 return -1;
408 }
409 if (commit_lock_file(&msg_file) < 0)
410 return error(_("failed to finalize '%s'"), filename);
411
412 return 0;
413}
414
415/*
416 * Reads a file that was presumably written by a shell script, i.e. with an
417 * end-of-line marker that needs to be stripped.
418 *
419 * Note that only the last end-of-line marker is stripped, consistent with the
420 * behavior of "$(cat path)" in a shell script.
421 *
422 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
423 */
424static int read_oneliner(struct strbuf *buf,
425 const char *path, int skip_if_empty)
426{
427 int orig_len = buf->len;
428
429 if (!file_exists(path))
430 return 0;
431
432 if (strbuf_read_file(buf, path, 0) < 0) {
433 warning_errno(_("could not read '%s'"), path);
434 return 0;
435 }
436
437 if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
438 if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
439 --buf->len;
440 buf->buf[buf->len] = '\0';
441 }
442
443 if (skip_if_empty && buf->len == orig_len)
444 return 0;
445
446 return 1;
447}
448
449static struct tree *empty_tree(struct repository *r)
450{
451 return lookup_tree(r, the_hash_algo->empty_tree);
452}
453
454static int error_dirty_index(struct repository *repo, struct replay_opts *opts)
455{
456 if (repo_read_index_unmerged(repo))
457 return error_resolve_conflict(_(action_name(opts)));
458
459 error(_("your local changes would be overwritten by %s."),
460 _(action_name(opts)));
461
462 if (advice_commit_before_merge)
463 advise(_("commit your changes or stash them to proceed."));
464 return -1;
465}
466
467static void update_abort_safety_file(void)
468{
469 struct object_id head;
470
471 /* Do nothing on a single-pick */
472 if (!file_exists(git_path_seq_dir()))
473 return;
474
475 if (!get_oid("HEAD", &head))
476 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
477 else
478 write_file(git_path_abort_safety_file(), "%s", "");
479}
480
481static int fast_forward_to(struct repository *r,
482 const struct object_id *to,
483 const struct object_id *from,
484 int unborn,
485 struct replay_opts *opts)
486{
487 struct ref_transaction *transaction;
488 struct strbuf sb = STRBUF_INIT;
489 struct strbuf err = STRBUF_INIT;
490
491 repo_read_index(r);
492 if (checkout_fast_forward(r, from, to, 1))
493 return -1; /* the callee should have complained already */
494
495 strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
496
497 transaction = ref_transaction_begin(&err);
498 if (!transaction ||
499 ref_transaction_update(transaction, "HEAD",
500 to, unborn && !is_rebase_i(opts) ?
501 &null_oid : from,
502 0, sb.buf, &err) ||
503 ref_transaction_commit(transaction, &err)) {
504 ref_transaction_free(transaction);
505 error("%s", err.buf);
506 strbuf_release(&sb);
507 strbuf_release(&err);
508 return -1;
509 }
510
511 strbuf_release(&sb);
512 strbuf_release(&err);
513 ref_transaction_free(transaction);
514 update_abort_safety_file();
515 return 0;
516}
517
518enum commit_msg_cleanup_mode get_cleanup_mode(const char *cleanup_arg,
519 int use_editor)
520{
521 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
522 return use_editor ? COMMIT_MSG_CLEANUP_ALL :
523 COMMIT_MSG_CLEANUP_SPACE;
524 else if (!strcmp(cleanup_arg, "verbatim"))
525 return COMMIT_MSG_CLEANUP_NONE;
526 else if (!strcmp(cleanup_arg, "whitespace"))
527 return COMMIT_MSG_CLEANUP_SPACE;
528 else if (!strcmp(cleanup_arg, "strip"))
529 return COMMIT_MSG_CLEANUP_ALL;
530 else if (!strcmp(cleanup_arg, "scissors"))
531 return use_editor ? COMMIT_MSG_CLEANUP_SCISSORS :
532 COMMIT_MSG_CLEANUP_SPACE;
533 else
534 die(_("Invalid cleanup mode %s"), cleanup_arg);
535}
536
537/*
538 * NB using int rather than enum cleanup_mode to stop clang's
539 * -Wtautological-constant-out-of-range-compare complaining that the comparison
540 * is always true.
541 */
542static const char *describe_cleanup_mode(int cleanup_mode)
543{
544 static const char *modes[] = { "whitespace",
545 "verbatim",
546 "scissors",
547 "strip" };
548
549 if (cleanup_mode < ARRAY_SIZE(modes))
550 return modes[cleanup_mode];
551
552 BUG("invalid cleanup_mode provided (%d)", cleanup_mode);
553}
554
555void append_conflicts_hint(struct index_state *istate,
556 struct strbuf *msgbuf, enum commit_msg_cleanup_mode cleanup_mode)
557{
558 int i;
559
560 if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS) {
561 strbuf_addch(msgbuf, '\n');
562 wt_status_append_cut_line(msgbuf);
563 strbuf_addch(msgbuf, comment_line_char);
564 }
565
566 strbuf_addch(msgbuf, '\n');
567 strbuf_commented_addf(msgbuf, "Conflicts:\n");
568 for (i = 0; i < istate->cache_nr;) {
569 const struct cache_entry *ce = istate->cache[i++];
570 if (ce_stage(ce)) {
571 strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
572 while (i < istate->cache_nr &&
573 !strcmp(ce->name, istate->cache[i]->name))
574 i++;
575 }
576 }
577}
578
579static int do_recursive_merge(struct repository *r,
580 struct commit *base, struct commit *next,
581 const char *base_label, const char *next_label,
582 struct object_id *head, struct strbuf *msgbuf,
583 struct replay_opts *opts)
584{
585 struct merge_options o;
586 struct tree *result, *next_tree, *base_tree, *head_tree;
587 int clean;
588 char **xopt;
589 struct lock_file index_lock = LOCK_INIT;
590
591 if (repo_hold_locked_index(r, &index_lock, LOCK_REPORT_ON_ERROR) < 0)
592 return -1;
593
594 repo_read_index(r);
595
596 init_merge_options(&o, r);
597 o.ancestor = base ? base_label : "(empty tree)";
598 o.branch1 = "HEAD";
599 o.branch2 = next ? next_label : "(empty tree)";
600 if (is_rebase_i(opts))
601 o.buffer_output = 2;
602 o.show_rename_progress = 1;
603
604 head_tree = parse_tree_indirect(head);
605 next_tree = next ? get_commit_tree(next) : empty_tree(r);
606 base_tree = base ? get_commit_tree(base) : empty_tree(r);
607
608 for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)
609 parse_merge_opt(&o, *xopt);
610
611 clean = merge_trees(&o,
612 head_tree,
613 next_tree, base_tree, &result);
614 if (is_rebase_i(opts) && clean <= 0)
615 fputs(o.obuf.buf, stdout);
616 strbuf_release(&o.obuf);
617 diff_warn_rename_limit("merge.renamelimit", o.needed_rename_limit, 0);
618 if (clean < 0) {
619 rollback_lock_file(&index_lock);
620 return clean;
621 }
622
623 if (write_locked_index(r->index, &index_lock,
624 COMMIT_LOCK | SKIP_IF_UNCHANGED))
625 /*
626 * TRANSLATORS: %s will be "revert", "cherry-pick" or
627 * "rebase -i".
628 */
629 return error(_("%s: Unable to write new index file"),
630 _(action_name(opts)));
631
632 if (!clean)
633 append_conflicts_hint(r->index, msgbuf,
634 opts->default_msg_cleanup);
635
636 return !clean;
637}
638
639static struct object_id *get_cache_tree_oid(struct index_state *istate)
640{
641 if (!istate->cache_tree)
642 istate->cache_tree = cache_tree();
643
644 if (!cache_tree_fully_valid(istate->cache_tree))
645 if (cache_tree_update(istate, 0)) {
646 error(_("unable to update cache tree"));
647 return NULL;
648 }
649
650 return &istate->cache_tree->oid;
651}
652
653static int is_index_unchanged(struct repository *r)
654{
655 struct object_id head_oid, *cache_tree_oid;
656 struct commit *head_commit;
657 struct index_state *istate = r->index;
658
659 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
660 return error(_("could not resolve HEAD commit"));
661
662 head_commit = lookup_commit(r, &head_oid);
663
664 /*
665 * If head_commit is NULL, check_commit, called from
666 * lookup_commit, would have indicated that head_commit is not
667 * a commit object already. parse_commit() will return failure
668 * without further complaints in such a case. Otherwise, if
669 * the commit is invalid, parse_commit() will complain. So
670 * there is nothing for us to say here. Just return failure.
671 */
672 if (parse_commit(head_commit))
673 return -1;
674
675 if (!(cache_tree_oid = get_cache_tree_oid(istate)))
676 return -1;
677
678 return oideq(cache_tree_oid, get_commit_tree_oid(head_commit));
679}
680
681static int write_author_script(const char *message)
682{
683 struct strbuf buf = STRBUF_INIT;
684 const char *eol;
685 int res;
686
687 for (;;)
688 if (!*message || starts_with(message, "\n")) {
689missing_author:
690 /* Missing 'author' line? */
691 unlink(rebase_path_author_script());
692 return 0;
693 } else if (skip_prefix(message, "author ", &message))
694 break;
695 else if ((eol = strchr(message, '\n')))
696 message = eol + 1;
697 else
698 goto missing_author;
699
700 strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
701 while (*message && *message != '\n' && *message != '\r')
702 if (skip_prefix(message, " <", &message))
703 break;
704 else if (*message != '\'')
705 strbuf_addch(&buf, *(message++));
706 else
707 strbuf_addf(&buf, "'\\%c'", *(message++));
708 strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
709 while (*message && *message != '\n' && *message != '\r')
710 if (skip_prefix(message, "> ", &message))
711 break;
712 else if (*message != '\'')
713 strbuf_addch(&buf, *(message++));
714 else
715 strbuf_addf(&buf, "'\\%c'", *(message++));
716 strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
717 while (*message && *message != '\n' && *message != '\r')
718 if (*message != '\'')
719 strbuf_addch(&buf, *(message++));
720 else
721 strbuf_addf(&buf, "'\\%c'", *(message++));
722 strbuf_addch(&buf, '\'');
723 res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
724 strbuf_release(&buf);
725 return res;
726}
727
728/**
729 * Take a series of KEY='VALUE' lines where VALUE part is
730 * sq-quoted, and append <KEY, VALUE> at the end of the string list
731 */
732static int parse_key_value_squoted(char *buf, struct string_list *list)
733{
734 while (*buf) {
735 struct string_list_item *item;
736 char *np;
737 char *cp = strchr(buf, '=');
738 if (!cp) {
739 np = strchrnul(buf, '\n');
740 return error(_("no key present in '%.*s'"),
741 (int) (np - buf), buf);
742 }
743 np = strchrnul(cp, '\n');
744 *cp++ = '\0';
745 item = string_list_append(list, buf);
746
747 buf = np + (*np == '\n');
748 *np = '\0';
749 cp = sq_dequote(cp);
750 if (!cp)
751 return error(_("unable to dequote value of '%s'"),
752 item->string);
753 item->util = xstrdup(cp);
754 }
755 return 0;
756}
757
758/**
759 * Reads and parses the state directory's "author-script" file, and sets name,
760 * email and date accordingly.
761 * Returns 0 on success, -1 if the file could not be parsed.
762 *
763 * The author script is of the format:
764 *
765 * GIT_AUTHOR_NAME='$author_name'
766 * GIT_AUTHOR_EMAIL='$author_email'
767 * GIT_AUTHOR_DATE='$author_date'
768 *
769 * where $author_name, $author_email and $author_date are quoted. We are strict
770 * with our parsing, as the file was meant to be eval'd in the old
771 * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
772 * from what this function expects, it is better to bail out than to do
773 * something that the user does not expect.
774 */
775int read_author_script(const char *path, char **name, char **email, char **date,
776 int allow_missing)
777{
778 struct strbuf buf = STRBUF_INIT;
779 struct string_list kv = STRING_LIST_INIT_DUP;
780 int retval = -1; /* assume failure */
781 int i, name_i = -2, email_i = -2, date_i = -2, err = 0;
782
783 if (strbuf_read_file(&buf, path, 256) <= 0) {
784 strbuf_release(&buf);
785 if (errno == ENOENT && allow_missing)
786 return 0;
787 else
788 return error_errno(_("could not open '%s' for reading"),
789 path);
790 }
791
792 if (parse_key_value_squoted(buf.buf, &kv))
793 goto finish;
794
795 for (i = 0; i < kv.nr; i++) {
796 if (!strcmp(kv.items[i].string, "GIT_AUTHOR_NAME")) {
797 if (name_i != -2)
798 name_i = error(_("'GIT_AUTHOR_NAME' already given"));
799 else
800 name_i = i;
801 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_EMAIL")) {
802 if (email_i != -2)
803 email_i = error(_("'GIT_AUTHOR_EMAIL' already given"));
804 else
805 email_i = i;
806 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_DATE")) {
807 if (date_i != -2)
808 date_i = error(_("'GIT_AUTHOR_DATE' already given"));
809 else
810 date_i = i;
811 } else {
812 err = error(_("unknown variable '%s'"),
813 kv.items[i].string);
814 }
815 }
816 if (name_i == -2)
817 error(_("missing 'GIT_AUTHOR_NAME'"));
818 if (email_i == -2)
819 error(_("missing 'GIT_AUTHOR_EMAIL'"));
820 if (date_i == -2)
821 error(_("missing 'GIT_AUTHOR_DATE'"));
822 if (date_i < 0 || email_i < 0 || date_i < 0 || err)
823 goto finish;
824 *name = kv.items[name_i].util;
825 *email = kv.items[email_i].util;
826 *date = kv.items[date_i].util;
827 retval = 0;
828finish:
829 string_list_clear(&kv, !!retval);
830 strbuf_release(&buf);
831 return retval;
832}
833
834/*
835 * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
836 * file with shell quoting into struct argv_array. Returns -1 on
837 * error, 0 otherwise.
838 */
839static int read_env_script(struct argv_array *env)
840{
841 char *name, *email, *date;
842
843 if (read_author_script(rebase_path_author_script(),
844 &name, &email, &date, 0))
845 return -1;
846
847 argv_array_pushf(env, "GIT_AUTHOR_NAME=%s", name);
848 argv_array_pushf(env, "GIT_AUTHOR_EMAIL=%s", email);
849 argv_array_pushf(env, "GIT_AUTHOR_DATE=%s", date);
850 free(name);
851 free(email);
852 free(date);
853
854 return 0;
855}
856
857static char *get_author(const char *message)
858{
859 size_t len;
860 const char *a;
861
862 a = find_commit_header(message, "author", &len);
863 if (a)
864 return xmemdupz(a, len);
865
866 return NULL;
867}
868
869/* Read author-script and return an ident line (author <email> timestamp) */
870static const char *read_author_ident(struct strbuf *buf)
871{
872 struct strbuf out = STRBUF_INIT;
873 char *name, *email, *date;
874
875 if (read_author_script(rebase_path_author_script(),
876 &name, &email, &date, 0))
877 return NULL;
878
879 /* validate date since fmt_ident() will die() on bad value */
880 if (parse_date(date, &out)){
881 warning(_("invalid date format '%s' in '%s'"),
882 date, rebase_path_author_script());
883 strbuf_release(&out);
884 return NULL;
885 }
886
887 strbuf_reset(&out);
888 strbuf_addstr(&out, fmt_ident(name, email, WANT_AUTHOR_IDENT, date, 0));
889 strbuf_swap(buf, &out);
890 strbuf_release(&out);
891 free(name);
892 free(email);
893 free(date);
894 return buf->buf;
895}
896
897static const char staged_changes_advice[] =
898N_("you have staged changes in your working tree\n"
899"If these changes are meant to be squashed into the previous commit, run:\n"
900"\n"
901" git commit --amend %s\n"
902"\n"
903"If they are meant to go into a new commit, run:\n"
904"\n"
905" git commit %s\n"
906"\n"
907"In both cases, once you're done, continue with:\n"
908"\n"
909" git rebase --continue\n");
910
911#define ALLOW_EMPTY (1<<0)
912#define EDIT_MSG (1<<1)
913#define AMEND_MSG (1<<2)
914#define CLEANUP_MSG (1<<3)
915#define VERIFY_MSG (1<<4)
916#define CREATE_ROOT_COMMIT (1<<5)
917
918static int run_command_silent_on_success(struct child_process *cmd)
919{
920 struct strbuf buf = STRBUF_INIT;
921 int rc;
922
923 cmd->stdout_to_stderr = 1;
924 rc = pipe_command(cmd,
925 NULL, 0,
926 NULL, 0,
927 &buf, 0);
928
929 if (rc)
930 fputs(buf.buf, stderr);
931 strbuf_release(&buf);
932 return rc;
933}
934
935/*
936 * If we are cherry-pick, and if the merge did not result in
937 * hand-editing, we will hit this commit and inherit the original
938 * author date and name.
939 *
940 * If we are revert, or if our cherry-pick results in a hand merge,
941 * we had better say that the current user is responsible for that.
942 *
943 * An exception is when run_git_commit() is called during an
944 * interactive rebase: in that case, we will want to retain the
945 * author metadata.
946 */
947static int run_git_commit(struct repository *r,
948 const char *defmsg,
949 struct replay_opts *opts,
950 unsigned int flags)
951{
952 struct child_process cmd = CHILD_PROCESS_INIT;
953
954 if ((flags & CREATE_ROOT_COMMIT) && !(flags & AMEND_MSG)) {
955 struct strbuf msg = STRBUF_INIT, script = STRBUF_INIT;
956 const char *author = NULL;
957 struct object_id root_commit, *cache_tree_oid;
958 int res = 0;
959
960 if (is_rebase_i(opts)) {
961 author = read_author_ident(&script);
962 if (!author) {
963 strbuf_release(&script);
964 return -1;
965 }
966 }
967
968 if (!defmsg)
969 BUG("root commit without message");
970
971 if (!(cache_tree_oid = get_cache_tree_oid(r->index)))
972 res = -1;
973
974 if (!res)
975 res = strbuf_read_file(&msg, defmsg, 0);
976
977 if (res <= 0)
978 res = error_errno(_("could not read '%s'"), defmsg);
979 else
980 res = commit_tree(msg.buf, msg.len, cache_tree_oid,
981 NULL, &root_commit, author,
982 opts->gpg_sign);
983
984 strbuf_release(&msg);
985 strbuf_release(&script);
986 if (!res) {
987 update_ref(NULL, "CHERRY_PICK_HEAD", &root_commit, NULL,
988 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR);
989 res = update_ref(NULL, "HEAD", &root_commit, NULL, 0,
990 UPDATE_REFS_MSG_ON_ERR);
991 }
992 return res < 0 ? error(_("writing root commit")) : 0;
993 }
994
995 cmd.git_cmd = 1;
996
997 if (is_rebase_i(opts) && read_env_script(&cmd.env_array)) {
998 const char *gpg_opt = gpg_sign_opt_quoted(opts);
999
1000 return error(_(staged_changes_advice),
1001 gpg_opt, gpg_opt);
1002 }
1003
1004 argv_array_push(&cmd.args, "commit");
1005
1006 if (!(flags & VERIFY_MSG))
1007 argv_array_push(&cmd.args, "-n");
1008 if ((flags & AMEND_MSG))
1009 argv_array_push(&cmd.args, "--amend");
1010 if (opts->gpg_sign)
1011 argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
1012 if (defmsg)
1013 argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
1014 else if (!(flags & EDIT_MSG))
1015 argv_array_pushl(&cmd.args, "-C", "HEAD", NULL);
1016 if ((flags & CLEANUP_MSG))
1017 argv_array_push(&cmd.args, "--cleanup=strip");
1018 if ((flags & EDIT_MSG))
1019 argv_array_push(&cmd.args, "-e");
1020 else if (!(flags & CLEANUP_MSG) &&
1021 !opts->signoff && !opts->record_origin &&
1022 !opts->explicit_cleanup)
1023 argv_array_push(&cmd.args, "--cleanup=verbatim");
1024
1025 if ((flags & ALLOW_EMPTY))
1026 argv_array_push(&cmd.args, "--allow-empty");
1027
1028 if (!(flags & EDIT_MSG))
1029 argv_array_push(&cmd.args, "--allow-empty-message");
1030
1031 if (is_rebase_i(opts) && !(flags & EDIT_MSG))
1032 return run_command_silent_on_success(&cmd);
1033 else
1034 return run_command(&cmd);
1035}
1036
1037static int rest_is_empty(const struct strbuf *sb, int start)
1038{
1039 int i, eol;
1040 const char *nl;
1041
1042 /* Check if the rest is just whitespace and Signed-off-by's. */
1043 for (i = start; i < sb->len; i++) {
1044 nl = memchr(sb->buf + i, '\n', sb->len - i);
1045 if (nl)
1046 eol = nl - sb->buf;
1047 else
1048 eol = sb->len;
1049
1050 if (strlen(sign_off_header) <= eol - i &&
1051 starts_with(sb->buf + i, sign_off_header)) {
1052 i = eol;
1053 continue;
1054 }
1055 while (i < eol)
1056 if (!isspace(sb->buf[i++]))
1057 return 0;
1058 }
1059
1060 return 1;
1061}
1062
1063void cleanup_message(struct strbuf *msgbuf,
1064 enum commit_msg_cleanup_mode cleanup_mode, int verbose)
1065{
1066 if (verbose || /* Truncate the message just before the diff, if any. */
1067 cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS)
1068 strbuf_setlen(msgbuf, wt_status_locate_end(msgbuf->buf, msgbuf->len));
1069 if (cleanup_mode != COMMIT_MSG_CLEANUP_NONE)
1070 strbuf_stripspace(msgbuf, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1071}
1072
1073/*
1074 * Find out if the message in the strbuf contains only whitespace and
1075 * Signed-off-by lines.
1076 */
1077int message_is_empty(const struct strbuf *sb,
1078 enum commit_msg_cleanup_mode cleanup_mode)
1079{
1080 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1081 return 0;
1082 return rest_is_empty(sb, 0);
1083}
1084
1085/*
1086 * See if the user edited the message in the editor or left what
1087 * was in the template intact
1088 */
1089int template_untouched(const struct strbuf *sb, const char *template_file,
1090 enum commit_msg_cleanup_mode cleanup_mode)
1091{
1092 struct strbuf tmpl = STRBUF_INIT;
1093 const char *start;
1094
1095 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1096 return 0;
1097
1098 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1099 return 0;
1100
1101 strbuf_stripspace(&tmpl, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1102 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1103 start = sb->buf;
1104 strbuf_release(&tmpl);
1105 return rest_is_empty(sb, start - sb->buf);
1106}
1107
1108int update_head_with_reflog(const struct commit *old_head,
1109 const struct object_id *new_head,
1110 const char *action, const struct strbuf *msg,
1111 struct strbuf *err)
1112{
1113 struct ref_transaction *transaction;
1114 struct strbuf sb = STRBUF_INIT;
1115 const char *nl;
1116 int ret = 0;
1117
1118 if (action) {
1119 strbuf_addstr(&sb, action);
1120 strbuf_addstr(&sb, ": ");
1121 }
1122
1123 nl = strchr(msg->buf, '\n');
1124 if (nl) {
1125 strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
1126 } else {
1127 strbuf_addbuf(&sb, msg);
1128 strbuf_addch(&sb, '\n');
1129 }
1130
1131 transaction = ref_transaction_begin(err);
1132 if (!transaction ||
1133 ref_transaction_update(transaction, "HEAD", new_head,
1134 old_head ? &old_head->object.oid : &null_oid,
1135 0, sb.buf, err) ||
1136 ref_transaction_commit(transaction, err)) {
1137 ret = -1;
1138 }
1139 ref_transaction_free(transaction);
1140 strbuf_release(&sb);
1141
1142 return ret;
1143}
1144
1145static int run_rewrite_hook(const struct object_id *oldoid,
1146 const struct object_id *newoid)
1147{
1148 struct child_process proc = CHILD_PROCESS_INIT;
1149 const char *argv[3];
1150 int code;
1151 struct strbuf sb = STRBUF_INIT;
1152
1153 argv[0] = find_hook("post-rewrite");
1154 if (!argv[0])
1155 return 0;
1156
1157 argv[1] = "amend";
1158 argv[2] = NULL;
1159
1160 proc.argv = argv;
1161 proc.in = -1;
1162 proc.stdout_to_stderr = 1;
1163 proc.trace2_hook_name = "post-rewrite";
1164
1165 code = start_command(&proc);
1166 if (code)
1167 return code;
1168 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1169 sigchain_push(SIGPIPE, SIG_IGN);
1170 write_in_full(proc.in, sb.buf, sb.len);
1171 close(proc.in);
1172 strbuf_release(&sb);
1173 sigchain_pop(SIGPIPE);
1174 return finish_command(&proc);
1175}
1176
1177void commit_post_rewrite(struct repository *r,
1178 const struct commit *old_head,
1179 const struct object_id *new_head)
1180{
1181 struct notes_rewrite_cfg *cfg;
1182
1183 cfg = init_copy_notes_for_rewrite("amend");
1184 if (cfg) {
1185 /* we are amending, so old_head is not NULL */
1186 copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
1187 finish_copy_notes_for_rewrite(r, cfg, "Notes added by 'git commit --amend'");
1188 }
1189 run_rewrite_hook(&old_head->object.oid, new_head);
1190}
1191
1192static int run_prepare_commit_msg_hook(struct repository *r,
1193 struct strbuf *msg,
1194 const char *commit)
1195{
1196 struct argv_array hook_env = ARGV_ARRAY_INIT;
1197 int ret;
1198 const char *name;
1199
1200 name = git_path_commit_editmsg();
1201 if (write_message(msg->buf, msg->len, name, 0))
1202 return -1;
1203
1204 argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", r->index_file);
1205 argv_array_push(&hook_env, "GIT_EDITOR=:");
1206 if (commit)
1207 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1208 "commit", commit, NULL);
1209 else
1210 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1211 "message", NULL);
1212 if (ret)
1213 ret = error(_("'prepare-commit-msg' hook failed"));
1214 argv_array_clear(&hook_env);
1215
1216 return ret;
1217}
1218
1219static const char implicit_ident_advice_noconfig[] =
1220N_("Your name and email address were configured automatically based\n"
1221"on your username and hostname. Please check that they are accurate.\n"
1222"You can suppress this message by setting them explicitly. Run the\n"
1223"following command and follow the instructions in your editor to edit\n"
1224"your configuration file:\n"
1225"\n"
1226" git config --global --edit\n"
1227"\n"
1228"After doing this, you may fix the identity used for this commit with:\n"
1229"\n"
1230" git commit --amend --reset-author\n");
1231
1232static const char implicit_ident_advice_config[] =
1233N_("Your name and email address were configured automatically based\n"
1234"on your username and hostname. Please check that they are accurate.\n"
1235"You can suppress this message by setting them explicitly:\n"
1236"\n"
1237" git config --global user.name \"Your Name\"\n"
1238" git config --global user.email you@example.com\n"
1239"\n"
1240"After doing this, you may fix the identity used for this commit with:\n"
1241"\n"
1242" git commit --amend --reset-author\n");
1243
1244static const char *implicit_ident_advice(void)
1245{
1246 char *user_config = expand_user_path("~/.gitconfig", 0);
1247 char *xdg_config = xdg_config_home("config");
1248 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1249
1250 free(user_config);
1251 free(xdg_config);
1252
1253 if (config_exists)
1254 return _(implicit_ident_advice_config);
1255 else
1256 return _(implicit_ident_advice_noconfig);
1257
1258}
1259
1260void print_commit_summary(struct repository *r,
1261 const char *prefix,
1262 const struct object_id *oid,
1263 unsigned int flags)
1264{
1265 struct rev_info rev;
1266 struct commit *commit;
1267 struct strbuf format = STRBUF_INIT;
1268 const char *head;
1269 struct pretty_print_context pctx = {0};
1270 struct strbuf author_ident = STRBUF_INIT;
1271 struct strbuf committer_ident = STRBUF_INIT;
1272
1273 commit = lookup_commit(r, oid);
1274 if (!commit)
1275 die(_("couldn't look up newly created commit"));
1276 if (parse_commit(commit))
1277 die(_("could not parse newly created commit"));
1278
1279 strbuf_addstr(&format, "format:%h] %s");
1280
1281 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1282 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1283 if (strbuf_cmp(&author_ident, &committer_ident)) {
1284 strbuf_addstr(&format, "\n Author: ");
1285 strbuf_addbuf_percentquote(&format, &author_ident);
1286 }
1287 if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
1288 struct strbuf date = STRBUF_INIT;
1289
1290 format_commit_message(commit, "%ad", &date, &pctx);
1291 strbuf_addstr(&format, "\n Date: ");
1292 strbuf_addbuf_percentquote(&format, &date);
1293 strbuf_release(&date);
1294 }
1295 if (!committer_ident_sufficiently_given()) {
1296 strbuf_addstr(&format, "\n Committer: ");
1297 strbuf_addbuf_percentquote(&format, &committer_ident);
1298 if (advice_implicit_identity) {
1299 strbuf_addch(&format, '\n');
1300 strbuf_addstr(&format, implicit_ident_advice());
1301 }
1302 }
1303 strbuf_release(&author_ident);
1304 strbuf_release(&committer_ident);
1305
1306 repo_init_revisions(r, &rev, prefix);
1307 setup_revisions(0, NULL, &rev, NULL);
1308
1309 rev.diff = 1;
1310 rev.diffopt.output_format =
1311 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1312
1313 rev.verbose_header = 1;
1314 rev.show_root_diff = 1;
1315 get_commit_format(format.buf, &rev);
1316 rev.always_show_header = 0;
1317 rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1318 rev.diffopt.break_opt = 0;
1319 diff_setup_done(&rev.diffopt);
1320
1321 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1322 if (!head)
1323 die_errno(_("unable to resolve HEAD after creating commit"));
1324 if (!strcmp(head, "HEAD"))
1325 head = _("detached HEAD");
1326 else
1327 skip_prefix(head, "refs/heads/", &head);
1328 printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1329 _(" (root-commit)") : "");
1330
1331 if (!log_tree_commit(&rev, commit)) {
1332 rev.always_show_header = 1;
1333 rev.use_terminator = 1;
1334 log_tree_commit(&rev, commit);
1335 }
1336
1337 strbuf_release(&format);
1338}
1339
1340static int parse_head(struct repository *r, struct commit **head)
1341{
1342 struct commit *current_head;
1343 struct object_id oid;
1344
1345 if (get_oid("HEAD", &oid)) {
1346 current_head = NULL;
1347 } else {
1348 current_head = lookup_commit_reference(r, &oid);
1349 if (!current_head)
1350 return error(_("could not parse HEAD"));
1351 if (!oideq(&oid, ¤t_head->object.oid)) {
1352 warning(_("HEAD %s is not a commit!"),
1353 oid_to_hex(&oid));
1354 }
1355 if (parse_commit(current_head))
1356 return error(_("could not parse HEAD commit"));
1357 }
1358 *head = current_head;
1359
1360 return 0;
1361}
1362
1363/*
1364 * Try to commit without forking 'git commit'. In some cases we need
1365 * to run 'git commit' to display an error message
1366 *
1367 * Returns:
1368 * -1 - error unable to commit
1369 * 0 - success
1370 * 1 - run 'git commit'
1371 */
1372static int try_to_commit(struct repository *r,
1373 struct strbuf *msg, const char *author,
1374 struct replay_opts *opts, unsigned int flags,
1375 struct object_id *oid)
1376{
1377 struct object_id tree;
1378 struct commit *current_head;
1379 struct commit_list *parents = NULL;
1380 struct commit_extra_header *extra = NULL;
1381 struct strbuf err = STRBUF_INIT;
1382 struct strbuf commit_msg = STRBUF_INIT;
1383 char *amend_author = NULL;
1384 const char *hook_commit = NULL;
1385 enum commit_msg_cleanup_mode cleanup;
1386 int res = 0;
1387
1388 if (parse_head(r, ¤t_head))
1389 return -1;
1390
1391 if (flags & AMEND_MSG) {
1392 const char *exclude_gpgsig[] = { "gpgsig", NULL };
1393 const char *out_enc = get_commit_output_encoding();
1394 const char *message = logmsg_reencode(current_head, NULL,
1395 out_enc);
1396
1397 if (!msg) {
1398 const char *orig_message = NULL;
1399
1400 find_commit_subject(message, &orig_message);
1401 msg = &commit_msg;
1402 strbuf_addstr(msg, orig_message);
1403 hook_commit = "HEAD";
1404 }
1405 author = amend_author = get_author(message);
1406 unuse_commit_buffer(current_head, message);
1407 if (!author) {
1408 res = error(_("unable to parse commit author"));
1409 goto out;
1410 }
1411 parents = copy_commit_list(current_head->parents);
1412 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1413 } else if (current_head) {
1414 commit_list_insert(current_head, &parents);
1415 }
1416
1417 if (write_index_as_tree(&tree, r->index, r->index_file, 0, NULL)) {
1418 res = error(_("git write-tree failed to write a tree"));
1419 goto out;
1420 }
1421
1422 if (!(flags & ALLOW_EMPTY) && oideq(current_head ?
1423 get_commit_tree_oid(current_head) :
1424 the_hash_algo->empty_tree, &tree)) {
1425 res = 1; /* run 'git commit' to display error message */
1426 goto out;
1427 }
1428
1429 if (find_hook("prepare-commit-msg")) {
1430 res = run_prepare_commit_msg_hook(r, msg, hook_commit);
1431 if (res)
1432 goto out;
1433 if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1434 2048) < 0) {
1435 res = error_errno(_("unable to read commit message "
1436 "from '%s'"),
1437 git_path_commit_editmsg());
1438 goto out;
1439 }
1440 msg = &commit_msg;
1441 }
1442
1443 if (flags & CLEANUP_MSG)
1444 cleanup = COMMIT_MSG_CLEANUP_ALL;
1445 else if ((opts->signoff || opts->record_origin) &&
1446 !opts->explicit_cleanup)
1447 cleanup = COMMIT_MSG_CLEANUP_SPACE;
1448 else
1449 cleanup = opts->default_msg_cleanup;
1450
1451 if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1452 strbuf_stripspace(msg, cleanup == COMMIT_MSG_CLEANUP_ALL);
1453 if ((flags & EDIT_MSG) && message_is_empty(msg, cleanup)) {
1454 res = 1; /* run 'git commit' to display error message */
1455 goto out;
1456 }
1457
1458 reset_ident_date();
1459
1460 if (commit_tree_extended(msg->buf, msg->len, &tree, parents,
1461 oid, author, opts->gpg_sign, extra)) {
1462 res = error(_("failed to write commit object"));
1463 goto out;
1464 }
1465
1466 if (update_head_with_reflog(current_head, oid,
1467 getenv("GIT_REFLOG_ACTION"), msg, &err)) {
1468 res = error("%s", err.buf);
1469 goto out;
1470 }
1471
1472 if (flags & AMEND_MSG)
1473 commit_post_rewrite(r, current_head, oid);
1474
1475out:
1476 free_commit_extra_headers(extra);
1477 strbuf_release(&err);
1478 strbuf_release(&commit_msg);
1479 free(amend_author);
1480
1481 return res;
1482}
1483
1484static int do_commit(struct repository *r,
1485 const char *msg_file, const char *author,
1486 struct replay_opts *opts, unsigned int flags)
1487{
1488 int res = 1;
1489
1490 if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG) &&
1491 !(flags & CREATE_ROOT_COMMIT)) {
1492 struct object_id oid;
1493 struct strbuf sb = STRBUF_INIT;
1494
1495 if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1496 return error_errno(_("unable to read commit message "
1497 "from '%s'"),
1498 msg_file);
1499
1500 res = try_to_commit(r, msg_file ? &sb : NULL,
1501 author, opts, flags, &oid);
1502 strbuf_release(&sb);
1503 if (!res) {
1504 unlink(git_path_cherry_pick_head(r));
1505 unlink(git_path_merge_msg(r));
1506 if (!is_rebase_i(opts))
1507 print_commit_summary(r, NULL, &oid,
1508 SUMMARY_SHOW_AUTHOR_DATE);
1509 return res;
1510 }
1511 }
1512 if (res == 1)
1513 return run_git_commit(r, msg_file, opts, flags);
1514
1515 return res;
1516}
1517
1518static int is_original_commit_empty(struct commit *commit)
1519{
1520 const struct object_id *ptree_oid;
1521
1522 if (parse_commit(commit))
1523 return error(_("could not parse commit %s"),
1524 oid_to_hex(&commit->object.oid));
1525 if (commit->parents) {
1526 struct commit *parent = commit->parents->item;
1527 if (parse_commit(parent))
1528 return error(_("could not parse parent commit %s"),
1529 oid_to_hex(&parent->object.oid));
1530 ptree_oid = get_commit_tree_oid(parent);
1531 } else {
1532 ptree_oid = the_hash_algo->empty_tree; /* commit is root */
1533 }
1534
1535 return oideq(ptree_oid, get_commit_tree_oid(commit));
1536}
1537
1538/*
1539 * Do we run "git commit" with "--allow-empty"?
1540 */
1541static int allow_empty(struct repository *r,
1542 struct replay_opts *opts,
1543 struct commit *commit)
1544{
1545 int index_unchanged, empty_commit;
1546
1547 /*
1548 * Three cases:
1549 *
1550 * (1) we do not allow empty at all and error out.
1551 *
1552 * (2) we allow ones that were initially empty, but
1553 * forbid the ones that become empty;
1554 *
1555 * (3) we allow both.
1556 */
1557 if (!opts->allow_empty)
1558 return 0; /* let "git commit" barf as necessary */
1559
1560 index_unchanged = is_index_unchanged(r);
1561 if (index_unchanged < 0)
1562 return index_unchanged;
1563 if (!index_unchanged)
1564 return 0; /* we do not have to say --allow-empty */
1565
1566 if (opts->keep_redundant_commits)
1567 return 1;
1568
1569 empty_commit = is_original_commit_empty(commit);
1570 if (empty_commit < 0)
1571 return empty_commit;
1572 if (!empty_commit)
1573 return 0;
1574 else
1575 return 1;
1576}
1577
1578static struct {
1579 char c;
1580 const char *str;
1581} todo_command_info[] = {
1582 { 'p', "pick" },
1583 { 0, "revert" },
1584 { 'e', "edit" },
1585 { 'r', "reword" },
1586 { 'f', "fixup" },
1587 { 's', "squash" },
1588 { 'x', "exec" },
1589 { 'b', "break" },
1590 { 'l', "label" },
1591 { 't', "reset" },
1592 { 'm', "merge" },
1593 { 0, "noop" },
1594 { 'd', "drop" },
1595 { 0, NULL }
1596};
1597
1598static const char *command_to_string(const enum todo_command command)
1599{
1600 if (command < TODO_COMMENT)
1601 return todo_command_info[command].str;
1602 die(_("unknown command: %d"), command);
1603}
1604
1605static char command_to_char(const enum todo_command command)
1606{
1607 if (command < TODO_COMMENT && todo_command_info[command].c)
1608 return todo_command_info[command].c;
1609 return comment_line_char;
1610}
1611
1612static int is_noop(const enum todo_command command)
1613{
1614 return TODO_NOOP <= command;
1615}
1616
1617static int is_fixup(enum todo_command command)
1618{
1619 return command == TODO_FIXUP || command == TODO_SQUASH;
1620}
1621
1622/* Does this command create a (non-merge) commit? */
1623static int is_pick_or_similar(enum todo_command command)
1624{
1625 switch (command) {
1626 case TODO_PICK:
1627 case TODO_REVERT:
1628 case TODO_EDIT:
1629 case TODO_REWORD:
1630 case TODO_FIXUP:
1631 case TODO_SQUASH:
1632 return 1;
1633 default:
1634 return 0;
1635 }
1636}
1637
1638static int update_squash_messages(struct repository *r,
1639 enum todo_command command,
1640 struct commit *commit,
1641 struct replay_opts *opts)
1642{
1643 struct strbuf buf = STRBUF_INIT;
1644 int res;
1645 const char *message, *body;
1646
1647 if (opts->current_fixup_count > 0) {
1648 struct strbuf header = STRBUF_INIT;
1649 char *eol;
1650
1651 if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
1652 return error(_("could not read '%s'"),
1653 rebase_path_squash_msg());
1654
1655 eol = buf.buf[0] != comment_line_char ?
1656 buf.buf : strchrnul(buf.buf, '\n');
1657
1658 strbuf_addf(&header, "%c ", comment_line_char);
1659 strbuf_addf(&header, _("This is a combination of %d commits."),
1660 opts->current_fixup_count + 2);
1661 strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
1662 strbuf_release(&header);
1663 } else {
1664 struct object_id head;
1665 struct commit *head_commit;
1666 const char *head_message, *body;
1667
1668 if (get_oid("HEAD", &head))
1669 return error(_("need a HEAD to fixup"));
1670 if (!(head_commit = lookup_commit_reference(r, &head)))
1671 return error(_("could not read HEAD"));
1672 if (!(head_message = get_commit_buffer(head_commit, NULL)))
1673 return error(_("could not read HEAD's commit message"));
1674
1675 find_commit_subject(head_message, &body);
1676 if (write_message(body, strlen(body),
1677 rebase_path_fixup_msg(), 0)) {
1678 unuse_commit_buffer(head_commit, head_message);
1679 return error(_("cannot write '%s'"),
1680 rebase_path_fixup_msg());
1681 }
1682
1683 strbuf_addf(&buf, "%c ", comment_line_char);
1684 strbuf_addf(&buf, _("This is a combination of %d commits."), 2);
1685 strbuf_addf(&buf, "\n%c ", comment_line_char);
1686 strbuf_addstr(&buf, _("This is the 1st commit message:"));
1687 strbuf_addstr(&buf, "\n\n");
1688 strbuf_addstr(&buf, body);
1689
1690 unuse_commit_buffer(head_commit, head_message);
1691 }
1692
1693 if (!(message = get_commit_buffer(commit, NULL)))
1694 return error(_("could not read commit message of %s"),
1695 oid_to_hex(&commit->object.oid));
1696 find_commit_subject(message, &body);
1697
1698 if (command == TODO_SQUASH) {
1699 unlink(rebase_path_fixup_msg());
1700 strbuf_addf(&buf, "\n%c ", comment_line_char);
1701 strbuf_addf(&buf, _("This is the commit message #%d:"),
1702 ++opts->current_fixup_count + 1);
1703 strbuf_addstr(&buf, "\n\n");
1704 strbuf_addstr(&buf, body);
1705 } else if (command == TODO_FIXUP) {
1706 strbuf_addf(&buf, "\n%c ", comment_line_char);
1707 strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
1708 ++opts->current_fixup_count + 1);
1709 strbuf_addstr(&buf, "\n\n");
1710 strbuf_add_commented_lines(&buf, body, strlen(body));
1711 } else
1712 return error(_("unknown command: %d"), command);
1713 unuse_commit_buffer(commit, message);
1714
1715 res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
1716 strbuf_release(&buf);
1717
1718 if (!res) {
1719 strbuf_addf(&opts->current_fixups, "%s%s %s",
1720 opts->current_fixups.len ? "\n" : "",
1721 command_to_string(command),
1722 oid_to_hex(&commit->object.oid));
1723 res = write_message(opts->current_fixups.buf,
1724 opts->current_fixups.len,
1725 rebase_path_current_fixups(), 0);
1726 }
1727
1728 return res;
1729}
1730
1731static void flush_rewritten_pending(void)
1732{
1733 struct strbuf buf = STRBUF_INIT;
1734 struct object_id newoid;
1735 FILE *out;
1736
1737 if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
1738 !get_oid("HEAD", &newoid) &&
1739 (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1740 char *bol = buf.buf, *eol;
1741
1742 while (*bol) {
1743 eol = strchrnul(bol, '\n');
1744 fprintf(out, "%.*s %s\n", (int)(eol - bol),
1745 bol, oid_to_hex(&newoid));
1746 if (!*eol)
1747 break;
1748 bol = eol + 1;
1749 }
1750 fclose(out);
1751 unlink(rebase_path_rewritten_pending());
1752 }
1753 strbuf_release(&buf);
1754}
1755
1756static void record_in_rewritten(struct object_id *oid,
1757 enum todo_command next_command)
1758{
1759 FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
1760
1761 if (!out)
1762 return;
1763
1764 fprintf(out, "%s\n", oid_to_hex(oid));
1765 fclose(out);
1766
1767 if (!is_fixup(next_command))
1768 flush_rewritten_pending();
1769}
1770
1771static int do_pick_commit(struct repository *r,
1772 enum todo_command command,
1773 struct commit *commit,
1774 struct replay_opts *opts,
1775 int final_fixup)
1776{
1777 unsigned int flags = opts->edit ? EDIT_MSG : 0;
1778 const char *msg_file = opts->edit ? NULL : git_path_merge_msg(r);
1779 struct object_id head;
1780 struct commit *base, *next, *parent;
1781 const char *base_label, *next_label;
1782 char *author = NULL;
1783 struct commit_message msg = { NULL, NULL, NULL, NULL };
1784 struct strbuf msgbuf = STRBUF_INIT;
1785 int res, unborn = 0, allow;
1786
1787 if (opts->no_commit) {
1788 /*
1789 * We do not intend to commit immediately. We just want to
1790 * merge the differences in, so let's compute the tree
1791 * that represents the "current" state for merge-recursive
1792 * to work on.
1793 */
1794 if (write_index_as_tree(&head, r->index, r->index_file, 0, NULL))
1795 return error(_("your index file is unmerged."));
1796 } else {
1797 unborn = get_oid("HEAD", &head);
1798 /* Do we want to generate a root commit? */
1799 if (is_pick_or_similar(command) && opts->have_squash_onto &&
1800 oideq(&head, &opts->squash_onto)) {
1801 if (is_fixup(command))
1802 return error(_("cannot fixup root commit"));
1803 flags |= CREATE_ROOT_COMMIT;
1804 unborn = 1;
1805 } else if (unborn)
1806 oidcpy(&head, the_hash_algo->empty_tree);
1807 if (index_differs_from(r, unborn ? empty_tree_oid_hex() : "HEAD",
1808 NULL, 0))
1809 return error_dirty_index(r, opts);
1810 }
1811 discard_index(r->index);
1812
1813 if (!commit->parents)
1814 parent = NULL;
1815 else if (commit->parents->next) {
1816 /* Reverting or cherry-picking a merge commit */
1817 int cnt;
1818 struct commit_list *p;
1819
1820 if (!opts->mainline)
1821 return error(_("commit %s is a merge but no -m option was given."),
1822 oid_to_hex(&commit->object.oid));
1823
1824 for (cnt = 1, p = commit->parents;
1825 cnt != opts->mainline && p;
1826 cnt++)
1827 p = p->next;
1828 if (cnt != opts->mainline || !p)
1829 return error(_("commit %s does not have parent %d"),
1830 oid_to_hex(&commit->object.oid), opts->mainline);
1831 parent = p->item;
1832 } else if (1 < opts->mainline)
1833 /*
1834 * Non-first parent explicitly specified as mainline for
1835 * non-merge commit
1836 */
1837 return error(_("commit %s does not have parent %d"),
1838 oid_to_hex(&commit->object.oid), opts->mainline);
1839 else
1840 parent = commit->parents->item;
1841
1842 if (get_message(commit, &msg) != 0)
1843 return error(_("cannot get commit message for %s"),
1844 oid_to_hex(&commit->object.oid));
1845
1846 if (opts->allow_ff && !is_fixup(command) &&
1847 ((parent && oideq(&parent->object.oid, &head)) ||
1848 (!parent && unborn))) {
1849 if (is_rebase_i(opts))
1850 write_author_script(msg.message);
1851 res = fast_forward_to(r, &commit->object.oid, &head, unborn,
1852 opts);
1853 if (res || command != TODO_REWORD)
1854 goto leave;
1855 flags |= EDIT_MSG | AMEND_MSG | VERIFY_MSG;
1856 msg_file = NULL;
1857 goto fast_forward_edit;
1858 }
1859 if (parent && parse_commit(parent) < 0)
1860 /* TRANSLATORS: The first %s will be a "todo" command like
1861 "revert" or "pick", the second %s a SHA1. */
1862 return error(_("%s: cannot parse parent commit %s"),
1863 command_to_string(command),
1864 oid_to_hex(&parent->object.oid));
1865
1866 /*
1867 * "commit" is an existing commit. We would want to apply
1868 * the difference it introduces since its first parent "prev"
1869 * on top of the current HEAD if we are cherry-pick. Or the
1870 * reverse of it if we are revert.
1871 */
1872
1873 if (command == TODO_REVERT) {
1874 base = commit;
1875 base_label = msg.label;
1876 next = parent;
1877 next_label = msg.parent_label;
1878 strbuf_addstr(&msgbuf, "Revert \"");
1879 strbuf_addstr(&msgbuf, msg.subject);
1880 strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
1881 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1882
1883 if (commit->parents && commit->parents->next) {
1884 strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
1885 strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
1886 }
1887 strbuf_addstr(&msgbuf, ".\n");
1888 } else {
1889 const char *p;
1890
1891 base = parent;
1892 base_label = msg.parent_label;
1893 next = commit;
1894 next_label = msg.label;
1895
1896 /* Append the commit log message to msgbuf. */
1897 if (find_commit_subject(msg.message, &p))
1898 strbuf_addstr(&msgbuf, p);
1899
1900 if (opts->record_origin) {
1901 strbuf_complete_line(&msgbuf);
1902 if (!has_conforming_footer(&msgbuf, NULL, 0))
1903 strbuf_addch(&msgbuf, '\n');
1904 strbuf_addstr(&msgbuf, cherry_picked_prefix);
1905 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1906 strbuf_addstr(&msgbuf, ")\n");
1907 }
1908 if (!is_fixup(command))
1909 author = get_author(msg.message);
1910 }
1911
1912 if (command == TODO_REWORD)
1913 flags |= EDIT_MSG | VERIFY_MSG;
1914 else if (is_fixup(command)) {
1915 if (update_squash_messages(r, command, commit, opts))
1916 return -1;
1917 flags |= AMEND_MSG;
1918 if (!final_fixup)
1919 msg_file = rebase_path_squash_msg();
1920 else if (file_exists(rebase_path_fixup_msg())) {
1921 flags |= CLEANUP_MSG;
1922 msg_file = rebase_path_fixup_msg();
1923 } else {
1924 const char *dest = git_path_squash_msg(r);
1925 unlink(dest);
1926 if (copy_file(dest, rebase_path_squash_msg(), 0666))
1927 return error(_("could not rename '%s' to '%s'"),
1928 rebase_path_squash_msg(), dest);
1929 unlink(git_path_merge_msg(r));
1930 msg_file = dest;
1931 flags |= EDIT_MSG;
1932 }
1933 }
1934
1935 if (opts->signoff && !is_fixup(command))
1936 append_signoff(&msgbuf, 0, 0);
1937
1938 if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1939 res = -1;
1940 else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
1941 res = do_recursive_merge(r, base, next, base_label, next_label,
1942 &head, &msgbuf, opts);
1943 if (res < 0)
1944 goto leave;
1945
1946 res |= write_message(msgbuf.buf, msgbuf.len,
1947 git_path_merge_msg(r), 0);
1948 } else {
1949 struct commit_list *common = NULL;
1950 struct commit_list *remotes = NULL;
1951
1952 res = write_message(msgbuf.buf, msgbuf.len,
1953 git_path_merge_msg(r), 0);
1954
1955 commit_list_insert(base, &common);
1956 commit_list_insert(next, &remotes);
1957 res |= try_merge_command(r, opts->strategy,
1958 opts->xopts_nr, (const char **)opts->xopts,
1959 common, oid_to_hex(&head), remotes);
1960 free_commit_list(common);
1961 free_commit_list(remotes);
1962 }
1963 strbuf_release(&msgbuf);
1964
1965 /*
1966 * If the merge was clean or if it failed due to conflict, we write
1967 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1968 * However, if the merge did not even start, then we don't want to
1969 * write it at all.
1970 */
1971 if (command == TODO_PICK && !opts->no_commit && (res == 0 || res == 1) &&
1972 update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
1973 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1974 res = -1;
1975 if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
1976 update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
1977 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1978 res = -1;
1979
1980 if (res) {
1981 error(command == TODO_REVERT
1982 ? _("could not revert %s... %s")
1983 : _("could not apply %s... %s"),
1984 short_commit_name(commit), msg.subject);
1985 print_advice(r, res == 1, opts);
1986 repo_rerere(r, opts->allow_rerere_auto);
1987 goto leave;
1988 }
1989
1990 allow = allow_empty(r, opts, commit);
1991 if (allow < 0) {
1992 res = allow;
1993 goto leave;
1994 } else if (allow)
1995 flags |= ALLOW_EMPTY;
1996 if (!opts->no_commit) {
1997fast_forward_edit:
1998 if (author || command == TODO_REVERT || (flags & AMEND_MSG))
1999 res = do_commit(r, msg_file, author, opts, flags);
2000 else
2001 res = error(_("unable to parse commit author"));
2002 }
2003
2004 if (!res && final_fixup) {
2005 unlink(rebase_path_fixup_msg());
2006 unlink(rebase_path_squash_msg());
2007 unlink(rebase_path_current_fixups());
2008 strbuf_reset(&opts->current_fixups);
2009 opts->current_fixup_count = 0;
2010 }
2011
2012leave:
2013 free_message(commit, &msg);
2014 free(author);
2015 update_abort_safety_file();
2016
2017 return res;
2018}
2019
2020static int prepare_revs(struct replay_opts *opts)
2021{
2022 /*
2023 * picking (but not reverting) ranges (but not individual revisions)
2024 * should be done in reverse
2025 */
2026 if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
2027 opts->revs->reverse ^= 1;
2028
2029 if (prepare_revision_walk(opts->revs))
2030 return error(_("revision walk setup failed"));
2031
2032 return 0;
2033}
2034
2035static int read_and_refresh_cache(struct repository *r,
2036 struct replay_opts *opts)
2037{
2038 struct lock_file index_lock = LOCK_INIT;
2039 int index_fd = repo_hold_locked_index(r, &index_lock, 0);
2040 if (repo_read_index(r) < 0) {
2041 rollback_lock_file(&index_lock);
2042 return error(_("git %s: failed to read the index"),
2043 _(action_name(opts)));
2044 }
2045 refresh_index(r->index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
2046 if (index_fd >= 0) {
2047 if (write_locked_index(r->index, &index_lock,
2048 COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
2049 return error(_("git %s: failed to refresh the index"),
2050 _(action_name(opts)));
2051 }
2052 }
2053 return 0;
2054}
2055
2056enum todo_item_flags {
2057 TODO_EDIT_MERGE_MSG = 1
2058};
2059
2060void todo_list_release(struct todo_list *todo_list)
2061{
2062 strbuf_release(&todo_list->buf);
2063 FREE_AND_NULL(todo_list->items);
2064 todo_list->nr = todo_list->alloc = 0;
2065}
2066
2067static struct todo_item *append_new_todo(struct todo_list *todo_list)
2068{
2069 ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
2070 return todo_list->items + todo_list->nr++;
2071}
2072
2073const char *todo_item_get_arg(struct todo_list *todo_list,
2074 struct todo_item *item)
2075{
2076 return todo_list->buf.buf + item->arg_offset;
2077}
2078
2079static int parse_insn_line(struct repository *r, struct todo_item *item,
2080 const char *buf, const char *bol, char *eol)
2081{
2082 struct object_id commit_oid;
2083 char *end_of_object_name;
2084 int i, saved, status, padding;
2085
2086 item->flags = 0;
2087
2088 /* left-trim */
2089 bol += strspn(bol, " \t");
2090
2091 if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
2092 item->command = TODO_COMMENT;
2093 item->commit = NULL;
2094 item->arg_offset = bol - buf;
2095 item->arg_len = eol - bol;
2096 return 0;
2097 }
2098
2099 for (i = 0; i < TODO_COMMENT; i++)
2100 if (skip_prefix(bol, todo_command_info[i].str, &bol)) {
2101 item->command = i;
2102 break;
2103 } else if ((bol + 1 == eol || bol[1] == ' ') &&
2104 *bol == todo_command_info[i].c) {
2105 bol++;
2106 item->command = i;
2107 break;
2108 }
2109 if (i >= TODO_COMMENT)
2110 return -1;
2111
2112 /* Eat up extra spaces/ tabs before object name */
2113 padding = strspn(bol, " \t");
2114 bol += padding;
2115
2116 if (item->command == TODO_NOOP || item->command == TODO_BREAK) {
2117 if (bol != eol)
2118 return error(_("%s does not accept arguments: '%s'"),
2119 command_to_string(item->command), bol);
2120 item->commit = NULL;
2121 item->arg_offset = bol - buf;
2122 item->arg_len = eol - bol;
2123 return 0;
2124 }
2125
2126 if (!padding)
2127 return error(_("missing arguments for %s"),
2128 command_to_string(item->command));
2129
2130 if (item->command == TODO_EXEC || item->command == TODO_LABEL ||
2131 item->command == TODO_RESET) {
2132 item->commit = NULL;
2133 item->arg_offset = bol - buf;
2134 item->arg_len = (int)(eol - bol);
2135 return 0;
2136 }
2137
2138 if (item->command == TODO_MERGE) {
2139 if (skip_prefix(bol, "-C", &bol))
2140 bol += strspn(bol, " \t");
2141 else if (skip_prefix(bol, "-c", &bol)) {
2142 bol += strspn(bol, " \t");
2143 item->flags |= TODO_EDIT_MERGE_MSG;
2144 } else {
2145 item->flags |= TODO_EDIT_MERGE_MSG;
2146 item->commit = NULL;
2147 item->arg_offset = bol - buf;
2148 item->arg_len = (int)(eol - bol);
2149 return 0;
2150 }
2151 }
2152
2153 end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
2154 saved = *end_of_object_name;
2155 *end_of_object_name = '\0';
2156 status = get_oid(bol, &commit_oid);
2157 *end_of_object_name = saved;
2158
2159 bol = end_of_object_name + strspn(end_of_object_name, " \t");
2160 item->arg_offset = bol - buf;
2161 item->arg_len = (int)(eol - bol);
2162
2163 if (status < 0)
2164 return error(_("could not parse '%.*s'"),
2165 (int)(end_of_object_name - bol), bol);
2166
2167 item->commit = lookup_commit_reference(r, &commit_oid);
2168 return !item->commit;
2169}
2170
2171int sequencer_get_last_command(struct repository *r, enum replay_action *action)
2172{
2173 struct todo_item item;
2174 char *eol;
2175 const char *todo_file;
2176 struct strbuf buf = STRBUF_INIT;
2177 int ret = -1;
2178
2179 todo_file = git_path_todo_file();
2180 if (strbuf_read_file(&buf, todo_file, 0) < 0) {
2181 if (errno == ENOENT)
2182 return -1;
2183 else
2184 return error_errno("unable to open '%s'", todo_file);
2185 }
2186 eol = strchrnul(buf.buf, '\n');
2187 if (buf.buf != eol && eol[-1] == '\r')
2188 eol--; /* strip Carriage Return */
2189 if (parse_insn_line(r, &item, buf.buf, buf.buf, eol))
2190 goto fail;
2191 if (item.command == TODO_PICK)
2192 *action = REPLAY_PICK;
2193 else if (item.command == TODO_REVERT)
2194 *action = REPLAY_REVERT;
2195 else
2196 goto fail;
2197
2198 ret = 0;
2199
2200 fail:
2201 strbuf_release(&buf);
2202
2203 return ret;
2204}
2205
2206int todo_list_parse_insn_buffer(struct repository *r, char *buf,
2207 struct todo_list *todo_list)
2208{
2209 struct todo_item *item;
2210 char *p = buf, *next_p;
2211 int i, res = 0, fixup_okay = file_exists(rebase_path_done());
2212
2213 todo_list->current = todo_list->nr = 0;
2214
2215 for (i = 1; *p; i++, p = next_p) {
2216 char *eol = strchrnul(p, '\n');
2217
2218 next_p = *eol ? eol + 1 /* skip LF */ : eol;
2219
2220 if (p != eol && eol[-1] == '\r')
2221 eol--; /* strip Carriage Return */
2222
2223 item = append_new_todo(todo_list);
2224 item->offset_in_buf = p - todo_list->buf.buf;
2225 if (parse_insn_line(r, item, buf, p, eol)) {
2226 res = error(_("invalid line %d: %.*s"),
2227 i, (int)(eol - p), p);
2228 item->command = TODO_COMMENT + 1;
2229 item->arg_offset = p - buf;
2230 item->arg_len = (int)(eol - p);
2231 item->commit = NULL;
2232 }
2233
2234 if (fixup_okay)
2235 ; /* do nothing */
2236 else if (is_fixup(item->command))
2237 return error(_("cannot '%s' without a previous commit"),
2238 command_to_string(item->command));
2239 else if (!is_noop(item->command))
2240 fixup_okay = 1;
2241 }
2242
2243 return res;
2244}
2245
2246static int count_commands(struct todo_list *todo_list)
2247{
2248 int count = 0, i;
2249
2250 for (i = 0; i < todo_list->nr; i++)
2251 if (todo_list->items[i].command != TODO_COMMENT)
2252 count++;
2253
2254 return count;
2255}
2256
2257static int get_item_line_offset(struct todo_list *todo_list, int index)
2258{
2259 return index < todo_list->nr ?
2260 todo_list->items[index].offset_in_buf : todo_list->buf.len;
2261}
2262
2263static const char *get_item_line(struct todo_list *todo_list, int index)
2264{
2265 return todo_list->buf.buf + get_item_line_offset(todo_list, index);
2266}
2267
2268static int get_item_line_length(struct todo_list *todo_list, int index)
2269{
2270 return get_item_line_offset(todo_list, index + 1)
2271 - get_item_line_offset(todo_list, index);
2272}
2273
2274static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
2275{
2276 int fd;
2277 ssize_t len;
2278
2279 fd = open(path, O_RDONLY);
2280 if (fd < 0)
2281 return error_errno(_("could not open '%s'"), path);
2282 len = strbuf_read(sb, fd, 0);
2283 close(fd);
2284 if (len < 0)
2285 return error(_("could not read '%s'."), path);
2286 return len;
2287}
2288
2289static int have_finished_the_last_pick(void)
2290{
2291 struct strbuf buf = STRBUF_INIT;
2292 const char *eol;
2293 const char *todo_path = git_path_todo_file();
2294 int ret = 0;
2295
2296 if (strbuf_read_file(&buf, todo_path, 0) < 0) {
2297 if (errno == ENOENT) {
2298 return 0;
2299 } else {
2300 error_errno("unable to open '%s'", todo_path);
2301 return 0;
2302 }
2303 }
2304 /* If there is only one line then we are done */
2305 eol = strchr(buf.buf, '\n');
2306 if (!eol || !eol[1])
2307 ret = 1;
2308
2309 strbuf_release(&buf);
2310
2311 return ret;
2312}
2313
2314void sequencer_post_commit_cleanup(struct repository *r)
2315{
2316 struct replay_opts opts = REPLAY_OPTS_INIT;
2317 int need_cleanup = 0;
2318
2319 if (file_exists(git_path_cherry_pick_head(r))) {
2320 unlink(git_path_cherry_pick_head(r));
2321 opts.action = REPLAY_PICK;
2322 need_cleanup = 1;
2323 }
2324
2325 if (file_exists(git_path_revert_head(r))) {
2326 unlink(git_path_revert_head(r));
2327 opts.action = REPLAY_REVERT;
2328 need_cleanup = 1;
2329 }
2330
2331 if (!need_cleanup)
2332 return;
2333
2334 if (!have_finished_the_last_pick())
2335 return;
2336
2337 sequencer_remove_state(&opts);
2338}
2339
2340static int read_populate_todo(struct repository *r,
2341 struct todo_list *todo_list,
2342 struct replay_opts *opts)
2343{
2344 struct stat st;
2345 const char *todo_file = get_todo_path(opts);
2346 int res;
2347
2348 strbuf_reset(&todo_list->buf);
2349 if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
2350 return -1;
2351
2352 res = stat(todo_file, &st);
2353 if (res)
2354 return error(_("could not stat '%s'"), todo_file);
2355 fill_stat_data(&todo_list->stat, &st);
2356
2357 res = todo_list_parse_insn_buffer(r, todo_list->buf.buf, todo_list);
2358 if (res) {
2359 if (is_rebase_i(opts))
2360 return error(_("please fix this using "
2361 "'git rebase --edit-todo'."));
2362 return error(_("unusable instruction sheet: '%s'"), todo_file);
2363 }
2364
2365 if (!todo_list->nr &&
2366 (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
2367 return error(_("no commits parsed."));
2368
2369 if (!is_rebase_i(opts)) {
2370 enum todo_command valid =
2371 opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
2372 int i;
2373
2374 for (i = 0; i < todo_list->nr; i++)
2375 if (valid == todo_list->items[i].command)
2376 continue;
2377 else if (valid == TODO_PICK)
2378 return error(_("cannot cherry-pick during a revert."));
2379 else
2380 return error(_("cannot revert during a cherry-pick."));
2381 }
2382
2383 if (is_rebase_i(opts)) {
2384 struct todo_list done = TODO_LIST_INIT;
2385 FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
2386
2387 if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
2388 !todo_list_parse_insn_buffer(r, done.buf.buf, &done))
2389 todo_list->done_nr = count_commands(&done);
2390 else
2391 todo_list->done_nr = 0;
2392
2393 todo_list->total_nr = todo_list->done_nr
2394 + count_commands(todo_list);
2395 todo_list_release(&done);
2396
2397 if (f) {
2398 fprintf(f, "%d\n", todo_list->total_nr);
2399 fclose(f);
2400 }
2401 }
2402
2403 return 0;
2404}
2405
2406static int git_config_string_dup(char **dest,
2407 const char *var, const char *value)
2408{
2409 if (!value)
2410 return config_error_nonbool(var);
2411 free(*dest);
2412 *dest = xstrdup(value);
2413 return 0;
2414}
2415
2416static int populate_opts_cb(const char *key, const char *value, void *data)
2417{
2418 struct replay_opts *opts = data;
2419 int error_flag = 1;
2420
2421 if (!value)
2422 error_flag = 0;
2423 else if (!strcmp(key, "options.no-commit"))
2424 opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
2425 else if (!strcmp(key, "options.edit"))
2426 opts->edit = git_config_bool_or_int(key, value, &error_flag);
2427 else if (!strcmp(key, "options.allow-empty"))
2428 opts->allow_empty =
2429 git_config_bool_or_int(key, value, &error_flag);
2430 else if (!strcmp(key, "options.allow-empty-message"))
2431 opts->allow_empty_message =
2432 git_config_bool_or_int(key, value, &error_flag);
2433 else if (!strcmp(key, "options.keep-redundant-commits"))
2434 opts->keep_redundant_commits =
2435 git_config_bool_or_int(key, value, &error_flag);
2436 else if (!strcmp(key, "options.signoff"))
2437 opts->signoff = git_config_bool_or_int(key, value, &error_flag);
2438 else if (!strcmp(key, "options.record-origin"))
2439 opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
2440 else if (!strcmp(key, "options.allow-ff"))
2441 opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
2442 else if (!strcmp(key, "options.mainline"))
2443 opts->mainline = git_config_int(key, value);
2444 else if (!strcmp(key, "options.strategy"))
2445 git_config_string_dup(&opts->strategy, key, value);
2446 else if (!strcmp(key, "options.gpg-sign"))
2447 git_config_string_dup(&opts->gpg_sign, key, value);
2448 else if (!strcmp(key, "options.strategy-option")) {
2449 ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
2450 opts->xopts[opts->xopts_nr++] = xstrdup(value);
2451 } else if (!strcmp(key, "options.allow-rerere-auto"))
2452 opts->allow_rerere_auto =
2453 git_config_bool_or_int(key, value, &error_flag) ?
2454 RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
2455 else if (!strcmp(key, "options.default-msg-cleanup")) {
2456 opts->explicit_cleanup = 1;
2457 opts->default_msg_cleanup = get_cleanup_mode(value, 1);
2458 } else
2459 return error(_("invalid key: %s"), key);
2460
2461 if (!error_flag)
2462 return error(_("invalid value for %s: %s"), key, value);
2463
2464 return 0;
2465}
2466
2467void parse_strategy_opts(struct replay_opts *opts, char *raw_opts)
2468{
2469 int i;
2470 char *strategy_opts_string = raw_opts;
2471
2472 if (*strategy_opts_string == ' ')
2473 strategy_opts_string++;
2474
2475 opts->xopts_nr = split_cmdline(strategy_opts_string,
2476 (const char ***)&opts->xopts);
2477 for (i = 0; i < opts->xopts_nr; i++) {
2478 const char *arg = opts->xopts[i];
2479
2480 skip_prefix(arg, "--", &arg);
2481 opts->xopts[i] = xstrdup(arg);
2482 }
2483}
2484
2485static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
2486{
2487 strbuf_reset(buf);
2488 if (!read_oneliner(buf, rebase_path_strategy(), 0))
2489 return;
2490 opts->strategy = strbuf_detach(buf, NULL);
2491 if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2492 return;
2493
2494 parse_strategy_opts(opts, buf->buf);
2495}
2496
2497static int read_populate_opts(struct replay_opts *opts)
2498{
2499 if (is_rebase_i(opts)) {
2500 struct strbuf buf = STRBUF_INIT;
2501
2502 if (read_oneliner(&buf, rebase_path_gpg_sign_opt(), 1)) {
2503 if (!starts_with(buf.buf, "-S"))
2504 strbuf_reset(&buf);
2505 else {
2506 free(opts->gpg_sign);
2507 opts->gpg_sign = xstrdup(buf.buf + 2);
2508 }
2509 strbuf_reset(&buf);
2510 }
2511
2512 if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(), 1)) {
2513 if (!strcmp(buf.buf, "--rerere-autoupdate"))
2514 opts->allow_rerere_auto = RERERE_AUTOUPDATE;
2515 else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
2516 opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
2517 strbuf_reset(&buf);
2518 }
2519
2520 if (file_exists(rebase_path_verbose()))
2521 opts->verbose = 1;
2522
2523 if (file_exists(rebase_path_quiet()))
2524 opts->quiet = 1;
2525
2526 if (file_exists(rebase_path_signoff())) {
2527 opts->allow_ff = 0;
2528 opts->signoff = 1;
2529 }
2530
2531 if (file_exists(rebase_path_reschedule_failed_exec()))
2532 opts->reschedule_failed_exec = 1;
2533
2534 read_strategy_opts(opts, &buf);
2535 strbuf_release(&buf);
2536
2537 if (read_oneliner(&opts->current_fixups,
2538 rebase_path_current_fixups(), 1)) {
2539 const char *p = opts->current_fixups.buf;
2540 opts->current_fixup_count = 1;
2541 while ((p = strchr(p, '\n'))) {
2542 opts->current_fixup_count++;
2543 p++;
2544 }
2545 }
2546
2547 if (read_oneliner(&buf, rebase_path_squash_onto(), 0)) {
2548 if (get_oid_hex(buf.buf, &opts->squash_onto) < 0)
2549 return error(_("unusable squash-onto"));
2550 opts->have_squash_onto = 1;
2551 }
2552
2553 return 0;
2554 }
2555
2556 if (!file_exists(git_path_opts_file()))
2557 return 0;
2558 /*
2559 * The function git_parse_source(), called from git_config_from_file(),
2560 * may die() in case of a syntactically incorrect file. We do not care
2561 * about this case, though, because we wrote that file ourselves, so we
2562 * are pretty certain that it is syntactically correct.
2563 */
2564 if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
2565 return error(_("malformed options sheet: '%s'"),
2566 git_path_opts_file());
2567 return 0;
2568}
2569
2570static void write_strategy_opts(struct replay_opts *opts)
2571{
2572 int i;
2573 struct strbuf buf = STRBUF_INIT;
2574
2575 for (i = 0; i < opts->xopts_nr; ++i)
2576 strbuf_addf(&buf, " --%s", opts->xopts[i]);
2577
2578 write_file(rebase_path_strategy_opts(), "%s\n", buf.buf);
2579 strbuf_release(&buf);
2580}
2581
2582int write_basic_state(struct replay_opts *opts, const char *head_name,
2583 struct commit *onto, const char *orig_head)
2584{
2585 const char *quiet = getenv("GIT_QUIET");
2586
2587 if (head_name)
2588 write_file(rebase_path_head_name(), "%s\n", head_name);
2589 if (onto)
2590 write_file(rebase_path_onto(), "%s\n",
2591 oid_to_hex(&onto->object.oid));
2592 if (orig_head)
2593 write_file(rebase_path_orig_head(), "%s\n", orig_head);
2594
2595 if (quiet)
2596 write_file(rebase_path_quiet(), "%s\n", quiet);
2597 if (opts->verbose)
2598 write_file(rebase_path_verbose(), "%s", "");
2599 if (opts->strategy)
2600 write_file(rebase_path_strategy(), "%s\n", opts->strategy);
2601 if (opts->xopts_nr > 0)
2602 write_strategy_opts(opts);
2603
2604 if (opts->allow_rerere_auto == RERERE_AUTOUPDATE)
2605 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2606 else if (opts->allow_rerere_auto == RERERE_NOAUTOUPDATE)
2607 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2608
2609 if (opts->gpg_sign)
2610 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts->gpg_sign);
2611 if (opts->signoff)
2612 write_file(rebase_path_signoff(), "--signoff\n");
2613 if (opts->reschedule_failed_exec)
2614 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
2615
2616 return 0;
2617}
2618
2619static int walk_revs_populate_todo(struct todo_list *todo_list,
2620 struct replay_opts *opts)
2621{
2622 enum todo_command command = opts->action == REPLAY_PICK ?
2623 TODO_PICK : TODO_REVERT;
2624 const char *command_string = todo_command_info[command].str;
2625 struct commit *commit;
2626
2627 if (prepare_revs(opts))
2628 return -1;
2629
2630 while ((commit = get_revision(opts->revs))) {
2631 struct todo_item *item = append_new_todo(todo_list);
2632 const char *commit_buffer = get_commit_buffer(commit, NULL);
2633 const char *subject;
2634 int subject_len;
2635
2636 item->command = command;
2637 item->commit = commit;
2638 item->arg_offset = 0;
2639 item->arg_len = 0;
2640 item->offset_in_buf = todo_list->buf.len;
2641 subject_len = find_commit_subject(commit_buffer, &subject);
2642 strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
2643 short_commit_name(commit), subject_len, subject);
2644 unuse_commit_buffer(commit, commit_buffer);
2645 }
2646
2647 if (!todo_list->nr)
2648 return error(_("empty commit set passed"));
2649
2650 return 0;
2651}
2652
2653static int create_seq_dir(void)
2654{
2655 if (file_exists(git_path_seq_dir())) {
2656 error(_("a cherry-pick or revert is already in progress"));
2657 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
2658 return -1;
2659 } else if (mkdir(git_path_seq_dir(), 0777) < 0)
2660 return error_errno(_("could not create sequencer directory '%s'"),
2661 git_path_seq_dir());
2662 return 0;
2663}
2664
2665static int save_head(const char *head)
2666{
2667 struct lock_file head_lock = LOCK_INIT;
2668 struct strbuf buf = STRBUF_INIT;
2669 int fd;
2670 ssize_t written;
2671
2672 fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
2673 if (fd < 0)
2674 return error_errno(_("could not lock HEAD"));
2675 strbuf_addf(&buf, "%s\n", head);
2676 written = write_in_full(fd, buf.buf, buf.len);
2677 strbuf_release(&buf);
2678 if (written < 0) {
2679 error_errno(_("could not write to '%s'"), git_path_head_file());
2680 rollback_lock_file(&head_lock);
2681 return -1;
2682 }
2683 if (commit_lock_file(&head_lock) < 0)
2684 return error(_("failed to finalize '%s'"), git_path_head_file());
2685 return 0;
2686}
2687
2688static int rollback_is_safe(void)
2689{
2690 struct strbuf sb = STRBUF_INIT;
2691 struct object_id expected_head, actual_head;
2692
2693 if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2694 strbuf_trim(&sb);
2695 if (get_oid_hex(sb.buf, &expected_head)) {
2696 strbuf_release(&sb);
2697 die(_("could not parse %s"), git_path_abort_safety_file());
2698 }
2699 strbuf_release(&sb);
2700 }
2701 else if (errno == ENOENT)
2702 oidclr(&expected_head);
2703 else
2704 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2705
2706 if (get_oid("HEAD", &actual_head))
2707 oidclr(&actual_head);
2708
2709 return oideq(&actual_head, &expected_head);
2710}
2711
2712static int reset_for_rollback(const struct object_id *oid)
2713{
2714 const char *argv[4]; /* reset --merge <arg> + NULL */
2715
2716 argv[0] = "reset";
2717 argv[1] = "--merge";
2718 argv[2] = oid_to_hex(oid);
2719 argv[3] = NULL;
2720 return run_command_v_opt(argv, RUN_GIT_CMD);
2721}
2722
2723static int rollback_single_pick(struct repository *r)
2724{
2725 struct object_id head_oid;
2726
2727 if (!file_exists(git_path_cherry_pick_head(r)) &&
2728 !file_exists(git_path_revert_head(r)))
2729 return error(_("no cherry-pick or revert in progress"));
2730 if (read_ref_full("HEAD", 0, &head_oid, NULL))
2731 return error(_("cannot resolve HEAD"));
2732 if (is_null_oid(&head_oid))
2733 return error(_("cannot abort from a branch yet to be born"));
2734 return reset_for_rollback(&head_oid);
2735}
2736
2737int sequencer_rollback(struct repository *r, struct replay_opts *opts)
2738{
2739 FILE *f;
2740 struct object_id oid;
2741 struct strbuf buf = STRBUF_INIT;
2742 const char *p;
2743
2744 f = fopen(git_path_head_file(), "r");
2745 if (!f && errno == ENOENT) {
2746 /*
2747 * There is no multiple-cherry-pick in progress.
2748 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2749 * a single-cherry-pick in progress, abort that.
2750 */
2751 return rollback_single_pick(r);
2752 }
2753 if (!f)
2754 return error_errno(_("cannot open '%s'"), git_path_head_file());
2755 if (strbuf_getline_lf(&buf, f)) {
2756 error(_("cannot read '%s': %s"), git_path_head_file(),
2757 ferror(f) ? strerror(errno) : _("unexpected end of file"));
2758 fclose(f);
2759 goto fail;
2760 }
2761 fclose(f);
2762 if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
2763 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2764 git_path_head_file());
2765 goto fail;
2766 }
2767 if (is_null_oid(&oid)) {
2768 error(_("cannot abort from a branch yet to be born"));
2769 goto fail;
2770 }
2771
2772 if (!rollback_is_safe()) {
2773 /* Do not error, just do not rollback */
2774 warning(_("You seem to have moved HEAD. "
2775 "Not rewinding, check your HEAD!"));
2776 } else
2777 if (reset_for_rollback(&oid))
2778 goto fail;
2779 strbuf_release(&buf);
2780 return sequencer_remove_state(opts);
2781fail:
2782 strbuf_release(&buf);
2783 return -1;
2784}
2785
2786static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
2787{
2788 struct lock_file todo_lock = LOCK_INIT;
2789 const char *todo_path = get_todo_path(opts);
2790 int next = todo_list->current, offset, fd;
2791
2792 /*
2793 * rebase -i writes "git-rebase-todo" without the currently executing
2794 * command, appending it to "done" instead.
2795 */
2796 if (is_rebase_i(opts))
2797 next++;
2798
2799 fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
2800 if (fd < 0)
2801 return error_errno(_("could not lock '%s'"), todo_path);
2802 offset = get_item_line_offset(todo_list, next);
2803 if (write_in_full(fd, todo_list->buf.buf + offset,
2804 todo_list->buf.len - offset) < 0)
2805 return error_errno(_("could not write to '%s'"), todo_path);
2806 if (commit_lock_file(&todo_lock) < 0)
2807 return error(_("failed to finalize '%s'"), todo_path);
2808
2809 if (is_rebase_i(opts) && next > 0) {
2810 const char *done = rebase_path_done();
2811 int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
2812 int ret = 0;
2813
2814 if (fd < 0)
2815 return 0;
2816 if (write_in_full(fd, get_item_line(todo_list, next - 1),
2817 get_item_line_length(todo_list, next - 1))
2818 < 0)
2819 ret = error_errno(_("could not write to '%s'"), done);
2820 if (close(fd) < 0)
2821 ret = error_errno(_("failed to finalize '%s'"), done);
2822 return ret;
2823 }
2824 return 0;
2825}
2826
2827static int save_opts(struct replay_opts *opts)
2828{
2829 const char *opts_file = git_path_opts_file();
2830 int res = 0;
2831
2832 if (opts->no_commit)
2833 res |= git_config_set_in_file_gently(opts_file,
2834 "options.no-commit", "true");
2835 if (opts->edit)
2836 res |= git_config_set_in_file_gently(opts_file,
2837 "options.edit", "true");
2838 if (opts->allow_empty)
2839 res |= git_config_set_in_file_gently(opts_file,
2840 "options.allow-empty", "true");
2841 if (opts->allow_empty_message)
2842 res |= git_config_set_in_file_gently(opts_file,
2843 "options.allow-empty-message", "true");
2844 if (opts->keep_redundant_commits)
2845 res |= git_config_set_in_file_gently(opts_file,
2846 "options.keep-redundant-commits", "true");
2847 if (opts->signoff)
2848 res |= git_config_set_in_file_gently(opts_file,
2849 "options.signoff", "true");
2850 if (opts->record_origin)
2851 res |= git_config_set_in_file_gently(opts_file,
2852 "options.record-origin", "true");
2853 if (opts->allow_ff)
2854 res |= git_config_set_in_file_gently(opts_file,
2855 "options.allow-ff", "true");
2856 if (opts->mainline) {
2857 struct strbuf buf = STRBUF_INIT;
2858 strbuf_addf(&buf, "%d", opts->mainline);
2859 res |= git_config_set_in_file_gently(opts_file,
2860 "options.mainline", buf.buf);
2861 strbuf_release(&buf);
2862 }
2863 if (opts->strategy)
2864 res |= git_config_set_in_file_gently(opts_file,
2865 "options.strategy", opts->strategy);
2866 if (opts->gpg_sign)
2867 res |= git_config_set_in_file_gently(opts_file,
2868 "options.gpg-sign", opts->gpg_sign);
2869 if (opts->xopts) {
2870 int i;
2871 for (i = 0; i < opts->xopts_nr; i++)
2872 res |= git_config_set_multivar_in_file_gently(opts_file,
2873 "options.strategy-option",
2874 opts->xopts[i], "^$", 0);
2875 }
2876 if (opts->allow_rerere_auto)
2877 res |= git_config_set_in_file_gently(opts_file,
2878 "options.allow-rerere-auto",
2879 opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
2880 "true" : "false");
2881
2882 if (opts->explicit_cleanup)
2883 res |= git_config_set_in_file_gently(opts_file,
2884 "options.default-msg-cleanup",
2885 describe_cleanup_mode(opts->default_msg_cleanup));
2886 return res;
2887}
2888
2889static int make_patch(struct repository *r,
2890 struct commit *commit,
2891 struct replay_opts *opts)
2892{
2893 struct strbuf buf = STRBUF_INIT;
2894 struct rev_info log_tree_opt;
2895 const char *subject, *p;
2896 int res = 0;
2897
2898 p = short_commit_name(commit);
2899 if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
2900 return -1;
2901 if (update_ref("rebase", "REBASE_HEAD", &commit->object.oid,
2902 NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2903 res |= error(_("could not update %s"), "REBASE_HEAD");
2904
2905 strbuf_addf(&buf, "%s/patch", get_dir(opts));
2906 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
2907 repo_init_revisions(r, &log_tree_opt, NULL);
2908 log_tree_opt.abbrev = 0;
2909 log_tree_opt.diff = 1;
2910 log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
2911 log_tree_opt.disable_stdin = 1;
2912 log_tree_opt.no_commit_id = 1;
2913 log_tree_opt.diffopt.file = fopen(buf.buf, "w");
2914 log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
2915 if (!log_tree_opt.diffopt.file)
2916 res |= error_errno(_("could not open '%s'"), buf.buf);
2917 else {
2918 res |= log_tree_commit(&log_tree_opt, commit);
2919 fclose(log_tree_opt.diffopt.file);
2920 }
2921 strbuf_reset(&buf);
2922
2923 strbuf_addf(&buf, "%s/message", get_dir(opts));
2924 if (!file_exists(buf.buf)) {
2925 const char *commit_buffer = get_commit_buffer(commit, NULL);
2926 find_commit_subject(commit_buffer, &subject);
2927 res |= write_message(subject, strlen(subject), buf.buf, 1);
2928 unuse_commit_buffer(commit, commit_buffer);
2929 }
2930 strbuf_release(&buf);
2931
2932 return res;
2933}
2934
2935static int intend_to_amend(void)
2936{
2937 struct object_id head;
2938 char *p;
2939
2940 if (get_oid("HEAD", &head))
2941 return error(_("cannot read HEAD"));
2942
2943 p = oid_to_hex(&head);
2944 return write_message(p, strlen(p), rebase_path_amend(), 1);
2945}
2946
2947static int error_with_patch(struct repository *r,
2948 struct commit *commit,
2949 const char *subject, int subject_len,
2950 struct replay_opts *opts,
2951 int exit_code, int to_amend)
2952{
2953 if (commit) {
2954 if (make_patch(r, commit, opts))
2955 return -1;
2956 } else if (copy_file(rebase_path_message(),
2957 git_path_merge_msg(r), 0666))
2958 return error(_("unable to copy '%s' to '%s'"),
2959 git_path_merge_msg(r), rebase_path_message());
2960
2961 if (to_amend) {
2962 if (intend_to_amend())
2963 return -1;
2964
2965 fprintf(stderr,
2966 _("You can amend the commit now, with\n"
2967 "\n"
2968 " git commit --amend %s\n"
2969 "\n"
2970 "Once you are satisfied with your changes, run\n"
2971 "\n"
2972 " git rebase --continue\n"),
2973 gpg_sign_opt_quoted(opts));
2974 } else if (exit_code) {
2975 if (commit)
2976 fprintf_ln(stderr, _("Could not apply %s... %.*s"),
2977 short_commit_name(commit), subject_len, subject);
2978 else
2979 /*
2980 * We don't have the hash of the parent so
2981 * just print the line from the todo file.
2982 */
2983 fprintf_ln(stderr, _("Could not merge %.*s"),
2984 subject_len, subject);
2985 }
2986
2987 return exit_code;
2988}
2989
2990static int error_failed_squash(struct repository *r,
2991 struct commit *commit,
2992 struct replay_opts *opts,
2993 int subject_len,
2994 const char *subject)
2995{
2996 if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
2997 return error(_("could not copy '%s' to '%s'"),
2998 rebase_path_squash_msg(), rebase_path_message());
2999 unlink(git_path_merge_msg(r));
3000 if (copy_file(git_path_merge_msg(r), rebase_path_message(), 0666))
3001 return error(_("could not copy '%s' to '%s'"),
3002 rebase_path_message(),
3003 git_path_merge_msg(r));
3004 return error_with_patch(r, commit, subject, subject_len, opts, 1, 0);
3005}
3006
3007static int do_exec(struct repository *r, const char *command_line)
3008{
3009 struct argv_array child_env = ARGV_ARRAY_INIT;
3010 const char *child_argv[] = { NULL, NULL };
3011 int dirty, status;
3012
3013 fprintf(stderr, "Executing: %s\n", command_line);
3014 child_argv[0] = command_line;
3015 argv_array_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
3016 argv_array_pushf(&child_env, "GIT_WORK_TREE=%s",
3017 absolute_path(get_git_work_tree()));
3018 status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
3019 child_env.argv);
3020
3021 /* force re-reading of the cache */
3022 if (discard_index(r->index) < 0 || repo_read_index(r) < 0)
3023 return error(_("could not read index"));
3024
3025 dirty = require_clean_work_tree(r, "rebase", NULL, 1, 1);
3026
3027 if (status) {
3028 warning(_("execution failed: %s\n%s"
3029 "You can fix the problem, and then run\n"
3030 "\n"
3031 " git rebase --continue\n"
3032 "\n"),
3033 command_line,
3034 dirty ? N_("and made changes to the index and/or the "
3035 "working tree\n") : "");
3036 if (status == 127)
3037 /* command not found */
3038 status = 1;
3039 } else if (dirty) {
3040 warning(_("execution succeeded: %s\nbut "
3041 "left changes to the index and/or the working tree\n"
3042 "Commit or stash your changes, and then run\n"
3043 "\n"
3044 " git rebase --continue\n"
3045 "\n"), command_line);
3046 status = 1;
3047 }
3048
3049 argv_array_clear(&child_env);
3050
3051 return status;
3052}
3053
3054static int safe_append(const char *filename, const char *fmt, ...)
3055{
3056 va_list ap;
3057 struct lock_file lock = LOCK_INIT;
3058 int fd = hold_lock_file_for_update(&lock, filename,
3059 LOCK_REPORT_ON_ERROR);
3060 struct strbuf buf = STRBUF_INIT;
3061
3062 if (fd < 0)
3063 return -1;
3064
3065 if (strbuf_read_file(&buf, filename, 0) < 0 && errno != ENOENT) {
3066 error_errno(_("could not read '%s'"), filename);
3067 rollback_lock_file(&lock);
3068 return -1;
3069 }
3070 strbuf_complete(&buf, '\n');
3071 va_start(ap, fmt);
3072 strbuf_vaddf(&buf, fmt, ap);
3073 va_end(ap);
3074
3075 if (write_in_full(fd, buf.buf, buf.len) < 0) {
3076 error_errno(_("could not write to '%s'"), filename);
3077 strbuf_release(&buf);
3078 rollback_lock_file(&lock);
3079 return -1;
3080 }
3081 if (commit_lock_file(&lock) < 0) {
3082 strbuf_release(&buf);
3083 rollback_lock_file(&lock);
3084 return error(_("failed to finalize '%s'"), filename);
3085 }
3086
3087 strbuf_release(&buf);
3088 return 0;
3089}
3090
3091static int do_label(struct repository *r, const char *name, int len)
3092{
3093 struct ref_store *refs = get_main_ref_store(r);
3094 struct ref_transaction *transaction;
3095 struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
3096 struct strbuf msg = STRBUF_INIT;
3097 int ret = 0;
3098 struct object_id head_oid;
3099
3100 if (len == 1 && *name == '#')
3101 return error(_("illegal label name: '%.*s'"), len, name);
3102
3103 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3104 strbuf_addf(&msg, "rebase -i (label) '%.*s'", len, name);
3105
3106 transaction = ref_store_transaction_begin(refs, &err);
3107 if (!transaction) {
3108 error("%s", err.buf);
3109 ret = -1;
3110 } else if (get_oid("HEAD", &head_oid)) {
3111 error(_("could not read HEAD"));
3112 ret = -1;
3113 } else if (ref_transaction_update(transaction, ref_name.buf, &head_oid,
3114 NULL, 0, msg.buf, &err) < 0 ||
3115 ref_transaction_commit(transaction, &err)) {
3116 error("%s", err.buf);
3117 ret = -1;
3118 }
3119 ref_transaction_free(transaction);
3120 strbuf_release(&err);
3121 strbuf_release(&msg);
3122
3123 if (!ret)
3124 ret = safe_append(rebase_path_refs_to_delete(),
3125 "%s\n", ref_name.buf);
3126 strbuf_release(&ref_name);
3127
3128 return ret;
3129}
3130
3131static const char *reflog_message(struct replay_opts *opts,
3132 const char *sub_action, const char *fmt, ...);
3133
3134static int do_reset(struct repository *r,
3135 const char *name, int len,
3136 struct replay_opts *opts)
3137{
3138 struct strbuf ref_name = STRBUF_INIT;
3139 struct object_id oid;
3140 struct lock_file lock = LOCK_INIT;
3141 struct tree_desc desc;
3142 struct tree *tree;
3143 struct unpack_trees_options unpack_tree_opts;
3144 int ret = 0;
3145
3146 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0)
3147 return -1;
3148
3149 if (len == 10 && !strncmp("[new root]", name, len)) {
3150 if (!opts->have_squash_onto) {
3151 const char *hex;
3152 if (commit_tree("", 0, the_hash_algo->empty_tree,
3153 NULL, &opts->squash_onto,
3154 NULL, NULL))
3155 return error(_("writing fake root commit"));
3156 opts->have_squash_onto = 1;
3157 hex = oid_to_hex(&opts->squash_onto);
3158 if (write_message(hex, strlen(hex),
3159 rebase_path_squash_onto(), 0))
3160 return error(_("writing squash-onto"));
3161 }
3162 oidcpy(&oid, &opts->squash_onto);
3163 } else {
3164 int i;
3165
3166 /* Determine the length of the label */
3167 for (i = 0; i < len; i++)
3168 if (isspace(name[i]))
3169 break;
3170 len = i;
3171
3172 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3173 if (get_oid(ref_name.buf, &oid) &&
3174 get_oid(ref_name.buf + strlen("refs/rewritten/"), &oid)) {
3175 error(_("could not read '%s'"), ref_name.buf);
3176 rollback_lock_file(&lock);
3177 strbuf_release(&ref_name);
3178 return -1;
3179 }
3180 }
3181
3182 memset(&unpack_tree_opts, 0, sizeof(unpack_tree_opts));
3183 setup_unpack_trees_porcelain(&unpack_tree_opts, "reset");
3184 unpack_tree_opts.head_idx = 1;
3185 unpack_tree_opts.src_index = r->index;
3186 unpack_tree_opts.dst_index = r->index;
3187 unpack_tree_opts.fn = oneway_merge;
3188 unpack_tree_opts.merge = 1;
3189 unpack_tree_opts.update = 1;
3190
3191 if (repo_read_index_unmerged(r)) {
3192 rollback_lock_file(&lock);
3193 strbuf_release(&ref_name);
3194 return error_resolve_conflict(_(action_name(opts)));
3195 }
3196
3197 if (!fill_tree_descriptor(&desc, &oid)) {
3198 error(_("failed to find tree of %s"), oid_to_hex(&oid));
3199 rollback_lock_file(&lock);
3200 free((void *)desc.buffer);
3201 strbuf_release(&ref_name);
3202 return -1;
3203 }
3204
3205 if (unpack_trees(1, &desc, &unpack_tree_opts)) {
3206 rollback_lock_file(&lock);
3207 free((void *)desc.buffer);
3208 strbuf_release(&ref_name);
3209 return -1;
3210 }
3211
3212 tree = parse_tree_indirect(&oid);
3213 prime_cache_tree(r, r->index, tree);
3214
3215 if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
3216 ret = error(_("could not write index"));
3217 free((void *)desc.buffer);
3218
3219 if (!ret)
3220 ret = update_ref(reflog_message(opts, "reset", "'%.*s'",
3221 len, name), "HEAD", &oid,
3222 NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3223
3224 strbuf_release(&ref_name);
3225 return ret;
3226}
3227
3228static struct commit *lookup_label(const char *label, int len,
3229 struct strbuf *buf)
3230{
3231 struct commit *commit;
3232
3233 strbuf_reset(buf);
3234 strbuf_addf(buf, "refs/rewritten/%.*s", len, label);
3235 commit = lookup_commit_reference_by_name(buf->buf);
3236 if (!commit) {
3237 /* fall back to non-rewritten ref or commit */
3238 strbuf_splice(buf, 0, strlen("refs/rewritten/"), "", 0);
3239 commit = lookup_commit_reference_by_name(buf->buf);
3240 }
3241
3242 if (!commit)
3243 error(_("could not resolve '%s'"), buf->buf);
3244
3245 return commit;
3246}
3247
3248static int do_merge(struct repository *r,
3249 struct commit *commit,
3250 const char *arg, int arg_len,
3251 int flags, struct replay_opts *opts)
3252{
3253 int run_commit_flags = (flags & TODO_EDIT_MERGE_MSG) ?
3254 EDIT_MSG | VERIFY_MSG : 0;
3255 struct strbuf ref_name = STRBUF_INIT;
3256 struct commit *head_commit, *merge_commit, *i;
3257 struct commit_list *bases, *j, *reversed = NULL;
3258 struct commit_list *to_merge = NULL, **tail = &to_merge;
3259 struct merge_options o;
3260 int merge_arg_len, oneline_offset, can_fast_forward, ret, k;
3261 static struct lock_file lock;
3262 const char *p;
3263
3264 if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0) {
3265 ret = -1;
3266 goto leave_merge;
3267 }
3268
3269 head_commit = lookup_commit_reference_by_name("HEAD");
3270 if (!head_commit) {
3271 ret = error(_("cannot merge without a current revision"));
3272 goto leave_merge;
3273 }
3274
3275 /*
3276 * For octopus merges, the arg starts with the list of revisions to be
3277 * merged. The list is optionally followed by '#' and the oneline.
3278 */
3279 merge_arg_len = oneline_offset = arg_len;
3280 for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {
3281 if (!*p)
3282 break;
3283 if (*p == '#' && (!p[1] || isspace(p[1]))) {
3284 p += 1 + strspn(p + 1, " \t\n");
3285 oneline_offset = p - arg;
3286 break;
3287 }
3288 k = strcspn(p, " \t\n");
3289 if (!k)
3290 continue;
3291 merge_commit = lookup_label(p, k, &ref_name);
3292 if (!merge_commit) {
3293 ret = error(_("unable to parse '%.*s'"), k, p);
3294 goto leave_merge;
3295 }
3296 tail = &commit_list_insert(merge_commit, tail)->next;
3297 p += k;
3298 merge_arg_len = p - arg;
3299 }
3300
3301 if (!to_merge) {
3302 ret = error(_("nothing to merge: '%.*s'"), arg_len, arg);
3303 goto leave_merge;
3304 }
3305
3306 if (opts->have_squash_onto &&
3307 oideq(&head_commit->object.oid, &opts->squash_onto)) {
3308 /*
3309 * When the user tells us to "merge" something into a
3310 * "[new root]", let's simply fast-forward to the merge head.
3311 */
3312 rollback_lock_file(&lock);
3313 if (to_merge->next)
3314 ret = error(_("octopus merge cannot be executed on "
3315 "top of a [new root]"));
3316 else
3317 ret = fast_forward_to(r, &to_merge->item->object.oid,
3318 &head_commit->object.oid, 0,
3319 opts);
3320 goto leave_merge;
3321 }
3322
3323 if (commit) {
3324 const char *message = get_commit_buffer(commit, NULL);
3325 const char *body;
3326 int len;
3327
3328 if (!message) {
3329 ret = error(_("could not get commit message of '%s'"),
3330 oid_to_hex(&commit->object.oid));
3331 goto leave_merge;
3332 }
3333 write_author_script(message);
3334 find_commit_subject(message, &body);
3335 len = strlen(body);
3336 ret = write_message(body, len, git_path_merge_msg(r), 0);
3337 unuse_commit_buffer(commit, message);
3338 if (ret) {
3339 error_errno(_("could not write '%s'"),
3340 git_path_merge_msg(r));
3341 goto leave_merge;
3342 }
3343 } else {
3344 struct strbuf buf = STRBUF_INIT;
3345 int len;
3346
3347 strbuf_addf(&buf, "author %s", git_author_info(0));
3348 write_author_script(buf.buf);
3349 strbuf_reset(&buf);
3350
3351 if (oneline_offset < arg_len) {
3352 p = arg + oneline_offset;
3353 len = arg_len - oneline_offset;
3354 } else {
3355 strbuf_addf(&buf, "Merge %s '%.*s'",
3356 to_merge->next ? "branches" : "branch",
3357 merge_arg_len, arg);
3358 p = buf.buf;
3359 len = buf.len;
3360 }
3361
3362 ret = write_message(p, len, git_path_merge_msg(r), 0);
3363 strbuf_release(&buf);
3364 if (ret) {
3365 error_errno(_("could not write '%s'"),
3366 git_path_merge_msg(r));
3367 goto leave_merge;
3368 }
3369 }
3370
3371 /*
3372 * If HEAD is not identical to the first parent of the original merge
3373 * commit, we cannot fast-forward.
3374 */
3375 can_fast_forward = opts->allow_ff && commit && commit->parents &&
3376 oideq(&commit->parents->item->object.oid,
3377 &head_commit->object.oid);
3378
3379 /*
3380 * If any merge head is different from the original one, we cannot
3381 * fast-forward.
3382 */
3383 if (can_fast_forward) {
3384 struct commit_list *p = commit->parents->next;
3385
3386 for (j = to_merge; j && p; j = j->next, p = p->next)
3387 if (!oideq(&j->item->object.oid,
3388 &p->item->object.oid)) {
3389 can_fast_forward = 0;
3390 break;
3391 }
3392 /*
3393 * If the number of merge heads differs from the original merge
3394 * commit, we cannot fast-forward.
3395 */
3396 if (j || p)
3397 can_fast_forward = 0;
3398 }
3399
3400 if (can_fast_forward) {
3401 rollback_lock_file(&lock);
3402 ret = fast_forward_to(r, &commit->object.oid,
3403 &head_commit->object.oid, 0, opts);
3404 goto leave_merge;
3405 }
3406
3407 if (to_merge->next) {
3408 /* Octopus merge */
3409 struct child_process cmd = CHILD_PROCESS_INIT;
3410
3411 if (read_env_script(&cmd.env_array)) {
3412 const char *gpg_opt = gpg_sign_opt_quoted(opts);
3413
3414 ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
3415 goto leave_merge;
3416 }
3417
3418 cmd.git_cmd = 1;
3419 argv_array_push(&cmd.args, "merge");
3420 argv_array_push(&cmd.args, "-s");
3421 argv_array_push(&cmd.args, "octopus");
3422 argv_array_push(&cmd.args, "--no-edit");
3423 argv_array_push(&cmd.args, "--no-ff");
3424 argv_array_push(&cmd.args, "--no-log");
3425 argv_array_push(&cmd.args, "--no-stat");
3426 argv_array_push(&cmd.args, "-F");
3427 argv_array_push(&cmd.args, git_path_merge_msg(r));
3428 if (opts->gpg_sign)
3429 argv_array_push(&cmd.args, opts->gpg_sign);
3430
3431 /* Add the tips to be merged */
3432 for (j = to_merge; j; j = j->next)
3433 argv_array_push(&cmd.args,
3434 oid_to_hex(&j->item->object.oid));
3435
3436 strbuf_release(&ref_name);
3437 unlink(git_path_cherry_pick_head(r));
3438 rollback_lock_file(&lock);
3439
3440 rollback_lock_file(&lock);
3441 ret = run_command(&cmd);
3442
3443 /* force re-reading of the cache */
3444 if (!ret && (discard_index(r->index) < 0 ||
3445 repo_read_index(r) < 0))
3446 ret = error(_("could not read index"));
3447 goto leave_merge;
3448 }
3449
3450 merge_commit = to_merge->item;
3451 bases = get_merge_bases(head_commit, merge_commit);
3452 if (bases && oideq(&merge_commit->object.oid,
3453 &bases->item->object.oid)) {
3454 ret = 0;
3455 /* skip merging an ancestor of HEAD */
3456 goto leave_merge;
3457 }
3458
3459 write_message(oid_to_hex(&merge_commit->object.oid), GIT_SHA1_HEXSZ,
3460 git_path_merge_head(r), 0);
3461 write_message("no-ff", 5, git_path_merge_mode(r), 0);
3462
3463 for (j = bases; j; j = j->next)
3464 commit_list_insert(j->item, &reversed);
3465 free_commit_list(bases);
3466
3467 repo_read_index(r);
3468 init_merge_options(&o, r);
3469 o.branch1 = "HEAD";
3470 o.branch2 = ref_name.buf;
3471 o.buffer_output = 2;
3472
3473 ret = merge_recursive(&o, head_commit, merge_commit, reversed, &i);
3474 if (ret <= 0)
3475 fputs(o.obuf.buf, stdout);
3476 strbuf_release(&o.obuf);
3477 if (ret < 0) {
3478 error(_("could not even attempt to merge '%.*s'"),
3479 merge_arg_len, arg);
3480 goto leave_merge;
3481 }
3482 /*
3483 * The return value of merge_recursive() is 1 on clean, and 0 on
3484 * unclean merge.
3485 *
3486 * Let's reverse that, so that do_merge() returns 0 upon success and
3487 * 1 upon failed merge (keeping the return value -1 for the cases where
3488 * we will want to reschedule the `merge` command).
3489 */
3490 ret = !ret;
3491
3492 if (r->index->cache_changed &&
3493 write_locked_index(r->index, &lock, COMMIT_LOCK)) {
3494 ret = error(_("merge: Unable to write new index file"));
3495 goto leave_merge;
3496 }
3497
3498 rollback_lock_file(&lock);
3499 if (ret)
3500 repo_rerere(r, opts->allow_rerere_auto);
3501 else
3502 /*
3503 * In case of problems, we now want to return a positive
3504 * value (a negative one would indicate that the `merge`
3505 * command needs to be rescheduled).
3506 */
3507 ret = !!run_git_commit(r, git_path_merge_msg(r), opts,
3508 run_commit_flags);
3509
3510leave_merge:
3511 strbuf_release(&ref_name);
3512 rollback_lock_file(&lock);
3513 free_commit_list(to_merge);
3514 return ret;
3515}
3516
3517static int is_final_fixup(struct todo_list *todo_list)
3518{
3519 int i = todo_list->current;
3520
3521 if (!is_fixup(todo_list->items[i].command))
3522 return 0;
3523
3524 while (++i < todo_list->nr)
3525 if (is_fixup(todo_list->items[i].command))
3526 return 0;
3527 else if (!is_noop(todo_list->items[i].command))
3528 break;
3529 return 1;
3530}
3531
3532static enum todo_command peek_command(struct todo_list *todo_list, int offset)
3533{
3534 int i;
3535
3536 for (i = todo_list->current + offset; i < todo_list->nr; i++)
3537 if (!is_noop(todo_list->items[i].command))
3538 return todo_list->items[i].command;
3539
3540 return -1;
3541}
3542
3543static int apply_autostash(struct replay_opts *opts)
3544{
3545 struct strbuf stash_sha1 = STRBUF_INIT;
3546 struct child_process child = CHILD_PROCESS_INIT;
3547 int ret = 0;
3548
3549 if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
3550 strbuf_release(&stash_sha1);
3551 return 0;
3552 }
3553 strbuf_trim(&stash_sha1);
3554
3555 child.git_cmd = 1;
3556 child.no_stdout = 1;
3557 child.no_stderr = 1;
3558 argv_array_push(&child.args, "stash");
3559 argv_array_push(&child.args, "apply");
3560 argv_array_push(&child.args, stash_sha1.buf);
3561 if (!run_command(&child))
3562 fprintf(stderr, _("Applied autostash.\n"));
3563 else {
3564 struct child_process store = CHILD_PROCESS_INIT;
3565
3566 store.git_cmd = 1;
3567 argv_array_push(&store.args, "stash");
3568 argv_array_push(&store.args, "store");
3569 argv_array_push(&store.args, "-m");
3570 argv_array_push(&store.args, "autostash");
3571 argv_array_push(&store.args, "-q");
3572 argv_array_push(&store.args, stash_sha1.buf);
3573 if (run_command(&store))
3574 ret = error(_("cannot store %s"), stash_sha1.buf);
3575 else
3576 fprintf(stderr,
3577 _("Applying autostash resulted in conflicts.\n"
3578 "Your changes are safe in the stash.\n"
3579 "You can run \"git stash pop\" or"
3580 " \"git stash drop\" at any time.\n"));
3581 }
3582
3583 strbuf_release(&stash_sha1);
3584 return ret;
3585}
3586
3587static const char *reflog_message(struct replay_opts *opts,
3588 const char *sub_action, const char *fmt, ...)
3589{
3590 va_list ap;
3591 static struct strbuf buf = STRBUF_INIT;
3592
3593 va_start(ap, fmt);
3594 strbuf_reset(&buf);
3595 strbuf_addstr(&buf, action_name(opts));
3596 if (sub_action)
3597 strbuf_addf(&buf, " (%s)", sub_action);
3598 if (fmt) {
3599 strbuf_addstr(&buf, ": ");
3600 strbuf_vaddf(&buf, fmt, ap);
3601 }
3602 va_end(ap);
3603
3604 return buf.buf;
3605}
3606
3607static int run_git_checkout(struct repository *r, struct replay_opts *opts,
3608 const char *commit, const char *action)
3609{
3610 struct child_process cmd = CHILD_PROCESS_INIT;
3611 int ret;
3612
3613 cmd.git_cmd = 1;
3614
3615 argv_array_push(&cmd.args, "checkout");
3616 argv_array_push(&cmd.args, commit);
3617 argv_array_pushf(&cmd.env_array, GIT_REFLOG_ACTION "=%s", action);
3618
3619 if (opts->verbose)
3620 ret = run_command(&cmd);
3621 else
3622 ret = run_command_silent_on_success(&cmd);
3623
3624 if (!ret)
3625 discard_index(r->index);
3626
3627 return ret;
3628}
3629
3630int prepare_branch_to_be_rebased(struct repository *r, struct replay_opts *opts,
3631 const char *commit)
3632{
3633 const char *action;
3634
3635 if (commit && *commit) {
3636 action = reflog_message(opts, "start", "checkout %s", commit);
3637 if (run_git_checkout(r, opts, commit, action))
3638 return error(_("could not checkout %s"), commit);
3639 }
3640
3641 return 0;
3642}
3643
3644static int checkout_onto(struct repository *r, struct replay_opts *opts,
3645 const char *onto_name, const struct object_id *onto,
3646 const char *orig_head)
3647{
3648 struct object_id oid;
3649 const char *action = reflog_message(opts, "start", "checkout %s", onto_name);
3650
3651 if (get_oid(orig_head, &oid))
3652 return error(_("%s: not a valid OID"), orig_head);
3653
3654 if (run_git_checkout(r, opts, oid_to_hex(onto), action)) {
3655 apply_autostash(opts);
3656 sequencer_remove_state(opts);
3657 return error(_("could not detach HEAD"));
3658 }
3659
3660 return update_ref(NULL, "ORIG_HEAD", &oid, NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3661}
3662
3663static int stopped_at_head(struct repository *r)
3664{
3665 struct object_id head;
3666 struct commit *commit;
3667 struct commit_message message;
3668
3669 if (get_oid("HEAD", &head) ||
3670 !(commit = lookup_commit(r, &head)) ||
3671 parse_commit(commit) || get_message(commit, &message))
3672 fprintf(stderr, _("Stopped at HEAD\n"));
3673 else {
3674 fprintf(stderr, _("Stopped at %s\n"), message.label);
3675 free_message(commit, &message);
3676 }
3677 return 0;
3678
3679}
3680
3681static const char rescheduled_advice[] =
3682N_("Could not execute the todo command\n"
3683"\n"
3684" %.*s"
3685"\n"
3686"It has been rescheduled; To edit the command before continuing, please\n"
3687"edit the todo list first:\n"
3688"\n"
3689" git rebase --edit-todo\n"
3690" git rebase --continue\n");
3691
3692static int pick_commits(struct repository *r,
3693 struct todo_list *todo_list,
3694 struct replay_opts *opts)
3695{
3696 int res = 0, reschedule = 0;
3697
3698 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
3699 if (opts->allow_ff)
3700 assert(!(opts->signoff || opts->no_commit ||
3701 opts->record_origin || opts->edit));
3702 if (read_and_refresh_cache(r, opts))
3703 return -1;
3704
3705 while (todo_list->current < todo_list->nr) {
3706 struct todo_item *item = todo_list->items + todo_list->current;
3707 const char *arg = todo_item_get_arg(todo_list, item);
3708
3709 if (save_todo(todo_list, opts))
3710 return -1;
3711 if (is_rebase_i(opts)) {
3712 if (item->command != TODO_COMMENT) {
3713 FILE *f = fopen(rebase_path_msgnum(), "w");
3714
3715 todo_list->done_nr++;
3716
3717 if (f) {
3718 fprintf(f, "%d\n", todo_list->done_nr);
3719 fclose(f);
3720 }
3721 if (!opts->quiet)
3722 fprintf(stderr, "Rebasing (%d/%d)%s",
3723 todo_list->done_nr,
3724 todo_list->total_nr,
3725 opts->verbose ? "\n" : "\r");
3726 }
3727 unlink(rebase_path_message());
3728 unlink(rebase_path_author_script());
3729 unlink(rebase_path_stopped_sha());
3730 unlink(rebase_path_amend());
3731 unlink(git_path_merge_head(the_repository));
3732 delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
3733
3734 if (item->command == TODO_BREAK)
3735 return stopped_at_head(r);
3736 }
3737 if (item->command <= TODO_SQUASH) {
3738 if (is_rebase_i(opts))
3739 setenv("GIT_REFLOG_ACTION", reflog_message(opts,
3740 command_to_string(item->command), NULL),
3741 1);
3742 res = do_pick_commit(r, item->command, item->commit,
3743 opts, is_final_fixup(todo_list));
3744 if (is_rebase_i(opts) && res < 0) {
3745 /* Reschedule */
3746 advise(_(rescheduled_advice),
3747 get_item_line_length(todo_list,
3748 todo_list->current),
3749 get_item_line(todo_list,
3750 todo_list->current));
3751 todo_list->current--;
3752 if (save_todo(todo_list, opts))
3753 return -1;
3754 }
3755 if (item->command == TODO_EDIT) {
3756 struct commit *commit = item->commit;
3757 if (!res)
3758 fprintf(stderr,
3759 _("Stopped at %s... %.*s\n"),
3760 short_commit_name(commit),
3761 item->arg_len, arg);
3762 return error_with_patch(r, commit,
3763 arg, item->arg_len, opts, res, !res);
3764 }
3765 if (is_rebase_i(opts) && !res)
3766 record_in_rewritten(&item->commit->object.oid,
3767 peek_command(todo_list, 1));
3768 if (res && is_fixup(item->command)) {
3769 if (res == 1)
3770 intend_to_amend();
3771 return error_failed_squash(r, item->commit, opts,
3772 item->arg_len, arg);
3773 } else if (res && is_rebase_i(opts) && item->commit) {
3774 int to_amend = 0;
3775 struct object_id oid;
3776
3777 /*
3778 * If we are rewording and have either
3779 * fast-forwarded already, or are about to
3780 * create a new root commit, we want to amend,
3781 * otherwise we do not.
3782 */
3783 if (item->command == TODO_REWORD &&
3784 !get_oid("HEAD", &oid) &&
3785 (oideq(&item->commit->object.oid, &oid) ||
3786 (opts->have_squash_onto &&
3787 oideq(&opts->squash_onto, &oid))))
3788 to_amend = 1;
3789
3790 return res | error_with_patch(r, item->commit,
3791 arg, item->arg_len, opts,
3792 res, to_amend);
3793 }
3794 } else if (item->command == TODO_EXEC) {
3795 char *end_of_arg = (char *)(arg + item->arg_len);
3796 int saved = *end_of_arg;
3797 struct stat st;
3798
3799 *end_of_arg = '\0';
3800 res = do_exec(r, arg);
3801 *end_of_arg = saved;
3802
3803 if (res) {
3804 if (opts->reschedule_failed_exec)
3805 reschedule = 1;
3806 } else if (stat(get_todo_path(opts), &st))
3807 res = error_errno(_("could not stat '%s'"),
3808 get_todo_path(opts));
3809 else if (match_stat_data(&todo_list->stat, &st)) {
3810 /* Reread the todo file if it has changed. */
3811 todo_list_release(todo_list);
3812 if (read_populate_todo(r, todo_list, opts))
3813 res = -1; /* message was printed */
3814 /* `current` will be incremented below */
3815 todo_list->current = -1;
3816 }
3817 } else if (item->command == TODO_LABEL) {
3818 if ((res = do_label(r, arg, item->arg_len)))
3819 reschedule = 1;
3820 } else if (item->command == TODO_RESET) {
3821 if ((res = do_reset(r, arg, item->arg_len, opts)))
3822 reschedule = 1;
3823 } else if (item->command == TODO_MERGE) {
3824 if ((res = do_merge(r, item->commit,
3825 arg, item->arg_len,
3826 item->flags, opts)) < 0)
3827 reschedule = 1;
3828 else if (item->commit)
3829 record_in_rewritten(&item->commit->object.oid,
3830 peek_command(todo_list, 1));
3831 if (res > 0)
3832 /* failed with merge conflicts */
3833 return error_with_patch(r, item->commit,
3834 arg, item->arg_len,
3835 opts, res, 0);
3836 } else if (!is_noop(item->command))
3837 return error(_("unknown command %d"), item->command);
3838
3839 if (reschedule) {
3840 advise(_(rescheduled_advice),
3841 get_item_line_length(todo_list,
3842 todo_list->current),
3843 get_item_line(todo_list, todo_list->current));
3844 todo_list->current--;
3845 if (save_todo(todo_list, opts))
3846 return -1;
3847 if (item->commit)
3848 return error_with_patch(r,
3849 item->commit,
3850 arg, item->arg_len,
3851 opts, res, 0);
3852 }
3853
3854 todo_list->current++;
3855 if (res)
3856 return res;
3857 }
3858
3859 if (is_rebase_i(opts)) {
3860 struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
3861 struct stat st;
3862
3863 /* Stopped in the middle, as planned? */
3864 if (todo_list->current < todo_list->nr)
3865 return 0;
3866
3867 if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
3868 starts_with(head_ref.buf, "refs/")) {
3869 const char *msg;
3870 struct object_id head, orig;
3871 int res;
3872
3873 if (get_oid("HEAD", &head)) {
3874 res = error(_("cannot read HEAD"));
3875cleanup_head_ref:
3876 strbuf_release(&head_ref);
3877 strbuf_release(&buf);
3878 return res;
3879 }
3880 if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
3881 get_oid_hex(buf.buf, &orig)) {
3882 res = error(_("could not read orig-head"));
3883 goto cleanup_head_ref;
3884 }
3885 strbuf_reset(&buf);
3886 if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
3887 res = error(_("could not read 'onto'"));
3888 goto cleanup_head_ref;
3889 }
3890 msg = reflog_message(opts, "finish", "%s onto %s",
3891 head_ref.buf, buf.buf);
3892 if (update_ref(msg, head_ref.buf, &head, &orig,
3893 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
3894 res = error(_("could not update %s"),
3895 head_ref.buf);
3896 goto cleanup_head_ref;
3897 }
3898 msg = reflog_message(opts, "finish", "returning to %s",
3899 head_ref.buf);
3900 if (create_symref("HEAD", head_ref.buf, msg)) {
3901 res = error(_("could not update HEAD to %s"),
3902 head_ref.buf);
3903 goto cleanup_head_ref;
3904 }
3905 strbuf_reset(&buf);
3906 }
3907
3908 if (opts->verbose) {
3909 struct rev_info log_tree_opt;
3910 struct object_id orig, head;
3911
3912 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
3913 repo_init_revisions(r, &log_tree_opt, NULL);
3914 log_tree_opt.diff = 1;
3915 log_tree_opt.diffopt.output_format =
3916 DIFF_FORMAT_DIFFSTAT;
3917 log_tree_opt.disable_stdin = 1;
3918
3919 if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
3920 !get_oid(buf.buf, &orig) &&
3921 !get_oid("HEAD", &head)) {
3922 diff_tree_oid(&orig, &head, "",
3923 &log_tree_opt.diffopt);
3924 log_tree_diff_flush(&log_tree_opt);
3925 }
3926 }
3927 flush_rewritten_pending();
3928 if (!stat(rebase_path_rewritten_list(), &st) &&
3929 st.st_size > 0) {
3930 struct child_process child = CHILD_PROCESS_INIT;
3931 const char *post_rewrite_hook =
3932 find_hook("post-rewrite");
3933
3934 child.in = open(rebase_path_rewritten_list(), O_RDONLY);
3935 child.git_cmd = 1;
3936 argv_array_push(&child.args, "notes");
3937 argv_array_push(&child.args, "copy");
3938 argv_array_push(&child.args, "--for-rewrite=rebase");
3939 /* we don't care if this copying failed */
3940 run_command(&child);
3941
3942 if (post_rewrite_hook) {
3943 struct child_process hook = CHILD_PROCESS_INIT;
3944
3945 hook.in = open(rebase_path_rewritten_list(),
3946 O_RDONLY);
3947 hook.stdout_to_stderr = 1;
3948 hook.trace2_hook_name = "post-rewrite";
3949 argv_array_push(&hook.args, post_rewrite_hook);
3950 argv_array_push(&hook.args, "rebase");
3951 /* we don't care if this hook failed */
3952 run_command(&hook);
3953 }
3954 }
3955 apply_autostash(opts);
3956
3957 if (!opts->quiet)
3958 fprintf(stderr,
3959 "Successfully rebased and updated %s.\n",
3960 head_ref.buf);
3961
3962 strbuf_release(&buf);
3963 strbuf_release(&head_ref);
3964 }
3965
3966 /*
3967 * Sequence of picks finished successfully; cleanup by
3968 * removing the .git/sequencer directory
3969 */
3970 return sequencer_remove_state(opts);
3971}
3972
3973static int continue_single_pick(struct repository *r)
3974{
3975 const char *argv[] = { "commit", NULL };
3976
3977 if (!file_exists(git_path_cherry_pick_head(r)) &&
3978 !file_exists(git_path_revert_head(r)))
3979 return error(_("no cherry-pick or revert in progress"));
3980 return run_command_v_opt(argv, RUN_GIT_CMD);
3981}
3982
3983static int commit_staged_changes(struct repository *r,
3984 struct replay_opts *opts,
3985 struct todo_list *todo_list)
3986{
3987 unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
3988 unsigned int final_fixup = 0, is_clean;
3989
3990 if (has_unstaged_changes(r, 1))
3991 return error(_("cannot rebase: You have unstaged changes."));
3992
3993 is_clean = !has_uncommitted_changes(r, 0);
3994
3995 if (file_exists(rebase_path_amend())) {
3996 struct strbuf rev = STRBUF_INIT;
3997 struct object_id head, to_amend;
3998
3999 if (get_oid("HEAD", &head))
4000 return error(_("cannot amend non-existing commit"));
4001 if (!read_oneliner(&rev, rebase_path_amend(), 0))
4002 return error(_("invalid file: '%s'"), rebase_path_amend());
4003 if (get_oid_hex(rev.buf, &to_amend))
4004 return error(_("invalid contents: '%s'"),
4005 rebase_path_amend());
4006 if (!is_clean && !oideq(&head, &to_amend))
4007 return error(_("\nYou have uncommitted changes in your "
4008 "working tree. Please, commit them\n"
4009 "first and then run 'git rebase "
4010 "--continue' again."));
4011 /*
4012 * When skipping a failed fixup/squash, we need to edit the
4013 * commit message, the current fixup list and count, and if it
4014 * was the last fixup/squash in the chain, we need to clean up
4015 * the commit message and if there was a squash, let the user
4016 * edit it.
4017 */
4018 if (!is_clean || !opts->current_fixup_count)
4019 ; /* this is not the final fixup */
4020 else if (!oideq(&head, &to_amend) ||
4021 !file_exists(rebase_path_stopped_sha())) {
4022 /* was a final fixup or squash done manually? */
4023 if (!is_fixup(peek_command(todo_list, 0))) {
4024 unlink(rebase_path_fixup_msg());
4025 unlink(rebase_path_squash_msg());
4026 unlink(rebase_path_current_fixups());
4027 strbuf_reset(&opts->current_fixups);
4028 opts->current_fixup_count = 0;
4029 }
4030 } else {
4031 /* we are in a fixup/squash chain */
4032 const char *p = opts->current_fixups.buf;
4033 int len = opts->current_fixups.len;
4034
4035 opts->current_fixup_count--;
4036 if (!len)
4037 BUG("Incorrect current_fixups:\n%s", p);
4038 while (len && p[len - 1] != '\n')
4039 len--;
4040 strbuf_setlen(&opts->current_fixups, len);
4041 if (write_message(p, len, rebase_path_current_fixups(),
4042 0) < 0)
4043 return error(_("could not write file: '%s'"),
4044 rebase_path_current_fixups());
4045
4046 /*
4047 * If a fixup/squash in a fixup/squash chain failed, the
4048 * commit message is already correct, no need to commit
4049 * it again.
4050 *
4051 * Only if it is the final command in the fixup/squash
4052 * chain, and only if the chain is longer than a single
4053 * fixup/squash command (which was just skipped), do we
4054 * actually need to re-commit with a cleaned up commit
4055 * message.
4056 */
4057 if (opts->current_fixup_count > 0 &&
4058 !is_fixup(peek_command(todo_list, 0))) {
4059 final_fixup = 1;
4060 /*
4061 * If there was not a single "squash" in the
4062 * chain, we only need to clean up the commit
4063 * message, no need to bother the user with
4064 * opening the commit message in the editor.
4065 */
4066 if (!starts_with(p, "squash ") &&
4067 !strstr(p, "\nsquash "))
4068 flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;
4069 } else if (is_fixup(peek_command(todo_list, 0))) {
4070 /*
4071 * We need to update the squash message to skip
4072 * the latest commit message.
4073 */
4074 struct commit *commit;
4075 const char *path = rebase_path_squash_msg();
4076
4077 if (parse_head(r, &commit) ||
4078 !(p = get_commit_buffer(commit, NULL)) ||
4079 write_message(p, strlen(p), path, 0)) {
4080 unuse_commit_buffer(commit, p);
4081 return error(_("could not write file: "
4082 "'%s'"), path);
4083 }
4084 unuse_commit_buffer(commit, p);
4085 }
4086 }
4087
4088 strbuf_release(&rev);
4089 flags |= AMEND_MSG;
4090 }
4091
4092 if (is_clean) {
4093 const char *cherry_pick_head = git_path_cherry_pick_head(r);
4094
4095 if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
4096 return error(_("could not remove CHERRY_PICK_HEAD"));
4097 if (!final_fixup)
4098 return 0;
4099 }
4100
4101 if (run_git_commit(r, final_fixup ? NULL : rebase_path_message(),
4102 opts, flags))
4103 return error(_("could not commit staged changes."));
4104 unlink(rebase_path_amend());
4105 unlink(git_path_merge_head(the_repository));
4106 if (final_fixup) {
4107 unlink(rebase_path_fixup_msg());
4108 unlink(rebase_path_squash_msg());
4109 }
4110 if (opts->current_fixup_count > 0) {
4111 /*
4112 * Whether final fixup or not, we just cleaned up the commit
4113 * message...
4114 */
4115 unlink(rebase_path_current_fixups());
4116 strbuf_reset(&opts->current_fixups);
4117 opts->current_fixup_count = 0;
4118 }
4119 return 0;
4120}
4121
4122int sequencer_continue(struct repository *r, struct replay_opts *opts)
4123{
4124 struct todo_list todo_list = TODO_LIST_INIT;
4125 int res;
4126
4127 if (read_and_refresh_cache(r, opts))
4128 return -1;
4129
4130 if (read_populate_opts(opts))
4131 return -1;
4132 if (is_rebase_i(opts)) {
4133 if ((res = read_populate_todo(r, &todo_list, opts)))
4134 goto release_todo_list;
4135 if (commit_staged_changes(r, opts, &todo_list))
4136 return -1;
4137 } else if (!file_exists(get_todo_path(opts)))
4138 return continue_single_pick(r);
4139 else if ((res = read_populate_todo(r, &todo_list, opts)))
4140 goto release_todo_list;
4141
4142 if (!is_rebase_i(opts)) {
4143 /* Verify that the conflict has been resolved */
4144 if (file_exists(git_path_cherry_pick_head(r)) ||
4145 file_exists(git_path_revert_head(r))) {
4146 res = continue_single_pick(r);
4147 if (res)
4148 goto release_todo_list;
4149 }
4150 if (index_differs_from(r, "HEAD", NULL, 0)) {
4151 res = error_dirty_index(r, opts);
4152 goto release_todo_list;
4153 }
4154 todo_list.current++;
4155 } else if (file_exists(rebase_path_stopped_sha())) {
4156 struct strbuf buf = STRBUF_INIT;
4157 struct object_id oid;
4158
4159 if (read_oneliner(&buf, rebase_path_stopped_sha(), 1) &&
4160 !get_oid_committish(buf.buf, &oid))
4161 record_in_rewritten(&oid, peek_command(&todo_list, 0));
4162 strbuf_release(&buf);
4163 }
4164
4165 res = pick_commits(r, &todo_list, opts);
4166release_todo_list:
4167 todo_list_release(&todo_list);
4168 return res;
4169}
4170
4171static int single_pick(struct repository *r,
4172 struct commit *cmit,
4173 struct replay_opts *opts)
4174{
4175 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
4176 return do_pick_commit(r, opts->action == REPLAY_PICK ?
4177 TODO_PICK : TODO_REVERT, cmit, opts, 0);
4178}
4179
4180int sequencer_pick_revisions(struct repository *r,
4181 struct replay_opts *opts)
4182{
4183 struct todo_list todo_list = TODO_LIST_INIT;
4184 struct object_id oid;
4185 int i, res;
4186
4187 assert(opts->revs);
4188 if (read_and_refresh_cache(r, opts))
4189 return -1;
4190
4191 for (i = 0; i < opts->revs->pending.nr; i++) {
4192 struct object_id oid;
4193 const char *name = opts->revs->pending.objects[i].name;
4194
4195 /* This happens when using --stdin. */
4196 if (!strlen(name))
4197 continue;
4198
4199 if (!get_oid(name, &oid)) {
4200 if (!lookup_commit_reference_gently(r, &oid, 1)) {
4201 enum object_type type = oid_object_info(r,
4202 &oid,
4203 NULL);
4204 return error(_("%s: can't cherry-pick a %s"),
4205 name, type_name(type));
4206 }
4207 } else
4208 return error(_("%s: bad revision"), name);
4209 }
4210
4211 /*
4212 * If we were called as "git cherry-pick <commit>", just
4213 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4214 * REVERT_HEAD, and don't touch the sequencer state.
4215 * This means it is possible to cherry-pick in the middle
4216 * of a cherry-pick sequence.
4217 */
4218 if (opts->revs->cmdline.nr == 1 &&
4219 opts->revs->cmdline.rev->whence == REV_CMD_REV &&
4220 opts->revs->no_walk &&
4221 !opts->revs->cmdline.rev->flags) {
4222 struct commit *cmit;
4223 if (prepare_revision_walk(opts->revs))
4224 return error(_("revision walk setup failed"));
4225 cmit = get_revision(opts->revs);
4226 if (!cmit)
4227 return error(_("empty commit set passed"));
4228 if (get_revision(opts->revs))
4229 BUG("unexpected extra commit from walk");
4230 return single_pick(r, cmit, opts);
4231 }
4232
4233 /*
4234 * Start a new cherry-pick/ revert sequence; but
4235 * first, make sure that an existing one isn't in
4236 * progress
4237 */
4238
4239 if (walk_revs_populate_todo(&todo_list, opts) ||
4240 create_seq_dir() < 0)
4241 return -1;
4242 if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
4243 return error(_("can't revert as initial commit"));
4244 if (save_head(oid_to_hex(&oid)))
4245 return -1;
4246 if (save_opts(opts))
4247 return -1;
4248 update_abort_safety_file();
4249 res = pick_commits(r, &todo_list, opts);
4250 todo_list_release(&todo_list);
4251 return res;
4252}
4253
4254void append_signoff(struct strbuf *msgbuf, size_t ignore_footer, unsigned flag)
4255{
4256 unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
4257 struct strbuf sob = STRBUF_INIT;
4258 int has_footer;
4259
4260 strbuf_addstr(&sob, sign_off_header);
4261 strbuf_addstr(&sob, fmt_name(WANT_COMMITTER_IDENT));
4262 strbuf_addch(&sob, '\n');
4263
4264 if (!ignore_footer)
4265 strbuf_complete_line(msgbuf);
4266
4267 /*
4268 * If the whole message buffer is equal to the sob, pretend that we
4269 * found a conforming footer with a matching sob
4270 */
4271 if (msgbuf->len - ignore_footer == sob.len &&
4272 !strncmp(msgbuf->buf, sob.buf, sob.len))
4273 has_footer = 3;
4274 else
4275 has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
4276
4277 if (!has_footer) {
4278 const char *append_newlines = NULL;
4279 size_t len = msgbuf->len - ignore_footer;
4280
4281 if (!len) {
4282 /*
4283 * The buffer is completely empty. Leave foom for
4284 * the title and body to be filled in by the user.
4285 */
4286 append_newlines = "\n\n";
4287 } else if (len == 1) {
4288 /*
4289 * Buffer contains a single newline. Add another
4290 * so that we leave room for the title and body.
4291 */
4292 append_newlines = "\n";
4293 } else if (msgbuf->buf[len - 2] != '\n') {
4294 /*
4295 * Buffer ends with a single newline. Add another
4296 * so that there is an empty line between the message
4297 * body and the sob.
4298 */
4299 append_newlines = "\n";
4300 } /* else, the buffer already ends with two newlines. */
4301
4302 if (append_newlines)
4303 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4304 append_newlines, strlen(append_newlines));
4305 }
4306
4307 if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
4308 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4309 sob.buf, sob.len);
4310
4311 strbuf_release(&sob);
4312}
4313
4314struct labels_entry {
4315 struct hashmap_entry entry;
4316 char label[FLEX_ARRAY];
4317};
4318
4319static int labels_cmp(const void *fndata, const struct labels_entry *a,
4320 const struct labels_entry *b, const void *key)
4321{
4322 return key ? strcmp(a->label, key) : strcmp(a->label, b->label);
4323}
4324
4325struct string_entry {
4326 struct oidmap_entry entry;
4327 char string[FLEX_ARRAY];
4328};
4329
4330struct label_state {
4331 struct oidmap commit2label;
4332 struct hashmap labels;
4333 struct strbuf buf;
4334};
4335
4336static const char *label_oid(struct object_id *oid, const char *label,
4337 struct label_state *state)
4338{
4339 struct labels_entry *labels_entry;
4340 struct string_entry *string_entry;
4341 struct object_id dummy;
4342 size_t len;
4343 int i;
4344
4345 string_entry = oidmap_get(&state->commit2label, oid);
4346 if (string_entry)
4347 return string_entry->string;
4348
4349 /*
4350 * For "uninteresting" commits, i.e. commits that are not to be
4351 * rebased, and which can therefore not be labeled, we use a unique
4352 * abbreviation of the commit name. This is slightly more complicated
4353 * than calling find_unique_abbrev() because we also need to make
4354 * sure that the abbreviation does not conflict with any other
4355 * label.
4356 *
4357 * We disallow "interesting" commits to be labeled by a string that
4358 * is a valid full-length hash, to ensure that we always can find an
4359 * abbreviation for any uninteresting commit's names that does not
4360 * clash with any other label.
4361 */
4362 if (!label) {
4363 char *p;
4364
4365 strbuf_reset(&state->buf);
4366 strbuf_grow(&state->buf, GIT_SHA1_HEXSZ);
4367 label = p = state->buf.buf;
4368
4369 find_unique_abbrev_r(p, oid, default_abbrev);
4370
4371 /*
4372 * We may need to extend the abbreviated hash so that there is
4373 * no conflicting label.
4374 */
4375 if (hashmap_get_from_hash(&state->labels, strihash(p), p)) {
4376 size_t i = strlen(p) + 1;
4377
4378 oid_to_hex_r(p, oid);
4379 for (; i < GIT_SHA1_HEXSZ; i++) {
4380 char save = p[i];
4381 p[i] = '\0';
4382 if (!hashmap_get_from_hash(&state->labels,
4383 strihash(p), p))
4384 break;
4385 p[i] = save;
4386 }
4387 }
4388 } else if (((len = strlen(label)) == the_hash_algo->hexsz &&
4389 !get_oid_hex(label, &dummy)) ||
4390 (len == 1 && *label == '#') ||
4391 hashmap_get_from_hash(&state->labels,
4392 strihash(label), label)) {
4393 /*
4394 * If the label already exists, or if the label is a valid full
4395 * OID, or the label is a '#' (which we use as a separator
4396 * between merge heads and oneline), we append a dash and a
4397 * number to make it unique.
4398 */
4399 struct strbuf *buf = &state->buf;
4400
4401 strbuf_reset(buf);
4402 strbuf_add(buf, label, len);
4403
4404 for (i = 2; ; i++) {
4405 strbuf_setlen(buf, len);
4406 strbuf_addf(buf, "-%d", i);
4407 if (!hashmap_get_from_hash(&state->labels,
4408 strihash(buf->buf),
4409 buf->buf))
4410 break;
4411 }
4412
4413 label = buf->buf;
4414 }
4415
4416 FLEX_ALLOC_STR(labels_entry, label, label);
4417 hashmap_entry_init(labels_entry, strihash(label));
4418 hashmap_add(&state->labels, labels_entry);
4419
4420 FLEX_ALLOC_STR(string_entry, string, label);
4421 oidcpy(&string_entry->entry.oid, oid);
4422 oidmap_put(&state->commit2label, string_entry);
4423
4424 return string_entry->string;
4425}
4426
4427static int make_script_with_merges(struct pretty_print_context *pp,
4428 struct rev_info *revs, struct strbuf *out,
4429 unsigned flags)
4430{
4431 int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4432 int rebase_cousins = flags & TODO_LIST_REBASE_COUSINS;
4433 struct strbuf buf = STRBUF_INIT, oneline = STRBUF_INIT;
4434 struct strbuf label = STRBUF_INIT;
4435 struct commit_list *commits = NULL, **tail = &commits, *iter;
4436 struct commit_list *tips = NULL, **tips_tail = &tips;
4437 struct commit *commit;
4438 struct oidmap commit2todo = OIDMAP_INIT;
4439 struct string_entry *entry;
4440 struct oidset interesting = OIDSET_INIT, child_seen = OIDSET_INIT,
4441 shown = OIDSET_INIT;
4442 struct label_state state = { OIDMAP_INIT, { NULL }, STRBUF_INIT };
4443
4444 int abbr = flags & TODO_LIST_ABBREVIATE_CMDS;
4445 const char *cmd_pick = abbr ? "p" : "pick",
4446 *cmd_label = abbr ? "l" : "label",
4447 *cmd_reset = abbr ? "t" : "reset",
4448 *cmd_merge = abbr ? "m" : "merge";
4449
4450 oidmap_init(&commit2todo, 0);
4451 oidmap_init(&state.commit2label, 0);
4452 hashmap_init(&state.labels, (hashmap_cmp_fn) labels_cmp, NULL, 0);
4453 strbuf_init(&state.buf, 32);
4454
4455 if (revs->cmdline.nr && (revs->cmdline.rev[0].flags & BOTTOM)) {
4456 struct object_id *oid = &revs->cmdline.rev[0].item->oid;
4457 FLEX_ALLOC_STR(entry, string, "onto");
4458 oidcpy(&entry->entry.oid, oid);
4459 oidmap_put(&state.commit2label, entry);
4460 }
4461
4462 /*
4463 * First phase:
4464 * - get onelines for all commits
4465 * - gather all branch tips (i.e. 2nd or later parents of merges)
4466 * - label all branch tips
4467 */
4468 while ((commit = get_revision(revs))) {
4469 struct commit_list *to_merge;
4470 const char *p1, *p2;
4471 struct object_id *oid;
4472 int is_empty;
4473
4474 tail = &commit_list_insert(commit, tail)->next;
4475 oidset_insert(&interesting, &commit->object.oid);
4476
4477 is_empty = is_original_commit_empty(commit);
4478 if (!is_empty && (commit->object.flags & PATCHSAME))
4479 continue;
4480
4481 strbuf_reset(&oneline);
4482 pretty_print_commit(pp, commit, &oneline);
4483
4484 to_merge = commit->parents ? commit->parents->next : NULL;
4485 if (!to_merge) {
4486 /* non-merge commit: easy case */
4487 strbuf_reset(&buf);
4488 if (!keep_empty && is_empty)
4489 strbuf_addf(&buf, "%c ", comment_line_char);
4490 strbuf_addf(&buf, "%s %s %s", cmd_pick,
4491 oid_to_hex(&commit->object.oid),
4492 oneline.buf);
4493
4494 FLEX_ALLOC_STR(entry, string, buf.buf);
4495 oidcpy(&entry->entry.oid, &commit->object.oid);
4496 oidmap_put(&commit2todo, entry);
4497
4498 continue;
4499 }
4500
4501 /* Create a label */
4502 strbuf_reset(&label);
4503 if (skip_prefix(oneline.buf, "Merge ", &p1) &&
4504 (p1 = strchr(p1, '\'')) &&
4505 (p2 = strchr(++p1, '\'')))
4506 strbuf_add(&label, p1, p2 - p1);
4507 else if (skip_prefix(oneline.buf, "Merge pull request ",
4508 &p1) &&
4509 (p1 = strstr(p1, " from ")))
4510 strbuf_addstr(&label, p1 + strlen(" from "));
4511 else
4512 strbuf_addbuf(&label, &oneline);
4513
4514 for (p1 = label.buf; *p1; p1++)
4515 if (isspace(*p1))
4516 *(char *)p1 = '-';
4517
4518 strbuf_reset(&buf);
4519 strbuf_addf(&buf, "%s -C %s",
4520 cmd_merge, oid_to_hex(&commit->object.oid));
4521
4522 /* label the tips of merged branches */
4523 for (; to_merge; to_merge = to_merge->next) {
4524 oid = &to_merge->item->object.oid;
4525 strbuf_addch(&buf, ' ');
4526
4527 if (!oidset_contains(&interesting, oid)) {
4528 strbuf_addstr(&buf, label_oid(oid, NULL,
4529 &state));
4530 continue;
4531 }
4532
4533 tips_tail = &commit_list_insert(to_merge->item,
4534 tips_tail)->next;
4535
4536 strbuf_addstr(&buf, label_oid(oid, label.buf, &state));
4537 }
4538 strbuf_addf(&buf, " # %s", oneline.buf);
4539
4540 FLEX_ALLOC_STR(entry, string, buf.buf);
4541 oidcpy(&entry->entry.oid, &commit->object.oid);
4542 oidmap_put(&commit2todo, entry);
4543 }
4544
4545 /*
4546 * Second phase:
4547 * - label branch points
4548 * - add HEAD to the branch tips
4549 */
4550 for (iter = commits; iter; iter = iter->next) {
4551 struct commit_list *parent = iter->item->parents;
4552 for (; parent; parent = parent->next) {
4553 struct object_id *oid = &parent->item->object.oid;
4554 if (!oidset_contains(&interesting, oid))
4555 continue;
4556 if (oidset_insert(&child_seen, oid))
4557 label_oid(oid, "branch-point", &state);
4558 }
4559
4560 /* Add HEAD as implict "tip of branch" */
4561 if (!iter->next)
4562 tips_tail = &commit_list_insert(iter->item,
4563 tips_tail)->next;
4564 }
4565
4566 /*
4567 * Third phase: output the todo list. This is a bit tricky, as we
4568 * want to avoid jumping back and forth between revisions. To
4569 * accomplish that goal, we walk backwards from the branch tips,
4570 * gathering commits not yet shown, reversing the list on the fly,
4571 * then outputting that list (labeling revisions as needed).
4572 */
4573 strbuf_addf(out, "%s onto\n", cmd_label);
4574 for (iter = tips; iter; iter = iter->next) {
4575 struct commit_list *list = NULL, *iter2;
4576
4577 commit = iter->item;
4578 if (oidset_contains(&shown, &commit->object.oid))
4579 continue;
4580 entry = oidmap_get(&state.commit2label, &commit->object.oid);
4581
4582 if (entry)
4583 strbuf_addf(out, "\n%c Branch %s\n", comment_line_char, entry->string);
4584 else
4585 strbuf_addch(out, '\n');
4586
4587 while (oidset_contains(&interesting, &commit->object.oid) &&
4588 !oidset_contains(&shown, &commit->object.oid)) {
4589 commit_list_insert(commit, &list);
4590 if (!commit->parents) {
4591 commit = NULL;
4592 break;
4593 }
4594 commit = commit->parents->item;
4595 }
4596
4597 if (!commit)
4598 strbuf_addf(out, "%s %s\n", cmd_reset,
4599 rebase_cousins ? "onto" : "[new root]");
4600 else {
4601 const char *to = NULL;
4602
4603 entry = oidmap_get(&state.commit2label,
4604 &commit->object.oid);
4605 if (entry)
4606 to = entry->string;
4607 else if (!rebase_cousins)
4608 to = label_oid(&commit->object.oid, NULL,
4609 &state);
4610
4611 if (!to || !strcmp(to, "onto"))
4612 strbuf_addf(out, "%s onto\n", cmd_reset);
4613 else {
4614 strbuf_reset(&oneline);
4615 pretty_print_commit(pp, commit, &oneline);
4616 strbuf_addf(out, "%s %s # %s\n",
4617 cmd_reset, to, oneline.buf);
4618 }
4619 }
4620
4621 for (iter2 = list; iter2; iter2 = iter2->next) {
4622 struct object_id *oid = &iter2->item->object.oid;
4623 entry = oidmap_get(&commit2todo, oid);
4624 /* only show if not already upstream */
4625 if (entry)
4626 strbuf_addf(out, "%s\n", entry->string);
4627 entry = oidmap_get(&state.commit2label, oid);
4628 if (entry)
4629 strbuf_addf(out, "%s %s\n",
4630 cmd_label, entry->string);
4631 oidset_insert(&shown, oid);
4632 }
4633
4634 free_commit_list(list);
4635 }
4636
4637 free_commit_list(commits);
4638 free_commit_list(tips);
4639
4640 strbuf_release(&label);
4641 strbuf_release(&oneline);
4642 strbuf_release(&buf);
4643
4644 oidmap_free(&commit2todo, 1);
4645 oidmap_free(&state.commit2label, 1);
4646 hashmap_free(&state.labels, 1);
4647 strbuf_release(&state.buf);
4648
4649 return 0;
4650}
4651
4652int sequencer_make_script(struct repository *r, struct strbuf *out, int argc,
4653 const char **argv, unsigned flags)
4654{
4655 char *format = NULL;
4656 struct pretty_print_context pp = {0};
4657 struct rev_info revs;
4658 struct commit *commit;
4659 int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4660 const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";
4661 int rebase_merges = flags & TODO_LIST_REBASE_MERGES;
4662
4663 repo_init_revisions(r, &revs, NULL);
4664 revs.verbose_header = 1;
4665 if (!rebase_merges)
4666 revs.max_parents = 1;
4667 revs.cherry_mark = 1;
4668 revs.limited = 1;
4669 revs.reverse = 1;
4670 revs.right_only = 1;
4671 revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
4672 revs.topo_order = 1;
4673
4674 revs.pretty_given = 1;
4675 git_config_get_string("rebase.instructionFormat", &format);
4676 if (!format || !*format) {
4677 free(format);
4678 format = xstrdup("%s");
4679 }
4680 get_commit_format(format, &revs);
4681 free(format);
4682 pp.fmt = revs.commit_format;
4683 pp.output_encoding = get_log_output_encoding();
4684
4685 if (setup_revisions(argc, argv, &revs, NULL) > 1)
4686 return error(_("make_script: unhandled options"));
4687
4688 if (prepare_revision_walk(&revs) < 0)
4689 return error(_("make_script: error preparing revisions"));
4690
4691 if (rebase_merges)
4692 return make_script_with_merges(&pp, &revs, out, flags);
4693
4694 while ((commit = get_revision(&revs))) {
4695 int is_empty = is_original_commit_empty(commit);
4696
4697 if (!is_empty && (commit->object.flags & PATCHSAME))
4698 continue;
4699 if (!keep_empty && is_empty)
4700 strbuf_addf(out, "%c ", comment_line_char);
4701 strbuf_addf(out, "%s %s ", insn,
4702 oid_to_hex(&commit->object.oid));
4703 pretty_print_commit(&pp, commit, out);
4704 strbuf_addch(out, '\n');
4705 }
4706 return 0;
4707}
4708
4709/*
4710 * Add commands after pick and (series of) squash/fixup commands
4711 * in the todo list.
4712 */
4713void todo_list_add_exec_commands(struct todo_list *todo_list,
4714 struct string_list *commands)
4715{
4716 struct strbuf *buf = &todo_list->buf;
4717 size_t base_offset = buf->len;
4718 int i, insert, nr = 0, alloc = 0;
4719 struct todo_item *items = NULL, *base_items = NULL;
4720
4721 base_items = xcalloc(commands->nr, sizeof(struct todo_item));
4722 for (i = 0; i < commands->nr; i++) {
4723 size_t command_len = strlen(commands->items[i].string);
4724
4725 strbuf_addstr(buf, commands->items[i].string);
4726 strbuf_addch(buf, '\n');
4727
4728 base_items[i].command = TODO_EXEC;
4729 base_items[i].offset_in_buf = base_offset;
4730 base_items[i].arg_offset = base_offset + strlen("exec ");
4731 base_items[i].arg_len = command_len - strlen("exec ");
4732
4733 base_offset += command_len + 1;
4734 }
4735
4736 /*
4737 * Insert <commands> after every pick. Here, fixup/squash chains
4738 * are considered part of the pick, so we insert the commands *after*
4739 * those chains if there are any.
4740 *
4741 * As we insert the exec commands immediatly after rearranging
4742 * any fixups and before the user edits the list, a fixup chain
4743 * can never contain comments (any comments are empty picks that
4744 * have been commented out because the user did not specify
4745 * --keep-empty). So, it is safe to insert an exec command
4746 * without looking at the command following a comment.
4747 */
4748 insert = 0;
4749 for (i = 0; i < todo_list->nr; i++) {
4750 enum todo_command command = todo_list->items[i].command;
4751 if (insert && !is_fixup(command)) {
4752 ALLOC_GROW(items, nr + commands->nr, alloc);
4753 COPY_ARRAY(items + nr, base_items, commands->nr);
4754 nr += commands->nr;
4755
4756 insert = 0;
4757 }
4758
4759 ALLOC_GROW(items, nr + 1, alloc);
4760 items[nr++] = todo_list->items[i];
4761
4762 if (command == TODO_PICK || command == TODO_MERGE)
4763 insert = 1;
4764 }
4765
4766 /* insert or append final <commands> */
4767 if (insert || nr == todo_list->nr) {
4768 ALLOC_GROW(items, nr + commands->nr, alloc);
4769 COPY_ARRAY(items + nr, base_items, commands->nr);
4770 nr += commands->nr;
4771 }
4772
4773 free(base_items);
4774 FREE_AND_NULL(todo_list->items);
4775 todo_list->items = items;
4776 todo_list->nr = nr;
4777 todo_list->alloc = alloc;
4778}
4779
4780static void todo_list_to_strbuf(struct repository *r, struct todo_list *todo_list,
4781 struct strbuf *buf, int num, unsigned flags)
4782{
4783 struct todo_item *item;
4784 int i, max = todo_list->nr;
4785
4786 if (num > 0 && num < max)
4787 max = num;
4788
4789 for (item = todo_list->items, i = 0; i < max; i++, item++) {
4790 /* if the item is not a command write it and continue */
4791 if (item->command >= TODO_COMMENT) {
4792 strbuf_addf(buf, "%.*s\n", item->arg_len,
4793 todo_item_get_arg(todo_list, item));
4794 continue;
4795 }
4796
4797 /* add command to the buffer */
4798 if (flags & TODO_LIST_ABBREVIATE_CMDS)
4799 strbuf_addch(buf, command_to_char(item->command));
4800 else
4801 strbuf_addstr(buf, command_to_string(item->command));
4802
4803 /* add commit id */
4804 if (item->commit) {
4805 const char *oid = flags & TODO_LIST_SHORTEN_IDS ?
4806 short_commit_name(item->commit) :
4807 oid_to_hex(&item->commit->object.oid);
4808
4809 if (item->command == TODO_MERGE) {
4810 if (item->flags & TODO_EDIT_MERGE_MSG)
4811 strbuf_addstr(buf, " -c");
4812 else
4813 strbuf_addstr(buf, " -C");
4814 }
4815
4816 strbuf_addf(buf, " %s", oid);
4817 }
4818
4819 /* add all the rest */
4820 if (!item->arg_len)
4821 strbuf_addch(buf, '\n');
4822 else
4823 strbuf_addf(buf, " %.*s\n", item->arg_len,
4824 todo_item_get_arg(todo_list, item));
4825 }
4826}
4827
4828int todo_list_write_to_file(struct repository *r, struct todo_list *todo_list,
4829 const char *file, const char *shortrevisions,
4830 const char *shortonto, int num, unsigned flags)
4831{
4832 int res;
4833 struct strbuf buf = STRBUF_INIT;
4834
4835 todo_list_to_strbuf(r, todo_list, &buf, num, flags);
4836 if (flags & TODO_LIST_APPEND_TODO_HELP)
4837 append_todo_help(flags & TODO_LIST_KEEP_EMPTY, count_commands(todo_list),
4838 shortrevisions, shortonto, &buf);
4839
4840 res = write_message(buf.buf, buf.len, file, 0);
4841 strbuf_release(&buf);
4842
4843 return res;
4844}
4845
4846static const char edit_todo_list_advice[] =
4847N_("You can fix this with 'git rebase --edit-todo' "
4848"and then run 'git rebase --continue'.\n"
4849"Or you can abort the rebase with 'git rebase"
4850" --abort'.\n");
4851
4852int check_todo_list_from_file(struct repository *r)
4853{
4854 struct todo_list old_todo = TODO_LIST_INIT, new_todo = TODO_LIST_INIT;
4855 int res = 0;
4856
4857 if (strbuf_read_file_or_whine(&new_todo.buf, rebase_path_todo()) < 0) {
4858 res = -1;
4859 goto out;
4860 }
4861
4862 if (strbuf_read_file_or_whine(&old_todo.buf, rebase_path_todo_backup()) < 0) {
4863 res = -1;
4864 goto out;
4865 }
4866
4867 res = todo_list_parse_insn_buffer(r, old_todo.buf.buf, &old_todo);
4868 if (!res)
4869 res = todo_list_parse_insn_buffer(r, new_todo.buf.buf, &new_todo);
4870 if (!res)
4871 res = todo_list_check(&old_todo, &new_todo);
4872 if (res)
4873 fprintf(stderr, _(edit_todo_list_advice));
4874out:
4875 todo_list_release(&old_todo);
4876 todo_list_release(&new_todo);
4877
4878 return res;
4879}
4880
4881/* skip picking commits whose parents are unchanged */
4882static int skip_unnecessary_picks(struct repository *r,
4883 struct todo_list *todo_list,
4884 struct object_id *base_oid)
4885{
4886 struct object_id *parent_oid;
4887 int i;
4888
4889 for (i = 0; i < todo_list->nr; i++) {
4890 struct todo_item *item = todo_list->items + i;
4891
4892 if (item->command >= TODO_NOOP)
4893 continue;
4894 if (item->command != TODO_PICK)
4895 break;
4896 if (parse_commit(item->commit)) {
4897 return error(_("could not parse commit '%s'"),
4898 oid_to_hex(&item->commit->object.oid));
4899 }
4900 if (!item->commit->parents)
4901 break; /* root commit */
4902 if (item->commit->parents->next)
4903 break; /* merge commit */
4904 parent_oid = &item->commit->parents->item->object.oid;
4905 if (!oideq(parent_oid, base_oid))
4906 break;
4907 oidcpy(base_oid, &item->commit->object.oid);
4908 }
4909 if (i > 0) {
4910 const char *done_path = rebase_path_done();
4911
4912 if (todo_list_write_to_file(r, todo_list, done_path, NULL, NULL, i, 0)) {
4913 error_errno(_("could not write to '%s'"), done_path);
4914 return -1;
4915 }
4916
4917 MOVE_ARRAY(todo_list->items, todo_list->items + i, todo_list->nr - i);
4918 todo_list->nr -= i;
4919 todo_list->current = 0;
4920
4921 if (is_fixup(peek_command(todo_list, 0)))
4922 record_in_rewritten(base_oid, peek_command(todo_list, 0));
4923 }
4924
4925 return 0;
4926}
4927
4928int complete_action(struct repository *r, struct replay_opts *opts, unsigned flags,
4929 const char *shortrevisions, const char *onto_name,
4930 struct commit *onto, const char *orig_head,
4931 struct string_list *commands, unsigned autosquash,
4932 struct todo_list *todo_list)
4933{
4934 const char *shortonto, *todo_file = rebase_path_todo();
4935 struct todo_list new_todo = TODO_LIST_INIT;
4936 struct strbuf *buf = &todo_list->buf;
4937 struct object_id oid = onto->object.oid;
4938 int res;
4939
4940 shortonto = find_unique_abbrev(&oid, DEFAULT_ABBREV);
4941
4942 if (buf->len == 0) {
4943 struct todo_item *item = append_new_todo(todo_list);
4944 item->command = TODO_NOOP;
4945 item->commit = NULL;
4946 item->arg_len = item->arg_offset = item->flags = item->offset_in_buf = 0;
4947 }
4948
4949 if (autosquash && todo_list_rearrange_squash(todo_list))
4950 return -1;
4951
4952 if (commands->nr)
4953 todo_list_add_exec_commands(todo_list, commands);
4954
4955 if (count_commands(todo_list) == 0) {
4956 apply_autostash(opts);
4957 sequencer_remove_state(opts);
4958
4959 return error(_("nothing to do"));
4960 }
4961
4962 res = edit_todo_list(r, todo_list, &new_todo, shortrevisions,
4963 shortonto, flags);
4964 if (res == -1)
4965 return -1;
4966 else if (res == -2) {
4967 apply_autostash(opts);
4968 sequencer_remove_state(opts);
4969
4970 return -1;
4971 } else if (res == -3) {
4972 apply_autostash(opts);
4973 sequencer_remove_state(opts);
4974 todo_list_release(&new_todo);
4975
4976 return error(_("nothing to do"));
4977 }
4978
4979 if (todo_list_parse_insn_buffer(r, new_todo.buf.buf, &new_todo) ||
4980 todo_list_check(todo_list, &new_todo)) {
4981 fprintf(stderr, _(edit_todo_list_advice));
4982 checkout_onto(r, opts, onto_name, &onto->object.oid, orig_head);
4983 todo_list_release(&new_todo);
4984
4985 return -1;
4986 }
4987
4988 if (opts->allow_ff && skip_unnecessary_picks(r, &new_todo, &oid)) {
4989 todo_list_release(&new_todo);
4990 return error(_("could not skip unnecessary pick commands"));
4991 }
4992
4993 if (todo_list_write_to_file(r, &new_todo, todo_file, NULL, NULL, -1,
4994 flags & ~(TODO_LIST_SHORTEN_IDS))) {
4995 todo_list_release(&new_todo);
4996 return error_errno(_("could not write '%s'"), todo_file);
4997 }
4998
4999 todo_list_release(&new_todo);
5000
5001 if (checkout_onto(r, opts, onto_name, &oid, orig_head))
5002 return -1;
5003
5004 if (require_clean_work_tree(r, "rebase", "", 1, 1))
5005 return -1;
5006
5007 return sequencer_continue(r, opts);
5008}
5009
5010struct subject2item_entry {
5011 struct hashmap_entry entry;
5012 int i;
5013 char subject[FLEX_ARRAY];
5014};
5015
5016static int subject2item_cmp(const void *fndata,
5017 const struct subject2item_entry *a,
5018 const struct subject2item_entry *b, const void *key)
5019{
5020 return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
5021}
5022
5023define_commit_slab(commit_todo_item, struct todo_item *);
5024
5025/*
5026 * Rearrange the todo list that has both "pick commit-id msg" and "pick
5027 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
5028 * after the former, and change "pick" to "fixup"/"squash".
5029 *
5030 * Note that if the config has specified a custom instruction format, each log
5031 * message will have to be retrieved from the commit (as the oneline in the
5032 * script cannot be trusted) in order to normalize the autosquash arrangement.
5033 */
5034int todo_list_rearrange_squash(struct todo_list *todo_list)
5035{
5036 struct hashmap subject2item;
5037 int rearranged = 0, *next, *tail, i, nr = 0, alloc = 0;
5038 char **subjects;
5039 struct commit_todo_item commit_todo;
5040 struct todo_item *items = NULL;
5041
5042 init_commit_todo_item(&commit_todo);
5043 /*
5044 * The hashmap maps onelines to the respective todo list index.
5045 *
5046 * If any items need to be rearranged, the next[i] value will indicate
5047 * which item was moved directly after the i'th.
5048 *
5049 * In that case, last[i] will indicate the index of the latest item to
5050 * be moved to appear after the i'th.
5051 */
5052 hashmap_init(&subject2item, (hashmap_cmp_fn) subject2item_cmp,
5053 NULL, todo_list->nr);
5054 ALLOC_ARRAY(next, todo_list->nr);
5055 ALLOC_ARRAY(tail, todo_list->nr);
5056 ALLOC_ARRAY(subjects, todo_list->nr);
5057 for (i = 0; i < todo_list->nr; i++) {
5058 struct strbuf buf = STRBUF_INIT;
5059 struct todo_item *item = todo_list->items + i;
5060 const char *commit_buffer, *subject, *p;
5061 size_t subject_len;
5062 int i2 = -1;
5063 struct subject2item_entry *entry;
5064
5065 next[i] = tail[i] = -1;
5066 if (!item->commit || item->command == TODO_DROP) {
5067 subjects[i] = NULL;
5068 continue;
5069 }
5070
5071 if (is_fixup(item->command)) {
5072 clear_commit_todo_item(&commit_todo);
5073 return error(_("the script was already rearranged."));
5074 }
5075
5076 *commit_todo_item_at(&commit_todo, item->commit) = item;
5077
5078 parse_commit(item->commit);
5079 commit_buffer = get_commit_buffer(item->commit, NULL);
5080 find_commit_subject(commit_buffer, &subject);
5081 format_subject(&buf, subject, " ");
5082 subject = subjects[i] = strbuf_detach(&buf, &subject_len);
5083 unuse_commit_buffer(item->commit, commit_buffer);
5084 if ((skip_prefix(subject, "fixup! ", &p) ||
5085 skip_prefix(subject, "squash! ", &p))) {
5086 struct commit *commit2;
5087
5088 for (;;) {
5089 while (isspace(*p))
5090 p++;
5091 if (!skip_prefix(p, "fixup! ", &p) &&
5092 !skip_prefix(p, "squash! ", &p))
5093 break;
5094 }
5095
5096 if ((entry = hashmap_get_from_hash(&subject2item,
5097 strhash(p), p)))
5098 /* found by title */
5099 i2 = entry->i;
5100 else if (!strchr(p, ' ') &&
5101 (commit2 =
5102 lookup_commit_reference_by_name(p)) &&
5103 *commit_todo_item_at(&commit_todo, commit2))
5104 /* found by commit name */
5105 i2 = *commit_todo_item_at(&commit_todo, commit2)
5106 - todo_list->items;
5107 else {
5108 /* copy can be a prefix of the commit subject */
5109 for (i2 = 0; i2 < i; i2++)
5110 if (subjects[i2] &&
5111 starts_with(subjects[i2], p))
5112 break;
5113 if (i2 == i)
5114 i2 = -1;
5115 }
5116 }
5117 if (i2 >= 0) {
5118 rearranged = 1;
5119 todo_list->items[i].command =
5120 starts_with(subject, "fixup!") ?
5121 TODO_FIXUP : TODO_SQUASH;
5122 if (next[i2] < 0)
5123 next[i2] = i;
5124 else
5125 next[tail[i2]] = i;
5126 tail[i2] = i;
5127 } else if (!hashmap_get_from_hash(&subject2item,
5128 strhash(subject), subject)) {
5129 FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
5130 entry->i = i;
5131 hashmap_entry_init(entry, strhash(entry->subject));
5132 hashmap_put(&subject2item, entry);
5133 }
5134 }
5135
5136 if (rearranged) {
5137 for (i = 0; i < todo_list->nr; i++) {
5138 enum todo_command command = todo_list->items[i].command;
5139 int cur = i;
5140
5141 /*
5142 * Initially, all commands are 'pick's. If it is a
5143 * fixup or a squash now, we have rearranged it.
5144 */
5145 if (is_fixup(command))
5146 continue;
5147
5148 while (cur >= 0) {
5149 ALLOC_GROW(items, nr + 1, alloc);
5150 items[nr++] = todo_list->items[cur];
5151 cur = next[cur];
5152 }
5153 }
5154
5155 FREE_AND_NULL(todo_list->items);
5156 todo_list->items = items;
5157 todo_list->nr = nr;
5158 todo_list->alloc = alloc;
5159 }
5160
5161 free(next);
5162 free(tail);
5163 for (i = 0; i < todo_list->nr; i++)
5164 free(subjects[i]);
5165 free(subjects);
5166 hashmap_free(&subject2item, 1);
5167
5168 clear_commit_todo_item(&commit_todo);
5169
5170 return 0;
5171}