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