1# This shell script fragment is sourced by git-rebase to implement 2# its interactive mode. "git rebase --interactive" makes it easy 3# to fix up commits in the middle of a series and rearrange commits. 4# 5# Copyright (c) 2006 Johannes E. Schindelin 6# 7# The original idea comes from Eric W. Biederman, in 8# https://public-inbox.org/git/m1odwkyuf5.fsf_-_@ebiederm.dsl.xmission.com/ 9# 10# The file containing rebase commands, comments, and empty lines. 11# This file is created by "git rebase -i" then edited by the user. As 12# the lines are processed, they are removed from the front of this 13# file and written to the tail of $done. 14todo="$state_dir"/git-rebase-todo 15 16# The rebase command lines that have already been processed. A line 17# is moved here when it is first handled, before any associated user 18# actions. 19done="$state_dir"/done 20 21# The commit message that is planned to be used for any changes that 22# need to be committed following a user interaction. 23msg="$state_dir"/message 24 25# The file into which is accumulated the suggested commit message for 26# squash/fixup commands. When the first of a series of squash/fixups 27# is seen, the file is created and the commit message from the 28# previous commit and from the first squash/fixup commit are written 29# to it. The commit message for each subsequent squash/fixup commit 30# is appended to the file as it is processed. 31# 32# The first line of the file is of the form 33# # This is a combination of $count commits. 34# where $count is the number of commits whose messages have been 35# written to the file so far (including the initial "pick" commit). 36# Each time that a commit message is processed, this line is read and 37# updated. It is deleted just before the combined commit is made. 38squash_msg="$state_dir"/message-squash 39 40# If the current series of squash/fixups has not yet included a squash 41# command, then this file exists and holds the commit message of the 42# original "pick" commit. (If the series ends without a "squash" 43# command, then this can be used as the commit message of the combined 44# commit without opening the editor.) 45fixup_msg="$state_dir"/message-fixup 46 47# $rewritten is the name of a directory containing files for each 48# commit that is reachable by at least one merge base of $head and 49# $upstream. They are not necessarily rewritten, but their children 50# might be. This ensures that commits on merged, but otherwise 51# unrelated side branches are left alone. (Think "X" in the man page's 52# example.) 53rewritten="$state_dir"/rewritten 54 55dropped="$state_dir"/dropped 56 57end="$state_dir"/end 58msgnum="$state_dir"/msgnum 59 60# A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and 61# GIT_AUTHOR_DATE that will be used for the commit that is currently 62# being rebased. 63author_script="$state_dir"/author-script 64 65# When an "edit" rebase command is being processed, the SHA1 of the 66# commit to be edited is recorded in this file. When "git rebase 67# --continue" is executed, if there are any staged changes then they 68# will be amended to the HEAD commit, but only provided the HEAD 69# commit is still the commit to be edited. When any other rebase 70# command is processed, this file is deleted. 71amend="$state_dir"/amend 72 73# For the post-rewrite hook, we make a list of rewritten commits and 74# their new sha1s. The rewritten-pending list keeps the sha1s of 75# commits that have been processed, but not committed yet, 76# e.g. because they are waiting for a 'squash' command. 77rewritten_list="$state_dir"/rewritten-list 78rewritten_pending="$state_dir"/rewritten-pending 79 80# Work around Git for Windows' Bash whose "read" does not strip CRLF 81# and leaves CR at the end instead. 82cr=$(printf "\015") 83 84strategy_args=${strategy:+--strategy=$strategy} 85test -n"$strategy_opts"&& 86eval' 87 for strategy_opt in '"$strategy_opts"' 88 do 89 strategy_args="$strategy_args-X$(git rev-parse --sq-quote "${strategy_opt#--}")" 90 done 91' 92 93GIT_CHERRY_PICK_HELP="$resolvemsg" 94export GIT_CHERRY_PICK_HELP 95 96comment_char=$(git config --get core.commentchar 2>/dev/null) 97case"$comment_char"in 98''| auto) 99 comment_char="#" 100;; 101?) 102;; 103*) 104 comment_char=$(echo "$comment_char" | cut -c1) 105;; 106esac 107 108warn () { 109printf'%s\n'"$*">&2 110} 111 112# Output the commit message for the specified commit. 113commit_message () { 114 git cat-file commit "$1"|sed"1,/^$/d" 115} 116 117orig_reflog_action="$GIT_REFLOG_ACTION" 118 119comment_for_reflog () { 120case"$orig_reflog_action"in 121''|rebase*) 122 GIT_REFLOG_ACTION="rebase -i ($1)" 123export GIT_REFLOG_ACTION 124;; 125esac 126} 127 128last_count= 129mark_action_done () { 130sed-e1q <"$todo">>"$done" 131sed-e1d <"$todo">>"$todo".new 132mv-f"$todo".new "$todo" 133 new_count=$(( $(git stripspace --strip-comments <"$done" | wc -l))) 134echo$new_count>"$msgnum" 135 total=$(($new_count + $(git stripspace --strip-comments <"$todo" | wc -l))) 136echo$total>"$end" 137iftest"$last_count"!="$new_count" 138then 139 last_count=$new_count 140 eval_gettext "Rebasing (\$new_count/\$total)";printf"\r" 141test -z"$verbose"||echo 142fi 143} 144 145# Put the last action marked done at the beginning of the todo list 146# again. If there has not been an action marked done yet, leave the list of 147# items on the todo list unchanged. 148reschedule_last_action () { 149tail-n1"$done"|cat-"$todo">"$todo".new 150sed-e \$d<"$done">"$done".new 151mv-f"$todo".new "$todo" 152mv-f"$done".new "$done" 153} 154 155append_todo_help () { 156gettext" 157Commands: 158p, pick = use commit 159r, reword = use commit, but edit the commit message 160e, edit = use commit, but stop for amending 161s, squash = use commit, but meld into previous commit 162f, fixup = like\"squash\", but discard this commit's log message 163x, exec = run command (the rest of the line) using shell 164d, drop = remove commit 165 166These lines can be re-ordered; they are executed from top to bottom. 167"| git stripspace --comment-lines>>"$todo" 168 169iftest$(get_missing_commit_check_level)= error 170then 171gettext" 172Do not remove any line. Use 'drop' explicitly to remove a commit. 173"| git stripspace --comment-lines>>"$todo" 174else 175gettext" 176If you remove a line here THAT COMMIT WILL BE LOST. 177"| git stripspace --comment-lines>>"$todo" 178fi 179} 180 181make_patch () { 182 sha1_and_parents="$(git rev-list --parents -1 "$1")" 183case"$sha1_and_parents"in 184 ?*' '?*' '?*) 185 git diff--cc$sha1_and_parents 186;; 187 ?*' '?*) 188 git diff-tree -p"$1^!" 189;; 190*) 191echo"Root commit" 192;; 193esac>"$state_dir"/patch 194test -f"$msg"|| 195 commit_message "$1">"$msg" 196test -f"$author_script"|| 197 get_author_ident_from_commit "$1">"$author_script" 198} 199 200die_with_patch () { 201echo"$1">"$state_dir"/stopped-sha 202 make_patch "$1" 203 die "$2" 204} 205 206exit_with_patch () { 207echo"$1">"$state_dir"/stopped-sha 208 make_patch $1 209 git rev-parse --verify HEAD >"$amend" 210 gpg_sign_opt_quoted=${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")} 211 warn "$(eval_gettext "\ 212You can amend the commit now, with 213 214 git commit --amend \$gpg_sign_opt_quoted 215 216Once you are satisfied with your changes, run 217 218 git rebase --continue")" 219 warn 220exit$2 221} 222 223die_abort () { 224 apply_autostash 225rm-rf"$state_dir" 226 die "$1" 227} 228 229has_action () { 230test -n"$(git stripspace --strip-comments <"$1")" 231} 232 233is_empty_commit() { 234 tree=$(git rev-parse -q --verify "$1"^{tree} 2>/dev/null)|| { 235 sha1=$1 236 die "$(eval_gettext "\$sha1: not a commit that can be picked")" 237} 238 ptree=$(git rev-parse -q --verify "$1"^^{tree} 2>/dev/null)|| 239 ptree=4b825dc642cb6eb9a060e54bf8d69288fbee4904 240test"$tree"="$ptree" 241} 242 243is_merge_commit() 244{ 245 git rev-parse --verify --quiet"$1"^2>/dev/null 2>&1 246} 247 248# Run command with GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and 249# GIT_AUTHOR_DATE exported from the current environment. 250do_with_author () { 251( 252export GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL GIT_AUTHOR_DATE 253"$@" 254) 255} 256 257git_sequence_editor () { 258iftest -z"$GIT_SEQUENCE_EDITOR" 259then 260 GIT_SEQUENCE_EDITOR="$(git config sequence.editor)" 261if[-z"$GIT_SEQUENCE_EDITOR"] 262then 263 GIT_SEQUENCE_EDITOR="$(git var GIT_EDITOR)"||return $? 264fi 265fi 266 267eval"$GIT_SEQUENCE_EDITOR"'"$@"' 268} 269 270pick_one () { 271 ff=--ff 272 273case"$1"in-n) sha1=$2; ff= ;; *) sha1=$1;;esac 274case"$force_rebase"in'') ;; ?*) ff= ;;esac 275 output git rev-parse --verify$sha1|| die "$(eval_gettext "Invalid commit name: \$sha1")" 276 277if is_empty_commit "$sha1" 278then 279 empty_args="--allow-empty" 280fi 281 282test -d"$rewritten"&& 283 pick_one_preserving_merges "$@"&&return 284 output eval git cherry-pick \ 285${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")} \ 286"$strategy_args"$empty_args $ff"$@" 287 288# If cherry-pick dies it leaves the to-be-picked commit unrecorded. Reschedule 289# previous task so this commit is not lost. 290 ret=$? 291case"$ret"in[01]) ;; *) reschedule_last_action ;;esac 292return$ret 293} 294 295pick_one_preserving_merges () { 296 fast_forward=t 297case"$1"in 298-n) 299 fast_forward=f 300 sha1=$2 301;; 302*) 303 sha1=$1 304;; 305esac 306 sha1=$(git rev-parse $sha1) 307 308iftest -f"$state_dir"/current-commit 309then 310iftest"$fast_forward"= t 311then 312whileread current_commit 313do 314 git rev-parse HEAD >"$rewritten"/$current_commit 315done<"$state_dir"/current-commit 316rm"$state_dir"/current-commit|| 317 die "$(gettext "Cannot write current commit's replacement sha1")" 318fi 319fi 320 321echo$sha1>>"$state_dir"/current-commit 322 323# rewrite parents; if none were rewritten, we can fast-forward. 324 new_parents= 325 pend="$(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-)" 326iftest"$pend"=" " 327then 328 pend=" root" 329fi 330while["$pend"!=""] 331do 332 p=$(expr "$pend" : ' \([^ ]*\)') 333 pend="${pend# $p}" 334 335 if test -f "$rewritten"/$p 336 then 337 new_p=$(cat "$rewritten"/$p) 338 339 # If the todo reordered commits, and our parent is marked for 340 # rewriting, but hasn't been gotten to yet, assume the user meant to 341# drop it on top of the current HEAD 342iftest -z"$new_p" 343then 344 new_p=$(git rev-parse HEAD) 345fi 346 347test$p!=$new_p&& fast_forward=f 348case"$new_parents"in 349*$new_p*) 350;;# do nothing; that parent is already there 351*) 352 new_parents="$new_parents$new_p" 353;; 354esac 355else 356iftest -f"$dropped"/$p 357then 358 fast_forward=f 359 replacement="$(cat "$dropped"/$p)" 360test -z"$replacement"&& replacement=root 361 pend="$replacement$pend" 362else 363 new_parents="$new_parents$p" 364fi 365fi 366done 367case$fast_forwardin 368 t) 369 output warn "$(eval_gettext "Fast-forward to \$sha1")" 370 output git reset--hard$sha1|| 371 die "$(eval_gettext "Cannot fast-forward to \$sha1")" 372;; 373 f) 374 first_parent=$(expr "$new_parents" : ' \([^ ]*\)') 375 376 if [ "$1" != "-n" ] 377 then 378 # detach HEAD to current parent 379 output git checkout$first_parent2> /dev/null || 380 die "$(eval_gettext "Cannot move HEAD to \$first_parent")" 381 fi 382 383 case "$new_parents" in 384 ''*''*) 385 test "a$1" = a-n && die "$(eval_gettext "Refusing to squash a merge: \$sha1")" 386 387 # redo merge 388 author_script_content=$(get_author_ident_from_commit $sha1) 389 eval "$author_script_content" 390 msg_content="$(commit_message $sha1)" 391 # No point in merging the first parent, that's HEAD 392 new_parents=${new_parents# $first_parent} 393 merge_args="--no-log --no-ff" 394if! do_with_author output eval \ 395'git merge${gpg_sign_opt:+"$gpg_sign_opt"}\ 396$merge_args$strategy_args-m "$msg_content"$new_parents' 397then 398printf"%s\n""$msg_content">"$GIT_DIR"/MERGE_MSG 399 die_with_patch $sha1"$(eval_gettext "Error redoing merge \$sha1")" 400fi 401echo"$sha1$(git rev-parse HEAD^0)">>"$rewritten_list" 402;; 403*) 404 output eval git cherry-pick \ 405${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")} \ 406"$strategy_args""$@"|| 407 die_with_patch $sha1"$(eval_gettext "Could not pick \$sha1")" 408;; 409esac 410;; 411esac 412} 413 414this_nth_commit_message () { 415 n=$1 416 eval_gettext "This is the commit message #\${n}:" 417} 418 419skip_nth_commit_message () { 420 n=$1 421 eval_gettext "The commit message #\${n}will be skipped:" 422} 423 424update_squash_messages () { 425iftest -f"$squash_msg";then 426mv"$squash_msg""$squash_msg".bak ||exit 427 count=$(($(sed-n \ 428-e"1s/^$comment_char[^0-9]*\([0-9][0-9]*\).*/\1/p" \ 429-e"q"<"$squash_msg".bak)+1)) 430{ 431printf'%s\n'"$comment_char$(eval_ngettext \ 432 "This is a combination of \$count commit." \ 433 "This is a combination of \$count commits." \ 434$count)" 435sed-e1d -e'2,/^./{ 436 /^$/d 437 }'<"$squash_msg".bak 438} >"$squash_msg" 439else 440 commit_message HEAD >"$fixup_msg"|| 441 die "$(eval_gettext "Cannot write \$fixup_msg")" 442 count=2 443{ 444printf'%s\n'"$comment_char$(gettext "This is a combination of 2 commits.")" 445printf'%s\n'"$comment_char$(gettext "This is the 1st commit message:")" 446echo 447cat"$fixup_msg" 448} >"$squash_msg" 449fi 450case$1in 451 squash) 452rm-f"$fixup_msg" 453echo 454printf'%s\n'"$comment_char$(this_nth_commit_message $count)" 455echo 456 commit_message $2 457;; 458 fixup) 459echo 460printf'%s\n'"$comment_char$(skip_nth_commit_message $count)" 461echo 462# Change the space after the comment character to TAB: 463 commit_message $2| git stripspace --comment-lines|sed-e's/ / /' 464;; 465esac>>"$squash_msg" 466} 467 468peek_next_command () { 469 git stripspace --strip-comments<"$todo"|sed-n -e's/ .*//p'-e q 470} 471 472# A squash/fixup has failed. Prepare the long version of the squash 473# commit message, then die_with_patch. This code path requires the 474# user to edit the combined commit message for all commits that have 475# been squashed/fixedup so far. So also erase the old squash 476# messages, effectively causing the combined commit to be used as the 477# new basis for any further squash/fixups. Args: sha1 rest 478die_failed_squash() { 479 sha1=$1 480 rest=$2 481mv"$squash_msg""$msg"||exit 482rm-f"$fixup_msg" 483cp"$msg""$GIT_DIR"/MERGE_MSG ||exit 484 warn 485 warn "$(eval_gettext "Could not apply \$sha1... \$rest")" 486 die_with_patch $sha1"" 487} 488 489flush_rewritten_pending() { 490test -s"$rewritten_pending"||return 491 newsha1="$(git rev-parse HEAD^0)" 492sed"s/$/$newsha1/"<"$rewritten_pending">>"$rewritten_list" 493rm-f"$rewritten_pending" 494} 495 496record_in_rewritten() { 497 oldsha1="$(git rev-parse $1)" 498echo"$oldsha1">>"$rewritten_pending" 499 500case"$(peek_next_command)"in 501 squash|s|fixup|f) 502;; 503*) 504 flush_rewritten_pending 505;; 506esac 507} 508 509do_pick () { 510 sha1=$1 511 rest=$2 512iftest"$(git rev-parse HEAD)"="$squash_onto" 513then 514# Set the correct commit message and author info on the 515# sentinel root before cherry-picking the original changes 516# without committing (-n). Finally, update the sentinel again 517# to include these changes. If the cherry-pick results in a 518# conflict, this means our behaviour is similar to a standard 519# failed cherry-pick during rebase, with a dirty index to 520# resolve before manually running git commit --amend then git 521# rebase --continue. 522 git commit --allow-empty --allow-empty-message --amend \ 523--no-post-rewrite -n -q -C$sha1&& 524 pick_one -n$sha1&& 525 git commit --allow-empty --allow-empty-message \ 526--amend --no-post-rewrite -n -q -C$sha1 \ 527${gpg_sign_opt:+"$gpg_sign_opt"}|| 528 die_with_patch $sha1"$(eval_gettext "Could not apply \$sha1... \$rest")" 529else 530 pick_one $sha1|| 531 die_with_patch $sha1"$(eval_gettext "Could not apply \$sha1... \$rest")" 532fi 533} 534 535do_next () { 536rm-f"$msg""$author_script""$amend""$state_dir"/stopped-sha||exit 537read -r command sha1 rest <"$todo" 538case"$command"in 539"$comment_char"*|''|noop|drop|d) 540 mark_action_done 541;; 542"$cr") 543# Work around CR left by "read" (e.g. with Git for Windows' Bash). 544 mark_action_done 545;; 546 pick|p) 547 comment_for_reflog pick 548 549 mark_action_done 550 do_pick $sha1"$rest" 551 record_in_rewritten $sha1 552;; 553 reword|r) 554 comment_for_reflog reword 555 556 mark_action_done 557 do_pick $sha1"$rest" 558 git commit --amend --no-post-rewrite${gpg_sign_opt:+"$gpg_sign_opt"}|| { 559 warn "$(eval_gettext "\ 560Could not amend commit after successfully picking \$sha1... \$rest 561This is most likely due to an empty commit message, or the pre-commit hook 562failed. If the pre-commit hook failed, you may need to resolve the issue before 563you are able to reword the commit.")" 564 exit_with_patch $sha11 565} 566 record_in_rewritten $sha1 567;; 568 edit|e) 569 comment_for_reflog edit 570 571 mark_action_done 572 do_pick $sha1"$rest" 573 sha1_abbrev=$(git rev-parse --short $sha1) 574 warn "$(eval_gettext "Stopped at \$sha1_abbrev... \$rest")" 575 exit_with_patch $sha10 576;; 577 squash|s|fixup|f) 578case"$command"in 579 squash|s) 580 squash_style=squash 581;; 582 fixup|f) 583 squash_style=fixup 584;; 585esac 586 comment_for_reflog $squash_style 587 588test -f"$done"&& has_action "$done"|| 589 die "$(eval_gettext "Cannot '\$squash_style' without a previous commit")" 590 591 mark_action_done 592 update_squash_messages $squash_style $sha1 593 author_script_content=$(get_author_ident_from_commit HEAD) 594echo"$author_script_content">"$author_script" 595eval"$author_script_content" 596if! pick_one -n$sha1 597then 598 git rev-parse --verify HEAD >"$amend" 599 die_failed_squash $sha1"$rest" 600fi 601case"$(peek_next_command)"in 602 squash|s|fixup|f) 603# This is an intermediate commit; its message will only be 604# used in case of trouble. So use the long version: 605 do_with_author output git commit --amend --no-verify -F"$squash_msg" \ 606${gpg_sign_opt:+"$gpg_sign_opt"}|| 607 die_failed_squash $sha1"$rest" 608;; 609*) 610# This is the final command of this squash/fixup group 611iftest -f"$fixup_msg" 612then 613 do_with_author git commit --amend --no-verify -F"$fixup_msg" \ 614${gpg_sign_opt:+"$gpg_sign_opt"}|| 615 die_failed_squash $sha1"$rest" 616else 617cp"$squash_msg""$GIT_DIR"/SQUASH_MSG ||exit 618rm-f"$GIT_DIR"/MERGE_MSG 619 do_with_author git commit --amend --no-verify -F"$GIT_DIR"/SQUASH_MSG -e \ 620${gpg_sign_opt:+"$gpg_sign_opt"}|| 621 die_failed_squash $sha1"$rest" 622fi 623rm-f"$squash_msg""$fixup_msg" 624;; 625esac 626 record_in_rewritten $sha1 627;; 628 x|"exec") 629read -r command rest <"$todo" 630 mark_action_done 631 eval_gettextln "Executing: \$rest" 632"${SHELL:-@SHELL_PATH@}"-c"$rest"# Actual execution 633 status=$? 634# Run in subshell because require_clean_work_tree can die. 635 dirty=f 636(require_clean_work_tree "rebase"2>/dev/null) || dirty=t 637iftest"$status"-ne0 638then 639 warn "$(eval_gettext "Execution failed: \$rest")" 640test"$dirty"= f || 641 warn "$(gettext "and made changes to the index and/or the working tree")" 642 643 warn "$(gettext "\ 644You can fix the problem, and then run 645 646 git rebase --continue")" 647 warn 648iftest$status-eq127# command not found 649then 650 status=1 651fi 652exit"$status" 653eliftest"$dirty"= t 654then 655# TRANSLATORS: after these lines is a command to be issued by the user 656 warn "$(eval_gettext "\ 657Execution succeeded: \$rest 658but left changes to the index and/or the working tree 659Commit or stash your changes, and then run 660 661 git rebase --continue")" 662 warn 663exit1 664fi 665;; 666*) 667 warn "$(eval_gettext "Unknown command: \$command \$sha1 \$rest")" 668 fixtodo="$(gettext "Please fix this using 'git rebase --edit-todo'.")" 669if git rev-parse --verify -q"$sha1">/dev/null 670then 671 die_with_patch $sha1"$fixtodo" 672else 673 die "$fixtodo" 674fi 675;; 676esac 677test -s"$todo"&&return 678 679 comment_for_reflog finish && 680 newhead=$(git rev-parse HEAD)&& 681case$head_namein 682 refs/*) 683 message="$GIT_REFLOG_ACTION:$head_nameonto$onto"&& 684 git update-ref -m"$message"$head_name $newhead $orig_head&& 685 git symbolic-ref \ 686-m"$GIT_REFLOG_ACTION: returning to$head_name" \ 687 HEAD $head_name 688;; 689esac&& { 690test!-f"$state_dir"/verbose || 691 git diff-tree --stat$orig_head..HEAD 692} && 693{ 694test -s"$rewritten_list"&& 695 git notes copy --for-rewrite=rebase <"$rewritten_list"|| 696 true # we don't care if this copying failed 697} && 698 hook="$(git rev-parse --git-path hooks/post-rewrite)" 699iftest -x"$hook"&&test -s"$rewritten_list";then 700"$hook" rebase <"$rewritten_list" 701 true # we don't care if this hook failed 702fi&& 703 warn "$(eval_gettext "Successfully rebased and updated \$head_name.")" 704 705return1# not failure; just to break the do_rest loop 706} 707 708# can only return 0, when the infinite loop breaks 709do_rest () { 710while: 711do 712 do_next ||break 713done 714} 715 716# skip picking commits whose parents are unchanged 717skip_unnecessary_picks () { 718 fd=3 719whileread -r command rest 720do 721# fd=3 means we skip the command 722case"$fd,$command"in 7233,pick|3,p) 724# pick a commit whose parent is current $onto -> skip 725 sha1=${rest%% *} 726case"$(git rev-parse --verify --quiet "$sha1"^)"in 727"$onto"*) 728 onto=$sha1 729;; 730*) 731 fd=1 732;; 733esac 734;; 7353,"$comment_char"*|3,) 736# copy comments 737;; 738*) 739 fd=1 740;; 741esac 742printf'%s\n'"$command${rest:+ }$rest">&$fd 743done<"$todo">"$todo.new"3>>"$done"&& 744mv-f"$todo".new "$todo"&& 745case"$(peek_next_command)"in 746 squash|s|fixup|f) 747 record_in_rewritten "$onto" 748;; 749esac|| 750 die "$(gettext "Could not skip unnecessary pick commands")" 751} 752 753transform_todo_ids () { 754whileread -r command rest 755do 756case"$command"in 757"$comment_char"* |exec) 758# Be careful for oddball commands like 'exec' 759# that do not have a SHA-1 at the beginning of $rest. 760;; 761*) 762 sha1=$(git rev-parse --verify --quiet "$@" ${rest%%[ ]*})&& 763 rest="$sha1${rest#*[ ]}" 764;; 765esac 766printf'%s\n'"$command${rest:+ }$rest" 767done<"$todo">"$todo.new"&& 768mv-f"$todo.new""$todo" 769} 770 771expand_todo_ids() { 772 transform_todo_ids 773} 774 775collapse_todo_ids() { 776 transform_todo_ids --short 777} 778 779# Rearrange the todo list that has both "pick sha1 msg" and 780# "pick sha1 fixup!/squash! msg" appears in it so that the latter 781# comes immediately after the former, and change "pick" to 782# "fixup"/"squash". 783# 784# Note that if the config has specified a custom instruction format 785# each log message will be re-retrieved in order to normalize the 786# autosquash arrangement 787rearrange_squash () { 788 format=$(git config --get rebase.instructionFormat) 789# extract fixup!/squash! lines and resolve any referenced sha1's 790whileread -r pick sha1 message 791do 792test -z"${format}"|| message=$(git log -n 1 --format="%s" ${sha1}) 793case"$message"in 794"squash! "*|"fixup! "*) 795 action="${message%%!*}" 796 rest=$message 797 prefix= 798# skip all squash! or fixup! (but save for later) 799while: 800do 801case"$rest"in 802"squash! "*|"fixup! "*) 803 prefix="$prefix${rest%%!*}," 804 rest="${rest#*! }" 805;; 806*) 807break 808;; 809esac 810done 811printf'%s %s %s %s\n'"$sha1""$action""$prefix""$rest" 812# if it's a single word, try to resolve to a full sha1 and 813# emit a second copy. This allows us to match on both message 814# and on sha1 prefix 815iftest"${rest#* }"="$rest";then 816 fullsha="$(git rev-parse -q --verify "$rest" 2>/dev/null)" 817iftest -n"$fullsha";then 818# prefix the action to uniquely identify this line as 819# intended for full sha1 match 820echo"$sha1+$action$prefix$fullsha" 821fi 822fi 823esac 824done>"$1.sq"<"$1" 825test -s"$1.sq"||return 826 827 used= 828whileread -r pick sha1 message 829do 830case"$used"in 831*"$sha1"*)continue;; 832esac 833printf'%s\n'"$pick$sha1$message" 834test -z"${format}"|| message=$(git log -n 1 --format="%s" ${sha1}) 835 used="$used$sha1" 836whileread -r squash action msg_prefix msg_content 837do 838case"$used"in 839*"$squash"*)continue;; 840esac 841 emit=0 842case"$action"in 843+*) 844 action="${action#+}" 845# full sha1 prefix test 846case"$msg_content"in"$sha1"*) emit=1;;esac;; 847*) 848# message prefix test 849case"$message"in"$msg_content"*) emit=1;;esac;; 850esac 851iftest$emit=1;then 852iftest -n"${format}" 853then 854 msg_content=$(git log -n 1 --format="${format}" ${squash}) 855else 856 msg_content="$(echo "$msg_prefix" | sed "s/,/! /g")$msg_content" 857fi 858printf'%s\n'"$action$squash$msg_content" 859 used="$used$squash" 860fi 861done<"$1.sq" 862done>"$1.rearranged"<"$1" 863cat"$1.rearranged">"$1" 864rm-f"$1.sq""$1.rearranged" 865} 866 867# Add commands after a pick or after a squash/fixup serie 868# in the todo list. 869add_exec_commands () { 870{ 871 first=t 872whileread -r insn rest 873do 874case$insnin 875 pick) 876test -n"$first"|| 877printf"%s""$cmd" 878;; 879esac 880printf"%s %s\n""$insn""$rest" 881 first= 882done 883printf"%s""$cmd" 884} <"$1">"$1.new"&& 885mv"$1.new""$1" 886} 887 888# Check if the SHA-1 passed as an argument is a 889# correct one, if not then print $2 in "$todo".badsha 890# $1: the SHA-1 to test 891# $2: the line number of the input 892# $3: the input filename 893check_commit_sha () { 894 badsha=0 895iftest -z"$1" 896then 897 badsha=1 898else 899 sha1_verif="$(git rev-parse --verify --quiet $1^{commit})" 900iftest -z"$sha1_verif" 901then 902 badsha=1 903fi 904fi 905 906iftest$badsha-ne0 907then 908 line="$(sed -n -e "${2}p" "$3")" 909 warn "$(eval_gettext "\ 910Warning: the SHA-1 is missing or isn't a commit in the following line: 911 - \$line")" 912 warn 913 fi 914 915 return$badsha 916} 917 918# prints the bad commits and bad commands 919# from the todolist in stdin 920check_bad_cmd_and_sha () { 921 retval=0 922 lineno=0 923 while read -r command rest 924 do 925 lineno=$(( $lineno + 1 )) 926 case$commandin 927 "$comment_char"*|''|noop|x|exec) 928 # Doesn't expect a SHA-1 929;; 930"$cr") 931# Work around CR left by "read" (e.g. with Git for 932# Windows' Bash). 933;; 934 pick|p|drop|d|reword|r|edit|e|squash|s|fixup|f) 935if! check_commit_sha "${rest%%[ ]*}""$lineno""$1" 936then 937 retval=1 938fi 939;; 940*) 941 line="$(sed -n -e "${lineno}p" "$1")" 942 warn "$(eval_gettext "\ 943Warning: the command isn't recognized in the following line: 944 - \$line")" 945 warn 946 retval=1 947 ;; 948 esac 949 done <"$1" 950 return$retval 951} 952 953# Print the list of the SHA-1 of the commits 954# from stdin to stdout 955todo_list_to_sha_list () { 956 git stripspace --strip-comments | 957 while read -r command sha1 rest 958 do 959 case$commandin 960 "$comment_char"*|''|noop|x|"exec") 961 ;; 962 *) 963 long_sha=$(git rev-list --no-walk "$sha1" 2>/dev/null) 964 printf "%s\n" "$long_sha" 965 ;; 966 esac 967 done 968} 969 970# Use warn for each line in stdin 971warn_lines () { 972 while read -r line 973 do 974 warn " -$line" 975 done 976} 977 978# Switch to the branch in$intoand notify it in the reflog 979checkout_onto () { 980 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout$onto_name" 981 output git checkout$onto|| die_abort "$(gettext "could not detach HEAD")" 982 git update-ref ORIG_HEAD$orig_head 983} 984 985get_missing_commit_check_level () { 986 check_level=$(git config --get rebase.missingCommitsCheck) 987 check_level=${check_level:-ignore} 988 # Don't be case sensitive 989printf'%s'"$check_level"|tr'A-Z''a-z' 990} 991 992# Check if the user dropped some commits by mistake 993# Behaviour determined by rebase.missingCommitsCheck. 994# Check if there is an unrecognized command or a 995# bad SHA-1 in a command. 996check_todo_list () { 997 raise_error=f 998 999 check_level=$(get_missing_commit_check_level)10001001case"$check_level"in1002 warn|error)1003# Get the SHA-1 of the commits1004 todo_list_to_sha_list <"$todo".backup >"$todo".oldsha11005 todo_list_to_sha_list <"$todo">"$todo".newsha110061007# Sort the SHA-1 and compare them1008sort-u"$todo".oldsha1 >"$todo".oldsha1+1009mv"$todo".oldsha1+"$todo".oldsha11010sort-u"$todo".newsha1 >"$todo".newsha1+1011mv"$todo".newsha1+"$todo".newsha11012comm-2 -3"$todo".oldsha1 "$todo".newsha1 >"$todo".miss10131014# Warn about missing commits1015iftest -s"$todo".miss1016then1017test"$check_level"= error && raise_error=t10181019 warn "$(gettext "\1020Warning: some commits may have been dropped accidentally.1021Dropped commits (newer to older):")"10221023# Make the list user-friendly and display1024 opt="--no-walk=sorted --format=oneline --abbrev-commit --stdin"1025 git rev-list$opt<"$todo".miss | warn_lines10261027 warn "$(gettext "\1028To avoid this message, use \"drop\" to explicitly remove a commit.10291030Use 'git config rebase.missingCommitsCheck' to change the level of warnings.1031The possible behaviours are: ignore, warn, error.")"1032 warn1033fi1034;;1035 ignore)1036;;1037*)1038 warn "$(eval_gettext "Unrecognized setting \$check_level for option rebase.missingCommitsCheck. Ignoring.")"1039;;1040esac10411042if! check_bad_cmd_and_sha "$todo"1043then1044 raise_error=t1045fi10461047iftest$raise_error= t1048then1049# Checkout before the first commit of the1050# rebase: this way git rebase --continue1051# will work correctly as it expects HEAD to be1052# placed before the commit of the next action1053 checkout_onto10541055 warn "$(gettext "You can fix this with 'git rebase --edit-todo' and then run 'git rebase --continue'.")"1056 die "$(gettext "Or you can abort the rebase with 'git rebase --abort'.")"1057fi1058}10591060# The whole contents of this file is run by dot-sourcing it from1061# inside a shell function. It used to be that "return"s we see1062# below were not inside any function, and expected to return1063# to the function that dot-sourced us.1064#1065# However, older (9.x) versions of FreeBSD /bin/sh misbehave on such a1066# construct and continue to run the statements that follow such a "return".1067# As a work-around, we introduce an extra layer of a function1068# here, and immediately call it after defining it.1069git_rebase__interactive () {10701071case"$action"in1072continue)1073iftest!-d"$rewritten"1074then1075exec git rebase--helper${force_rebase:+--no-ff}--continue1076fi1077# do we have anything to commit?1078if git diff-index --cached --quiet HEAD --1079then1080# Nothing to commit -- skip this commit10811082test!-f"$GIT_DIR"/CHERRY_PICK_HEAD ||1083rm"$GIT_DIR"/CHERRY_PICK_HEAD ||1084 die "$(gettext "Could not remove CHERRY_PICK_HEAD")"1085else1086if!test -f"$author_script"1087then1088 gpg_sign_opt_quoted=${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")}1089 die "$(eval_gettext "\1090You have staged changes in your working tree.1091If these changes are meant to be1092squashed into the previous commit, run:10931094 git commit --amend \$gpg_sign_opt_quoted10951096If they are meant to go into a new commit, run:10971098 git commit \$gpg_sign_opt_quoted10991100In both cases, once you're done, continue with:11011102 git rebase --continue1103")"1104 fi1105 . "$author_script" ||1106 die "$(gettext "Error trying to find the author identity to amend commit")"1107 if test -f "$amend"1108 then1109 current_head=$(git rev-parse --verify HEAD)1110 test "$current_head" =$(cat "$amend")||1111 die "$(gettext "\1112You have uncommitted changes in your working tree. Please commit them1113first and then run 'git rebase --continue' again.")"1114 do_with_author git commit --amend --no-verify -F "$msg" -e \1115${gpg_sign_opt:+"$gpg_sign_opt"}||1116 die "$(gettext "Could not commit staged changes.")"1117 else1118 do_with_author git commit --no-verify -F "$msg" -e \1119${gpg_sign_opt:+"$gpg_sign_opt"}||1120 die "$(gettext "Could not commit staged changes.")"1121 fi1122 fi11231124 if test -r "$state_dir"/stopped-sha1125 then1126 record_in_rewritten "$(cat "$state_dir"/stopped-sha)"1127 fi11281129 require_clean_work_tree "rebase"1130 do_rest1131 return 01132 ;;1133skip)1134 git rerere clear11351136 if test ! -d "$rewritten"1137 then1138 exec git rebase--helper${force_rebase:+--no-ff}--continue1139 fi1140 do_rest1141 return 01142 ;;1143edit-todo)1144 git stripspace --strip-comments <"$todo" >"$todo".new1145 mv -f "$todo".new "$todo"1146 collapse_todo_ids1147 append_todo_help1148 gettext "1149You are editing the todo file of an ongoing interactive rebase.1150To continue rebase after editing, run:1151 git rebase --continue11521153" | git stripspace --comment-lines >>"$todo"11541155 git_sequence_editor "$todo" ||1156 die "$(gettext "Could not execute editor")"1157 expand_todo_ids11581159 exit1160 ;;1161esac11621163comment_for_reflog start11641165if test ! -z "$switch_to"1166then1167 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout$switch_to"1168 output git checkout "$switch_to" -- ||1169 die "$(eval_gettext "Could not checkout \$switch_to")"11701171 comment_for_reflog start1172fi11731174orig_head=$(git rev-parse --verify HEAD)|| die "$(gettext "No HEAD?")"1175mkdir -p "$state_dir" || die "$(eval_gettext "Could not create temporary \$state_dir")"11761177: > "$state_dir"/interactive || die "$(gettext "Could not mark as interactive")"1178write_basic_state1179if test t = "$preserve_merges"1180then1181 if test -z "$rebase_root"1182 then1183 mkdir "$rewritten" &&1184 for c in$(git merge-base --all $orig_head $upstream)1185 do1186 echo$onto> "$rewritten"/$c||1187 die "$(gettext "Could not init rewritten commits")"1188 done1189 else1190 mkdir "$rewritten" &&1191 echo$onto> "$rewritten"/root ||1192 die "$(gettext "Could not init rewritten commits")"1193 fi1194 # No cherry-pick because our first pass is to determine1195 # parents to rewrite and skipping dropped commits would1196 # prematurely end our probe1197 merges_option=1198else1199 merges_option="--no-merges --cherry-pick"1200fi12011202shorthead=$(git rev-parse --short $orig_head)1203shortonto=$(git rev-parse --short $onto)1204if test -z "$rebase_root"1205 # this is now equivalent to ! -z "$upstream"1206then1207 shortupstream=$(git rev-parse --short $upstream)1208 revisions=$upstream...$orig_head1209 shortrevisions=$shortupstream..$shorthead1210else1211 revisions=$onto...$orig_head1212 shortrevisions=$shorthead1213fi1214if test t != "$preserve_merges"1215then1216 git rebase--helper --make-script${keep_empty:+--keep-empty}\1217$revisions${restrict_revision+^$restrict_revision}>"$todo"1218else1219 format=$(git config --get rebase.instructionFormat)1220 # the 'rev-list .. |sed' requires %m to parse; the instruction requires %H to parse1221 git rev-list$merges_option--format="%m%H${format:-%s}" \1222 --reverse --left-right --topo-order \1223$revisions${restrict_revision+^$restrict_revision}| \1224 sed -n "s/^>//p" |1225 while read -r sha1 rest1226 do12271228 if test -z "$keep_empty" && is_empty_commit$sha1&& ! is_merge_commit$sha11229 then1230 comment_out="$comment_char"1231 else1232 comment_out=1233 fi12341235 if test -z "$rebase_root"1236 then1237 preserve=t1238 for p in$(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-)1239 do1240 if test -f "$rewritten"/$p1241 then1242 preserve=f1243 fi1244 done1245 else1246 preserve=f1247 fi1248 if test f = "$preserve"1249 then1250 touch "$rewritten"/$sha11251 printf '%s\n' "${comment_out}pick$sha1$rest" >>"$todo"1252 fi1253 done1254fi12551256# Watch for commits that been dropped by --cherry-pick1257if test t = "$preserve_merges"1258then1259 mkdir "$dropped"1260 # Save all non-cherry-picked changes1261 git rev-list$revisions--left-right --cherry-pick | \1262 sed -n "s/^>//p" > "$state_dir"/not-cherry-picks1263 # Now all commits and note which ones are missing in1264 # not-cherry-picks and hence being dropped1265 git rev-list$revisions|1266 while read rev1267 do1268 if test -f "$rewritten"/$rev&&1269 ! sane_grep "$rev" "$state_dir"/not-cherry-picks >/dev/null1270 then1271 # Use -f2 because if rev-list is telling us this commit is1272 # not worthwhile, we don't want to track its multiple heads,1273# just the history of its first-parent for others that will1274# be rebasing on top of it1275 git rev-list --parents -1$rev| cut -d' '-s -f2>"$dropped"/$rev1276 sha1=$(git rev-list -1 $rev)1277 sane_grep -v"^[a-z][a-z]*$sha1"<"$todo">"${todo}2";mv"${todo}2""$todo"1278rm"$rewritten"/$rev1279fi1280done1281fi12821283test -s"$todo"||echo noop >>"$todo"1284test -n"$autosquash"&& rearrange_squash "$todo"1285test -n"$cmd"&& add_exec_commands "$todo"12861287todocount=$(git stripspace --strip-comments <"$todo" | wc -l)1288todocount=${todocount##* }12891290cat>>"$todo"<<EOF12911292$comment_char$(eval_ngettext \1293 "Rebase \$shortrevisionsonto \$shortonto(\$todocountcommand)" \1294 "Rebase \$shortrevisionsonto \$shortonto(\$todocountcommands)" \1295 "$todocount")1296EOF1297append_todo_help1298gettext"1299However, if you remove everything, the rebase will be aborted.13001301"| git stripspace --comment-lines>>"$todo"13021303iftest -z"$keep_empty"1304then1305printf'%s\n'"$comment_char$(gettext "Note that empty commits are commented out")">>"$todo"1306fi130713081309has_action "$todo"||1310return213111312cp"$todo""$todo".backup1313collapse_todo_ids1314git_sequence_editor "$todo"||1315 die_abort "$(gettext "Could not execute editor")"13161317has_action "$todo"||1318return213191320check_todo_list13211322expand_todo_ids13231324test -d"$rewritten"||test -n"$force_rebase"|| skip_unnecessary_picks13251326checkout_onto1327iftest -z"$rebase_root"&&test!-d"$rewritten"1328then1329 require_clean_work_tree "rebase"1330exec git rebase--helper${force_rebase:+--no-ff}--continue1331fi1332do_rest13331334}1335# ... and then we call the whole thing.1336git_rebase__interactive