f9c1ddb53857164dbb85491148ef462eb2424573
1#include "cache.h"
2#include "config.h"
3#include "lockfile.h"
4#include "dir.h"
5#include "object.h"
6#include "commit.h"
7#include "sequencer.h"
8#include "tag.h"
9#include "run-command.h"
10#include "exec-cmd.h"
11#include "utf8.h"
12#include "cache-tree.h"
13#include "diff.h"
14#include "revision.h"
15#include "rerere.h"
16#include "merge-recursive.h"
17#include "refs.h"
18#include "argv-array.h"
19#include "quote.h"
20#include "trailer.h"
21#include "log-tree.h"
22#include "wt-status.h"
23#include "hashmap.h"
24#include "notes-utils.h"
25#include "sigchain.h"
26
27#define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
28
29const char sign_off_header[] = "Signed-off-by: ";
30static const char cherry_picked_prefix[] = "(cherry picked from commit ";
31
32GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
33
34GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
35
36static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
37static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
38static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
39static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
40
41static GIT_PATH_FUNC(rebase_path, "rebase-merge")
42/*
43 * The file containing rebase commands, comments, and empty lines.
44 * This file is created by "git rebase -i" then edited by the user. As
45 * the lines are processed, they are removed from the front of this
46 * file and written to the tail of 'done'.
47 */
48static GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
49/*
50 * The rebase command lines that have already been processed. A line
51 * is moved here when it is first handled, before any associated user
52 * actions.
53 */
54static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
55/*
56 * The file to keep track of how many commands were already processed (e.g.
57 * for the prompt).
58 */
59static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum");
60/*
61 * The file to keep track of how many commands are to be processed in total
62 * (e.g. for the prompt).
63 */
64static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end");
65/*
66 * The commit message that is planned to be used for any changes that
67 * need to be committed following a user interaction.
68 */
69static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
70/*
71 * The file into which is accumulated the suggested commit message for
72 * squash/fixup commands. When the first of a series of squash/fixups
73 * is seen, the file is created and the commit message from the
74 * previous commit and from the first squash/fixup commit are written
75 * to it. The commit message for each subsequent squash/fixup commit
76 * is appended to the file as it is processed.
77 *
78 * The first line of the file is of the form
79 * # This is a combination of $count commits.
80 * where $count is the number of commits whose messages have been
81 * written to the file so far (including the initial "pick" commit).
82 * Each time that a commit message is processed, this line is read and
83 * updated. It is deleted just before the combined commit is made.
84 */
85static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
86/*
87 * If the current series of squash/fixups has not yet included a squash
88 * command, then this file exists and holds the commit message of the
89 * original "pick" commit. (If the series ends without a "squash"
90 * command, then this can be used as the commit message of the combined
91 * commit without opening the editor.)
92 */
93static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
94/*
95 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
96 * GIT_AUTHOR_DATE that will be used for the commit that is currently
97 * being rebased.
98 */
99static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
100/*
101 * When an "edit" rebase command is being processed, the SHA1 of the
102 * commit to be edited is recorded in this file. When "git rebase
103 * --continue" is executed, if there are any staged changes then they
104 * will be amended to the HEAD commit, but only provided the HEAD
105 * commit is still the commit to be edited. When any other rebase
106 * command is processed, this file is deleted.
107 */
108static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
109/*
110 * When we stop at a given patch via the "edit" command, this file contains
111 * the abbreviated commit name of the corresponding patch.
112 */
113static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
114/*
115 * For the post-rewrite hook, we make a list of rewritten commits and
116 * their new sha1s. The rewritten-pending list keeps the sha1s of
117 * commits that have been processed, but not committed yet,
118 * e.g. because they are waiting for a 'squash' command.
119 */
120static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
121static GIT_PATH_FUNC(rebase_path_rewritten_pending,
122 "rebase-merge/rewritten-pending")
123/*
124 * The following files are written by git-rebase just after parsing the
125 * command-line (and are only consumed, not modified, by the sequencer).
126 */
127static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
128static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
129static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
130static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")
131static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
132static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
133static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
134static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
135static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
136static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
137
138static int git_sequencer_config(const char *k, const char *v, void *cb)
139{
140 struct replay_opts *opts = cb;
141 int status;
142
143 if (!strcmp(k, "commit.cleanup")) {
144 const char *s;
145
146 status = git_config_string(&s, k, v);
147 if (status)
148 return status;
149
150 if (!strcmp(s, "verbatim"))
151 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
152 else if (!strcmp(s, "whitespace"))
153 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
154 else if (!strcmp(s, "strip"))
155 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
156 else if (!strcmp(s, "scissors"))
157 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
158 else
159 warning(_("invalid commit message cleanup mode '%s'"),
160 s);
161
162 return status;
163 }
164
165 if (!strcmp(k, "commit.gpgsign")) {
166 opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
167 return 0;
168 }
169
170 status = git_gpg_config(k, v, NULL);
171 if (status)
172 return status;
173
174 return git_diff_basic_config(k, v, NULL);
175}
176
177void sequencer_init_config(struct replay_opts *opts)
178{
179 opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
180 git_config(git_sequencer_config, opts);
181}
182
183static inline int is_rebase_i(const struct replay_opts *opts)
184{
185 return opts->action == REPLAY_INTERACTIVE_REBASE;
186}
187
188static const char *get_dir(const struct replay_opts *opts)
189{
190 if (is_rebase_i(opts))
191 return rebase_path();
192 return git_path_seq_dir();
193}
194
195static const char *get_todo_path(const struct replay_opts *opts)
196{
197 if (is_rebase_i(opts))
198 return rebase_path_todo();
199 return git_path_todo_file();
200}
201
202/*
203 * Returns 0 for non-conforming footer
204 * Returns 1 for conforming footer
205 * Returns 2 when sob exists within conforming footer
206 * Returns 3 when sob exists within conforming footer as last entry
207 */
208static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
209 int ignore_footer)
210{
211 struct trailer_info info;
212 int i;
213 int found_sob = 0, found_sob_last = 0;
214
215 trailer_info_get(&info, sb->buf);
216
217 if (info.trailer_start == info.trailer_end)
218 return 0;
219
220 for (i = 0; i < info.trailer_nr; i++)
221 if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
222 found_sob = 1;
223 if (i == info.trailer_nr - 1)
224 found_sob_last = 1;
225 }
226
227 trailer_info_release(&info);
228
229 if (found_sob_last)
230 return 3;
231 if (found_sob)
232 return 2;
233 return 1;
234}
235
236static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
237{
238 static struct strbuf buf = STRBUF_INIT;
239
240 strbuf_reset(&buf);
241 if (opts->gpg_sign)
242 sq_quotef(&buf, "-S%s", opts->gpg_sign);
243 return buf.buf;
244}
245
246int sequencer_remove_state(struct replay_opts *opts)
247{
248 struct strbuf dir = STRBUF_INIT;
249 int i;
250
251 free(opts->gpg_sign);
252 free(opts->strategy);
253 for (i = 0; i < opts->xopts_nr; i++)
254 free(opts->xopts[i]);
255 free(opts->xopts);
256
257 strbuf_addstr(&dir, get_dir(opts));
258 remove_dir_recursively(&dir, 0);
259 strbuf_release(&dir);
260
261 return 0;
262}
263
264static const char *action_name(const struct replay_opts *opts)
265{
266 switch (opts->action) {
267 case REPLAY_REVERT:
268 return N_("revert");
269 case REPLAY_PICK:
270 return N_("cherry-pick");
271 case REPLAY_INTERACTIVE_REBASE:
272 return N_("rebase -i");
273 }
274 die(_("Unknown action: %d"), opts->action);
275}
276
277struct commit_message {
278 char *parent_label;
279 char *label;
280 char *subject;
281 const char *message;
282};
283
284static const char *short_commit_name(struct commit *commit)
285{
286 return find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV);
287}
288
289static int get_message(struct commit *commit, struct commit_message *out)
290{
291 const char *abbrev, *subject;
292 int subject_len;
293
294 out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
295 abbrev = short_commit_name(commit);
296
297 subject_len = find_commit_subject(out->message, &subject);
298
299 out->subject = xmemdupz(subject, subject_len);
300 out->label = xstrfmt("%s... %s", abbrev, out->subject);
301 out->parent_label = xstrfmt("parent of %s", out->label);
302
303 return 0;
304}
305
306static void free_message(struct commit *commit, struct commit_message *msg)
307{
308 free(msg->parent_label);
309 free(msg->label);
310 free(msg->subject);
311 unuse_commit_buffer(commit, msg->message);
312}
313
314static void print_advice(int show_hint, struct replay_opts *opts)
315{
316 char *msg = getenv("GIT_CHERRY_PICK_HELP");
317
318 if (msg) {
319 fprintf(stderr, "%s\n", msg);
320 /*
321 * A conflict has occurred but the porcelain
322 * (typically rebase --interactive) wants to take care
323 * of the commit itself so remove CHERRY_PICK_HEAD
324 */
325 unlink(git_path_cherry_pick_head());
326 return;
327 }
328
329 if (show_hint) {
330 if (opts->no_commit)
331 advise(_("after resolving the conflicts, mark the corrected paths\n"
332 "with 'git add <paths>' or 'git rm <paths>'"));
333 else
334 advise(_("after resolving the conflicts, mark the corrected paths\n"
335 "with 'git add <paths>' or 'git rm <paths>'\n"
336 "and commit the result with 'git commit'"));
337 }
338}
339
340static int write_message(const void *buf, size_t len, const char *filename,
341 int append_eol)
342{
343 struct lock_file msg_file = LOCK_INIT;
344
345 int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
346 if (msg_fd < 0)
347 return error_errno(_("could not lock '%s'"), filename);
348 if (write_in_full(msg_fd, buf, len) < 0) {
349 error_errno(_("could not write to '%s'"), filename);
350 rollback_lock_file(&msg_file);
351 return -1;
352 }
353 if (append_eol && write(msg_fd, "\n", 1) < 0) {
354 error_errno(_("could not write eol to '%s'"), filename);
355 rollback_lock_file(&msg_file);
356 return -1;
357 }
358 if (commit_lock_file(&msg_file) < 0)
359 return error(_("failed to finalize '%s'"), filename);
360
361 return 0;
362}
363
364/*
365 * Reads a file that was presumably written by a shell script, i.e. with an
366 * end-of-line marker that needs to be stripped.
367 *
368 * Note that only the last end-of-line marker is stripped, consistent with the
369 * behavior of "$(cat path)" in a shell script.
370 *
371 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
372 */
373static int read_oneliner(struct strbuf *buf,
374 const char *path, int skip_if_empty)
375{
376 int orig_len = buf->len;
377
378 if (!file_exists(path))
379 return 0;
380
381 if (strbuf_read_file(buf, path, 0) < 0) {
382 warning_errno(_("could not read '%s'"), path);
383 return 0;
384 }
385
386 if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
387 if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
388 --buf->len;
389 buf->buf[buf->len] = '\0';
390 }
391
392 if (skip_if_empty && buf->len == orig_len)
393 return 0;
394
395 return 1;
396}
397
398static struct tree *empty_tree(void)
399{
400 return lookup_tree(the_hash_algo->empty_tree);
401}
402
403static int error_dirty_index(struct replay_opts *opts)
404{
405 if (read_cache_unmerged())
406 return error_resolve_conflict(_(action_name(opts)));
407
408 error(_("your local changes would be overwritten by %s."),
409 _(action_name(opts)));
410
411 if (advice_commit_before_merge)
412 advise(_("commit your changes or stash them to proceed."));
413 return -1;
414}
415
416static void update_abort_safety_file(void)
417{
418 struct object_id head;
419
420 /* Do nothing on a single-pick */
421 if (!file_exists(git_path_seq_dir()))
422 return;
423
424 if (!get_oid("HEAD", &head))
425 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
426 else
427 write_file(git_path_abort_safety_file(), "%s", "");
428}
429
430static int fast_forward_to(const struct object_id *to, const struct object_id *from,
431 int unborn, struct replay_opts *opts)
432{
433 struct ref_transaction *transaction;
434 struct strbuf sb = STRBUF_INIT;
435 struct strbuf err = STRBUF_INIT;
436
437 read_cache();
438 if (checkout_fast_forward(from, to, 1))
439 return -1; /* the callee should have complained already */
440
441 strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
442
443 transaction = ref_transaction_begin(&err);
444 if (!transaction ||
445 ref_transaction_update(transaction, "HEAD",
446 to, unborn ? &null_oid : from,
447 0, sb.buf, &err) ||
448 ref_transaction_commit(transaction, &err)) {
449 ref_transaction_free(transaction);
450 error("%s", err.buf);
451 strbuf_release(&sb);
452 strbuf_release(&err);
453 return -1;
454 }
455
456 strbuf_release(&sb);
457 strbuf_release(&err);
458 ref_transaction_free(transaction);
459 update_abort_safety_file();
460 return 0;
461}
462
463void append_conflicts_hint(struct strbuf *msgbuf)
464{
465 int i;
466
467 strbuf_addch(msgbuf, '\n');
468 strbuf_commented_addf(msgbuf, "Conflicts:\n");
469 for (i = 0; i < active_nr;) {
470 const struct cache_entry *ce = active_cache[i++];
471 if (ce_stage(ce)) {
472 strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
473 while (i < active_nr && !strcmp(ce->name,
474 active_cache[i]->name))
475 i++;
476 }
477 }
478}
479
480static int do_recursive_merge(struct commit *base, struct commit *next,
481 const char *base_label, const char *next_label,
482 struct object_id *head, struct strbuf *msgbuf,
483 struct replay_opts *opts)
484{
485 struct merge_options o;
486 struct tree *result, *next_tree, *base_tree, *head_tree;
487 int clean;
488 char **xopt;
489 struct lock_file index_lock = LOCK_INIT;
490
491 if (hold_locked_index(&index_lock, LOCK_REPORT_ON_ERROR) < 0)
492 return -1;
493
494 read_cache();
495
496 init_merge_options(&o);
497 o.ancestor = base ? base_label : "(empty tree)";
498 o.branch1 = "HEAD";
499 o.branch2 = next ? next_label : "(empty tree)";
500 if (is_rebase_i(opts))
501 o.buffer_output = 2;
502 o.show_rename_progress = 1;
503
504 head_tree = parse_tree_indirect(head);
505 next_tree = next ? next->tree : empty_tree();
506 base_tree = base ? base->tree : empty_tree();
507
508 for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)
509 parse_merge_opt(&o, *xopt);
510
511 clean = merge_trees(&o,
512 head_tree,
513 next_tree, base_tree, &result);
514 if (is_rebase_i(opts) && clean <= 0)
515 fputs(o.obuf.buf, stdout);
516 strbuf_release(&o.obuf);
517 diff_warn_rename_limit("merge.renamelimit", o.needed_rename_limit, 0);
518 if (clean < 0) {
519 rollback_lock_file(&index_lock);
520 return clean;
521 }
522
523 if (write_locked_index(&the_index, &index_lock,
524 COMMIT_LOCK | SKIP_IF_UNCHANGED))
525 /*
526 * TRANSLATORS: %s will be "revert", "cherry-pick" or
527 * "rebase -i".
528 */
529 return error(_("%s: Unable to write new index file"),
530 _(action_name(opts)));
531
532 if (!clean)
533 append_conflicts_hint(msgbuf);
534
535 return !clean;
536}
537
538static int is_index_unchanged(void)
539{
540 struct object_id head_oid;
541 struct commit *head_commit;
542
543 if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
544 return error(_("could not resolve HEAD commit"));
545
546 head_commit = lookup_commit(&head_oid);
547
548 /*
549 * If head_commit is NULL, check_commit, called from
550 * lookup_commit, would have indicated that head_commit is not
551 * a commit object already. parse_commit() will return failure
552 * without further complaints in such a case. Otherwise, if
553 * the commit is invalid, parse_commit() will complain. So
554 * there is nothing for us to say here. Just return failure.
555 */
556 if (parse_commit(head_commit))
557 return -1;
558
559 if (!active_cache_tree)
560 active_cache_tree = cache_tree();
561
562 if (!cache_tree_fully_valid(active_cache_tree))
563 if (cache_tree_update(&the_index, 0))
564 return error(_("unable to update cache tree"));
565
566 return !oidcmp(&active_cache_tree->oid,
567 &head_commit->tree->object.oid);
568}
569
570static int write_author_script(const char *message)
571{
572 struct strbuf buf = STRBUF_INIT;
573 const char *eol;
574 int res;
575
576 for (;;)
577 if (!*message || starts_with(message, "\n")) {
578missing_author:
579 /* Missing 'author' line? */
580 unlink(rebase_path_author_script());
581 return 0;
582 } else if (skip_prefix(message, "author ", &message))
583 break;
584 else if ((eol = strchr(message, '\n')))
585 message = eol + 1;
586 else
587 goto missing_author;
588
589 strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
590 while (*message && *message != '\n' && *message != '\r')
591 if (skip_prefix(message, " <", &message))
592 break;
593 else if (*message != '\'')
594 strbuf_addch(&buf, *(message++));
595 else
596 strbuf_addf(&buf, "'\\\\%c'", *(message++));
597 strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
598 while (*message && *message != '\n' && *message != '\r')
599 if (skip_prefix(message, "> ", &message))
600 break;
601 else if (*message != '\'')
602 strbuf_addch(&buf, *(message++));
603 else
604 strbuf_addf(&buf, "'\\\\%c'", *(message++));
605 strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
606 while (*message && *message != '\n' && *message != '\r')
607 if (*message != '\'')
608 strbuf_addch(&buf, *(message++));
609 else
610 strbuf_addf(&buf, "'\\\\%c'", *(message++));
611 res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
612 strbuf_release(&buf);
613 return res;
614}
615
616/*
617 * Read a list of environment variable assignments (such as the author-script
618 * file) into an environment block. Returns -1 on error, 0 otherwise.
619 */
620static int read_env_script(struct argv_array *env)
621{
622 struct strbuf script = STRBUF_INIT;
623 int i, count = 0;
624 char *p, *p2;
625
626 if (strbuf_read_file(&script, rebase_path_author_script(), 256) <= 0)
627 return -1;
628
629 for (p = script.buf; *p; p++)
630 if (skip_prefix(p, "'\\\\''", (const char **)&p2))
631 strbuf_splice(&script, p - script.buf, p2 - p, "'", 1);
632 else if (*p == '\'')
633 strbuf_splice(&script, p-- - script.buf, 1, "", 0);
634 else if (*p == '\n') {
635 *p = '\0';
636 count++;
637 }
638
639 for (i = 0, p = script.buf; i < count; i++) {
640 argv_array_push(env, p);
641 p += strlen(p) + 1;
642 }
643
644 return 0;
645}
646
647static char *get_author(const char *message)
648{
649 size_t len;
650 const char *a;
651
652 a = find_commit_header(message, "author", &len);
653 if (a)
654 return xmemdupz(a, len);
655
656 return NULL;
657}
658
659static const char staged_changes_advice[] =
660N_("you have staged changes in your working tree\n"
661"If these changes are meant to be squashed into the previous commit, run:\n"
662"\n"
663" git commit --amend %s\n"
664"\n"
665"If they are meant to go into a new commit, run:\n"
666"\n"
667" git commit %s\n"
668"\n"
669"In both cases, once you're done, continue with:\n"
670"\n"
671" git rebase --continue\n");
672
673#define ALLOW_EMPTY (1<<0)
674#define EDIT_MSG (1<<1)
675#define AMEND_MSG (1<<2)
676#define CLEANUP_MSG (1<<3)
677#define VERIFY_MSG (1<<4)
678
679/*
680 * If we are cherry-pick, and if the merge did not result in
681 * hand-editing, we will hit this commit and inherit the original
682 * author date and name.
683 *
684 * If we are revert, or if our cherry-pick results in a hand merge,
685 * we had better say that the current user is responsible for that.
686 *
687 * An exception is when run_git_commit() is called during an
688 * interactive rebase: in that case, we will want to retain the
689 * author metadata.
690 */
691static int run_git_commit(const char *defmsg, struct replay_opts *opts,
692 unsigned int flags)
693{
694 struct child_process cmd = CHILD_PROCESS_INIT;
695 const char *value;
696
697 cmd.git_cmd = 1;
698
699 if (is_rebase_i(opts)) {
700 if (!(flags & EDIT_MSG)) {
701 cmd.stdout_to_stderr = 1;
702 cmd.err = -1;
703 }
704
705 if (read_env_script(&cmd.env_array)) {
706 const char *gpg_opt = gpg_sign_opt_quoted(opts);
707
708 return error(_(staged_changes_advice),
709 gpg_opt, gpg_opt);
710 }
711 }
712
713 argv_array_push(&cmd.args, "commit");
714
715 if (!(flags & VERIFY_MSG))
716 argv_array_push(&cmd.args, "-n");
717 if ((flags & AMEND_MSG))
718 argv_array_push(&cmd.args, "--amend");
719 if (opts->gpg_sign)
720 argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
721 if (defmsg)
722 argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
723 if ((flags & CLEANUP_MSG))
724 argv_array_push(&cmd.args, "--cleanup=strip");
725 if ((flags & EDIT_MSG))
726 argv_array_push(&cmd.args, "-e");
727 else if (!(flags & CLEANUP_MSG) &&
728 !opts->signoff && !opts->record_origin &&
729 git_config_get_value("commit.cleanup", &value))
730 argv_array_push(&cmd.args, "--cleanup=verbatim");
731
732 if ((flags & ALLOW_EMPTY))
733 argv_array_push(&cmd.args, "--allow-empty");
734
735 if (opts->allow_empty_message)
736 argv_array_push(&cmd.args, "--allow-empty-message");
737
738 if (cmd.err == -1) {
739 /* hide stderr on success */
740 struct strbuf buf = STRBUF_INIT;
741 int rc = pipe_command(&cmd,
742 NULL, 0,
743 /* stdout is already redirected */
744 NULL, 0,
745 &buf, 0);
746 if (rc)
747 fputs(buf.buf, stderr);
748 strbuf_release(&buf);
749 return rc;
750 }
751
752 return run_command(&cmd);
753}
754
755static int rest_is_empty(const struct strbuf *sb, int start)
756{
757 int i, eol;
758 const char *nl;
759
760 /* Check if the rest is just whitespace and Signed-off-by's. */
761 for (i = start; i < sb->len; i++) {
762 nl = memchr(sb->buf + i, '\n', sb->len - i);
763 if (nl)
764 eol = nl - sb->buf;
765 else
766 eol = sb->len;
767
768 if (strlen(sign_off_header) <= eol - i &&
769 starts_with(sb->buf + i, sign_off_header)) {
770 i = eol;
771 continue;
772 }
773 while (i < eol)
774 if (!isspace(sb->buf[i++]))
775 return 0;
776 }
777
778 return 1;
779}
780
781/*
782 * Find out if the message in the strbuf contains only whitespace and
783 * Signed-off-by lines.
784 */
785int message_is_empty(const struct strbuf *sb,
786 enum commit_msg_cleanup_mode cleanup_mode)
787{
788 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
789 return 0;
790 return rest_is_empty(sb, 0);
791}
792
793/*
794 * See if the user edited the message in the editor or left what
795 * was in the template intact
796 */
797int template_untouched(const struct strbuf *sb, const char *template_file,
798 enum commit_msg_cleanup_mode cleanup_mode)
799{
800 struct strbuf tmpl = STRBUF_INIT;
801 const char *start;
802
803 if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
804 return 0;
805
806 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
807 return 0;
808
809 strbuf_stripspace(&tmpl, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
810 if (!skip_prefix(sb->buf, tmpl.buf, &start))
811 start = sb->buf;
812 strbuf_release(&tmpl);
813 return rest_is_empty(sb, start - sb->buf);
814}
815
816int update_head_with_reflog(const struct commit *old_head,
817 const struct object_id *new_head,
818 const char *action, const struct strbuf *msg,
819 struct strbuf *err)
820{
821 struct ref_transaction *transaction;
822 struct strbuf sb = STRBUF_INIT;
823 const char *nl;
824 int ret = 0;
825
826 if (action) {
827 strbuf_addstr(&sb, action);
828 strbuf_addstr(&sb, ": ");
829 }
830
831 nl = strchr(msg->buf, '\n');
832 if (nl) {
833 strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
834 } else {
835 strbuf_addbuf(&sb, msg);
836 strbuf_addch(&sb, '\n');
837 }
838
839 transaction = ref_transaction_begin(err);
840 if (!transaction ||
841 ref_transaction_update(transaction, "HEAD", new_head,
842 old_head ? &old_head->object.oid : &null_oid,
843 0, sb.buf, err) ||
844 ref_transaction_commit(transaction, err)) {
845 ret = -1;
846 }
847 ref_transaction_free(transaction);
848 strbuf_release(&sb);
849
850 return ret;
851}
852
853static int run_rewrite_hook(const struct object_id *oldoid,
854 const struct object_id *newoid)
855{
856 struct child_process proc = CHILD_PROCESS_INIT;
857 const char *argv[3];
858 int code;
859 struct strbuf sb = STRBUF_INIT;
860
861 argv[0] = find_hook("post-rewrite");
862 if (!argv[0])
863 return 0;
864
865 argv[1] = "amend";
866 argv[2] = NULL;
867
868 proc.argv = argv;
869 proc.in = -1;
870 proc.stdout_to_stderr = 1;
871
872 code = start_command(&proc);
873 if (code)
874 return code;
875 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
876 sigchain_push(SIGPIPE, SIG_IGN);
877 write_in_full(proc.in, sb.buf, sb.len);
878 close(proc.in);
879 strbuf_release(&sb);
880 sigchain_pop(SIGPIPE);
881 return finish_command(&proc);
882}
883
884void commit_post_rewrite(const struct commit *old_head,
885 const struct object_id *new_head)
886{
887 struct notes_rewrite_cfg *cfg;
888
889 cfg = init_copy_notes_for_rewrite("amend");
890 if (cfg) {
891 /* we are amending, so old_head is not NULL */
892 copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
893 finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
894 }
895 run_rewrite_hook(&old_head->object.oid, new_head);
896}
897
898static int run_prepare_commit_msg_hook(struct strbuf *msg, const char *commit)
899{
900 struct argv_array hook_env = ARGV_ARRAY_INIT;
901 int ret;
902 const char *name;
903
904 name = git_path_commit_editmsg();
905 if (write_message(msg->buf, msg->len, name, 0))
906 return -1;
907
908 argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", get_index_file());
909 argv_array_push(&hook_env, "GIT_EDITOR=:");
910 if (commit)
911 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
912 "commit", commit, NULL);
913 else
914 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
915 "message", NULL);
916 if (ret)
917 ret = error(_("'prepare-commit-msg' hook failed"));
918 argv_array_clear(&hook_env);
919
920 return ret;
921}
922
923static const char implicit_ident_advice_noconfig[] =
924N_("Your name and email address were configured automatically based\n"
925"on your username and hostname. Please check that they are accurate.\n"
926"You can suppress this message by setting them explicitly. Run the\n"
927"following command and follow the instructions in your editor to edit\n"
928"your configuration file:\n"
929"\n"
930" git config --global --edit\n"
931"\n"
932"After doing this, you may fix the identity used for this commit with:\n"
933"\n"
934" git commit --amend --reset-author\n");
935
936static const char implicit_ident_advice_config[] =
937N_("Your name and email address were configured automatically based\n"
938"on your username and hostname. Please check that they are accurate.\n"
939"You can suppress this message by setting them explicitly:\n"
940"\n"
941" git config --global user.name \"Your Name\"\n"
942" git config --global user.email you@example.com\n"
943"\n"
944"After doing this, you may fix the identity used for this commit with:\n"
945"\n"
946" git commit --amend --reset-author\n");
947
948static const char *implicit_ident_advice(void)
949{
950 char *user_config = expand_user_path("~/.gitconfig", 0);
951 char *xdg_config = xdg_config_home("config");
952 int config_exists = file_exists(user_config) || file_exists(xdg_config);
953
954 free(user_config);
955 free(xdg_config);
956
957 if (config_exists)
958 return _(implicit_ident_advice_config);
959 else
960 return _(implicit_ident_advice_noconfig);
961
962}
963
964void print_commit_summary(const char *prefix, const struct object_id *oid,
965 unsigned int flags)
966{
967 struct rev_info rev;
968 struct commit *commit;
969 struct strbuf format = STRBUF_INIT;
970 const char *head;
971 struct pretty_print_context pctx = {0};
972 struct strbuf author_ident = STRBUF_INIT;
973 struct strbuf committer_ident = STRBUF_INIT;
974
975 commit = lookup_commit(oid);
976 if (!commit)
977 die(_("couldn't look up newly created commit"));
978 if (parse_commit(commit))
979 die(_("could not parse newly created commit"));
980
981 strbuf_addstr(&format, "format:%h] %s");
982
983 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
984 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
985 if (strbuf_cmp(&author_ident, &committer_ident)) {
986 strbuf_addstr(&format, "\n Author: ");
987 strbuf_addbuf_percentquote(&format, &author_ident);
988 }
989 if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
990 struct strbuf date = STRBUF_INIT;
991
992 format_commit_message(commit, "%ad", &date, &pctx);
993 strbuf_addstr(&format, "\n Date: ");
994 strbuf_addbuf_percentquote(&format, &date);
995 strbuf_release(&date);
996 }
997 if (!committer_ident_sufficiently_given()) {
998 strbuf_addstr(&format, "\n Committer: ");
999 strbuf_addbuf_percentquote(&format, &committer_ident);
1000 if (advice_implicit_identity) {
1001 strbuf_addch(&format, '\n');
1002 strbuf_addstr(&format, implicit_ident_advice());
1003 }
1004 }
1005 strbuf_release(&author_ident);
1006 strbuf_release(&committer_ident);
1007
1008 init_revisions(&rev, prefix);
1009 setup_revisions(0, NULL, &rev, NULL);
1010
1011 rev.diff = 1;
1012 rev.diffopt.output_format =
1013 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1014
1015 rev.verbose_header = 1;
1016 rev.show_root_diff = 1;
1017 get_commit_format(format.buf, &rev);
1018 rev.always_show_header = 0;
1019 rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1020 rev.diffopt.break_opt = 0;
1021 diff_setup_done(&rev.diffopt);
1022
1023 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1024 if (!head)
1025 die_errno(_("unable to resolve HEAD after creating commit"));
1026 if (!strcmp(head, "HEAD"))
1027 head = _("detached HEAD");
1028 else
1029 skip_prefix(head, "refs/heads/", &head);
1030 printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1031 _(" (root-commit)") : "");
1032
1033 if (!log_tree_commit(&rev, commit)) {
1034 rev.always_show_header = 1;
1035 rev.use_terminator = 1;
1036 log_tree_commit(&rev, commit);
1037 }
1038
1039 strbuf_release(&format);
1040}
1041
1042static int parse_head(struct commit **head)
1043{
1044 struct commit *current_head;
1045 struct object_id oid;
1046
1047 if (get_oid("HEAD", &oid)) {
1048 current_head = NULL;
1049 } else {
1050 current_head = lookup_commit_reference(&oid);
1051 if (!current_head)
1052 return error(_("could not parse HEAD"));
1053 if (oidcmp(&oid, ¤t_head->object.oid)) {
1054 warning(_("HEAD %s is not a commit!"),
1055 oid_to_hex(&oid));
1056 }
1057 if (parse_commit(current_head))
1058 return error(_("could not parse HEAD commit"));
1059 }
1060 *head = current_head;
1061
1062 return 0;
1063}
1064
1065/*
1066 * Try to commit without forking 'git commit'. In some cases we need
1067 * to run 'git commit' to display an error message
1068 *
1069 * Returns:
1070 * -1 - error unable to commit
1071 * 0 - success
1072 * 1 - run 'git commit'
1073 */
1074static int try_to_commit(struct strbuf *msg, const char *author,
1075 struct replay_opts *opts, unsigned int flags,
1076 struct object_id *oid)
1077{
1078 struct object_id tree;
1079 struct commit *current_head;
1080 struct commit_list *parents = NULL;
1081 struct commit_extra_header *extra = NULL;
1082 struct strbuf err = STRBUF_INIT;
1083 struct strbuf commit_msg = STRBUF_INIT;
1084 char *amend_author = NULL;
1085 const char *hook_commit = NULL;
1086 enum commit_msg_cleanup_mode cleanup;
1087 int res = 0;
1088
1089 if (parse_head(¤t_head))
1090 return -1;
1091
1092 if (flags & AMEND_MSG) {
1093 const char *exclude_gpgsig[] = { "gpgsig", NULL };
1094 const char *out_enc = get_commit_output_encoding();
1095 const char *message = logmsg_reencode(current_head, NULL,
1096 out_enc);
1097
1098 if (!msg) {
1099 const char *orig_message = NULL;
1100
1101 find_commit_subject(message, &orig_message);
1102 msg = &commit_msg;
1103 strbuf_addstr(msg, orig_message);
1104 hook_commit = "HEAD";
1105 }
1106 author = amend_author = get_author(message);
1107 unuse_commit_buffer(current_head, message);
1108 if (!author) {
1109 res = error(_("unable to parse commit author"));
1110 goto out;
1111 }
1112 parents = copy_commit_list(current_head->parents);
1113 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1114 } else if (current_head) {
1115 commit_list_insert(current_head, &parents);
1116 }
1117
1118 if (write_cache_as_tree(&tree, 0, NULL)) {
1119 res = error(_("git write-tree failed to write a tree"));
1120 goto out;
1121 }
1122
1123 if (!(flags & ALLOW_EMPTY) && !oidcmp(current_head ?
1124 ¤t_head->tree->object.oid :
1125 &empty_tree_oid, &tree)) {
1126 res = 1; /* run 'git commit' to display error message */
1127 goto out;
1128 }
1129
1130 if (find_hook("prepare-commit-msg")) {
1131 res = run_prepare_commit_msg_hook(msg, hook_commit);
1132 if (res)
1133 goto out;
1134 if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1135 2048) < 0) {
1136 res = error_errno(_("unable to read commit message "
1137 "from '%s'"),
1138 git_path_commit_editmsg());
1139 goto out;
1140 }
1141 msg = &commit_msg;
1142 }
1143
1144 cleanup = (flags & CLEANUP_MSG) ? COMMIT_MSG_CLEANUP_ALL :
1145 opts->default_msg_cleanup;
1146
1147 if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1148 strbuf_stripspace(msg, cleanup == COMMIT_MSG_CLEANUP_ALL);
1149 if (!opts->allow_empty_message && message_is_empty(msg, cleanup)) {
1150 res = 1; /* run 'git commit' to display error message */
1151 goto out;
1152 }
1153
1154 if (commit_tree_extended(msg->buf, msg->len, &tree, parents,
1155 oid, author, opts->gpg_sign, extra)) {
1156 res = error(_("failed to write commit object"));
1157 goto out;
1158 }
1159
1160 if (update_head_with_reflog(current_head, oid,
1161 getenv("GIT_REFLOG_ACTION"), msg, &err)) {
1162 res = error("%s", err.buf);
1163 goto out;
1164 }
1165
1166 if (flags & AMEND_MSG)
1167 commit_post_rewrite(current_head, oid);
1168
1169out:
1170 free_commit_extra_headers(extra);
1171 strbuf_release(&err);
1172 strbuf_release(&commit_msg);
1173 free(amend_author);
1174
1175 return res;
1176}
1177
1178static int do_commit(const char *msg_file, const char *author,
1179 struct replay_opts *opts, unsigned int flags)
1180{
1181 int res = 1;
1182
1183 if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG)) {
1184 struct object_id oid;
1185 struct strbuf sb = STRBUF_INIT;
1186
1187 if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1188 return error_errno(_("unable to read commit message "
1189 "from '%s'"),
1190 msg_file);
1191
1192 res = try_to_commit(msg_file ? &sb : NULL, author, opts, flags,
1193 &oid);
1194 strbuf_release(&sb);
1195 if (!res) {
1196 unlink(git_path_cherry_pick_head());
1197 unlink(git_path_merge_msg());
1198 if (!is_rebase_i(opts))
1199 print_commit_summary(NULL, &oid,
1200 SUMMARY_SHOW_AUTHOR_DATE);
1201 return res;
1202 }
1203 }
1204 if (res == 1)
1205 return run_git_commit(msg_file, opts, flags);
1206
1207 return res;
1208}
1209
1210static int is_original_commit_empty(struct commit *commit)
1211{
1212 const struct object_id *ptree_oid;
1213
1214 if (parse_commit(commit))
1215 return error(_("could not parse commit %s"),
1216 oid_to_hex(&commit->object.oid));
1217 if (commit->parents) {
1218 struct commit *parent = commit->parents->item;
1219 if (parse_commit(parent))
1220 return error(_("could not parse parent commit %s"),
1221 oid_to_hex(&parent->object.oid));
1222 ptree_oid = &parent->tree->object.oid;
1223 } else {
1224 ptree_oid = the_hash_algo->empty_tree; /* commit is root */
1225 }
1226
1227 return !oidcmp(ptree_oid, &commit->tree->object.oid);
1228}
1229
1230/*
1231 * Do we run "git commit" with "--allow-empty"?
1232 */
1233static int allow_empty(struct replay_opts *opts, struct commit *commit)
1234{
1235 int index_unchanged, empty_commit;
1236
1237 /*
1238 * Three cases:
1239 *
1240 * (1) we do not allow empty at all and error out.
1241 *
1242 * (2) we allow ones that were initially empty, but
1243 * forbid the ones that become empty;
1244 *
1245 * (3) we allow both.
1246 */
1247 if (!opts->allow_empty)
1248 return 0; /* let "git commit" barf as necessary */
1249
1250 index_unchanged = is_index_unchanged();
1251 if (index_unchanged < 0)
1252 return index_unchanged;
1253 if (!index_unchanged)
1254 return 0; /* we do not have to say --allow-empty */
1255
1256 if (opts->keep_redundant_commits)
1257 return 1;
1258
1259 empty_commit = is_original_commit_empty(commit);
1260 if (empty_commit < 0)
1261 return empty_commit;
1262 if (!empty_commit)
1263 return 0;
1264 else
1265 return 1;
1266}
1267
1268/*
1269 * Note that ordering matters in this enum. Not only must it match the mapping
1270 * below, it is also divided into several sections that matter. When adding
1271 * new commands, make sure you add it in the right section.
1272 */
1273enum todo_command {
1274 /* commands that handle commits */
1275 TODO_PICK = 0,
1276 TODO_REVERT,
1277 TODO_EDIT,
1278 TODO_REWORD,
1279 TODO_FIXUP,
1280 TODO_SQUASH,
1281 /* commands that do something else than handling a single commit */
1282 TODO_EXEC,
1283 /* commands that do nothing but are counted for reporting progress */
1284 TODO_NOOP,
1285 TODO_DROP,
1286 /* comments (not counted for reporting progress) */
1287 TODO_COMMENT
1288};
1289
1290static struct {
1291 char c;
1292 const char *str;
1293} todo_command_info[] = {
1294 { 'p', "pick" },
1295 { 0, "revert" },
1296 { 'e', "edit" },
1297 { 'r', "reword" },
1298 { 'f', "fixup" },
1299 { 's', "squash" },
1300 { 'x', "exec" },
1301 { 0, "noop" },
1302 { 'd', "drop" },
1303 { 0, NULL }
1304};
1305
1306static const char *command_to_string(const enum todo_command command)
1307{
1308 if (command < TODO_COMMENT)
1309 return todo_command_info[command].str;
1310 die("Unknown command: %d", command);
1311}
1312
1313static char command_to_char(const enum todo_command command)
1314{
1315 if (command < TODO_COMMENT && todo_command_info[command].c)
1316 return todo_command_info[command].c;
1317 return comment_line_char;
1318}
1319
1320static int is_noop(const enum todo_command command)
1321{
1322 return TODO_NOOP <= command;
1323}
1324
1325static int is_fixup(enum todo_command command)
1326{
1327 return command == TODO_FIXUP || command == TODO_SQUASH;
1328}
1329
1330static int update_squash_messages(enum todo_command command,
1331 struct commit *commit, struct replay_opts *opts)
1332{
1333 struct strbuf buf = STRBUF_INIT;
1334 int count, res;
1335 const char *message, *body;
1336
1337 if (file_exists(rebase_path_squash_msg())) {
1338 struct strbuf header = STRBUF_INIT;
1339 char *eol, *p;
1340
1341 if (strbuf_read_file(&buf, rebase_path_squash_msg(), 2048) <= 0)
1342 return error(_("could not read '%s'"),
1343 rebase_path_squash_msg());
1344
1345 p = buf.buf + 1;
1346 eol = strchrnul(buf.buf, '\n');
1347 if (buf.buf[0] != comment_line_char ||
1348 (p += strcspn(p, "0123456789\n")) == eol)
1349 return error(_("unexpected 1st line of squash message:"
1350 "\n\n\t%.*s"),
1351 (int)(eol - buf.buf), buf.buf);
1352 count = strtol(p, NULL, 10);
1353
1354 if (count < 1)
1355 return error(_("invalid 1st line of squash message:\n"
1356 "\n\t%.*s"),
1357 (int)(eol - buf.buf), buf.buf);
1358
1359 strbuf_addf(&header, "%c ", comment_line_char);
1360 strbuf_addf(&header,
1361 _("This is a combination of %d commits."), ++count);
1362 strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
1363 strbuf_release(&header);
1364 } else {
1365 struct object_id head;
1366 struct commit *head_commit;
1367 const char *head_message, *body;
1368
1369 if (get_oid("HEAD", &head))
1370 return error(_("need a HEAD to fixup"));
1371 if (!(head_commit = lookup_commit_reference(&head)))
1372 return error(_("could not read HEAD"));
1373 if (!(head_message = get_commit_buffer(head_commit, NULL)))
1374 return error(_("could not read HEAD's commit message"));
1375
1376 find_commit_subject(head_message, &body);
1377 if (write_message(body, strlen(body),
1378 rebase_path_fixup_msg(), 0)) {
1379 unuse_commit_buffer(head_commit, head_message);
1380 return error(_("cannot write '%s'"),
1381 rebase_path_fixup_msg());
1382 }
1383
1384 count = 2;
1385 strbuf_addf(&buf, "%c ", comment_line_char);
1386 strbuf_addf(&buf, _("This is a combination of %d commits."),
1387 count);
1388 strbuf_addf(&buf, "\n%c ", comment_line_char);
1389 strbuf_addstr(&buf, _("This is the 1st commit message:"));
1390 strbuf_addstr(&buf, "\n\n");
1391 strbuf_addstr(&buf, body);
1392
1393 unuse_commit_buffer(head_commit, head_message);
1394 }
1395
1396 if (!(message = get_commit_buffer(commit, NULL)))
1397 return error(_("could not read commit message of %s"),
1398 oid_to_hex(&commit->object.oid));
1399 find_commit_subject(message, &body);
1400
1401 if (command == TODO_SQUASH) {
1402 unlink(rebase_path_fixup_msg());
1403 strbuf_addf(&buf, "\n%c ", comment_line_char);
1404 strbuf_addf(&buf, _("This is the commit message #%d:"), count);
1405 strbuf_addstr(&buf, "\n\n");
1406 strbuf_addstr(&buf, body);
1407 } else if (command == TODO_FIXUP) {
1408 strbuf_addf(&buf, "\n%c ", comment_line_char);
1409 strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
1410 count);
1411 strbuf_addstr(&buf, "\n\n");
1412 strbuf_add_commented_lines(&buf, body, strlen(body));
1413 } else
1414 return error(_("unknown command: %d"), command);
1415 unuse_commit_buffer(commit, message);
1416
1417 res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
1418 strbuf_release(&buf);
1419 return res;
1420}
1421
1422static void flush_rewritten_pending(void) {
1423 struct strbuf buf = STRBUF_INIT;
1424 struct object_id newoid;
1425 FILE *out;
1426
1427 if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
1428 !get_oid("HEAD", &newoid) &&
1429 (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1430 char *bol = buf.buf, *eol;
1431
1432 while (*bol) {
1433 eol = strchrnul(bol, '\n');
1434 fprintf(out, "%.*s %s\n", (int)(eol - bol),
1435 bol, oid_to_hex(&newoid));
1436 if (!*eol)
1437 break;
1438 bol = eol + 1;
1439 }
1440 fclose(out);
1441 unlink(rebase_path_rewritten_pending());
1442 }
1443 strbuf_release(&buf);
1444}
1445
1446static void record_in_rewritten(struct object_id *oid,
1447 enum todo_command next_command) {
1448 FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
1449
1450 if (!out)
1451 return;
1452
1453 fprintf(out, "%s\n", oid_to_hex(oid));
1454 fclose(out);
1455
1456 if (!is_fixup(next_command))
1457 flush_rewritten_pending();
1458}
1459
1460static int do_pick_commit(enum todo_command command, struct commit *commit,
1461 struct replay_opts *opts, int final_fixup)
1462{
1463 unsigned int flags = opts->edit ? EDIT_MSG : 0;
1464 const char *msg_file = opts->edit ? NULL : git_path_merge_msg();
1465 struct object_id head;
1466 struct commit *base, *next, *parent;
1467 const char *base_label, *next_label;
1468 char *author = NULL;
1469 struct commit_message msg = { NULL, NULL, NULL, NULL };
1470 struct strbuf msgbuf = STRBUF_INIT;
1471 int res, unborn = 0, allow;
1472
1473 if (opts->no_commit) {
1474 /*
1475 * We do not intend to commit immediately. We just want to
1476 * merge the differences in, so let's compute the tree
1477 * that represents the "current" state for merge-recursive
1478 * to work on.
1479 */
1480 if (write_cache_as_tree(&head, 0, NULL))
1481 return error(_("your index file is unmerged."));
1482 } else {
1483 unborn = get_oid("HEAD", &head);
1484 if (unborn)
1485 oidcpy(&head, the_hash_algo->empty_tree);
1486 if (index_differs_from(unborn ? EMPTY_TREE_SHA1_HEX : "HEAD",
1487 NULL, 0))
1488 return error_dirty_index(opts);
1489 }
1490 discard_cache();
1491
1492 if (!commit->parents)
1493 parent = NULL;
1494 else if (commit->parents->next) {
1495 /* Reverting or cherry-picking a merge commit */
1496 int cnt;
1497 struct commit_list *p;
1498
1499 if (!opts->mainline)
1500 return error(_("commit %s is a merge but no -m option was given."),
1501 oid_to_hex(&commit->object.oid));
1502
1503 for (cnt = 1, p = commit->parents;
1504 cnt != opts->mainline && p;
1505 cnt++)
1506 p = p->next;
1507 if (cnt != opts->mainline || !p)
1508 return error(_("commit %s does not have parent %d"),
1509 oid_to_hex(&commit->object.oid), opts->mainline);
1510 parent = p->item;
1511 } else if (0 < opts->mainline)
1512 return error(_("mainline was specified but commit %s is not a merge."),
1513 oid_to_hex(&commit->object.oid));
1514 else
1515 parent = commit->parents->item;
1516
1517 if (get_message(commit, &msg) != 0)
1518 return error(_("cannot get commit message for %s"),
1519 oid_to_hex(&commit->object.oid));
1520
1521 if (opts->allow_ff && !is_fixup(command) &&
1522 ((parent && !oidcmp(&parent->object.oid, &head)) ||
1523 (!parent && unborn))) {
1524 if (is_rebase_i(opts))
1525 write_author_script(msg.message);
1526 res = fast_forward_to(&commit->object.oid, &head, unborn,
1527 opts);
1528 if (res || command != TODO_REWORD)
1529 goto leave;
1530 flags |= EDIT_MSG | AMEND_MSG | VERIFY_MSG;
1531 msg_file = NULL;
1532 goto fast_forward_edit;
1533 }
1534 if (parent && parse_commit(parent) < 0)
1535 /* TRANSLATORS: The first %s will be a "todo" command like
1536 "revert" or "pick", the second %s a SHA1. */
1537 return error(_("%s: cannot parse parent commit %s"),
1538 command_to_string(command),
1539 oid_to_hex(&parent->object.oid));
1540
1541 /*
1542 * "commit" is an existing commit. We would want to apply
1543 * the difference it introduces since its first parent "prev"
1544 * on top of the current HEAD if we are cherry-pick. Or the
1545 * reverse of it if we are revert.
1546 */
1547
1548 if (command == TODO_REVERT) {
1549 base = commit;
1550 base_label = msg.label;
1551 next = parent;
1552 next_label = msg.parent_label;
1553 strbuf_addstr(&msgbuf, "Revert \"");
1554 strbuf_addstr(&msgbuf, msg.subject);
1555 strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
1556 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1557
1558 if (commit->parents && commit->parents->next) {
1559 strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
1560 strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
1561 }
1562 strbuf_addstr(&msgbuf, ".\n");
1563 } else {
1564 const char *p;
1565
1566 base = parent;
1567 base_label = msg.parent_label;
1568 next = commit;
1569 next_label = msg.label;
1570
1571 /* Append the commit log message to msgbuf. */
1572 if (find_commit_subject(msg.message, &p))
1573 strbuf_addstr(&msgbuf, p);
1574
1575 if (opts->record_origin) {
1576 strbuf_complete_line(&msgbuf);
1577 if (!has_conforming_footer(&msgbuf, NULL, 0))
1578 strbuf_addch(&msgbuf, '\n');
1579 strbuf_addstr(&msgbuf, cherry_picked_prefix);
1580 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1581 strbuf_addstr(&msgbuf, ")\n");
1582 }
1583 if (!is_fixup(command))
1584 author = get_author(msg.message);
1585 }
1586
1587 if (command == TODO_REWORD)
1588 flags |= EDIT_MSG | VERIFY_MSG;
1589 else if (is_fixup(command)) {
1590 if (update_squash_messages(command, commit, opts))
1591 return -1;
1592 flags |= AMEND_MSG;
1593 if (!final_fixup)
1594 msg_file = rebase_path_squash_msg();
1595 else if (file_exists(rebase_path_fixup_msg())) {
1596 flags |= CLEANUP_MSG;
1597 msg_file = rebase_path_fixup_msg();
1598 } else {
1599 const char *dest = git_path_squash_msg();
1600 unlink(dest);
1601 if (copy_file(dest, rebase_path_squash_msg(), 0666))
1602 return error(_("could not rename '%s' to '%s'"),
1603 rebase_path_squash_msg(), dest);
1604 unlink(git_path_merge_msg());
1605 msg_file = dest;
1606 flags |= EDIT_MSG;
1607 }
1608 }
1609
1610 if (opts->signoff && !is_fixup(command))
1611 append_signoff(&msgbuf, 0, 0);
1612
1613 if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1614 res = -1;
1615 else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
1616 res = do_recursive_merge(base, next, base_label, next_label,
1617 &head, &msgbuf, opts);
1618 if (res < 0)
1619 return res;
1620 res |= write_message(msgbuf.buf, msgbuf.len,
1621 git_path_merge_msg(), 0);
1622 } else {
1623 struct commit_list *common = NULL;
1624 struct commit_list *remotes = NULL;
1625
1626 res = write_message(msgbuf.buf, msgbuf.len,
1627 git_path_merge_msg(), 0);
1628
1629 commit_list_insert(base, &common);
1630 commit_list_insert(next, &remotes);
1631 res |= try_merge_command(opts->strategy,
1632 opts->xopts_nr, (const char **)opts->xopts,
1633 common, oid_to_hex(&head), remotes);
1634 free_commit_list(common);
1635 free_commit_list(remotes);
1636 }
1637 strbuf_release(&msgbuf);
1638
1639 /*
1640 * If the merge was clean or if it failed due to conflict, we write
1641 * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1642 * However, if the merge did not even start, then we don't want to
1643 * write it at all.
1644 */
1645 if (command == TODO_PICK && !opts->no_commit && (res == 0 || res == 1) &&
1646 update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
1647 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1648 res = -1;
1649 if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
1650 update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
1651 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1652 res = -1;
1653
1654 if (res) {
1655 error(command == TODO_REVERT
1656 ? _("could not revert %s... %s")
1657 : _("could not apply %s... %s"),
1658 short_commit_name(commit), msg.subject);
1659 print_advice(res == 1, opts);
1660 rerere(opts->allow_rerere_auto);
1661 goto leave;
1662 }
1663
1664 allow = allow_empty(opts, commit);
1665 if (allow < 0) {
1666 res = allow;
1667 goto leave;
1668 } else if (allow)
1669 flags |= ALLOW_EMPTY;
1670 if (!opts->no_commit) {
1671fast_forward_edit:
1672 if (author || command == TODO_REVERT || (flags & AMEND_MSG))
1673 res = do_commit(msg_file, author, opts, flags);
1674 else
1675 res = error(_("unable to parse commit author"));
1676 }
1677
1678 if (!res && final_fixup) {
1679 unlink(rebase_path_fixup_msg());
1680 unlink(rebase_path_squash_msg());
1681 }
1682
1683leave:
1684 free_message(commit, &msg);
1685 free(author);
1686 update_abort_safety_file();
1687
1688 return res;
1689}
1690
1691static int prepare_revs(struct replay_opts *opts)
1692{
1693 /*
1694 * picking (but not reverting) ranges (but not individual revisions)
1695 * should be done in reverse
1696 */
1697 if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
1698 opts->revs->reverse ^= 1;
1699
1700 if (prepare_revision_walk(opts->revs))
1701 return error(_("revision walk setup failed"));
1702
1703 if (!opts->revs->commits)
1704 return error(_("empty commit set passed"));
1705 return 0;
1706}
1707
1708static int read_and_refresh_cache(struct replay_opts *opts)
1709{
1710 struct lock_file index_lock = LOCK_INIT;
1711 int index_fd = hold_locked_index(&index_lock, 0);
1712 if (read_index_preload(&the_index, NULL) < 0) {
1713 rollback_lock_file(&index_lock);
1714 return error(_("git %s: failed to read the index"),
1715 _(action_name(opts)));
1716 }
1717 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
1718 if (index_fd >= 0) {
1719 if (write_locked_index(&the_index, &index_lock,
1720 COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
1721 return error(_("git %s: failed to refresh the index"),
1722 _(action_name(opts)));
1723 }
1724 }
1725 return 0;
1726}
1727
1728struct todo_item {
1729 enum todo_command command;
1730 struct commit *commit;
1731 const char *arg;
1732 int arg_len;
1733 size_t offset_in_buf;
1734};
1735
1736struct todo_list {
1737 struct strbuf buf;
1738 struct todo_item *items;
1739 int nr, alloc, current;
1740 int done_nr, total_nr;
1741 struct stat_data stat;
1742};
1743
1744#define TODO_LIST_INIT { STRBUF_INIT }
1745
1746static void todo_list_release(struct todo_list *todo_list)
1747{
1748 strbuf_release(&todo_list->buf);
1749 FREE_AND_NULL(todo_list->items);
1750 todo_list->nr = todo_list->alloc = 0;
1751}
1752
1753static struct todo_item *append_new_todo(struct todo_list *todo_list)
1754{
1755 ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
1756 return todo_list->items + todo_list->nr++;
1757}
1758
1759static int parse_insn_line(struct todo_item *item, const char *bol, char *eol)
1760{
1761 struct object_id commit_oid;
1762 char *end_of_object_name;
1763 int i, saved, status, padding;
1764
1765 /* left-trim */
1766 bol += strspn(bol, " \t");
1767
1768 if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
1769 item->command = TODO_COMMENT;
1770 item->commit = NULL;
1771 item->arg = bol;
1772 item->arg_len = eol - bol;
1773 return 0;
1774 }
1775
1776 for (i = 0; i < TODO_COMMENT; i++)
1777 if (skip_prefix(bol, todo_command_info[i].str, &bol)) {
1778 item->command = i;
1779 break;
1780 } else if (bol[1] == ' ' && *bol == todo_command_info[i].c) {
1781 bol++;
1782 item->command = i;
1783 break;
1784 }
1785 if (i >= TODO_COMMENT)
1786 return -1;
1787
1788 /* Eat up extra spaces/ tabs before object name */
1789 padding = strspn(bol, " \t");
1790 bol += padding;
1791
1792 if (item->command == TODO_NOOP) {
1793 if (bol != eol)
1794 return error(_("%s does not accept arguments: '%s'"),
1795 command_to_string(item->command), bol);
1796 item->commit = NULL;
1797 item->arg = bol;
1798 item->arg_len = eol - bol;
1799 return 0;
1800 }
1801
1802 if (!padding)
1803 return error(_("missing arguments for %s"),
1804 command_to_string(item->command));
1805
1806 if (item->command == TODO_EXEC) {
1807 item->commit = NULL;
1808 item->arg = bol;
1809 item->arg_len = (int)(eol - bol);
1810 return 0;
1811 }
1812
1813 end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
1814 saved = *end_of_object_name;
1815 *end_of_object_name = '\0';
1816 status = get_oid(bol, &commit_oid);
1817 *end_of_object_name = saved;
1818
1819 item->arg = end_of_object_name + strspn(end_of_object_name, " \t");
1820 item->arg_len = (int)(eol - item->arg);
1821
1822 if (status < 0)
1823 return -1;
1824
1825 item->commit = lookup_commit_reference(&commit_oid);
1826 return !item->commit;
1827}
1828
1829static int parse_insn_buffer(char *buf, struct todo_list *todo_list)
1830{
1831 struct todo_item *item;
1832 char *p = buf, *next_p;
1833 int i, res = 0, fixup_okay = file_exists(rebase_path_done());
1834
1835 for (i = 1; *p; i++, p = next_p) {
1836 char *eol = strchrnul(p, '\n');
1837
1838 next_p = *eol ? eol + 1 /* skip LF */ : eol;
1839
1840 if (p != eol && eol[-1] == '\r')
1841 eol--; /* strip Carriage Return */
1842
1843 item = append_new_todo(todo_list);
1844 item->offset_in_buf = p - todo_list->buf.buf;
1845 if (parse_insn_line(item, p, eol)) {
1846 res = error(_("invalid line %d: %.*s"),
1847 i, (int)(eol - p), p);
1848 item->command = TODO_NOOP;
1849 }
1850
1851 if (fixup_okay)
1852 ; /* do nothing */
1853 else if (is_fixup(item->command))
1854 return error(_("cannot '%s' without a previous commit"),
1855 command_to_string(item->command));
1856 else if (!is_noop(item->command))
1857 fixup_okay = 1;
1858 }
1859
1860 return res;
1861}
1862
1863static int count_commands(struct todo_list *todo_list)
1864{
1865 int count = 0, i;
1866
1867 for (i = 0; i < todo_list->nr; i++)
1868 if (todo_list->items[i].command != TODO_COMMENT)
1869 count++;
1870
1871 return count;
1872}
1873
1874static int get_item_line_offset(struct todo_list *todo_list, int index)
1875{
1876 return index < todo_list->nr ?
1877 todo_list->items[index].offset_in_buf : todo_list->buf.len;
1878}
1879
1880static const char *get_item_line(struct todo_list *todo_list, int index)
1881{
1882 return todo_list->buf.buf + get_item_line_offset(todo_list, index);
1883}
1884
1885static int get_item_line_length(struct todo_list *todo_list, int index)
1886{
1887 return get_item_line_offset(todo_list, index + 1)
1888 - get_item_line_offset(todo_list, index);
1889}
1890
1891static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
1892{
1893 int fd;
1894 ssize_t len;
1895
1896 fd = open(path, O_RDONLY);
1897 if (fd < 0)
1898 return error_errno(_("could not open '%s'"), path);
1899 len = strbuf_read(sb, fd, 0);
1900 close(fd);
1901 if (len < 0)
1902 return error(_("could not read '%s'."), path);
1903 return len;
1904}
1905
1906static int read_populate_todo(struct todo_list *todo_list,
1907 struct replay_opts *opts)
1908{
1909 struct stat st;
1910 const char *todo_file = get_todo_path(opts);
1911 int res;
1912
1913 strbuf_reset(&todo_list->buf);
1914 if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
1915 return -1;
1916
1917 res = stat(todo_file, &st);
1918 if (res)
1919 return error(_("could not stat '%s'"), todo_file);
1920 fill_stat_data(&todo_list->stat, &st);
1921
1922 res = parse_insn_buffer(todo_list->buf.buf, todo_list);
1923 if (res) {
1924 if (is_rebase_i(opts))
1925 return error(_("please fix this using "
1926 "'git rebase --edit-todo'."));
1927 return error(_("unusable instruction sheet: '%s'"), todo_file);
1928 }
1929
1930 if (!todo_list->nr &&
1931 (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
1932 return error(_("no commits parsed."));
1933
1934 if (!is_rebase_i(opts)) {
1935 enum todo_command valid =
1936 opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
1937 int i;
1938
1939 for (i = 0; i < todo_list->nr; i++)
1940 if (valid == todo_list->items[i].command)
1941 continue;
1942 else if (valid == TODO_PICK)
1943 return error(_("cannot cherry-pick during a revert."));
1944 else
1945 return error(_("cannot revert during a cherry-pick."));
1946 }
1947
1948 if (is_rebase_i(opts)) {
1949 struct todo_list done = TODO_LIST_INIT;
1950 FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
1951
1952 if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
1953 !parse_insn_buffer(done.buf.buf, &done))
1954 todo_list->done_nr = count_commands(&done);
1955 else
1956 todo_list->done_nr = 0;
1957
1958 todo_list->total_nr = todo_list->done_nr
1959 + count_commands(todo_list);
1960 todo_list_release(&done);
1961
1962 if (f) {
1963 fprintf(f, "%d\n", todo_list->total_nr);
1964 fclose(f);
1965 }
1966 }
1967
1968 return 0;
1969}
1970
1971static int git_config_string_dup(char **dest,
1972 const char *var, const char *value)
1973{
1974 if (!value)
1975 return config_error_nonbool(var);
1976 free(*dest);
1977 *dest = xstrdup(value);
1978 return 0;
1979}
1980
1981static int populate_opts_cb(const char *key, const char *value, void *data)
1982{
1983 struct replay_opts *opts = data;
1984 int error_flag = 1;
1985
1986 if (!value)
1987 error_flag = 0;
1988 else if (!strcmp(key, "options.no-commit"))
1989 opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
1990 else if (!strcmp(key, "options.edit"))
1991 opts->edit = git_config_bool_or_int(key, value, &error_flag);
1992 else if (!strcmp(key, "options.signoff"))
1993 opts->signoff = git_config_bool_or_int(key, value, &error_flag);
1994 else if (!strcmp(key, "options.record-origin"))
1995 opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
1996 else if (!strcmp(key, "options.allow-ff"))
1997 opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
1998 else if (!strcmp(key, "options.mainline"))
1999 opts->mainline = git_config_int(key, value);
2000 else if (!strcmp(key, "options.strategy"))
2001 git_config_string_dup(&opts->strategy, key, value);
2002 else if (!strcmp(key, "options.gpg-sign"))
2003 git_config_string_dup(&opts->gpg_sign, key, value);
2004 else if (!strcmp(key, "options.strategy-option")) {
2005 ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
2006 opts->xopts[opts->xopts_nr++] = xstrdup(value);
2007 } else if (!strcmp(key, "options.allow-rerere-auto"))
2008 opts->allow_rerere_auto =
2009 git_config_bool_or_int(key, value, &error_flag) ?
2010 RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
2011 else
2012 return error(_("invalid key: %s"), key);
2013
2014 if (!error_flag)
2015 return error(_("invalid value for %s: %s"), key, value);
2016
2017 return 0;
2018}
2019
2020static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
2021{
2022 int i;
2023
2024 strbuf_reset(buf);
2025 if (!read_oneliner(buf, rebase_path_strategy(), 0))
2026 return;
2027 opts->strategy = strbuf_detach(buf, NULL);
2028 if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2029 return;
2030
2031 opts->xopts_nr = split_cmdline(buf->buf, (const char ***)&opts->xopts);
2032 for (i = 0; i < opts->xopts_nr; i++) {
2033 const char *arg = opts->xopts[i];
2034
2035 skip_prefix(arg, "--", &arg);
2036 opts->xopts[i] = xstrdup(arg);
2037 }
2038}
2039
2040static int read_populate_opts(struct replay_opts *opts)
2041{
2042 if (is_rebase_i(opts)) {
2043 struct strbuf buf = STRBUF_INIT;
2044
2045 if (read_oneliner(&buf, rebase_path_gpg_sign_opt(), 1)) {
2046 if (!starts_with(buf.buf, "-S"))
2047 strbuf_reset(&buf);
2048 else {
2049 free(opts->gpg_sign);
2050 opts->gpg_sign = xstrdup(buf.buf + 2);
2051 }
2052 strbuf_reset(&buf);
2053 }
2054
2055 if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(), 1)) {
2056 if (!strcmp(buf.buf, "--rerere-autoupdate"))
2057 opts->allow_rerere_auto = RERERE_AUTOUPDATE;
2058 else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
2059 opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
2060 strbuf_reset(&buf);
2061 }
2062
2063 if (file_exists(rebase_path_verbose()))
2064 opts->verbose = 1;
2065
2066 if (file_exists(rebase_path_signoff())) {
2067 opts->allow_ff = 0;
2068 opts->signoff = 1;
2069 }
2070
2071 read_strategy_opts(opts, &buf);
2072 strbuf_release(&buf);
2073
2074 return 0;
2075 }
2076
2077 if (!file_exists(git_path_opts_file()))
2078 return 0;
2079 /*
2080 * The function git_parse_source(), called from git_config_from_file(),
2081 * may die() in case of a syntactically incorrect file. We do not care
2082 * about this case, though, because we wrote that file ourselves, so we
2083 * are pretty certain that it is syntactically correct.
2084 */
2085 if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
2086 return error(_("malformed options sheet: '%s'"),
2087 git_path_opts_file());
2088 return 0;
2089}
2090
2091static int walk_revs_populate_todo(struct todo_list *todo_list,
2092 struct replay_opts *opts)
2093{
2094 enum todo_command command = opts->action == REPLAY_PICK ?
2095 TODO_PICK : TODO_REVERT;
2096 const char *command_string = todo_command_info[command].str;
2097 struct commit *commit;
2098
2099 if (prepare_revs(opts))
2100 return -1;
2101
2102 while ((commit = get_revision(opts->revs))) {
2103 struct todo_item *item = append_new_todo(todo_list);
2104 const char *commit_buffer = get_commit_buffer(commit, NULL);
2105 const char *subject;
2106 int subject_len;
2107
2108 item->command = command;
2109 item->commit = commit;
2110 item->arg = NULL;
2111 item->arg_len = 0;
2112 item->offset_in_buf = todo_list->buf.len;
2113 subject_len = find_commit_subject(commit_buffer, &subject);
2114 strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
2115 short_commit_name(commit), subject_len, subject);
2116 unuse_commit_buffer(commit, commit_buffer);
2117 }
2118 return 0;
2119}
2120
2121static int create_seq_dir(void)
2122{
2123 if (file_exists(git_path_seq_dir())) {
2124 error(_("a cherry-pick or revert is already in progress"));
2125 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
2126 return -1;
2127 } else if (mkdir(git_path_seq_dir(), 0777) < 0)
2128 return error_errno(_("could not create sequencer directory '%s'"),
2129 git_path_seq_dir());
2130 return 0;
2131}
2132
2133static int save_head(const char *head)
2134{
2135 struct lock_file head_lock = LOCK_INIT;
2136 struct strbuf buf = STRBUF_INIT;
2137 int fd;
2138 ssize_t written;
2139
2140 fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
2141 if (fd < 0)
2142 return error_errno(_("could not lock HEAD"));
2143 strbuf_addf(&buf, "%s\n", head);
2144 written = write_in_full(fd, buf.buf, buf.len);
2145 strbuf_release(&buf);
2146 if (written < 0) {
2147 error_errno(_("could not write to '%s'"), git_path_head_file());
2148 rollback_lock_file(&head_lock);
2149 return -1;
2150 }
2151 if (commit_lock_file(&head_lock) < 0)
2152 return error(_("failed to finalize '%s'"), git_path_head_file());
2153 return 0;
2154}
2155
2156static int rollback_is_safe(void)
2157{
2158 struct strbuf sb = STRBUF_INIT;
2159 struct object_id expected_head, actual_head;
2160
2161 if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2162 strbuf_trim(&sb);
2163 if (get_oid_hex(sb.buf, &expected_head)) {
2164 strbuf_release(&sb);
2165 die(_("could not parse %s"), git_path_abort_safety_file());
2166 }
2167 strbuf_release(&sb);
2168 }
2169 else if (errno == ENOENT)
2170 oidclr(&expected_head);
2171 else
2172 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2173
2174 if (get_oid("HEAD", &actual_head))
2175 oidclr(&actual_head);
2176
2177 return !oidcmp(&actual_head, &expected_head);
2178}
2179
2180static int reset_for_rollback(const struct object_id *oid)
2181{
2182 const char *argv[4]; /* reset --merge <arg> + NULL */
2183
2184 argv[0] = "reset";
2185 argv[1] = "--merge";
2186 argv[2] = oid_to_hex(oid);
2187 argv[3] = NULL;
2188 return run_command_v_opt(argv, RUN_GIT_CMD);
2189}
2190
2191static int rollback_single_pick(void)
2192{
2193 struct object_id head_oid;
2194
2195 if (!file_exists(git_path_cherry_pick_head()) &&
2196 !file_exists(git_path_revert_head()))
2197 return error(_("no cherry-pick or revert in progress"));
2198 if (read_ref_full("HEAD", 0, &head_oid, NULL))
2199 return error(_("cannot resolve HEAD"));
2200 if (is_null_oid(&head_oid))
2201 return error(_("cannot abort from a branch yet to be born"));
2202 return reset_for_rollback(&head_oid);
2203}
2204
2205int sequencer_rollback(struct replay_opts *opts)
2206{
2207 FILE *f;
2208 struct object_id oid;
2209 struct strbuf buf = STRBUF_INIT;
2210 const char *p;
2211
2212 f = fopen(git_path_head_file(), "r");
2213 if (!f && errno == ENOENT) {
2214 /*
2215 * There is no multiple-cherry-pick in progress.
2216 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2217 * a single-cherry-pick in progress, abort that.
2218 */
2219 return rollback_single_pick();
2220 }
2221 if (!f)
2222 return error_errno(_("cannot open '%s'"), git_path_head_file());
2223 if (strbuf_getline_lf(&buf, f)) {
2224 error(_("cannot read '%s': %s"), git_path_head_file(),
2225 ferror(f) ? strerror(errno) : _("unexpected end of file"));
2226 fclose(f);
2227 goto fail;
2228 }
2229 fclose(f);
2230 if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
2231 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2232 git_path_head_file());
2233 goto fail;
2234 }
2235 if (is_null_oid(&oid)) {
2236 error(_("cannot abort from a branch yet to be born"));
2237 goto fail;
2238 }
2239
2240 if (!rollback_is_safe()) {
2241 /* Do not error, just do not rollback */
2242 warning(_("You seem to have moved HEAD. "
2243 "Not rewinding, check your HEAD!"));
2244 } else
2245 if (reset_for_rollback(&oid))
2246 goto fail;
2247 strbuf_release(&buf);
2248 return sequencer_remove_state(opts);
2249fail:
2250 strbuf_release(&buf);
2251 return -1;
2252}
2253
2254static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
2255{
2256 struct lock_file todo_lock = LOCK_INIT;
2257 const char *todo_path = get_todo_path(opts);
2258 int next = todo_list->current, offset, fd;
2259
2260 /*
2261 * rebase -i writes "git-rebase-todo" without the currently executing
2262 * command, appending it to "done" instead.
2263 */
2264 if (is_rebase_i(opts))
2265 next++;
2266
2267 fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
2268 if (fd < 0)
2269 return error_errno(_("could not lock '%s'"), todo_path);
2270 offset = get_item_line_offset(todo_list, next);
2271 if (write_in_full(fd, todo_list->buf.buf + offset,
2272 todo_list->buf.len - offset) < 0)
2273 return error_errno(_("could not write to '%s'"), todo_path);
2274 if (commit_lock_file(&todo_lock) < 0)
2275 return error(_("failed to finalize '%s'"), todo_path);
2276
2277 if (is_rebase_i(opts) && next > 0) {
2278 const char *done = rebase_path_done();
2279 int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
2280 int ret = 0;
2281
2282 if (fd < 0)
2283 return 0;
2284 if (write_in_full(fd, get_item_line(todo_list, next - 1),
2285 get_item_line_length(todo_list, next - 1))
2286 < 0)
2287 ret = error_errno(_("could not write to '%s'"), done);
2288 if (close(fd) < 0)
2289 ret = error_errno(_("failed to finalize '%s'"), done);
2290 return ret;
2291 }
2292 return 0;
2293}
2294
2295static int save_opts(struct replay_opts *opts)
2296{
2297 const char *opts_file = git_path_opts_file();
2298 int res = 0;
2299
2300 if (opts->no_commit)
2301 res |= git_config_set_in_file_gently(opts_file, "options.no-commit", "true");
2302 if (opts->edit)
2303 res |= git_config_set_in_file_gently(opts_file, "options.edit", "true");
2304 if (opts->signoff)
2305 res |= git_config_set_in_file_gently(opts_file, "options.signoff", "true");
2306 if (opts->record_origin)
2307 res |= git_config_set_in_file_gently(opts_file, "options.record-origin", "true");
2308 if (opts->allow_ff)
2309 res |= git_config_set_in_file_gently(opts_file, "options.allow-ff", "true");
2310 if (opts->mainline) {
2311 struct strbuf buf = STRBUF_INIT;
2312 strbuf_addf(&buf, "%d", opts->mainline);
2313 res |= git_config_set_in_file_gently(opts_file, "options.mainline", buf.buf);
2314 strbuf_release(&buf);
2315 }
2316 if (opts->strategy)
2317 res |= git_config_set_in_file_gently(opts_file, "options.strategy", opts->strategy);
2318 if (opts->gpg_sign)
2319 res |= git_config_set_in_file_gently(opts_file, "options.gpg-sign", opts->gpg_sign);
2320 if (opts->xopts) {
2321 int i;
2322 for (i = 0; i < opts->xopts_nr; i++)
2323 res |= git_config_set_multivar_in_file_gently(opts_file,
2324 "options.strategy-option",
2325 opts->xopts[i], "^$", 0);
2326 }
2327 if (opts->allow_rerere_auto)
2328 res |= git_config_set_in_file_gently(opts_file, "options.allow-rerere-auto",
2329 opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
2330 "true" : "false");
2331 return res;
2332}
2333
2334static int make_patch(struct commit *commit, struct replay_opts *opts)
2335{
2336 struct strbuf buf = STRBUF_INIT;
2337 struct rev_info log_tree_opt;
2338 const char *subject, *p;
2339 int res = 0;
2340
2341 p = short_commit_name(commit);
2342 if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
2343 return -1;
2344 if (update_ref("rebase", "REBASE_HEAD", &commit->object.oid,
2345 NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2346 res |= error(_("could not update %s"), "REBASE_HEAD");
2347
2348 strbuf_addf(&buf, "%s/patch", get_dir(opts));
2349 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
2350 init_revisions(&log_tree_opt, NULL);
2351 log_tree_opt.abbrev = 0;
2352 log_tree_opt.diff = 1;
2353 log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
2354 log_tree_opt.disable_stdin = 1;
2355 log_tree_opt.no_commit_id = 1;
2356 log_tree_opt.diffopt.file = fopen(buf.buf, "w");
2357 log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
2358 if (!log_tree_opt.diffopt.file)
2359 res |= error_errno(_("could not open '%s'"), buf.buf);
2360 else {
2361 res |= log_tree_commit(&log_tree_opt, commit);
2362 fclose(log_tree_opt.diffopt.file);
2363 }
2364 strbuf_reset(&buf);
2365
2366 strbuf_addf(&buf, "%s/message", get_dir(opts));
2367 if (!file_exists(buf.buf)) {
2368 const char *commit_buffer = get_commit_buffer(commit, NULL);
2369 find_commit_subject(commit_buffer, &subject);
2370 res |= write_message(subject, strlen(subject), buf.buf, 1);
2371 unuse_commit_buffer(commit, commit_buffer);
2372 }
2373 strbuf_release(&buf);
2374
2375 return res;
2376}
2377
2378static int intend_to_amend(void)
2379{
2380 struct object_id head;
2381 char *p;
2382
2383 if (get_oid("HEAD", &head))
2384 return error(_("cannot read HEAD"));
2385
2386 p = oid_to_hex(&head);
2387 return write_message(p, strlen(p), rebase_path_amend(), 1);
2388}
2389
2390static int error_with_patch(struct commit *commit,
2391 const char *subject, int subject_len,
2392 struct replay_opts *opts, int exit_code, int to_amend)
2393{
2394 if (make_patch(commit, opts))
2395 return -1;
2396
2397 if (to_amend) {
2398 if (intend_to_amend())
2399 return -1;
2400
2401 fprintf(stderr, "You can amend the commit now, with\n"
2402 "\n"
2403 " git commit --amend %s\n"
2404 "\n"
2405 "Once you are satisfied with your changes, run\n"
2406 "\n"
2407 " git rebase --continue\n", gpg_sign_opt_quoted(opts));
2408 } else if (exit_code)
2409 fprintf(stderr, "Could not apply %s... %.*s\n",
2410 short_commit_name(commit), subject_len, subject);
2411
2412 return exit_code;
2413}
2414
2415static int error_failed_squash(struct commit *commit,
2416 struct replay_opts *opts, int subject_len, const char *subject)
2417{
2418 if (rename(rebase_path_squash_msg(), rebase_path_message()))
2419 return error(_("could not rename '%s' to '%s'"),
2420 rebase_path_squash_msg(), rebase_path_message());
2421 unlink(rebase_path_fixup_msg());
2422 unlink(git_path_merge_msg());
2423 if (copy_file(git_path_merge_msg(), rebase_path_message(), 0666))
2424 return error(_("could not copy '%s' to '%s'"),
2425 rebase_path_message(), git_path_merge_msg());
2426 return error_with_patch(commit, subject, subject_len, opts, 1, 0);
2427}
2428
2429static int do_exec(const char *command_line)
2430{
2431 struct argv_array child_env = ARGV_ARRAY_INIT;
2432 const char *child_argv[] = { NULL, NULL };
2433 int dirty, status;
2434
2435 fprintf(stderr, "Executing: %s\n", command_line);
2436 child_argv[0] = command_line;
2437 argv_array_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
2438 status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
2439 child_env.argv);
2440
2441 /* force re-reading of the cache */
2442 if (discard_cache() < 0 || read_cache() < 0)
2443 return error(_("could not read index"));
2444
2445 dirty = require_clean_work_tree("rebase", NULL, 1, 1);
2446
2447 if (status) {
2448 warning(_("execution failed: %s\n%s"
2449 "You can fix the problem, and then run\n"
2450 "\n"
2451 " git rebase --continue\n"
2452 "\n"),
2453 command_line,
2454 dirty ? N_("and made changes to the index and/or the "
2455 "working tree\n") : "");
2456 if (status == 127)
2457 /* command not found */
2458 status = 1;
2459 } else if (dirty) {
2460 warning(_("execution succeeded: %s\nbut "
2461 "left changes to the index and/or the working tree\n"
2462 "Commit or stash your changes, and then run\n"
2463 "\n"
2464 " git rebase --continue\n"
2465 "\n"), command_line);
2466 status = 1;
2467 }
2468
2469 argv_array_clear(&child_env);
2470
2471 return status;
2472}
2473
2474static int is_final_fixup(struct todo_list *todo_list)
2475{
2476 int i = todo_list->current;
2477
2478 if (!is_fixup(todo_list->items[i].command))
2479 return 0;
2480
2481 while (++i < todo_list->nr)
2482 if (is_fixup(todo_list->items[i].command))
2483 return 0;
2484 else if (!is_noop(todo_list->items[i].command))
2485 break;
2486 return 1;
2487}
2488
2489static enum todo_command peek_command(struct todo_list *todo_list, int offset)
2490{
2491 int i;
2492
2493 for (i = todo_list->current + offset; i < todo_list->nr; i++)
2494 if (!is_noop(todo_list->items[i].command))
2495 return todo_list->items[i].command;
2496
2497 return -1;
2498}
2499
2500static int apply_autostash(struct replay_opts *opts)
2501{
2502 struct strbuf stash_sha1 = STRBUF_INIT;
2503 struct child_process child = CHILD_PROCESS_INIT;
2504 int ret = 0;
2505
2506 if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
2507 strbuf_release(&stash_sha1);
2508 return 0;
2509 }
2510 strbuf_trim(&stash_sha1);
2511
2512 child.git_cmd = 1;
2513 child.no_stdout = 1;
2514 child.no_stderr = 1;
2515 argv_array_push(&child.args, "stash");
2516 argv_array_push(&child.args, "apply");
2517 argv_array_push(&child.args, stash_sha1.buf);
2518 if (!run_command(&child))
2519 fprintf(stderr, _("Applied autostash.\n"));
2520 else {
2521 struct child_process store = CHILD_PROCESS_INIT;
2522
2523 store.git_cmd = 1;
2524 argv_array_push(&store.args, "stash");
2525 argv_array_push(&store.args, "store");
2526 argv_array_push(&store.args, "-m");
2527 argv_array_push(&store.args, "autostash");
2528 argv_array_push(&store.args, "-q");
2529 argv_array_push(&store.args, stash_sha1.buf);
2530 if (run_command(&store))
2531 ret = error(_("cannot store %s"), stash_sha1.buf);
2532 else
2533 fprintf(stderr,
2534 _("Applying autostash resulted in conflicts.\n"
2535 "Your changes are safe in the stash.\n"
2536 "You can run \"git stash pop\" or"
2537 " \"git stash drop\" at any time.\n"));
2538 }
2539
2540 strbuf_release(&stash_sha1);
2541 return ret;
2542}
2543
2544static const char *reflog_message(struct replay_opts *opts,
2545 const char *sub_action, const char *fmt, ...)
2546{
2547 va_list ap;
2548 static struct strbuf buf = STRBUF_INIT;
2549
2550 va_start(ap, fmt);
2551 strbuf_reset(&buf);
2552 strbuf_addstr(&buf, action_name(opts));
2553 if (sub_action)
2554 strbuf_addf(&buf, " (%s)", sub_action);
2555 if (fmt) {
2556 strbuf_addstr(&buf, ": ");
2557 strbuf_vaddf(&buf, fmt, ap);
2558 }
2559 va_end(ap);
2560
2561 return buf.buf;
2562}
2563
2564static const char rescheduled_advice[] =
2565N_("Could not execute the todo command\n"
2566"\n"
2567" %.*s"
2568"\n"
2569"It has been rescheduled; To edit the command before continuing, please\n"
2570"edit the todo list first:\n"
2571"\n"
2572" git rebase --edit-todo\n"
2573" git rebase --continue\n");
2574
2575static int pick_commits(struct todo_list *todo_list, struct replay_opts *opts)
2576{
2577 int res = 0;
2578
2579 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
2580 if (opts->allow_ff)
2581 assert(!(opts->signoff || opts->no_commit ||
2582 opts->record_origin || opts->edit));
2583 if (read_and_refresh_cache(opts))
2584 return -1;
2585
2586 while (todo_list->current < todo_list->nr) {
2587 struct todo_item *item = todo_list->items + todo_list->current;
2588 if (save_todo(todo_list, opts))
2589 return -1;
2590 if (is_rebase_i(opts)) {
2591 if (item->command != TODO_COMMENT) {
2592 FILE *f = fopen(rebase_path_msgnum(), "w");
2593
2594 todo_list->done_nr++;
2595
2596 if (f) {
2597 fprintf(f, "%d\n", todo_list->done_nr);
2598 fclose(f);
2599 }
2600 fprintf(stderr, "Rebasing (%d/%d)%s",
2601 todo_list->done_nr,
2602 todo_list->total_nr,
2603 opts->verbose ? "\n" : "\r");
2604 }
2605 unlink(rebase_path_message());
2606 unlink(rebase_path_author_script());
2607 unlink(rebase_path_stopped_sha());
2608 unlink(rebase_path_amend());
2609 delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
2610 }
2611 if (item->command <= TODO_SQUASH) {
2612 if (is_rebase_i(opts))
2613 setenv("GIT_REFLOG_ACTION", reflog_message(opts,
2614 command_to_string(item->command), NULL),
2615 1);
2616 res = do_pick_commit(item->command, item->commit,
2617 opts, is_final_fixup(todo_list));
2618 if (is_rebase_i(opts) && res < 0) {
2619 /* Reschedule */
2620 advise(_(rescheduled_advice),
2621 get_item_line_length(todo_list,
2622 todo_list->current),
2623 get_item_line(todo_list,
2624 todo_list->current));
2625 todo_list->current--;
2626 if (save_todo(todo_list, opts))
2627 return -1;
2628 }
2629 if (item->command == TODO_EDIT) {
2630 struct commit *commit = item->commit;
2631 if (!res)
2632 fprintf(stderr,
2633 _("Stopped at %s... %.*s\n"),
2634 short_commit_name(commit),
2635 item->arg_len, item->arg);
2636 return error_with_patch(commit,
2637 item->arg, item->arg_len, opts, res,
2638 !res);
2639 }
2640 if (is_rebase_i(opts) && !res)
2641 record_in_rewritten(&item->commit->object.oid,
2642 peek_command(todo_list, 1));
2643 if (res && is_fixup(item->command)) {
2644 if (res == 1)
2645 intend_to_amend();
2646 return error_failed_squash(item->commit, opts,
2647 item->arg_len, item->arg);
2648 } else if (res && is_rebase_i(opts))
2649 return res | error_with_patch(item->commit,
2650 item->arg, item->arg_len, opts, res,
2651 item->command == TODO_REWORD);
2652 } else if (item->command == TODO_EXEC) {
2653 char *end_of_arg = (char *)(item->arg + item->arg_len);
2654 int saved = *end_of_arg;
2655 struct stat st;
2656
2657 *end_of_arg = '\0';
2658 res = do_exec(item->arg);
2659 *end_of_arg = saved;
2660
2661 /* Reread the todo file if it has changed. */
2662 if (res)
2663 ; /* fall through */
2664 else if (stat(get_todo_path(opts), &st))
2665 res = error_errno(_("could not stat '%s'"),
2666 get_todo_path(opts));
2667 else if (match_stat_data(&todo_list->stat, &st)) {
2668 todo_list_release(todo_list);
2669 if (read_populate_todo(todo_list, opts))
2670 res = -1; /* message was printed */
2671 /* `current` will be incremented below */
2672 todo_list->current = -1;
2673 }
2674 } else if (!is_noop(item->command))
2675 return error(_("unknown command %d"), item->command);
2676
2677 todo_list->current++;
2678 if (res)
2679 return res;
2680 }
2681
2682 if (is_rebase_i(opts)) {
2683 struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
2684 struct stat st;
2685
2686 /* Stopped in the middle, as planned? */
2687 if (todo_list->current < todo_list->nr)
2688 return 0;
2689
2690 if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
2691 starts_with(head_ref.buf, "refs/")) {
2692 const char *msg;
2693 struct object_id head, orig;
2694 int res;
2695
2696 if (get_oid("HEAD", &head)) {
2697 res = error(_("cannot read HEAD"));
2698cleanup_head_ref:
2699 strbuf_release(&head_ref);
2700 strbuf_release(&buf);
2701 return res;
2702 }
2703 if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
2704 get_oid_hex(buf.buf, &orig)) {
2705 res = error(_("could not read orig-head"));
2706 goto cleanup_head_ref;
2707 }
2708 strbuf_reset(&buf);
2709 if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
2710 res = error(_("could not read 'onto'"));
2711 goto cleanup_head_ref;
2712 }
2713 msg = reflog_message(opts, "finish", "%s onto %s",
2714 head_ref.buf, buf.buf);
2715 if (update_ref(msg, head_ref.buf, &head, &orig,
2716 REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
2717 res = error(_("could not update %s"),
2718 head_ref.buf);
2719 goto cleanup_head_ref;
2720 }
2721 msg = reflog_message(opts, "finish", "returning to %s",
2722 head_ref.buf);
2723 if (create_symref("HEAD", head_ref.buf, msg)) {
2724 res = error(_("could not update HEAD to %s"),
2725 head_ref.buf);
2726 goto cleanup_head_ref;
2727 }
2728 strbuf_reset(&buf);
2729 }
2730
2731 if (opts->verbose) {
2732 struct rev_info log_tree_opt;
2733 struct object_id orig, head;
2734
2735 memset(&log_tree_opt, 0, sizeof(log_tree_opt));
2736 init_revisions(&log_tree_opt, NULL);
2737 log_tree_opt.diff = 1;
2738 log_tree_opt.diffopt.output_format =
2739 DIFF_FORMAT_DIFFSTAT;
2740 log_tree_opt.disable_stdin = 1;
2741
2742 if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
2743 !get_oid(buf.buf, &orig) &&
2744 !get_oid("HEAD", &head)) {
2745 diff_tree_oid(&orig, &head, "",
2746 &log_tree_opt.diffopt);
2747 log_tree_diff_flush(&log_tree_opt);
2748 }
2749 }
2750 flush_rewritten_pending();
2751 if (!stat(rebase_path_rewritten_list(), &st) &&
2752 st.st_size > 0) {
2753 struct child_process child = CHILD_PROCESS_INIT;
2754 const char *post_rewrite_hook =
2755 find_hook("post-rewrite");
2756
2757 child.in = open(rebase_path_rewritten_list(), O_RDONLY);
2758 child.git_cmd = 1;
2759 argv_array_push(&child.args, "notes");
2760 argv_array_push(&child.args, "copy");
2761 argv_array_push(&child.args, "--for-rewrite=rebase");
2762 /* we don't care if this copying failed */
2763 run_command(&child);
2764
2765 if (post_rewrite_hook) {
2766 struct child_process hook = CHILD_PROCESS_INIT;
2767
2768 hook.in = open(rebase_path_rewritten_list(),
2769 O_RDONLY);
2770 hook.stdout_to_stderr = 1;
2771 argv_array_push(&hook.args, post_rewrite_hook);
2772 argv_array_push(&hook.args, "rebase");
2773 /* we don't care if this hook failed */
2774 run_command(&hook);
2775 }
2776 }
2777 apply_autostash(opts);
2778
2779 fprintf(stderr, "Successfully rebased and updated %s.\n",
2780 head_ref.buf);
2781
2782 strbuf_release(&buf);
2783 strbuf_release(&head_ref);
2784 }
2785
2786 /*
2787 * Sequence of picks finished successfully; cleanup by
2788 * removing the .git/sequencer directory
2789 */
2790 return sequencer_remove_state(opts);
2791}
2792
2793static int continue_single_pick(void)
2794{
2795 const char *argv[] = { "commit", NULL };
2796
2797 if (!file_exists(git_path_cherry_pick_head()) &&
2798 !file_exists(git_path_revert_head()))
2799 return error(_("no cherry-pick or revert in progress"));
2800 return run_command_v_opt(argv, RUN_GIT_CMD);
2801}
2802
2803static int commit_staged_changes(struct replay_opts *opts)
2804{
2805 unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
2806
2807 if (has_unstaged_changes(1))
2808 return error(_("cannot rebase: You have unstaged changes."));
2809 if (!has_uncommitted_changes(0)) {
2810 const char *cherry_pick_head = git_path_cherry_pick_head();
2811
2812 if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
2813 return error(_("could not remove CHERRY_PICK_HEAD"));
2814 return 0;
2815 }
2816
2817 if (file_exists(rebase_path_amend())) {
2818 struct strbuf rev = STRBUF_INIT;
2819 struct object_id head, to_amend;
2820
2821 if (get_oid("HEAD", &head))
2822 return error(_("cannot amend non-existing commit"));
2823 if (!read_oneliner(&rev, rebase_path_amend(), 0))
2824 return error(_("invalid file: '%s'"), rebase_path_amend());
2825 if (get_oid_hex(rev.buf, &to_amend))
2826 return error(_("invalid contents: '%s'"),
2827 rebase_path_amend());
2828 if (oidcmp(&head, &to_amend))
2829 return error(_("\nYou have uncommitted changes in your "
2830 "working tree. Please, commit them\n"
2831 "first and then run 'git rebase "
2832 "--continue' again."));
2833
2834 strbuf_release(&rev);
2835 flags |= AMEND_MSG;
2836 }
2837
2838 if (run_git_commit(rebase_path_message(), opts, flags))
2839 return error(_("could not commit staged changes."));
2840 unlink(rebase_path_amend());
2841 return 0;
2842}
2843
2844int sequencer_continue(struct replay_opts *opts)
2845{
2846 struct todo_list todo_list = TODO_LIST_INIT;
2847 int res;
2848
2849 if (read_and_refresh_cache(opts))
2850 return -1;
2851
2852 if (is_rebase_i(opts)) {
2853 if (commit_staged_changes(opts))
2854 return -1;
2855 } else if (!file_exists(get_todo_path(opts)))
2856 return continue_single_pick();
2857 if (read_populate_opts(opts))
2858 return -1;
2859 if ((res = read_populate_todo(&todo_list, opts)))
2860 goto release_todo_list;
2861
2862 if (!is_rebase_i(opts)) {
2863 /* Verify that the conflict has been resolved */
2864 if (file_exists(git_path_cherry_pick_head()) ||
2865 file_exists(git_path_revert_head())) {
2866 res = continue_single_pick();
2867 if (res)
2868 goto release_todo_list;
2869 }
2870 if (index_differs_from("HEAD", NULL, 0)) {
2871 res = error_dirty_index(opts);
2872 goto release_todo_list;
2873 }
2874 todo_list.current++;
2875 } else if (file_exists(rebase_path_stopped_sha())) {
2876 struct strbuf buf = STRBUF_INIT;
2877 struct object_id oid;
2878
2879 if (read_oneliner(&buf, rebase_path_stopped_sha(), 1) &&
2880 !get_oid_committish(buf.buf, &oid))
2881 record_in_rewritten(&oid, peek_command(&todo_list, 0));
2882 strbuf_release(&buf);
2883 }
2884
2885 res = pick_commits(&todo_list, opts);
2886release_todo_list:
2887 todo_list_release(&todo_list);
2888 return res;
2889}
2890
2891static int single_pick(struct commit *cmit, struct replay_opts *opts)
2892{
2893 setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
2894 return do_pick_commit(opts->action == REPLAY_PICK ?
2895 TODO_PICK : TODO_REVERT, cmit, opts, 0);
2896}
2897
2898int sequencer_pick_revisions(struct replay_opts *opts)
2899{
2900 struct todo_list todo_list = TODO_LIST_INIT;
2901 struct object_id oid;
2902 int i, res;
2903
2904 assert(opts->revs);
2905 if (read_and_refresh_cache(opts))
2906 return -1;
2907
2908 for (i = 0; i < opts->revs->pending.nr; i++) {
2909 struct object_id oid;
2910 const char *name = opts->revs->pending.objects[i].name;
2911
2912 /* This happens when using --stdin. */
2913 if (!strlen(name))
2914 continue;
2915
2916 if (!get_oid(name, &oid)) {
2917 if (!lookup_commit_reference_gently(&oid, 1)) {
2918 enum object_type type = oid_object_info(&oid,
2919 NULL);
2920 return error(_("%s: can't cherry-pick a %s"),
2921 name, type_name(type));
2922 }
2923 } else
2924 return error(_("%s: bad revision"), name);
2925 }
2926
2927 /*
2928 * If we were called as "git cherry-pick <commit>", just
2929 * cherry-pick/revert it, set CHERRY_PICK_HEAD /
2930 * REVERT_HEAD, and don't touch the sequencer state.
2931 * This means it is possible to cherry-pick in the middle
2932 * of a cherry-pick sequence.
2933 */
2934 if (opts->revs->cmdline.nr == 1 &&
2935 opts->revs->cmdline.rev->whence == REV_CMD_REV &&
2936 opts->revs->no_walk &&
2937 !opts->revs->cmdline.rev->flags) {
2938 struct commit *cmit;
2939 if (prepare_revision_walk(opts->revs))
2940 return error(_("revision walk setup failed"));
2941 cmit = get_revision(opts->revs);
2942 if (!cmit || get_revision(opts->revs))
2943 return error("BUG: expected exactly one commit from walk");
2944 return single_pick(cmit, opts);
2945 }
2946
2947 /*
2948 * Start a new cherry-pick/ revert sequence; but
2949 * first, make sure that an existing one isn't in
2950 * progress
2951 */
2952
2953 if (walk_revs_populate_todo(&todo_list, opts) ||
2954 create_seq_dir() < 0)
2955 return -1;
2956 if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
2957 return error(_("can't revert as initial commit"));
2958 if (save_head(oid_to_hex(&oid)))
2959 return -1;
2960 if (save_opts(opts))
2961 return -1;
2962 update_abort_safety_file();
2963 res = pick_commits(&todo_list, opts);
2964 todo_list_release(&todo_list);
2965 return res;
2966}
2967
2968void append_signoff(struct strbuf *msgbuf, int ignore_footer, unsigned flag)
2969{
2970 unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
2971 struct strbuf sob = STRBUF_INIT;
2972 int has_footer;
2973
2974 strbuf_addstr(&sob, sign_off_header);
2975 strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
2976 getenv("GIT_COMMITTER_EMAIL")));
2977 strbuf_addch(&sob, '\n');
2978
2979 if (!ignore_footer)
2980 strbuf_complete_line(msgbuf);
2981
2982 /*
2983 * If the whole message buffer is equal to the sob, pretend that we
2984 * found a conforming footer with a matching sob
2985 */
2986 if (msgbuf->len - ignore_footer == sob.len &&
2987 !strncmp(msgbuf->buf, sob.buf, sob.len))
2988 has_footer = 3;
2989 else
2990 has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
2991
2992 if (!has_footer) {
2993 const char *append_newlines = NULL;
2994 size_t len = msgbuf->len - ignore_footer;
2995
2996 if (!len) {
2997 /*
2998 * The buffer is completely empty. Leave foom for
2999 * the title and body to be filled in by the user.
3000 */
3001 append_newlines = "\n\n";
3002 } else if (len == 1) {
3003 /*
3004 * Buffer contains a single newline. Add another
3005 * so that we leave room for the title and body.
3006 */
3007 append_newlines = "\n";
3008 } else if (msgbuf->buf[len - 2] != '\n') {
3009 /*
3010 * Buffer ends with a single newline. Add another
3011 * so that there is an empty line between the message
3012 * body and the sob.
3013 */
3014 append_newlines = "\n";
3015 } /* else, the buffer already ends with two newlines. */
3016
3017 if (append_newlines)
3018 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
3019 append_newlines, strlen(append_newlines));
3020 }
3021
3022 if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
3023 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
3024 sob.buf, sob.len);
3025
3026 strbuf_release(&sob);
3027}
3028
3029int sequencer_make_script(FILE *out, int argc, const char **argv,
3030 unsigned flags)
3031{
3032 char *format = NULL;
3033 struct pretty_print_context pp = {0};
3034 struct strbuf buf = STRBUF_INIT;
3035 struct rev_info revs;
3036 struct commit *commit;
3037 int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
3038 const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";
3039
3040 init_revisions(&revs, NULL);
3041 revs.verbose_header = 1;
3042 revs.max_parents = 1;
3043 revs.cherry_mark = 1;
3044 revs.limited = 1;
3045 revs.reverse = 1;
3046 revs.right_only = 1;
3047 revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
3048 revs.topo_order = 1;
3049
3050 revs.pretty_given = 1;
3051 git_config_get_string("rebase.instructionFormat", &format);
3052 if (!format || !*format) {
3053 free(format);
3054 format = xstrdup("%s");
3055 }
3056 get_commit_format(format, &revs);
3057 free(format);
3058 pp.fmt = revs.commit_format;
3059 pp.output_encoding = get_log_output_encoding();
3060
3061 if (setup_revisions(argc, argv, &revs, NULL) > 1)
3062 return error(_("make_script: unhandled options"));
3063
3064 if (prepare_revision_walk(&revs) < 0)
3065 return error(_("make_script: error preparing revisions"));
3066
3067 while ((commit = get_revision(&revs))) {
3068 int is_empty = is_original_commit_empty(commit);
3069
3070 if (!is_empty && (commit->object.flags & PATCHSAME))
3071 continue;
3072 strbuf_reset(&buf);
3073 if (!keep_empty && is_empty)
3074 strbuf_addf(&buf, "%c ", comment_line_char);
3075 strbuf_addf(&buf, "%s %s ", insn,
3076 oid_to_hex(&commit->object.oid));
3077 pretty_print_commit(&pp, commit, &buf);
3078 strbuf_addch(&buf, '\n');
3079 fputs(buf.buf, out);
3080 }
3081 strbuf_release(&buf);
3082 return 0;
3083}
3084
3085/*
3086 * Add commands after pick and (series of) squash/fixup commands
3087 * in the todo list.
3088 */
3089int sequencer_add_exec_commands(const char *commands)
3090{
3091 const char *todo_file = rebase_path_todo();
3092 struct todo_list todo_list = TODO_LIST_INIT;
3093 struct todo_item *item;
3094 struct strbuf *buf = &todo_list.buf;
3095 size_t offset = 0, commands_len = strlen(commands);
3096 int i, first;
3097
3098 if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
3099 return error(_("could not read '%s'."), todo_file);
3100
3101 if (parse_insn_buffer(todo_list.buf.buf, &todo_list)) {
3102 todo_list_release(&todo_list);
3103 return error(_("unusable todo list: '%s'"), todo_file);
3104 }
3105
3106 first = 1;
3107 /* insert <commands> before every pick except the first one */
3108 for (item = todo_list.items, i = 0; i < todo_list.nr; i++, item++) {
3109 if (item->command == TODO_PICK && !first) {
3110 strbuf_insert(buf, item->offset_in_buf + offset,
3111 commands, commands_len);
3112 offset += commands_len;
3113 }
3114 first = 0;
3115 }
3116
3117 /* append final <commands> */
3118 strbuf_add(buf, commands, commands_len);
3119
3120 i = write_message(buf->buf, buf->len, todo_file, 0);
3121 todo_list_release(&todo_list);
3122 return i;
3123}
3124
3125int transform_todos(unsigned flags)
3126{
3127 const char *todo_file = rebase_path_todo();
3128 struct todo_list todo_list = TODO_LIST_INIT;
3129 struct strbuf buf = STRBUF_INIT;
3130 struct todo_item *item;
3131 int i;
3132
3133 if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
3134 return error(_("could not read '%s'."), todo_file);
3135
3136 if (parse_insn_buffer(todo_list.buf.buf, &todo_list)) {
3137 todo_list_release(&todo_list);
3138 return error(_("unusable todo list: '%s'"), todo_file);
3139 }
3140
3141 for (item = todo_list.items, i = 0; i < todo_list.nr; i++, item++) {
3142 /* if the item is not a command write it and continue */
3143 if (item->command >= TODO_COMMENT) {
3144 strbuf_addf(&buf, "%.*s\n", item->arg_len, item->arg);
3145 continue;
3146 }
3147
3148 /* add command to the buffer */
3149 if (flags & TODO_LIST_ABBREVIATE_CMDS)
3150 strbuf_addch(&buf, command_to_char(item->command));
3151 else
3152 strbuf_addstr(&buf, command_to_string(item->command));
3153
3154 /* add commit id */
3155 if (item->commit) {
3156 const char *oid = flags & TODO_LIST_SHORTEN_IDS ?
3157 short_commit_name(item->commit) :
3158 oid_to_hex(&item->commit->object.oid);
3159
3160 strbuf_addf(&buf, " %s", oid);
3161 }
3162 /* add all the rest */
3163 if (!item->arg_len)
3164 strbuf_addch(&buf, '\n');
3165 else
3166 strbuf_addf(&buf, " %.*s\n", item->arg_len, item->arg);
3167 }
3168
3169 i = write_message(buf.buf, buf.len, todo_file, 0);
3170 todo_list_release(&todo_list);
3171 return i;
3172}
3173
3174enum check_level {
3175 CHECK_IGNORE = 0, CHECK_WARN, CHECK_ERROR
3176};
3177
3178static enum check_level get_missing_commit_check_level(void)
3179{
3180 const char *value;
3181
3182 if (git_config_get_value("rebase.missingcommitscheck", &value) ||
3183 !strcasecmp("ignore", value))
3184 return CHECK_IGNORE;
3185 if (!strcasecmp("warn", value))
3186 return CHECK_WARN;
3187 if (!strcasecmp("error", value))
3188 return CHECK_ERROR;
3189 warning(_("unrecognized setting %s for option "
3190 "rebase.missingCommitsCheck. Ignoring."), value);
3191 return CHECK_IGNORE;
3192}
3193
3194/*
3195 * Check if the user dropped some commits by mistake
3196 * Behaviour determined by rebase.missingCommitsCheck.
3197 * Check if there is an unrecognized command or a
3198 * bad SHA-1 in a command.
3199 */
3200int check_todo_list(void)
3201{
3202 enum check_level check_level = get_missing_commit_check_level();
3203 struct strbuf todo_file = STRBUF_INIT;
3204 struct todo_list todo_list = TODO_LIST_INIT;
3205 struct strbuf missing = STRBUF_INIT;
3206 int advise_to_edit_todo = 0, res = 0, i;
3207
3208 strbuf_addstr(&todo_file, rebase_path_todo());
3209 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file.buf) < 0) {
3210 res = -1;
3211 goto leave_check;
3212 }
3213 advise_to_edit_todo = res =
3214 parse_insn_buffer(todo_list.buf.buf, &todo_list);
3215
3216 if (res || check_level == CHECK_IGNORE)
3217 goto leave_check;
3218
3219 /* Mark the commits in git-rebase-todo as seen */
3220 for (i = 0; i < todo_list.nr; i++) {
3221 struct commit *commit = todo_list.items[i].commit;
3222 if (commit)
3223 commit->util = (void *)1;
3224 }
3225
3226 todo_list_release(&todo_list);
3227 strbuf_addstr(&todo_file, ".backup");
3228 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file.buf) < 0) {
3229 res = -1;
3230 goto leave_check;
3231 }
3232 strbuf_release(&todo_file);
3233 res = !!parse_insn_buffer(todo_list.buf.buf, &todo_list);
3234
3235 /* Find commits in git-rebase-todo.backup yet unseen */
3236 for (i = todo_list.nr - 1; i >= 0; i--) {
3237 struct todo_item *item = todo_list.items + i;
3238 struct commit *commit = item->commit;
3239 if (commit && !commit->util) {
3240 strbuf_addf(&missing, " - %s %.*s\n",
3241 short_commit_name(commit),
3242 item->arg_len, item->arg);
3243 commit->util = (void *)1;
3244 }
3245 }
3246
3247 /* Warn about missing commits */
3248 if (!missing.len)
3249 goto leave_check;
3250
3251 if (check_level == CHECK_ERROR)
3252 advise_to_edit_todo = res = 1;
3253
3254 fprintf(stderr,
3255 _("Warning: some commits may have been dropped accidentally.\n"
3256 "Dropped commits (newer to older):\n"));
3257
3258 /* Make the list user-friendly and display */
3259 fputs(missing.buf, stderr);
3260 strbuf_release(&missing);
3261
3262 fprintf(stderr, _("To avoid this message, use \"drop\" to "
3263 "explicitly remove a commit.\n\n"
3264 "Use 'git config rebase.missingCommitsCheck' to change "
3265 "the level of warnings.\n"
3266 "The possible behaviours are: ignore, warn, error.\n\n"));
3267
3268leave_check:
3269 strbuf_release(&todo_file);
3270 todo_list_release(&todo_list);
3271
3272 if (advise_to_edit_todo)
3273 fprintf(stderr,
3274 _("You can fix this with 'git rebase --edit-todo' "
3275 "and then run 'git rebase --continue'.\n"
3276 "Or you can abort the rebase with 'git rebase"
3277 " --abort'.\n"));
3278
3279 return res;
3280}
3281
3282static int rewrite_file(const char *path, const char *buf, size_t len)
3283{
3284 int rc = 0;
3285 int fd = open(path, O_WRONLY | O_TRUNC);
3286 if (fd < 0)
3287 return error_errno(_("could not open '%s' for writing"), path);
3288 if (write_in_full(fd, buf, len) < 0)
3289 rc = error_errno(_("could not write to '%s'"), path);
3290 if (close(fd) && !rc)
3291 rc = error_errno(_("could not close '%s'"), path);
3292 return rc;
3293}
3294
3295/* skip picking commits whose parents are unchanged */
3296int skip_unnecessary_picks(void)
3297{
3298 const char *todo_file = rebase_path_todo();
3299 struct strbuf buf = STRBUF_INIT;
3300 struct todo_list todo_list = TODO_LIST_INIT;
3301 struct object_id onto_oid, *oid = &onto_oid, *parent_oid;
3302 int fd, i;
3303
3304 if (!read_oneliner(&buf, rebase_path_onto(), 0))
3305 return error(_("could not read 'onto'"));
3306 if (get_oid(buf.buf, &onto_oid)) {
3307 strbuf_release(&buf);
3308 return error(_("need a HEAD to fixup"));
3309 }
3310 strbuf_release(&buf);
3311
3312 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file) < 0)
3313 return -1;
3314 if (parse_insn_buffer(todo_list.buf.buf, &todo_list) < 0) {
3315 todo_list_release(&todo_list);
3316 return -1;
3317 }
3318
3319 for (i = 0; i < todo_list.nr; i++) {
3320 struct todo_item *item = todo_list.items + i;
3321
3322 if (item->command >= TODO_NOOP)
3323 continue;
3324 if (item->command != TODO_PICK)
3325 break;
3326 if (parse_commit(item->commit)) {
3327 todo_list_release(&todo_list);
3328 return error(_("could not parse commit '%s'"),
3329 oid_to_hex(&item->commit->object.oid));
3330 }
3331 if (!item->commit->parents)
3332 break; /* root commit */
3333 if (item->commit->parents->next)
3334 break; /* merge commit */
3335 parent_oid = &item->commit->parents->item->object.oid;
3336 if (hashcmp(parent_oid->hash, oid->hash))
3337 break;
3338 oid = &item->commit->object.oid;
3339 }
3340 if (i > 0) {
3341 int offset = get_item_line_offset(&todo_list, i);
3342 const char *done_path = rebase_path_done();
3343
3344 fd = open(done_path, O_CREAT | O_WRONLY | O_APPEND, 0666);
3345 if (fd < 0) {
3346 error_errno(_("could not open '%s' for writing"),
3347 done_path);
3348 todo_list_release(&todo_list);
3349 return -1;
3350 }
3351 if (write_in_full(fd, todo_list.buf.buf, offset) < 0) {
3352 error_errno(_("could not write to '%s'"), done_path);
3353 todo_list_release(&todo_list);
3354 close(fd);
3355 return -1;
3356 }
3357 close(fd);
3358
3359 if (rewrite_file(rebase_path_todo(), todo_list.buf.buf + offset,
3360 todo_list.buf.len - offset) < 0) {
3361 todo_list_release(&todo_list);
3362 return -1;
3363 }
3364
3365 todo_list.current = i;
3366 if (is_fixup(peek_command(&todo_list, 0)))
3367 record_in_rewritten(oid, peek_command(&todo_list, 0));
3368 }
3369
3370 todo_list_release(&todo_list);
3371 printf("%s\n", oid_to_hex(oid));
3372
3373 return 0;
3374}
3375
3376struct subject2item_entry {
3377 struct hashmap_entry entry;
3378 int i;
3379 char subject[FLEX_ARRAY];
3380};
3381
3382static int subject2item_cmp(const void *fndata,
3383 const struct subject2item_entry *a,
3384 const struct subject2item_entry *b, const void *key)
3385{
3386 return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
3387}
3388
3389/*
3390 * Rearrange the todo list that has both "pick commit-id msg" and "pick
3391 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
3392 * after the former, and change "pick" to "fixup"/"squash".
3393 *
3394 * Note that if the config has specified a custom instruction format, each log
3395 * message will have to be retrieved from the commit (as the oneline in the
3396 * script cannot be trusted) in order to normalize the autosquash arrangement.
3397 */
3398int rearrange_squash(void)
3399{
3400 const char *todo_file = rebase_path_todo();
3401 struct todo_list todo_list = TODO_LIST_INIT;
3402 struct hashmap subject2item;
3403 int res = 0, rearranged = 0, *next, *tail, i;
3404 char **subjects;
3405
3406 if (strbuf_read_file_or_whine(&todo_list.buf, todo_file) < 0)
3407 return -1;
3408 if (parse_insn_buffer(todo_list.buf.buf, &todo_list) < 0) {
3409 todo_list_release(&todo_list);
3410 return -1;
3411 }
3412
3413 /*
3414 * The hashmap maps onelines to the respective todo list index.
3415 *
3416 * If any items need to be rearranged, the next[i] value will indicate
3417 * which item was moved directly after the i'th.
3418 *
3419 * In that case, last[i] will indicate the index of the latest item to
3420 * be moved to appear after the i'th.
3421 */
3422 hashmap_init(&subject2item, (hashmap_cmp_fn) subject2item_cmp,
3423 NULL, todo_list.nr);
3424 ALLOC_ARRAY(next, todo_list.nr);
3425 ALLOC_ARRAY(tail, todo_list.nr);
3426 ALLOC_ARRAY(subjects, todo_list.nr);
3427 for (i = 0; i < todo_list.nr; i++) {
3428 struct strbuf buf = STRBUF_INIT;
3429 struct todo_item *item = todo_list.items + i;
3430 const char *commit_buffer, *subject, *p;
3431 size_t subject_len;
3432 int i2 = -1;
3433 struct subject2item_entry *entry;
3434
3435 next[i] = tail[i] = -1;
3436 if (!item->commit || item->command == TODO_DROP) {
3437 subjects[i] = NULL;
3438 continue;
3439 }
3440
3441 if (is_fixup(item->command)) {
3442 todo_list_release(&todo_list);
3443 return error(_("the script was already rearranged."));
3444 }
3445
3446 item->commit->util = item;
3447
3448 parse_commit(item->commit);
3449 commit_buffer = get_commit_buffer(item->commit, NULL);
3450 find_commit_subject(commit_buffer, &subject);
3451 format_subject(&buf, subject, " ");
3452 subject = subjects[i] = strbuf_detach(&buf, &subject_len);
3453 unuse_commit_buffer(item->commit, commit_buffer);
3454 if ((skip_prefix(subject, "fixup! ", &p) ||
3455 skip_prefix(subject, "squash! ", &p))) {
3456 struct commit *commit2;
3457
3458 for (;;) {
3459 while (isspace(*p))
3460 p++;
3461 if (!skip_prefix(p, "fixup! ", &p) &&
3462 !skip_prefix(p, "squash! ", &p))
3463 break;
3464 }
3465
3466 if ((entry = hashmap_get_from_hash(&subject2item,
3467 strhash(p), p)))
3468 /* found by title */
3469 i2 = entry->i;
3470 else if (!strchr(p, ' ') &&
3471 (commit2 =
3472 lookup_commit_reference_by_name(p)) &&
3473 commit2->util)
3474 /* found by commit name */
3475 i2 = (struct todo_item *)commit2->util
3476 - todo_list.items;
3477 else {
3478 /* copy can be a prefix of the commit subject */
3479 for (i2 = 0; i2 < i; i2++)
3480 if (subjects[i2] &&
3481 starts_with(subjects[i2], p))
3482 break;
3483 if (i2 == i)
3484 i2 = -1;
3485 }
3486 }
3487 if (i2 >= 0) {
3488 rearranged = 1;
3489 todo_list.items[i].command =
3490 starts_with(subject, "fixup!") ?
3491 TODO_FIXUP : TODO_SQUASH;
3492 if (next[i2] < 0)
3493 next[i2] = i;
3494 else
3495 next[tail[i2]] = i;
3496 tail[i2] = i;
3497 } else if (!hashmap_get_from_hash(&subject2item,
3498 strhash(subject), subject)) {
3499 FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
3500 entry->i = i;
3501 hashmap_entry_init(entry, strhash(entry->subject));
3502 hashmap_put(&subject2item, entry);
3503 }
3504 }
3505
3506 if (rearranged) {
3507 struct strbuf buf = STRBUF_INIT;
3508
3509 for (i = 0; i < todo_list.nr; i++) {
3510 enum todo_command command = todo_list.items[i].command;
3511 int cur = i;
3512
3513 /*
3514 * Initially, all commands are 'pick's. If it is a
3515 * fixup or a squash now, we have rearranged it.
3516 */
3517 if (is_fixup(command))
3518 continue;
3519
3520 while (cur >= 0) {
3521 const char *bol =
3522 get_item_line(&todo_list, cur);
3523 const char *eol =
3524 get_item_line(&todo_list, cur + 1);
3525
3526 /* replace 'pick', by 'fixup' or 'squash' */
3527 command = todo_list.items[cur].command;
3528 if (is_fixup(command)) {
3529 strbuf_addstr(&buf,
3530 todo_command_info[command].str);
3531 bol += strcspn(bol, " \t");
3532 }
3533
3534 strbuf_add(&buf, bol, eol - bol);
3535
3536 cur = next[cur];
3537 }
3538 }
3539
3540 res = rewrite_file(todo_file, buf.buf, buf.len);
3541 strbuf_release(&buf);
3542 }
3543
3544 free(next);
3545 free(tail);
3546 for (i = 0; i < todo_list.nr; i++)
3547 free(subjects[i]);
3548 free(subjects);
3549 hashmap_free(&subject2item, 1);
3550 todo_list_release(&todo_list);
3551
3552 return res;
3553}