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# http://article.gmane.org/gmane.comp.version-control.git/22407 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 | cut -c1) 97:${comment_char:=#} 98 99warn () { 100printf'%s\n'"$*">&2 101} 102 103# Output the commit message for the specified commit. 104commit_message () { 105 git cat-file commit "$1"|sed"1,/^$/d" 106} 107 108orig_reflog_action="$GIT_REFLOG_ACTION" 109 110comment_for_reflog () { 111case"$orig_reflog_action"in 112''|rebase*) 113 GIT_REFLOG_ACTION="rebase -i ($1)" 114export GIT_REFLOG_ACTION 115;; 116esac 117} 118 119last_count= 120mark_action_done () { 121sed-e1q <"$todo">>"$done" 122sed-e1d <"$todo">>"$todo".new 123mv-f"$todo".new "$todo" 124 new_count=$(( $(git stripspace --strip-comments <"$done" | wc -l))) 125echo$new_count>"$msgnum" 126 total=$(($new_count + $(git stripspace --strip-comments <"$todo" | wc -l))) 127echo$total>"$end" 128iftest"$last_count"!="$new_count" 129then 130 last_count=$new_count 131 eval_gettext "Rebasing (\$new_count/\$total)";printf"\r" 132test -z"$verbose"||echo 133fi 134} 135 136# Put the last action marked done at the beginning of the todo list 137# again. If there has not been an action marked done yet, leave the list of 138# items on the todo list unchanged. 139reschedule_last_action () { 140tail-n1"$done"|cat-"$todo">"$todo".new 141sed-e \$d<"$done">"$done".new 142mv-f"$todo".new "$todo" 143mv-f"$done".new "$done" 144} 145 146append_todo_help () { 147 git stripspace --comment-lines>>"$todo"<<\EOF 148 149Commands: 150 p, pick = use commit 151 r, reword = use commit, but edit the commit message 152 e, edit = use commit, but stop for amending 153 s, squash = use commit, but meld into previous commit 154 f, fixup = like "squash", but discard this commit's log message 155 x, exec = run command (the rest of the line) using shell 156 d, drop = remove commit 157 158These lines can be re-ordered; they are executed from top to bottom. 159 160EOF 161 if test$(get_missing_commit_check_level)= error 162 then 163 git stripspace --comment-lines >>"$todo" <<\EOF 164Do not remove any line. Use 'drop' explicitly to remove a commit. 165EOF 166 else 167 git stripspace --comment-lines >>"$todo" <<\EOF 168If you remove a line here THAT COMMIT WILL BE LOST. 169EOF 170 fi 171} 172 173make_patch () { 174 sha1_and_parents="$(git rev-list --parents -1 "$1")" 175 case "$sha1_and_parents" in 176 ?*''?*''?*) 177 git diff --cc$sha1_and_parents 178 ;; 179 ?*''?*) 180 git diff-tree -p "$1^!" 181 ;; 182 *) 183 echo "Root commit" 184 ;; 185 esac > "$state_dir"/patch 186 test -f "$msg" || 187 commit_message "$1" > "$msg" 188 test -f "$author_script" || 189 get_author_ident_from_commit "$1" > "$author_script" 190} 191 192die_with_patch () { 193 echo "$1" > "$state_dir"/stopped-sha 194 make_patch "$1" 195 git rerere 196 die "$2" 197} 198 199exit_with_patch () { 200 echo "$1" > "$state_dir"/stopped-sha 201 make_patch$1 202 git rev-parse --verify HEAD > "$amend" 203 gpg_sign_opt_quoted=${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")} 204 warn "$(eval_gettext "\ 205You can amend the commit now, with 206 207 git commit --amend \$gpg_sign_opt_quoted 208 209Once you are satisfied with your changes, run 210 211 git rebase --continue")" 212 warn 213 exit$2 214} 215 216die_abort () { 217 rm -rf "$state_dir" 218 die "$1" 219} 220 221has_action () { 222 test -n "$(git stripspace --strip-comments <"$1")" 223} 224 225is_empty_commit() { 226 tree=$(git rev-parse -q --verify "$1"^{tree} 2>/dev/null)|| { 227 sha1=$1 228 die "$(eval_gettext "\$sha1: not a commit that can be picked")" 229 } 230 ptree=$(git rev-parse -q --verify "$1"^^{tree} 2>/dev/null)|| 231 ptree=4b825dc642cb6eb9a060e54bf8d69288fbee4904 232 test "$tree" = "$ptree" 233} 234 235is_merge_commit() 236{ 237 git rev-parse --verify --quiet "$1"^2 >/dev/null 2>&1 238} 239 240# Run command with GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and 241# GIT_AUTHOR_DATE exported from the current environment. 242do_with_author () { 243 ( 244 export GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL GIT_AUTHOR_DATE 245 "$@" 246 ) 247} 248 249git_sequence_editor () { 250 if test -z "$GIT_SEQUENCE_EDITOR" 251 then 252 GIT_SEQUENCE_EDITOR="$(git config sequence.editor)" 253 if [ -z "$GIT_SEQUENCE_EDITOR" ] 254 then 255 GIT_SEQUENCE_EDITOR="$(git var GIT_EDITOR)" || return $? 256 fi 257 fi 258 259 eval "$GIT_SEQUENCE_EDITOR" '"$@"' 260} 261 262pick_one () { 263 ff=--ff 264 265 case "$1" in -n) sha1=$2; ff= ;; *) sha1=$1;; esac 266 case "$force_rebase" in '') ;; ?*) ff= ;; esac 267 output git rev-parse --verify$sha1|| die "$(eval_gettext "Invalid commit name: \$sha1")" 268 269 if is_empty_commit "$sha1" 270 then 271 empty_args="--allow-empty" 272 fi 273 274 test -d "$rewritten" && 275 pick_one_preserving_merges "$@" && return 276 output eval git cherry-pick \ 277${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")}\ 278 "$strategy_args"$empty_args$ff"$@" 279 280 # If cherry-pick dies it leaves the to-be-picked commit unrecorded. Reschedule 281 # previous task so this commit is not lost. 282 ret=$? 283 case "$ret" in [01]) ;; *) reschedule_last_action ;; esac 284 return$ret 285} 286 287pick_one_preserving_merges () { 288 fast_forward=t 289 case "$1" in 290 -n) 291 fast_forward=f 292 sha1=$2 293 ;; 294 *) 295 sha1=$1 296 ;; 297 esac 298 sha1=$(git rev-parse $sha1) 299 300 if test -f "$state_dir"/current-commit 301 then 302 if test "$fast_forward" = t 303 then 304 while read current_commit 305 do 306 git rev-parse HEAD > "$rewritten"/$current_commit 307 done <"$state_dir"/current-commit 308 rm "$state_dir"/current-commit || 309 die "$(gettext "Cannot write current commit's replacement sha1")" 310 fi 311 fi 312 313 echo$sha1>> "$state_dir"/current-commit 314 315 # rewrite parents; if none were rewritten, we can fast-forward. 316 new_parents= 317 pend="$(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-)" 318 if test "$pend" = " " 319 then 320 pend=" root" 321 fi 322 while [ "$pend" != "" ] 323 do 324 p=$(expr "$pend" : ' \([^ ]*\)') 325 pend="${pend# $p}" 326 327iftest -f"$rewritten"/$p 328then 329 new_p=$(cat "$rewritten"/$p) 330 331# If the todo reordered commits, and our parent is marked for 332# rewriting, but hasn't been gotten to yet, assume the user meant to 333# drop it on top of the current HEAD 334iftest -z"$new_p" 335then 336 new_p=$(git rev-parse HEAD) 337fi 338 339test$p!=$new_p&& fast_forward=f 340case"$new_parents"in 341*$new_p*) 342;;# do nothing; that parent is already there 343*) 344 new_parents="$new_parents$new_p" 345;; 346esac 347else 348iftest -f"$dropped"/$p 349then 350 fast_forward=f 351 replacement="$(cat "$dropped"/$p)" 352test -z"$replacement"&& replacement=root 353 pend="$replacement$pend" 354else 355 new_parents="$new_parents$p" 356fi 357fi 358done 359case$fast_forwardin 360 t) 361 output warn "$(eval_gettext "Fast-forward to \$sha1")" 362 output git reset--hard$sha1|| 363 die "$(eval_gettext "Cannot fast-forward to \$sha1")" 364;; 365 f) 366 first_parent=$(expr "$new_parents" : ' \([^ ]*\)') 367 368 if [ "$1" != "-n" ] 369 then 370 # detach HEAD to current parent 371 output git checkout$first_parent2> /dev/null || 372 die "$(eval_gettext "Cannot move HEAD to \$first_parent")" 373 fi 374 375 case "$new_parents" in 376 ''*''*) 377 test "a$1" = a-n && die "$(eval_gettext "Refusing to squash a merge: \$sha1")" 378 379 # redo merge 380 author_script_content=$(get_author_ident_from_commit $sha1) 381 eval "$author_script_content" 382 msg_content="$(commit_message $sha1)" 383 # No point in merging the first parent, that's HEAD 384 new_parents=${new_parents# $first_parent} 385 merge_args="--no-log --no-ff" 386if! do_with_author output eval \ 387'git merge${gpg_sign_opt:+"$gpg_sign_opt"}\ 388$merge_args$strategy_args-m "$msg_content"$new_parents' 389then 390printf"%s\n""$msg_content">"$GIT_DIR"/MERGE_MSG 391 die_with_patch $sha1"$(eval_gettext "Error redoing merge \$sha1")" 392fi 393echo"$sha1$(git rev-parse HEAD^0)">>"$rewritten_list" 394;; 395*) 396 output eval git cherry-pick \ 397${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")} \ 398"$strategy_args""$@"|| 399 die_with_patch $sha1"$(eval_gettext "Could not pick \$sha1")" 400;; 401esac 402;; 403esac 404} 405 406nth_string () { 407case"$1"in 408*1[0-9]|*[04-9])echo"$1"th;; 409*1)echo"$1"st;; 410*2)echo"$1"nd;; 411*3)echo"$1"rd;; 412esac 413} 414 415update_squash_messages () { 416iftest -f"$squash_msg";then 417mv"$squash_msg""$squash_msg".bak ||exit 418 count=$(($(sed-n \ 419-e"1s/^. This is a combination of \(.*\) commits\./\1/p" \ 420-e"q"<"$squash_msg".bak)+1)) 421{ 422printf'%s\n'"$comment_charThis is a combination of$countcommits." 423sed-e1d -e'2,/^./{ 424 /^$/d 425 }'<"$squash_msg".bak 426} >"$squash_msg" 427else 428 commit_message HEAD >"$fixup_msg"|| die "Cannot write$fixup_msg" 429 count=2 430{ 431printf'%s\n'"$comment_charThis is a combination of 2 commits." 432printf'%s\n'"$comment_charThe first commit's message is:" 433echo 434cat"$fixup_msg" 435} >"$squash_msg" 436fi 437case$1in 438 squash) 439rm-f"$fixup_msg" 440echo 441printf'%s\n'"$comment_charThis is the$(nth_string $count)commit message:" 442echo 443 commit_message $2 444;; 445 fixup) 446echo 447printf'%s\n'"$comment_charThe$(nth_string $count)commit message will be skipped:" 448echo 449# Change the space after the comment character to TAB: 450 commit_message $2| git stripspace --comment-lines|sed-e's/ / /' 451;; 452esac>>"$squash_msg" 453} 454 455peek_next_command () { 456 git stripspace --strip-comments<"$todo"|sed-n -e's/ .*//p'-e q 457} 458 459# A squash/fixup has failed. Prepare the long version of the squash 460# commit message, then die_with_patch. This code path requires the 461# user to edit the combined commit message for all commits that have 462# been squashed/fixedup so far. So also erase the old squash 463# messages, effectively causing the combined commit to be used as the 464# new basis for any further squash/fixups. Args: sha1 rest 465die_failed_squash() { 466 sha1=$1 467 rest=$2 468mv"$squash_msg""$msg"||exit 469rm-f"$fixup_msg" 470cp"$msg""$GIT_DIR"/MERGE_MSG ||exit 471 warn 472 warn "$(eval_gettext "Could not apply \$sha1... \$rest")" 473 die_with_patch $sha1"" 474} 475 476flush_rewritten_pending() { 477test -s"$rewritten_pending"||return 478 newsha1="$(git rev-parse HEAD^0)" 479sed"s/$/$newsha1/"<"$rewritten_pending">>"$rewritten_list" 480rm-f"$rewritten_pending" 481} 482 483record_in_rewritten() { 484 oldsha1="$(git rev-parse $1)" 485echo"$oldsha1">>"$rewritten_pending" 486 487case"$(peek_next_command)"in 488 squash|s|fixup|f) 489;; 490*) 491 flush_rewritten_pending 492;; 493esac 494} 495 496do_pick () { 497 sha1=$1 498 rest=$2 499iftest"$(git rev-parse HEAD)"="$squash_onto" 500then 501# Set the correct commit message and author info on the 502# sentinel root before cherry-picking the original changes 503# without committing (-n). Finally, update the sentinel again 504# to include these changes. If the cherry-pick results in a 505# conflict, this means our behaviour is similar to a standard 506# failed cherry-pick during rebase, with a dirty index to 507# resolve before manually running git commit --amend then git 508# rebase --continue. 509 git commit --allow-empty --allow-empty-message --amend \ 510--no-post-rewrite -n -q -C$sha1&& 511 pick_one -n$sha1&& 512 git commit --allow-empty --allow-empty-message \ 513--amend --no-post-rewrite -n -q -C$sha1 \ 514${gpg_sign_opt:+"$gpg_sign_opt"}|| 515 die_with_patch $sha1"$(eval_gettext "Could not apply \$sha1... \$rest")" 516else 517 pick_one $sha1|| 518 die_with_patch $sha1"$(eval_gettext "Could not apply \$sha1... \$rest")" 519fi 520} 521 522do_next () { 523rm-f"$msg""$author_script""$amend""$state_dir"/stopped-sha||exit 524read -r command sha1 rest <"$todo" 525case"$command"in 526"$comment_char"*|''|noop|drop|d) 527 mark_action_done 528;; 529"$cr") 530# Work around CR left by "read" (e.g. with Git for Windows' Bash). 531 mark_action_done 532;; 533 pick|p) 534 comment_for_reflog pick 535 536 mark_action_done 537 do_pick $sha1"$rest" 538 record_in_rewritten $sha1 539;; 540 reword|r) 541 comment_for_reflog reword 542 543 mark_action_done 544 do_pick $sha1"$rest" 545 git commit --amend --no-post-rewrite${gpg_sign_opt:+"$gpg_sign_opt"}|| { 546 warn "$(eval_gettext "\ 547Could not amend commit after successfully picking \$sha1... \$rest 548This is most likely due to an empty commit message, or the pre-commit hook 549failed. If the pre-commit hook failed, you may need to resolve the issue before 550you are able to reword the commit.")" 551 exit_with_patch $sha11 552} 553 record_in_rewritten $sha1 554;; 555 edit|e) 556 comment_for_reflog edit 557 558 mark_action_done 559 do_pick $sha1"$rest" 560 sha1_abbrev=$(git rev-parse --short $sha1) 561 warn "$(eval_gettext "Stopped at \$sha1_abbrev... \$rest")" 562 exit_with_patch $sha10 563;; 564 squash|s|fixup|f) 565case"$command"in 566 squash|s) 567 squash_style=squash 568;; 569 fixup|f) 570 squash_style=fixup 571;; 572esac 573 comment_for_reflog $squash_style 574 575test -f"$done"&& has_action "$done"|| 576 die "$(eval_gettext "Cannot '\$squash_style' without a previous commit")" 577 578 mark_action_done 579 update_squash_messages $squash_style $sha1 580 author_script_content=$(get_author_ident_from_commit HEAD) 581echo"$author_script_content">"$author_script" 582eval"$author_script_content" 583if! pick_one -n$sha1 584then 585 git rev-parse --verify HEAD >"$amend" 586 die_failed_squash $sha1"$rest" 587fi 588case"$(peek_next_command)"in 589 squash|s|fixup|f) 590# This is an intermediate commit; its message will only be 591# used in case of trouble. So use the long version: 592 do_with_author output git commit --amend --no-verify -F"$squash_msg" \ 593${gpg_sign_opt:+"$gpg_sign_opt"}|| 594 die_failed_squash $sha1"$rest" 595;; 596*) 597# This is the final command of this squash/fixup group 598iftest -f"$fixup_msg" 599then 600 do_with_author git commit --amend --no-verify -F"$fixup_msg" \ 601${gpg_sign_opt:+"$gpg_sign_opt"}|| 602 die_failed_squash $sha1"$rest" 603else 604cp"$squash_msg""$GIT_DIR"/SQUASH_MSG ||exit 605rm-f"$GIT_DIR"/MERGE_MSG 606 do_with_author git commit --amend --no-verify -F"$GIT_DIR"/SQUASH_MSG -e \ 607${gpg_sign_opt:+"$gpg_sign_opt"}|| 608 die_failed_squash $sha1"$rest" 609fi 610rm-f"$squash_msg""$fixup_msg" 611;; 612esac 613 record_in_rewritten $sha1 614;; 615 x|"exec") 616read -r command rest <"$todo" 617 mark_action_done 618 eval_gettextln "Executing: \$rest" 619"${SHELL:-@SHELL_PATH@}"-c"$rest"# Actual execution 620 status=$? 621# Run in subshell because require_clean_work_tree can die. 622 dirty=f 623(require_clean_work_tree "rebase"2>/dev/null) || dirty=t 624iftest"$status"-ne0 625then 626 warn "$(eval_gettext "Execution failed: \$rest")" 627test"$dirty"= f || 628 warn "$(gettext "and made changes to the index and/or the working tree")" 629 630 warn "$(gettext "\ 631You can fix the problem, and then run 632 633 git rebase --continue")" 634 warn 635iftest$status-eq127# command not found 636then 637 status=1 638fi 639exit"$status" 640eliftest"$dirty"= t 641then 642# TRANSLATORS: after these lines is a command to be issued by the user 643 warn "$(eval_gettext "\ 644Execution succeeded: \$rest 645but left changes to the index and/or the working tree 646Commit or stash your changes, and then run 647 648 git rebase --continue")" 649 warn 650exit1 651fi 652;; 653*) 654 warn "$(eval_gettext "Unknown command: \$command \$sha1 \$rest")" 655 fixtodo="$(gettext "Please fix this using 'git rebase --edit-todo'.")" 656if git rev-parse --verify -q"$sha1">/dev/null 657then 658 die_with_patch $sha1"$fixtodo" 659else 660 die "$fixtodo" 661fi 662;; 663esac 664test -s"$todo"&&return 665 666 comment_for_reflog finish && 667 newhead=$(git rev-parse HEAD)&& 668case$head_namein 669 refs/*) 670 message="$GIT_REFLOG_ACTION:$head_nameonto$onto"&& 671 git update-ref -m"$message"$head_name $newhead $orig_head&& 672 git symbolic-ref \ 673-m"$GIT_REFLOG_ACTION: returning to$head_name" \ 674 HEAD $head_name 675;; 676esac&& { 677test!-f"$state_dir"/verbose || 678 git diff-tree --stat$orig_head..HEAD 679} && 680{ 681test -s"$rewritten_list"&& 682 git notes copy --for-rewrite=rebase <"$rewritten_list"|| 683 true # we don't care if this copying failed 684} && 685 hook="$(git rev-parse --git-path hooks/post-rewrite)" 686iftest -x"$hook"&&test -s"$rewritten_list";then 687"$hook" rebase <"$rewritten_list" 688 true # we don't care if this hook failed 689fi&& 690 warn "$(eval_gettext "Successfully rebased and updated \$head_name.")" 691 692return1# not failure; just to break the do_rest loop 693} 694 695# can only return 0, when the infinite loop breaks 696do_rest () { 697while: 698do 699 do_next ||break 700done 701} 702 703# skip picking commits whose parents are unchanged 704skip_unnecessary_picks () { 705 fd=3 706whileread -r command rest 707do 708# fd=3 means we skip the command 709case"$fd,$command"in 7103,pick|3,p) 711# pick a commit whose parent is current $onto -> skip 712 sha1=${rest%% *} 713case"$(git rev-parse --verify --quiet "$sha1"^)"in 714"$onto"*) 715 onto=$sha1 716;; 717*) 718 fd=1 719;; 720esac 721;; 7223,"$comment_char"*|3,) 723# copy comments 724;; 725*) 726 fd=1 727;; 728esac 729printf'%s\n'"$command${rest:+ }$rest">&$fd 730done<"$todo">"$todo.new"3>>"$done"&& 731mv-f"$todo".new "$todo"&& 732case"$(peek_next_command)"in 733 squash|s|fixup|f) 734 record_in_rewritten "$onto" 735;; 736esac|| 737 die "$(gettext "Could not skip unnecessary pick commands")" 738} 739 740transform_todo_ids () { 741whileread -r command rest 742do 743case"$command"in 744"$comment_char"* |exec) 745# Be careful for oddball commands like 'exec' 746# that do not have a SHA-1 at the beginning of $rest. 747;; 748*) 749 sha1=$(git rev-parse --verify --quiet "$@" ${rest%%[ ]*})&& 750 rest="$sha1${rest#*[ ]}" 751;; 752esac 753printf'%s\n'"$command${rest:+ }$rest" 754done<"$todo">"$todo.new"&& 755mv-f"$todo.new""$todo" 756} 757 758expand_todo_ids() { 759 transform_todo_ids 760} 761 762collapse_todo_ids() { 763 transform_todo_ids --short 764} 765 766# Rearrange the todo list that has both "pick sha1 msg" and 767# "pick sha1 fixup!/squash! msg" appears in it so that the latter 768# comes immediately after the former, and change "pick" to 769# "fixup"/"squash". 770# 771# Note that if the config has specified a custom instruction format 772# each log message will be re-retrieved in order to normalize the 773# autosquash arrangement 774rearrange_squash () { 775# extract fixup!/squash! lines and resolve any referenced sha1's 776whileread -r pick sha1 message 777do 778test -z"${format}"|| message=$(git log -n 1 --format="%s" ${sha1}) 779case"$message"in 780"squash! "*|"fixup! "*) 781 action="${message%%!*}" 782 rest=$message 783 prefix= 784# skip all squash! or fixup! (but save for later) 785while: 786do 787case"$rest"in 788"squash! "*|"fixup! "*) 789 prefix="$prefix${rest%%!*}," 790 rest="${rest#*! }" 791;; 792*) 793break 794;; 795esac 796done 797printf'%s %s %s %s\n'"$sha1""$action""$prefix""$rest" 798# if it's a single word, try to resolve to a full sha1 and 799# emit a second copy. This allows us to match on both message 800# and on sha1 prefix 801iftest"${rest#* }"="$rest";then 802 fullsha="$(git rev-parse -q --verify "$rest" 2>/dev/null)" 803iftest -n"$fullsha";then 804# prefix the action to uniquely identify this line as 805# intended for full sha1 match 806echo"$sha1+$action$prefix$fullsha" 807fi 808fi 809esac 810done>"$1.sq"<"$1" 811test -s"$1.sq"||return 812 813 used= 814whileread -r pick sha1 message 815do 816case"$used"in 817*"$sha1"*)continue;; 818esac 819printf'%s\n'"$pick$sha1$message" 820test -z"${format}"|| message=$(git log -n 1 --format="%s" ${sha1}) 821 used="$used$sha1" 822whileread -r squash action msg_prefix msg_content 823do 824case"$used"in 825*"$squash"*)continue;; 826esac 827 emit=0 828case"$action"in 829+*) 830 action="${action#+}" 831# full sha1 prefix test 832case"$msg_content"in"$sha1"*) emit=1;;esac;; 833*) 834# message prefix test 835case"$message"in"$msg_content"*) emit=1;;esac;; 836esac 837iftest$emit=1;then 838iftest -n"${format}" 839then 840 msg_content=$(git log -n 1 --format="${format}" ${squash}) 841else 842 msg_content="$(echo "$msg_prefix" | sed "s/,/! /g")$msg_content" 843fi 844printf'%s\n'"$action$squash$msg_content" 845 used="$used$squash" 846fi 847done<"$1.sq" 848done>"$1.rearranged"<"$1" 849cat"$1.rearranged">"$1" 850rm-f"$1.sq""$1.rearranged" 851} 852 853# Add commands after a pick or after a squash/fixup serie 854# in the todo list. 855add_exec_commands () { 856{ 857 first=t 858whileread -r insn rest 859do 860case$insnin 861 pick) 862test -n"$first"|| 863printf"%s""$cmd" 864;; 865esac 866printf"%s %s\n""$insn""$rest" 867 first= 868done 869printf"%s""$cmd" 870} <"$1">"$1.new"&& 871mv"$1.new""$1" 872} 873 874# Check if the SHA-1 passed as an argument is a 875# correct one, if not then print $2 in "$todo".badsha 876# $1: the SHA-1 to test 877# $2: the line number of the input 878# $3: the input filename 879check_commit_sha () { 880 badsha=0 881iftest -z"$1" 882then 883 badsha=1 884else 885 sha1_verif="$(git rev-parse --verify --quiet $1^{commit})" 886iftest -z"$sha1_verif" 887then 888 badsha=1 889fi 890fi 891 892iftest$badsha-ne0 893then 894 line="$(sed -n -e "${2}p" "$3")" 895 warn "$(eval_gettext "\ 896Warning: the SHA-1 is missing or isn't a commit in the following line: 897 - \$line")" 898 warn 899 fi 900 901 return$badsha 902} 903 904# prints the bad commits and bad commands 905# from the todolist in stdin 906check_bad_cmd_and_sha () { 907 retval=0 908 lineno=0 909 while read -r command rest 910 do 911 lineno=$(( $lineno + 1 )) 912 case$commandin 913 "$comment_char"*|''|noop|x|exec) 914 # Doesn't expect a SHA-1 915;; 916"$cr") 917# Work around CR left by "read" (e.g. with Git for 918# Windows' Bash). 919;; 920 pick|p|drop|d|reword|r|edit|e|squash|s|fixup|f) 921if! check_commit_sha "${rest%%[ ]*}""$lineno""$1" 922then 923 retval=1 924fi 925;; 926*) 927 line="$(sed -n -e "${lineno}p" "$1")" 928 warn "$(eval_gettext "\ 929Warning: the command isn't recognized in the following line: 930 - \$line")" 931 warn 932 retval=1 933 ;; 934 esac 935 done <"$1" 936 return$retval 937} 938 939# Print the list of the SHA-1 of the commits 940# from stdin to stdout 941todo_list_to_sha_list () { 942 git stripspace --strip-comments | 943 while read -r command sha1 rest 944 do 945 case$commandin 946 "$comment_char"*|''|noop|x|"exec") 947 ;; 948 *) 949 long_sha=$(git rev-list --no-walk "$sha1" 2>/dev/null) 950 printf "%s\n" "$long_sha" 951 ;; 952 esac 953 done 954} 955 956# Use warn for each line in stdin 957warn_lines () { 958 while read -r line 959 do 960 warn " -$line" 961 done 962} 963 964# Switch to the branch in$intoand notify it in the reflog 965checkout_onto () { 966 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout$onto_name" 967 output git checkout$onto|| die_abort "$(gettext "could not detach HEAD")" 968 git update-ref ORIG_HEAD$orig_head 969} 970 971get_missing_commit_check_level () { 972 check_level=$(git config --get rebase.missingCommitsCheck) 973 check_level=${check_level:-ignore} 974 # Don't be case sensitive 975printf'%s'"$check_level"|tr'A-Z''a-z' 976} 977 978# Check if the user dropped some commits by mistake 979# Behaviour determined by rebase.missingCommitsCheck. 980# Check if there is an unrecognized command or a 981# bad SHA-1 in a command. 982check_todo_list () { 983 raise_error=f 984 985 check_level=$(get_missing_commit_check_level) 986 987case"$check_level"in 988 warn|error) 989# Get the SHA-1 of the commits 990 todo_list_to_sha_list <"$todo".backup >"$todo".oldsha1 991 todo_list_to_sha_list <"$todo">"$todo".newsha1 992 993# Sort the SHA-1 and compare them 994sort-u"$todo".oldsha1 >"$todo".oldsha1+ 995mv"$todo".oldsha1+"$todo".oldsha1 996sort-u"$todo".newsha1 >"$todo".newsha1+ 997mv"$todo".newsha1+"$todo".newsha1 998comm-2 -3"$todo".oldsha1 "$todo".newsha1 >"$todo".miss 9991000# Warn about missing commits1001iftest -s"$todo".miss1002then1003test"$check_level"= error && raise_error=t10041005 warn "$(gettext "\1006Warning: some commits may have been dropped accidentally.1007Dropped commits (newer to older):")"10081009# Make the list user-friendly and display1010 opt="--no-walk=sorted --format=oneline --abbrev-commit --stdin"1011 git rev-list$opt<"$todo".miss | warn_lines10121013 warn "$(gettext "\1014To avoid this message, use \"drop\" to explicitly remove a commit.10151016Use 'git config rebase.missingCommitsCheck' to change the level of warnings.1017The possible behaviours are: ignore, warn, error.")"1018 warn1019fi1020;;1021 ignore)1022;;1023*)1024 warn "$(eval_gettext "Unrecognized setting \$check_level for option rebase.missingCommitsCheck. Ignoring.")"1025;;1026esac10271028if! check_bad_cmd_and_sha "$todo"1029then1030 raise_error=t1031fi10321033iftest$raise_error= t1034then1035# Checkout before the first commit of the1036# rebase: this way git rebase --continue1037# will work correctly as it expects HEAD to be1038# placed before the commit of the next action1039 checkout_onto10401041 warn "$(gettext "You can fix this with 'git rebase --edit-todo'.")"1042 die "$(gettext "Or you can abort the rebase with 'git rebase --abort'.")"1043fi1044}10451046# The whole contents of this file is run by dot-sourcing it from1047# inside a shell function. It used to be that "return"s we see1048# below were not inside any function, and expected to return1049# to the function that dot-sourced us.1050#1051# However, FreeBSD /bin/sh misbehaves on such a construct and1052# continues to run the statements that follow such a "return".1053# As a work-around, we introduce an extra layer of a function1054# here, and immediately call it after defining it.1055git_rebase__interactive () {10561057case"$action"in1058continue)1059# do we have anything to commit?1060if git diff-index --cached --quiet HEAD --1061then1062# Nothing to commit -- skip this commit10631064test!-f"$GIT_DIR"/CHERRY_PICK_HEAD ||1065rm"$GIT_DIR"/CHERRY_PICK_HEAD ||1066 die "$(gettext "Could not remove CHERRY_PICK_HEAD")"1067else1068if!test -f"$author_script"1069then1070 gpg_sign_opt_quoted=${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")}1071 die "$(eval_gettext "\1072You have staged changes in your working tree.1073If these changes are meant to be1074squashed into the previous commit, run:10751076 git commit --amend \$gpg_sign_opt_quoted10771078If they are meant to go into a new commit, run:10791080 git commit \$gpg_sign_opt_quoted10811082In both case, once you're done, continue with:10831084 git rebase --continue1085")"1086 fi1087 . "$author_script" ||1088 die "$(gettext "Error trying to find the author identity to amend commit")"1089 if test -f "$amend"1090 then1091 current_head=$(git rev-parse --verify HEAD)1092 test "$current_head" =$(cat "$amend")||1093 die "$(gettext "\1094You have uncommitted changes in your working tree. Please commit them1095first and then run 'git rebase --continue' again.")"1096 do_with_author git commit --amend --no-verify -F "$msg" -e \1097${gpg_sign_opt:+"$gpg_sign_opt"}||1098 die "$(gettext "Could not commit staged changes.")"1099 else1100 do_with_author git commit --no-verify -F "$msg" -e \1101${gpg_sign_opt:+"$gpg_sign_opt"}||1102 die "$(gettext "Could not commit staged changes.")"1103 fi1104 fi11051106 if test -r "$state_dir"/stopped-sha1107 then1108 record_in_rewritten "$(cat "$state_dir"/stopped-sha)"1109 fi11101111 require_clean_work_tree "rebase"1112 do_rest1113 return 01114 ;;1115skip)1116 git rerere clear11171118 do_rest1119 return 01120 ;;1121edit-todo)1122 git stripspace --strip-comments <"$todo" >"$todo".new1123 mv -f "$todo".new "$todo"1124 collapse_todo_ids1125 append_todo_help1126 git stripspace --comment-lines >>"$todo" <<\EOF11271128You are editing the todo file of an ongoing interactive rebase.1129To continue rebase after editing, run:1130 git rebase --continue11311132EOF11331134 git_sequence_editor "$todo" ||1135 die "$(gettext "Could not execute editor")"1136 expand_todo_ids11371138 exit1139 ;;1140esac11411142git var GIT_COMMITTER_IDENT >/dev/null ||1143 die "$(gettext "You need to set your committer info first")"11441145comment_for_reflog start11461147if test ! -z "$switch_to"1148then1149 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout$switch_to"1150 output git checkout "$switch_to" -- ||1151 die "$(eval_gettext "Could not checkout \$switch_to")"11521153 comment_for_reflog start1154fi11551156orig_head=$(git rev-parse --verify HEAD)|| die "$(gettext "No HEAD?")"1157mkdir -p "$state_dir" || die "$(eval_gettext "Could not create temporary \$state_dir")"11581159: > "$state_dir"/interactive || die "$(gettext "Could not mark as interactive")"1160write_basic_state1161if test t = "$preserve_merges"1162then1163 if test -z "$rebase_root"1164 then1165 mkdir "$rewritten" &&1166 for c in$(git merge-base --all $orig_head $upstream)1167 do1168 echo$onto> "$rewritten"/$c||1169 die "$(gettext "Could not init rewritten commits")"1170 done1171 else1172 mkdir "$rewritten" &&1173 echo$onto> "$rewritten"/root ||1174 die "$(gettext "Could not init rewritten commits")"1175 fi1176 # No cherry-pick because our first pass is to determine1177 # parents to rewrite and skipping dropped commits would1178 # prematurely end our probe1179 merges_option=1180else1181 merges_option="--no-merges --cherry-pick"1182fi11831184shorthead=$(git rev-parse --short $orig_head)1185shortonto=$(git rev-parse --short $onto)1186if test -z "$rebase_root"1187 # this is now equivalent to ! -z "$upstream"1188then1189 shortupstream=$(git rev-parse --short $upstream)1190 revisions=$upstream...$orig_head1191 shortrevisions=$shortupstream..$shorthead1192else1193 revisions=$onto...$orig_head1194 shortrevisions=$shorthead1195fi1196format=$(git config --get rebase.instructionFormat)1197# the 'rev-list .. |sed' requires %m to parse; the instruction requires %H to parse1198git rev-list$merges_option--format="%m%H${format:-%s}" \1199 --reverse --left-right --topo-order \1200$revisions${restrict_revision+^$restrict_revision}| \1201 sed -n "s/^>//p" |1202while read -r sha1 rest1203do12041205 if test -z "$keep_empty" && is_empty_commit$sha1&& ! is_merge_commit$sha11206 then1207 comment_out="$comment_char"1208 else1209 comment_out=1210 fi12111212 if test t != "$preserve_merges"1213 then1214 printf '%s\n' "${comment_out}pick$sha1$rest" >>"$todo"1215 else1216 if test -z "$rebase_root"1217 then1218 preserve=t1219 for p in$(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-)1220 do1221 if test -f "$rewritten"/$p1222 then1223 preserve=f1224 fi1225 done1226 else1227 preserve=f1228 fi1229 if test f = "$preserve"1230 then1231 touch "$rewritten"/$sha11232 printf '%s\n' "${comment_out}pick$sha1$rest" >>"$todo"1233 fi1234 fi1235done12361237# Watch for commits that been dropped by --cherry-pick1238if test t = "$preserve_merges"1239then1240 mkdir "$dropped"1241 # Save all non-cherry-picked changes1242 git rev-list$revisions--left-right --cherry-pick | \1243 sed -n "s/^>//p" > "$state_dir"/not-cherry-picks1244 # Now all commits and note which ones are missing in1245 # not-cherry-picks and hence being dropped1246 git rev-list$revisions|1247 while read rev1248 do1249 if test -f "$rewritten"/$rev&&1250 ! sane_grep "$rev" "$state_dir"/not-cherry-picks >/dev/null1251 then1252 # Use -f2 because if rev-list is telling us this commit is1253 # not worthwhile, we don't want to track its multiple heads,1254# just the history of its first-parent for others that will1255# be rebasing on top of it1256 git rev-list --parents -1$rev| cut -d' '-s -f2>"$dropped"/$rev1257 sha1=$(git rev-list -1 $rev)1258 sane_grep -v"^[a-z][a-z]*$sha1"<"$todo">"${todo}2";mv"${todo}2""$todo"1259rm"$rewritten"/$rev1260fi1261done1262fi12631264test -s"$todo"||echo noop >>"$todo"1265test -n"$autosquash"&& rearrange_squash "$todo"1266test -n"$cmd"&& add_exec_commands "$todo"12671268todocount=$(git stripspace --strip-comments <"$todo" | wc -l)1269todocount=${todocount##* }12701271cat>>"$todo"<<EOF12721273$comment_charRebase$shortrevisionsonto$shortonto($todocountcommand(s))1274EOF1275append_todo_help1276git stripspace --comment-lines>>"$todo"<<\EOF12771278However,if you remove everything, the rebase will be aborted.12791280EOF12811282iftest -z"$keep_empty"1283then1284printf'%s\n'"$comment_char$(gettext "Note that empty commits are commented out")">>"$todo"1285fi128612871288has_action "$todo"||1289return212901291cp"$todo""$todo".backup1292collapse_todo_ids1293git_sequence_editor "$todo"||1294 die_abort "$(gettext "Could not execute editor")"12951296has_action "$todo"||1297return212981299check_todo_list13001301expand_todo_ids13021303test -d"$rewritten"||test -n"$force_rebase"|| skip_unnecessary_picks13041305checkout_onto1306do_rest13071308}1309# ... and then we call the whole thing.1310git_rebase__interactive