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 git update-ref REBASE_HEAD "$1" 203 make_patch "$1" 204 die "$2" 205} 206 207exit_with_patch () { 208echo"$1">"$state_dir"/stopped-sha 209 git update-ref REBASE_HEAD "$1" 210 make_patch $1 211 git rev-parse --verify HEAD >"$amend" 212 gpg_sign_opt_quoted=${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")} 213 warn "$(eval_gettext "\ 214You can amend the commit now, with 215 216 git commit --amend \$gpg_sign_opt_quoted 217 218Once you are satisfied with your changes, run 219 220 git rebase --continue")" 221 warn 222exit$2 223} 224 225die_abort () { 226 apply_autostash 227rm-rf"$state_dir" 228 die "$1" 229} 230 231has_action () { 232test -n"$(git stripspace --strip-comments <"$1")" 233} 234 235is_empty_commit() { 236 tree=$(git rev-parse -q --verify "$1"^{tree} 2>/dev/null)|| { 237 sha1=$1 238 die "$(eval_gettext "\$sha1: not a commit that can be picked")" 239} 240 ptree=$(git rev-parse -q --verify "$1"^^{tree} 2>/dev/null)|| 241 ptree=4b825dc642cb6eb9a060e54bf8d69288fbee4904 242test"$tree"="$ptree" 243} 244 245is_merge_commit() 246{ 247 git rev-parse --verify --quiet"$1"^2>/dev/null 2>&1 248} 249 250# Run command with GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and 251# GIT_AUTHOR_DATE exported from the current environment. 252do_with_author () { 253( 254export GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL GIT_AUTHOR_DATE 255"$@" 256) 257} 258 259git_sequence_editor () { 260iftest -z"$GIT_SEQUENCE_EDITOR" 261then 262 GIT_SEQUENCE_EDITOR="$(git config sequence.editor)" 263if[-z"$GIT_SEQUENCE_EDITOR"] 264then 265 GIT_SEQUENCE_EDITOR="$(git var GIT_EDITOR)"||return $? 266fi 267fi 268 269eval"$GIT_SEQUENCE_EDITOR"'"$@"' 270} 271 272pick_one () { 273 ff=--ff 274 275case"$1"in-n) sha1=$2; ff= ;; *) sha1=$1;;esac 276case"$force_rebase"in'') ;; ?*) ff= ;;esac 277 output git rev-parse --verify$sha1|| die "$(eval_gettext "Invalid commit name: \$sha1")" 278 279if is_empty_commit "$sha1" 280then 281 empty_args="--allow-empty" 282fi 283 284test -d"$rewritten"&& 285 pick_one_preserving_merges "$@"&&return 286 output eval git cherry-pick$allow_rerere_autoupdate \ 287${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")} \ 288"$strategy_args"$empty_args $ff"$@" 289 290# If cherry-pick dies it leaves the to-be-picked commit unrecorded. Reschedule 291# previous task so this commit is not lost. 292 ret=$? 293case"$ret"in[01]) ;; *) reschedule_last_action ;;esac 294return$ret 295} 296 297pick_one_preserving_merges () { 298 fast_forward=t 299case"$1"in 300-n) 301 fast_forward=f 302 sha1=$2 303;; 304*) 305 sha1=$1 306;; 307esac 308 sha1=$(git rev-parse $sha1) 309 310iftest -f"$state_dir"/current-commit 311then 312iftest"$fast_forward"= t 313then 314whileread current_commit 315do 316 git rev-parse HEAD >"$rewritten"/$current_commit 317done<"$state_dir"/current-commit 318rm"$state_dir"/current-commit|| 319 die "$(gettext "Cannot write current commit's replacement sha1")" 320fi 321fi 322 323echo$sha1>>"$state_dir"/current-commit 324 325# rewrite parents; if none were rewritten, we can fast-forward. 326 new_parents= 327 pend="$(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-)" 328iftest"$pend"=" " 329then 330 pend=" root" 331fi 332while["$pend"!=""] 333do 334 p=$(expr "$pend" : ' \([^ ]*\)') 335 pend="${pend# $p}" 336 337 if test -f "$rewritten"/$p 338 then 339 new_p=$(cat "$rewritten"/$p) 340 341 # If the todo reordered commits, and our parent is marked for 342 # rewriting, but hasn't been gotten to yet, assume the user meant to 343# drop it on top of the current HEAD 344iftest -z"$new_p" 345then 346 new_p=$(git rev-parse HEAD) 347fi 348 349test$p!=$new_p&& fast_forward=f 350case"$new_parents"in 351*$new_p*) 352;;# do nothing; that parent is already there 353*) 354 new_parents="$new_parents$new_p" 355;; 356esac 357else 358iftest -f"$dropped"/$p 359then 360 fast_forward=f 361 replacement="$(cat "$dropped"/$p)" 362test -z"$replacement"&& replacement=root 363 pend="$replacement$pend" 364else 365 new_parents="$new_parents$p" 366fi 367fi 368done 369case$fast_forwardin 370 t) 371 output warn "$(eval_gettext "Fast-forward to \$sha1")" 372 output git reset--hard$sha1|| 373 die "$(eval_gettext "Cannot fast-forward to \$sha1")" 374;; 375 f) 376 first_parent=$(expr "$new_parents" : ' \([^ ]*\)') 377 378 if [ "$1" != "-n" ] 379 then 380 # detach HEAD to current parent 381 output git checkout$first_parent2> /dev/null || 382 die "$(eval_gettext "Cannot move HEAD to \$first_parent")" 383 fi 384 385 case "$new_parents" in 386 ''*''*) 387 test "a$1" = a-n && die "$(eval_gettext "Refusing to squash a merge: \$sha1")" 388 389 # redo merge 390 author_script_content=$(get_author_ident_from_commit $sha1) 391 eval "$author_script_content" 392 msg_content="$(commit_message $sha1)" 393 # No point in merging the first parent, that's HEAD 394 new_parents=${new_parents# $first_parent} 395 merge_args="--no-log --no-ff" 396if! do_with_author output eval \ 397 git merge ${gpg_sign_opt:+$(git rev-parse \ 398--sq-quote"$gpg_sign_opt")} \ 399$allow_rerere_autoupdate"$merge_args" \ 400"$strategy_args" \ 401-m$(git rev-parse --sq-quote "$msg_content") \ 402"$new_parents" 403then 404printf"%s\n""$msg_content">"$GIT_DIR"/MERGE_MSG 405 die_with_patch $sha1"$(eval_gettext "Error redoing merge \$sha1")" 406fi 407echo"$sha1$(git rev-parse HEAD^0)">>"$rewritten_list" 408;; 409*) 410 output eval git cherry-pick$allow_rerere_autoupdate \ 411${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")} \ 412"$strategy_args""$@"|| 413 die_with_patch $sha1"$(eval_gettext "Could not pick \$sha1")" 414;; 415esac 416;; 417esac 418} 419 420this_nth_commit_message () { 421 n=$1 422 eval_gettext "This is the commit message #\${n}:" 423} 424 425skip_nth_commit_message () { 426 n=$1 427 eval_gettext "The commit message #\${n}will be skipped:" 428} 429 430update_squash_messages () { 431iftest -f"$squash_msg";then 432mv"$squash_msg""$squash_msg".bak ||exit 433 count=$(($(sed-n \ 434-e"1s/^$comment_char[^0-9]*\([0-9][0-9]*\).*/\1/p" \ 435-e"q"<"$squash_msg".bak)+1)) 436{ 437printf'%s\n'"$comment_char$(eval_ngettext \ 438 "This is a combination of \$count commit." \ 439 "This is a combination of \$count commits." \ 440$count)" 441sed-e1d -e'2,/^./{ 442 /^$/d 443 }'<"$squash_msg".bak 444} >"$squash_msg" 445else 446 commit_message HEAD >"$fixup_msg"|| 447 die "$(eval_gettext "Cannot write \$fixup_msg")" 448 count=2 449{ 450printf'%s\n'"$comment_char$(gettext "This is a combination of 2 commits.")" 451printf'%s\n'"$comment_char$(gettext "This is the 1st commit message:")" 452echo 453cat"$fixup_msg" 454} >"$squash_msg" 455fi 456case$1in 457 squash) 458rm-f"$fixup_msg" 459echo 460printf'%s\n'"$comment_char$(this_nth_commit_message $count)" 461echo 462 commit_message $2 463;; 464 fixup) 465echo 466printf'%s\n'"$comment_char$(skip_nth_commit_message $count)" 467echo 468# Change the space after the comment character to TAB: 469 commit_message $2| git stripspace --comment-lines|sed-e's/ / /' 470;; 471esac>>"$squash_msg" 472} 473 474peek_next_command () { 475 git stripspace --strip-comments<"$todo"|sed-n -e's/ .*//p'-e q 476} 477 478# A squash/fixup has failed. Prepare the long version of the squash 479# commit message, then die_with_patch. This code path requires the 480# user to edit the combined commit message for all commits that have 481# been squashed/fixedup so far. So also erase the old squash 482# messages, effectively causing the combined commit to be used as the 483# new basis for any further squash/fixups. Args: sha1 rest 484die_failed_squash() { 485 sha1=$1 486 rest=$2 487mv"$squash_msg""$msg"||exit 488rm-f"$fixup_msg" 489cp"$msg""$GIT_DIR"/MERGE_MSG ||exit 490 warn 491 warn "$(eval_gettext "Could not apply \$sha1... \$rest")" 492 die_with_patch $sha1"" 493} 494 495flush_rewritten_pending() { 496test -s"$rewritten_pending"||return 497 newsha1="$(git rev-parse HEAD^0)" 498sed"s/$/$newsha1/"<"$rewritten_pending">>"$rewritten_list" 499rm-f"$rewritten_pending" 500} 501 502record_in_rewritten() { 503 oldsha1="$(git rev-parse $1)" 504echo"$oldsha1">>"$rewritten_pending" 505 506case"$(peek_next_command)"in 507 squash|s|fixup|f) 508;; 509*) 510 flush_rewritten_pending 511;; 512esac 513} 514 515do_pick () { 516 sha1=$1 517 rest=$2 518iftest"$(git rev-parse HEAD)"="$squash_onto" 519then 520# Set the correct commit message and author info on the 521# sentinel root before cherry-picking the original changes 522# without committing (-n). Finally, update the sentinel again 523# to include these changes. If the cherry-pick results in a 524# conflict, this means our behaviour is similar to a standard 525# failed cherry-pick during rebase, with a dirty index to 526# resolve before manually running git commit --amend then git 527# rebase --continue. 528 git commit --allow-empty --allow-empty-message --amend \ 529--no-post-rewrite -n -q -C$sha1&& 530 pick_one -n$sha1&& 531 git commit --allow-empty --allow-empty-message \ 532--amend --no-post-rewrite -n -q -C$sha1 \ 533${gpg_sign_opt:+"$gpg_sign_opt"}|| 534 die_with_patch $sha1"$(eval_gettext "Could not apply \$sha1... \$rest")" 535else 536 pick_one $sha1|| 537 die_with_patch $sha1"$(eval_gettext "Could not apply \$sha1... \$rest")" 538fi 539} 540 541do_next () { 542rm-f"$msg""$author_script""$amend""$state_dir"/stopped-sha||exit 543read -r command sha1 rest <"$todo" 544case"$command"in 545"$comment_char"*|''|noop|drop|d) 546 mark_action_done 547;; 548"$cr") 549# Work around CR left by "read" (e.g. with Git for Windows' Bash). 550 mark_action_done 551;; 552 pick|p) 553 comment_for_reflog pick 554 555 mark_action_done 556 do_pick $sha1"$rest" 557 record_in_rewritten $sha1 558;; 559 reword|r) 560 comment_for_reflog reword 561 562 mark_action_done 563 do_pick $sha1"$rest" 564 git commit --amend --no-post-rewrite${gpg_sign_opt:+"$gpg_sign_opt"}|| { 565 warn "$(eval_gettext "\ 566Could not amend commit after successfully picking \$sha1... \$rest 567This is most likely due to an empty commit message, or the pre-commit hook 568failed. If the pre-commit hook failed, you may need to resolve the issue before 569you are able to reword the commit.")" 570 exit_with_patch $sha11 571} 572 record_in_rewritten $sha1 573;; 574 edit|e) 575 comment_for_reflog edit 576 577 mark_action_done 578 do_pick $sha1"$rest" 579 sha1_abbrev=$(git rev-parse --short $sha1) 580 warn "$(eval_gettext "Stopped at \$sha1_abbrev... \$rest")" 581 exit_with_patch $sha10 582;; 583 squash|s|fixup|f) 584case"$command"in 585 squash|s) 586 squash_style=squash 587;; 588 fixup|f) 589 squash_style=fixup 590;; 591esac 592 comment_for_reflog $squash_style 593 594test -f"$done"&& has_action "$done"|| 595 die "$(eval_gettext "Cannot '\$squash_style' without a previous commit")" 596 597 mark_action_done 598 update_squash_messages $squash_style $sha1 599 author_script_content=$(get_author_ident_from_commit HEAD) 600echo"$author_script_content">"$author_script" 601eval"$author_script_content" 602if! pick_one -n$sha1 603then 604 git rev-parse --verify HEAD >"$amend" 605 die_failed_squash $sha1"$rest" 606fi 607case"$(peek_next_command)"in 608 squash|s|fixup|f) 609# This is an intermediate commit; its message will only be 610# used in case of trouble. So use the long version: 611 do_with_author output git commit --amend --no-verify -F"$squash_msg" \ 612${gpg_sign_opt:+"$gpg_sign_opt"}|| 613 die_failed_squash $sha1"$rest" 614;; 615*) 616# This is the final command of this squash/fixup group 617iftest -f"$fixup_msg" 618then 619 do_with_author git commit --amend --no-verify -F"$fixup_msg" \ 620${gpg_sign_opt:+"$gpg_sign_opt"}|| 621 die_failed_squash $sha1"$rest" 622else 623cp"$squash_msg""$GIT_DIR"/SQUASH_MSG ||exit 624rm-f"$GIT_DIR"/MERGE_MSG 625 do_with_author git commit --amend --no-verify -F"$GIT_DIR"/SQUASH_MSG -e \ 626${gpg_sign_opt:+"$gpg_sign_opt"}|| 627 die_failed_squash $sha1"$rest" 628fi 629rm-f"$squash_msg""$fixup_msg" 630;; 631esac 632 record_in_rewritten $sha1 633;; 634 x|"exec") 635read -r command rest <"$todo" 636 mark_action_done 637 eval_gettextln "Executing: \$rest" 638"${SHELL:-@SHELL_PATH@}"-c"$rest"# Actual execution 639 status=$? 640# Run in subshell because require_clean_work_tree can die. 641 dirty=f 642(require_clean_work_tree "rebase"2>/dev/null) || dirty=t 643iftest"$status"-ne0 644then 645 warn "$(eval_gettext "Execution failed: \$rest")" 646test"$dirty"= f || 647 warn "$(gettext "and made changes to the index and/or the working tree")" 648 649 warn "$(gettext "\ 650You can fix the problem, and then run 651 652 git rebase --continue")" 653 warn 654iftest$status-eq127# command not found 655then 656 status=1 657fi 658exit"$status" 659eliftest"$dirty"= t 660then 661# TRANSLATORS: after these lines is a command to be issued by the user 662 warn "$(eval_gettext "\ 663Execution succeeded: \$rest 664but left changes to the index and/or the working tree 665Commit or stash your changes, and then run 666 667 git rebase --continue")" 668 warn 669exit1 670fi 671;; 672*) 673 warn "$(eval_gettext "Unknown command: \$command \$sha1 \$rest")" 674 fixtodo="$(gettext "Please fix this using 'git rebase --edit-todo'.")" 675if git rev-parse --verify -q"$sha1">/dev/null 676then 677 die_with_patch $sha1"$fixtodo" 678else 679 die "$fixtodo" 680fi 681;; 682esac 683test -s"$todo"&&return 684 685 comment_for_reflog finish && 686 newhead=$(git rev-parse HEAD)&& 687case$head_namein 688 refs/*) 689 message="$GIT_REFLOG_ACTION:$head_nameonto$onto"&& 690 git update-ref -m"$message"$head_name $newhead $orig_head&& 691 git symbolic-ref \ 692-m"$GIT_REFLOG_ACTION: returning to$head_name" \ 693 HEAD $head_name 694;; 695esac&& { 696test!-f"$state_dir"/verbose || 697 git diff-tree --stat$orig_head..HEAD 698} && 699{ 700test -s"$rewritten_list"&& 701 git notes copy --for-rewrite=rebase <"$rewritten_list"|| 702 true # we don't care if this copying failed 703} && 704 hook="$(git rev-parse --git-path hooks/post-rewrite)" 705iftest -x"$hook"&&test -s"$rewritten_list";then 706"$hook" rebase <"$rewritten_list" 707 true # we don't care if this hook failed 708fi&& 709 warn "$(eval_gettext "Successfully rebased and updated \$head_name.")" 710 711return1# not failure; just to break the do_rest loop 712} 713 714# can only return 0, when the infinite loop breaks 715do_rest () { 716while: 717do 718 do_next ||break 719done 720} 721 722expand_todo_ids() { 723 git rebase--helper --expand-ids 724} 725 726collapse_todo_ids() { 727 git rebase--helper --shorten-ids 728} 729 730# Switch to the branch in $into and notify it in the reflog 731checkout_onto () { 732 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout$onto_name" 733 output git checkout $onto|| die_abort "$(gettext "could not detach HEAD")" 734 git update-ref ORIG_HEAD $orig_head 735} 736 737get_missing_commit_check_level () { 738 check_level=$(git config --get rebase.missingCommitsCheck) 739 check_level=${check_level:-ignore} 740# Don't be case sensitive 741printf'%s'"$check_level"|tr'A-Z''a-z' 742} 743 744# The whole contents of this file is run by dot-sourcing it from 745# inside a shell function. It used to be that "return"s we see 746# below were not inside any function, and expected to return 747# to the function that dot-sourced us. 748# 749# However, older (9.x) versions of FreeBSD /bin/sh misbehave on such a 750# construct and continue to run the statements that follow such a "return". 751# As a work-around, we introduce an extra layer of a function 752# here, and immediately call it after defining it. 753git_rebase__interactive () { 754 755case"$action"in 756continue) 757iftest!-d"$rewritten" 758then 759exec git rebase--helper${force_rebase:+--no-ff}--continue 760fi 761# do we have anything to commit? 762if git diff-index --cached --quiet HEAD -- 763then 764# Nothing to commit -- skip this commit 765 766test!-f"$GIT_DIR"/CHERRY_PICK_HEAD || 767rm"$GIT_DIR"/CHERRY_PICK_HEAD || 768 die "$(gettext "Could not remove CHERRY_PICK_HEAD")" 769else 770if!test -f"$author_script" 771then 772 gpg_sign_opt_quoted=${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")} 773 die "$(eval_gettext "\ 774You have staged changes in your working tree. 775If these changes are meant to be 776squashed into the previous commit, run: 777 778 git commit --amend \$gpg_sign_opt_quoted 779 780If they are meant to go into a new commit, run: 781 782 git commit \$gpg_sign_opt_quoted 783 784In both cases, once you're done, continue with: 785 786 git rebase --continue 787")" 788 fi 789 . "$author_script" || 790 die "$(gettext "Error trying to find the author identity to amend commit")" 791 if test -f "$amend" 792 then 793 current_head=$(git rev-parse --verify HEAD) 794 test "$current_head" =$(cat "$amend")|| 795 die "$(gettext "\ 796You have uncommitted changes in your working tree. Please commit them 797first and then run 'git rebase --continue' again.")" 798 do_with_author git commit --amend --no-verify -F "$msg" -e \ 799${gpg_sign_opt:+"$gpg_sign_opt"}|| 800 die "$(gettext "Could not commit staged changes.")" 801 else 802 do_with_author git commit --no-verify -F "$msg" -e \ 803${gpg_sign_opt:+"$gpg_sign_opt"}|| 804 die "$(gettext "Could not commit staged changes.")" 805 fi 806 fi 807 808 if test -r "$state_dir"/stopped-sha 809 then 810 record_in_rewritten "$(cat "$state_dir"/stopped-sha)" 811 fi 812 813 require_clean_work_tree "rebase" 814 do_rest 815 return 0 816 ;; 817skip) 818 git rerere clear 819 820 if test ! -d "$rewritten" 821 then 822 exec git rebase--helper${force_rebase:+--no-ff}--continue 823 fi 824 do_rest 825 return 0 826 ;; 827edit-todo) 828 git stripspace --strip-comments <"$todo" >"$todo".new 829 mv -f "$todo".new "$todo" 830 collapse_todo_ids 831 append_todo_help 832 gettext " 833You are editing the todo file of an ongoing interactive rebase. 834To continue rebase after editing, run: 835 git rebase --continue 836 837" | git stripspace --comment-lines >>"$todo" 838 839 git_sequence_editor "$todo" || 840 die "$(gettext "Could not execute editor")" 841 expand_todo_ids 842 843 exit 844 ;; 845show-current-patch) 846 exec git show REBASE_HEAD -- 847 ;; 848esac 849 850comment_for_reflog start 851 852if test ! -z "$switch_to" 853then 854 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout$switch_to" 855 output git checkout "$switch_to" -- || 856 die "$(eval_gettext "Could not checkout \$switch_to")" 857 858 comment_for_reflog start 859fi 860 861orig_head=$(git rev-parse --verify HEAD)|| die "$(gettext "No HEAD?")" 862mkdir -p "$state_dir" || die "$(eval_gettext "Could not create temporary \$state_dir")" 863rm -f "$(git rev-parse --git-path REBASE_HEAD)" 864 865: > "$state_dir"/interactive || die "$(gettext "Could not mark as interactive")" 866write_basic_state 867if test t = "$preserve_merges" 868then 869 if test -z "$rebase_root" 870 then 871 mkdir "$rewritten" && 872 for c in$(git merge-base --all $orig_head $upstream) 873 do 874 echo$onto> "$rewritten"/$c|| 875 die "$(gettext "Could not init rewritten commits")" 876 done 877 else 878 mkdir "$rewritten" && 879 echo$onto> "$rewritten"/root || 880 die "$(gettext "Could not init rewritten commits")" 881 fi 882 # No cherry-pick because our first pass is to determine 883 # parents to rewrite and skipping dropped commits would 884 # prematurely end our probe 885 merges_option= 886else 887 merges_option="--no-merges --cherry-pick" 888fi 889 890shorthead=$(git rev-parse --short $orig_head) 891shortonto=$(git rev-parse --short $onto) 892if test -z "$rebase_root" 893 # this is now equivalent to ! -z "$upstream" 894then 895 shortupstream=$(git rev-parse --short $upstream) 896 revisions=$upstream...$orig_head 897 shortrevisions=$shortupstream..$shorthead 898else 899 revisions=$onto...$orig_head 900 shortrevisions=$shorthead 901fi 902if test t != "$preserve_merges" 903then 904 git rebase--helper --make-script${keep_empty:+--keep-empty}\ 905$revisions${restrict_revision+^$restrict_revision}>"$todo" || 906 die "$(gettext "Could not generate todo list")" 907else 908 format=$(git config --get rebase.instructionFormat) 909 # the 'rev-list .. |sed' requires %m to parse; the instruction requires %H to parse 910 git rev-list$merges_option--format="%m%H${format:-%s}" \ 911 --reverse --left-right --topo-order \ 912$revisions${restrict_revision+^$restrict_revision}| \ 913 sed -n "s/^>//p" | 914 while read -r sha1 rest 915 do 916 917 if test -z "$keep_empty" && is_empty_commit$sha1&& ! is_merge_commit$sha1 918 then 919 comment_out="$comment_char" 920 else 921 comment_out= 922 fi 923 924 if test -z "$rebase_root" 925 then 926 preserve=t 927 for p in$(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-) 928 do 929 if test -f "$rewritten"/$p 930 then 931 preserve=f 932 fi 933 done 934 else 935 preserve=f 936 fi 937 if test f = "$preserve" 938 then 939 touch "$rewritten"/$sha1 940 printf '%s\n' "${comment_out}pick$sha1$rest" >>"$todo" 941 fi 942 done 943fi 944 945# Watch for commits that been dropped by --cherry-pick 946if test t = "$preserve_merges" 947then 948 mkdir "$dropped" 949 # Save all non-cherry-picked changes 950 git rev-list$revisions--left-right --cherry-pick | \ 951 sed -n "s/^>//p" > "$state_dir"/not-cherry-picks 952 # Now all commits and note which ones are missing in 953 # not-cherry-picks and hence being dropped 954 git rev-list$revisions| 955 while read rev 956 do 957 if test -f "$rewritten"/$rev&& 958 ! sane_grep "$rev" "$state_dir"/not-cherry-picks >/dev/null 959 then 960 # Use -f2 because if rev-list is telling us this commit is 961 # not worthwhile, we don't want to track its multiple heads, 962# just the history of its first-parent for others that will 963# be rebasing on top of it 964 git rev-list --parents -1$rev| cut -d' '-s -f2>"$dropped"/$rev 965 sha1=$(git rev-list -1 $rev) 966 sane_grep -v"^[a-z][a-z]*$sha1"<"$todo">"${todo}2";mv"${todo}2""$todo" 967rm"$rewritten"/$rev 968fi 969done 970fi 971 972test -s"$todo"||echo noop >>"$todo" 973test -z"$autosquash"|| git rebase--helper --rearrange-squash||exit 974test -n"$cmd"&& git rebase--helper --add-exec-commands"$cmd" 975 976todocount=$(git stripspace --strip-comments <"$todo" | wc -l) 977todocount=${todocount##* } 978 979cat>>"$todo"<<EOF 980 981$comment_char$(eval_ngettext \ 982 "Rebase \$shortrevisionsonto \$shortonto(\$todocountcommand)" \ 983 "Rebase \$shortrevisionsonto \$shortonto(\$todocountcommands)" \ 984 "$todocount") 985EOF 986append_todo_help 987gettext" 988However, if you remove everything, the rebase will be aborted. 989 990"| git stripspace --comment-lines>>"$todo" 991 992iftest -z"$keep_empty" 993then 994printf'%s\n'"$comment_char$(gettext "Note that empty commits are commented out")">>"$todo" 995fi 996 997 998has_action "$todo"|| 999return210001001cp"$todo""$todo".backup1002collapse_todo_ids1003git_sequence_editor "$todo"||1004 die_abort "$(gettext "Could not execute editor")"10051006has_action "$todo"||1007return210081009git rebase--helper --check-todo-list|| {1010 ret=$?1011 checkout_onto1012exit$ret1013}10141015expand_todo_ids10161017test -d"$rewritten"||test -n"$force_rebase"||1018onto="$(git rebase--helper --skip-unnecessary-picks)"||1019die "Could not skip unnecessary pick commands"10201021checkout_onto1022iftest -z"$rebase_root"&&test!-d"$rewritten"1023then1024 require_clean_work_tree "rebase"1025exec git rebase--helper${force_rebase:+--no-ff}--continue1026fi1027do_rest10281029}1030# ... and then we call the whole thing.1031git_rebase__interactive