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