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