git-rebase--interactive.shon commit Merge branch 'rs/submodule-config-code-cleanup' (f4fa8a9)
   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 () {
 100        printf '%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 () {
 111        case "$orig_reflog_action" in
 112        ''|rebase*)
 113                GIT_REFLOG_ACTION="rebase -i ($1)"
 114                export GIT_REFLOG_ACTION
 115                ;;
 116        esac
 117}
 118
 119last_count=
 120mark_action_done () {
 121        sed -e 1q < "$todo" >> "$done"
 122        sed -e 1d < "$todo" >> "$todo".new
 123        mv -f "$todo".new "$todo"
 124        new_count=$(git stripspace --strip-comments <"$done" | wc -l)
 125        echo $new_count >"$msgnum"
 126        total=$(($new_count + $(git stripspace --strip-comments <"$todo" | wc -l)))
 127        echo $total >"$end"
 128        if test "$last_count" != "$new_count"
 129        then
 130                last_count=$new_count
 131                eval_gettext "Rebasing (\$new_count/\$total)"; printf "\r"
 132                test -z "$verbose" || echo
 133        fi
 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 () {
 140        tail -n 1 "$done" | cat - "$todo" >"$todo".new
 141        sed -e \$d <"$done" >"$done".new
 142        mv -f "$todo".new "$todo"
 143        mv -f "$done".new "$done"
 144}
 145
 146append_todo_help () {
 147        gettext "
 148Commands:
 149 p, pick = use commit
 150 r, reword = use commit, but edit the commit message
 151 e, edit = use commit, but stop for amending
 152 s, squash = use commit, but meld into previous commit
 153 f, fixup = like \"squash\", but discard this commit's log message
 154 x, exec = run command (the rest of the line) using shell
 155 d, drop = remove commit
 156
 157These lines can be re-ordered; they are executed from top to bottom.
 158" | git stripspace --comment-lines >>"$todo"
 159
 160        if test $(get_missing_commit_check_level) = error
 161        then
 162                gettext "
 163Do not remove any line. Use 'drop' explicitly to remove a commit.
 164" | git stripspace --comment-lines >>"$todo"
 165        else
 166                gettext "
 167If you remove a line here THAT COMMIT WILL BE LOST.
 168" | git stripspace --comment-lines >>"$todo"
 169        fi
 170}
 171
 172make_patch () {
 173        sha1_and_parents="$(git rev-list --parents -1 "$1")"
 174        case "$sha1_and_parents" in
 175        ?*' '?*' '?*)
 176                git diff --cc $sha1_and_parents
 177                ;;
 178        ?*' '?*)
 179                git diff-tree -p "$1^!"
 180                ;;
 181        *)
 182                echo "Root commit"
 183                ;;
 184        esac > "$state_dir"/patch
 185        test -f "$msg" ||
 186                commit_message "$1" > "$msg"
 187        test -f "$author_script" ||
 188                get_author_ident_from_commit "$1" > "$author_script"
 189}
 190
 191die_with_patch () {
 192        echo "$1" > "$state_dir"/stopped-sha
 193        make_patch "$1"
 194        die "$2"
 195}
 196
 197exit_with_patch () {
 198        echo "$1" > "$state_dir"/stopped-sha
 199        make_patch $1
 200        git rev-parse --verify HEAD > "$amend"
 201        gpg_sign_opt_quoted=${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")}
 202        warn "$(eval_gettext "\
 203You can amend the commit now, with
 204
 205        git commit --amend \$gpg_sign_opt_quoted
 206
 207Once you are satisfied with your changes, run
 208
 209        git rebase --continue")"
 210        warn
 211        exit $2
 212}
 213
 214die_abort () {
 215        apply_autostash
 216        rm -rf "$state_dir"
 217        die "$1"
 218}
 219
 220has_action () {
 221        test -n "$(git stripspace --strip-comments <"$1")"
 222}
 223
 224is_empty_commit() {
 225        tree=$(git rev-parse -q --verify "$1"^{tree} 2>/dev/null) || {
 226                sha1=$1
 227                die "$(eval_gettext "\$sha1: not a commit that can be picked")"
 228        }
 229        ptree=$(git rev-parse -q --verify "$1"^^{tree} 2>/dev/null) ||
 230                ptree=4b825dc642cb6eb9a060e54bf8d69288fbee4904
 231        test "$tree" = "$ptree"
 232}
 233
 234is_merge_commit()
 235{
 236        git rev-parse --verify --quiet "$1"^2 >/dev/null 2>&1
 237}
 238
 239# Run command with GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
 240# GIT_AUTHOR_DATE exported from the current environment.
 241do_with_author () {
 242        (
 243                export GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL GIT_AUTHOR_DATE
 244                "$@"
 245        )
 246}
 247
 248git_sequence_editor () {
 249        if test -z "$GIT_SEQUENCE_EDITOR"
 250        then
 251                GIT_SEQUENCE_EDITOR="$(git config sequence.editor)"
 252                if [ -z "$GIT_SEQUENCE_EDITOR" ]
 253                then
 254                        GIT_SEQUENCE_EDITOR="$(git var GIT_EDITOR)" || return $?
 255                fi
 256        fi
 257
 258        eval "$GIT_SEQUENCE_EDITOR" '"$@"'
 259}
 260
 261pick_one () {
 262        ff=--ff
 263
 264        case "$1" in -n) sha1=$2; ff= ;; *) sha1=$1 ;; esac
 265        case "$force_rebase" in '') ;; ?*) ff= ;; esac
 266        output git rev-parse --verify $sha1 || die "$(eval_gettext "Invalid commit name: \$sha1")"
 267
 268        if is_empty_commit "$sha1"
 269        then
 270                empty_args="--allow-empty"
 271        fi
 272
 273        test -d "$rewritten" &&
 274                pick_one_preserving_merges "$@" && return
 275        output eval git cherry-pick \
 276                        ${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")} \
 277                        "$strategy_args" $empty_args $ff "$@"
 278
 279        # If cherry-pick dies it leaves the to-be-picked commit unrecorded. Reschedule
 280        # previous task so this commit is not lost.
 281        ret=$?
 282        case "$ret" in [01]) ;; *) reschedule_last_action ;; esac
 283        return $ret
 284}
 285
 286pick_one_preserving_merges () {
 287        fast_forward=t
 288        case "$1" in
 289        -n)
 290                fast_forward=f
 291                sha1=$2
 292                ;;
 293        *)
 294                sha1=$1
 295                ;;
 296        esac
 297        sha1=$(git rev-parse $sha1)
 298
 299        if test -f "$state_dir"/current-commit
 300        then
 301                if test "$fast_forward" = t
 302                then
 303                        while read current_commit
 304                        do
 305                                git rev-parse HEAD > "$rewritten"/$current_commit
 306                        done <"$state_dir"/current-commit
 307                        rm "$state_dir"/current-commit ||
 308                                die "$(gettext "Cannot write current commit's replacement sha1")"
 309                fi
 310        fi
 311
 312        echo $sha1 >> "$state_dir"/current-commit
 313
 314        # rewrite parents; if none were rewritten, we can fast-forward.
 315        new_parents=
 316        pend=" $(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-)"
 317        if test "$pend" = " "
 318        then
 319                pend=" root"
 320        fi
 321        while [ "$pend" != "" ]
 322        do
 323                p=$(expr "$pend" : ' \([^ ]*\)')
 324                pend="${pend# $p}"
 325
 326                if test -f "$rewritten"/$p
 327                then
 328                        new_p=$(cat "$rewritten"/$p)
 329
 330                        # If the todo reordered commits, and our parent is marked for
 331                        # rewriting, but hasn't been gotten to yet, assume the user meant to
 332                        # drop it on top of the current HEAD
 333                        if test -z "$new_p"
 334                        then
 335                                new_p=$(git rev-parse HEAD)
 336                        fi
 337
 338                        test $p != $new_p && fast_forward=f
 339                        case "$new_parents" in
 340                        *$new_p*)
 341                                ;; # do nothing; that parent is already there
 342                        *)
 343                                new_parents="$new_parents $new_p"
 344                                ;;
 345                        esac
 346                else
 347                        if test -f "$dropped"/$p
 348                        then
 349                                fast_forward=f
 350                                replacement="$(cat "$dropped"/$p)"
 351                                test -z "$replacement" && replacement=root
 352                                pend=" $replacement$pend"
 353                        else
 354                                new_parents="$new_parents $p"
 355                        fi
 356                fi
 357        done
 358        case $fast_forward in
 359        t)
 360                output warn "$(eval_gettext "Fast-forward to \$sha1")"
 361                output git reset --hard $sha1 ||
 362                        die "$(eval_gettext "Cannot fast-forward to \$sha1")"
 363                ;;
 364        f)
 365                first_parent=$(expr "$new_parents" : ' \([^ ]*\)')
 366
 367                if [ "$1" != "-n" ]
 368                then
 369                        # detach HEAD to current parent
 370                        output git checkout $first_parent 2> /dev/null ||
 371                                die "$(eval_gettext "Cannot move HEAD to \$first_parent")"
 372                fi
 373
 374                case "$new_parents" in
 375                ' '*' '*)
 376                        test "a$1" = a-n && die "$(eval_gettext "Refusing to squash a merge: \$sha1")"
 377
 378                        # redo merge
 379                        author_script_content=$(get_author_ident_from_commit $sha1)
 380                        eval "$author_script_content"
 381                        msg_content="$(commit_message $sha1)"
 382                        # No point in merging the first parent, that's HEAD
 383                        new_parents=${new_parents# $first_parent}
 384                        merge_args="--no-log --no-ff"
 385                        if ! do_with_author output eval \
 386                        'git merge ${gpg_sign_opt:+"$gpg_sign_opt"} \
 387                                $merge_args $strategy_args -m "$msg_content" $new_parents'
 388                        then
 389                                printf "%s\n" "$msg_content" > "$GIT_DIR"/MERGE_MSG
 390                                die_with_patch $sha1 "$(eval_gettext "Error redoing merge \$sha1")"
 391                        fi
 392                        echo "$sha1 $(git rev-parse HEAD^0)" >> "$rewritten_list"
 393                        ;;
 394                *)
 395                        output eval git cherry-pick \
 396                                ${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")} \
 397                                "$strategy_args" "$@" ||
 398                                die_with_patch $sha1 "$(eval_gettext "Could not pick \$sha1")"
 399                        ;;
 400                esac
 401                ;;
 402        esac
 403}
 404
 405this_nth_commit_message () {
 406        n=$1
 407        case "$n" in
 408        1) gettext "This is the 1st commit message:";;
 409        2) gettext "This is the 2nd commit message:";;
 410        3) gettext "This is the 3rd commit message:";;
 411        4) gettext "This is the 4th commit message:";;
 412        5) gettext "This is the 5th commit message:";;
 413        6) gettext "This is the 6th commit message:";;
 414        7) gettext "This is the 7th commit message:";;
 415        8) gettext "This is the 8th commit message:";;
 416        9) gettext "This is the 9th commit message:";;
 417        10) gettext "This is the 10th commit message:";;
 418        # TRANSLATORS: if the language you are translating into
 419        # doesn't allow you to compose a sentence in this fashion,
 420        # consider translating as if this and the following few strings
 421        # were "This is the commit message ${n}:"
 422        *1[0-9]|*[04-9]) eval_gettext "This is the \${n}th commit message:";;
 423        *1) eval_gettext "This is the \${n}st commit message:";;
 424        *2) eval_gettext "This is the \${n}nd commit message:";;
 425        *3) eval_gettext "This is the \${n}rd commit message:";;
 426        *) eval_gettext "This is the commit message \${n}:";;
 427        esac
 428}
 429skip_nth_commit_message () {
 430        n=$1
 431        case "$n" in
 432        1) gettext "The 1st commit message will be skipped:";;
 433        2) gettext "The 2nd commit message will be skipped:";;
 434        3) gettext "The 3rd commit message will be skipped:";;
 435        4) gettext "The 4th commit message will be skipped:";;
 436        5) gettext "The 5th commit message will be skipped:";;
 437        6) gettext "The 6th commit message will be skipped:";;
 438        7) gettext "The 7th commit message will be skipped:";;
 439        8) gettext "The 8th commit message will be skipped:";;
 440        9) gettext "The 9th commit message will be skipped:";;
 441        10) gettext "The 10th commit message will be skipped:";;
 442        # TRANSLATORS: if the language you are translating into
 443        # doesn't allow you to compose a sentence in this fashion,
 444        # consider translating as if this and the following few strings
 445        # were "The commit message ${n} will be skipped:"
 446        *1[0-9]|*[04-9]) eval_gettext "The \${n}th commit message will be skipped:";;
 447        *1) eval_gettext "The \${n}st commit message will be skipped:";;
 448        *2) eval_gettext "The \${n}nd commit message will be skipped:";;
 449        *3) eval_gettext "The \${n}rd commit message will be skipped:";;
 450        *) eval_gettext "The commit message \${n} will be skipped:";;
 451        esac
 452}
 453
 454update_squash_messages () {
 455        if test -f "$squash_msg"; then
 456                mv "$squash_msg" "$squash_msg".bak || exit
 457                count=$(($(sed -n \
 458                        -e "1s/^$comment_char.*\([0-9][0-9]*\).*/\1/p" \
 459                        -e "q" < "$squash_msg".bak)+1))
 460                {
 461                        printf '%s\n' "$comment_char $(eval_ngettext \
 462                                "This is a combination of \$count commit." \
 463                                "This is a combination of \$count commits." \
 464                                $count)"
 465                        sed -e 1d -e '2,/^./{
 466                                /^$/d
 467                        }' <"$squash_msg".bak
 468                } >"$squash_msg"
 469        else
 470                commit_message HEAD > "$fixup_msg" || die "$(gettext "Cannot write \$fixup_msg")"
 471                count=2
 472                {
 473                        printf '%s\n' "$comment_char $(gettext "This is a combination of 2 commits.")"
 474                        printf '%s\n' "$comment_char $(gettext "This is the 1st commit message:")"
 475                        echo
 476                        cat "$fixup_msg"
 477                } >"$squash_msg"
 478        fi
 479        case $1 in
 480        squash)
 481                rm -f "$fixup_msg"
 482                echo
 483                printf '%s\n' "$comment_char $(this_nth_commit_message $count)"
 484                echo
 485                commit_message $2
 486                ;;
 487        fixup)
 488                echo
 489                printf '%s\n' "$comment_char $(skip_nth_commit_message $count)"
 490                echo
 491                # Change the space after the comment character to TAB:
 492                commit_message $2 | git stripspace --comment-lines | sed -e 's/ /       /'
 493                ;;
 494        esac >>"$squash_msg"
 495}
 496
 497peek_next_command () {
 498        git stripspace --strip-comments <"$todo" | sed -n -e 's/ .*//p' -e q
 499}
 500
 501# A squash/fixup has failed.  Prepare the long version of the squash
 502# commit message, then die_with_patch.  This code path requires the
 503# user to edit the combined commit message for all commits that have
 504# been squashed/fixedup so far.  So also erase the old squash
 505# messages, effectively causing the combined commit to be used as the
 506# new basis for any further squash/fixups.  Args: sha1 rest
 507die_failed_squash() {
 508        sha1=$1
 509        rest=$2
 510        mv "$squash_msg" "$msg" || exit
 511        rm -f "$fixup_msg"
 512        cp "$msg" "$GIT_DIR"/MERGE_MSG || exit
 513        warn
 514        warn "$(eval_gettext "Could not apply \$sha1... \$rest")"
 515        die_with_patch $sha1 ""
 516}
 517
 518flush_rewritten_pending() {
 519        test -s "$rewritten_pending" || return
 520        newsha1="$(git rev-parse HEAD^0)"
 521        sed "s/$/ $newsha1/" < "$rewritten_pending" >> "$rewritten_list"
 522        rm -f "$rewritten_pending"
 523}
 524
 525record_in_rewritten() {
 526        oldsha1="$(git rev-parse $1)"
 527        echo "$oldsha1" >> "$rewritten_pending"
 528
 529        case "$(peek_next_command)" in
 530        squash|s|fixup|f)
 531                ;;
 532        *)
 533                flush_rewritten_pending
 534                ;;
 535        esac
 536}
 537
 538do_pick () {
 539        sha1=$1
 540        rest=$2
 541        if test "$(git rev-parse HEAD)" = "$squash_onto"
 542        then
 543                # Set the correct commit message and author info on the
 544                # sentinel root before cherry-picking the original changes
 545                # without committing (-n).  Finally, update the sentinel again
 546                # to include these changes.  If the cherry-pick results in a
 547                # conflict, this means our behaviour is similar to a standard
 548                # failed cherry-pick during rebase, with a dirty index to
 549                # resolve before manually running git commit --amend then git
 550                # rebase --continue.
 551                git commit --allow-empty --allow-empty-message --amend \
 552                           --no-post-rewrite -n -q -C $sha1 &&
 553                        pick_one -n $sha1 &&
 554                        git commit --allow-empty --allow-empty-message \
 555                                   --amend --no-post-rewrite -n -q -C $sha1 \
 556                                   ${gpg_sign_opt:+"$gpg_sign_opt"} ||
 557                                   die_with_patch $sha1 "$(eval_gettext "Could not apply \$sha1... \$rest")"
 558        else
 559                pick_one $sha1 ||
 560                        die_with_patch $sha1 "$(eval_gettext "Could not apply \$sha1... \$rest")"
 561        fi
 562}
 563
 564do_next () {
 565        rm -f "$msg" "$author_script" "$amend" "$state_dir"/stopped-sha || exit
 566        read -r command sha1 rest < "$todo"
 567        case "$command" in
 568        "$comment_char"*|''|noop|drop|d)
 569                mark_action_done
 570                ;;
 571        "$cr")
 572                # Work around CR left by "read" (e.g. with Git for Windows' Bash).
 573                mark_action_done
 574                ;;
 575        pick|p)
 576                comment_for_reflog pick
 577
 578                mark_action_done
 579                do_pick $sha1 "$rest"
 580                record_in_rewritten $sha1
 581                ;;
 582        reword|r)
 583                comment_for_reflog reword
 584
 585                mark_action_done
 586                do_pick $sha1 "$rest"
 587                git commit --amend --no-post-rewrite ${gpg_sign_opt:+"$gpg_sign_opt"} || {
 588                        warn "$(eval_gettext "\
 589Could not amend commit after successfully picking \$sha1... \$rest
 590This is most likely due to an empty commit message, or the pre-commit hook
 591failed. If the pre-commit hook failed, you may need to resolve the issue before
 592you are able to reword the commit.")"
 593                        exit_with_patch $sha1 1
 594                }
 595                record_in_rewritten $sha1
 596                ;;
 597        edit|e)
 598                comment_for_reflog edit
 599
 600                mark_action_done
 601                do_pick $sha1 "$rest"
 602                sha1_abbrev=$(git rev-parse --short $sha1)
 603                warn "$(eval_gettext "Stopped at \$sha1_abbrev... \$rest")"
 604                exit_with_patch $sha1 0
 605                ;;
 606        squash|s|fixup|f)
 607                case "$command" in
 608                squash|s)
 609                        squash_style=squash
 610                        ;;
 611                fixup|f)
 612                        squash_style=fixup
 613                        ;;
 614                esac
 615                comment_for_reflog $squash_style
 616
 617                test -f "$done" && has_action "$done" ||
 618                        die "$(eval_gettext "Cannot '\$squash_style' without a previous commit")"
 619
 620                mark_action_done
 621                update_squash_messages $squash_style $sha1
 622                author_script_content=$(get_author_ident_from_commit HEAD)
 623                echo "$author_script_content" > "$author_script"
 624                eval "$author_script_content"
 625                if ! pick_one -n $sha1
 626                then
 627                        git rev-parse --verify HEAD >"$amend"
 628                        die_failed_squash $sha1 "$rest"
 629                fi
 630                case "$(peek_next_command)" in
 631                squash|s|fixup|f)
 632                        # This is an intermediate commit; its message will only be
 633                        # used in case of trouble.  So use the long version:
 634                        do_with_author output git commit --amend --no-verify -F "$squash_msg" \
 635                                ${gpg_sign_opt:+"$gpg_sign_opt"} ||
 636                                die_failed_squash $sha1 "$rest"
 637                        ;;
 638                *)
 639                        # This is the final command of this squash/fixup group
 640                        if test -f "$fixup_msg"
 641                        then
 642                                do_with_author git commit --amend --no-verify -F "$fixup_msg" \
 643                                        ${gpg_sign_opt:+"$gpg_sign_opt"} ||
 644                                        die_failed_squash $sha1 "$rest"
 645                        else
 646                                cp "$squash_msg" "$GIT_DIR"/SQUASH_MSG || exit
 647                                rm -f "$GIT_DIR"/MERGE_MSG
 648                                do_with_author git commit --amend --no-verify -F "$GIT_DIR"/SQUASH_MSG -e \
 649                                        ${gpg_sign_opt:+"$gpg_sign_opt"} ||
 650                                        die_failed_squash $sha1 "$rest"
 651                        fi
 652                        rm -f "$squash_msg" "$fixup_msg"
 653                        ;;
 654                esac
 655                record_in_rewritten $sha1
 656                ;;
 657        x|"exec")
 658                read -r command rest < "$todo"
 659                mark_action_done
 660                eval_gettextln "Executing: \$rest"
 661                "${SHELL:-@SHELL_PATH@}" -c "$rest" # Actual execution
 662                status=$?
 663                # Run in subshell because require_clean_work_tree can die.
 664                dirty=f
 665                (require_clean_work_tree "rebase" 2>/dev/null) || dirty=t
 666                if test "$status" -ne 0
 667                then
 668                        warn "$(eval_gettext "Execution failed: \$rest")"
 669                        test "$dirty" = f ||
 670                                warn "$(gettext "and made changes to the index and/or the working tree")"
 671
 672                        warn "$(gettext "\
 673You can fix the problem, and then run
 674
 675        git rebase --continue")"
 676                        warn
 677                        if test $status -eq 127         # command not found
 678                        then
 679                                status=1
 680                        fi
 681                        exit "$status"
 682                elif test "$dirty" = t
 683                then
 684                        # TRANSLATORS: after these lines is a command to be issued by the user
 685                        warn "$(eval_gettext "\
 686Execution succeeded: \$rest
 687but left changes to the index and/or the working tree
 688Commit or stash your changes, and then run
 689
 690        git rebase --continue")"
 691                        warn
 692                        exit 1
 693                fi
 694                ;;
 695        *)
 696                warn "$(eval_gettext "Unknown command: \$command \$sha1 \$rest")"
 697                fixtodo="$(gettext "Please fix this using 'git rebase --edit-todo'.")"
 698                if git rev-parse --verify -q "$sha1" >/dev/null
 699                then
 700                        die_with_patch $sha1 "$fixtodo"
 701                else
 702                        die "$fixtodo"
 703                fi
 704                ;;
 705        esac
 706        test -s "$todo" && return
 707
 708        comment_for_reflog finish &&
 709        newhead=$(git rev-parse HEAD) &&
 710        case $head_name in
 711        refs/*)
 712                message="$GIT_REFLOG_ACTION: $head_name onto $onto" &&
 713                git update-ref -m "$message" $head_name $newhead $orig_head &&
 714                git symbolic-ref \
 715                  -m "$GIT_REFLOG_ACTION: returning to $head_name" \
 716                  HEAD $head_name
 717                ;;
 718        esac && {
 719                test ! -f "$state_dir"/verbose ||
 720                        git diff-tree --stat $orig_head..HEAD
 721        } &&
 722        {
 723                test -s "$rewritten_list" &&
 724                git notes copy --for-rewrite=rebase < "$rewritten_list" ||
 725                true # we don't care if this copying failed
 726        } &&
 727        hook="$(git rev-parse --git-path hooks/post-rewrite)"
 728        if test -x "$hook" && test -s "$rewritten_list"; then
 729                "$hook" rebase < "$rewritten_list"
 730                true # we don't care if this hook failed
 731        fi &&
 732                warn "$(eval_gettext "Successfully rebased and updated \$head_name.")"
 733
 734        return 1 # not failure; just to break the do_rest loop
 735}
 736
 737# can only return 0, when the infinite loop breaks
 738do_rest () {
 739        while :
 740        do
 741                do_next || break
 742        done
 743}
 744
 745# skip picking commits whose parents are unchanged
 746skip_unnecessary_picks () {
 747        fd=3
 748        while read -r command rest
 749        do
 750                # fd=3 means we skip the command
 751                case "$fd,$command" in
 752                3,pick|3,p)
 753                        # pick a commit whose parent is current $onto -> skip
 754                        sha1=${rest%% *}
 755                        case "$(git rev-parse --verify --quiet "$sha1"^)" in
 756                        "$onto"*)
 757                                onto=$sha1
 758                                ;;
 759                        *)
 760                                fd=1
 761                                ;;
 762                        esac
 763                        ;;
 764                3,"$comment_char"*|3,)
 765                        # copy comments
 766                        ;;
 767                *)
 768                        fd=1
 769                        ;;
 770                esac
 771                printf '%s\n' "$command${rest:+ }$rest" >&$fd
 772        done <"$todo" >"$todo.new" 3>>"$done" &&
 773        mv -f "$todo".new "$todo" &&
 774        case "$(peek_next_command)" in
 775        squash|s|fixup|f)
 776                record_in_rewritten "$onto"
 777                ;;
 778        esac ||
 779                die "$(gettext "Could not skip unnecessary pick commands")"
 780}
 781
 782transform_todo_ids () {
 783        while read -r command rest
 784        do
 785                case "$command" in
 786                "$comment_char"* | exec)
 787                        # Be careful for oddball commands like 'exec'
 788                        # that do not have a SHA-1 at the beginning of $rest.
 789                        ;;
 790                *)
 791                        sha1=$(git rev-parse --verify --quiet "$@" ${rest%%[     ]*}) &&
 792                        rest="$sha1 ${rest#*[    ]}"
 793                        ;;
 794                esac
 795                printf '%s\n' "$command${rest:+ }$rest"
 796        done <"$todo" >"$todo.new" &&
 797        mv -f "$todo.new" "$todo"
 798}
 799
 800expand_todo_ids() {
 801        transform_todo_ids
 802}
 803
 804collapse_todo_ids() {
 805        transform_todo_ids --short
 806}
 807
 808# Rearrange the todo list that has both "pick sha1 msg" and
 809# "pick sha1 fixup!/squash! msg" appears in it so that the latter
 810# comes immediately after the former, and change "pick" to
 811# "fixup"/"squash".
 812#
 813# Note that if the config has specified a custom instruction format
 814# each log message will be re-retrieved in order to normalize the
 815# autosquash arrangement
 816rearrange_squash () {
 817        # extract fixup!/squash! lines and resolve any referenced sha1's
 818        while read -r pick sha1 message
 819        do
 820                test -z "${format}" || message=$(git log -n 1 --format="%s" ${sha1})
 821                case "$message" in
 822                "squash! "*|"fixup! "*)
 823                        action="${message%%!*}"
 824                        rest=$message
 825                        prefix=
 826                        # skip all squash! or fixup! (but save for later)
 827                        while :
 828                        do
 829                                case "$rest" in
 830                                "squash! "*|"fixup! "*)
 831                                        prefix="$prefix${rest%%!*},"
 832                                        rest="${rest#*! }"
 833                                        ;;
 834                                *)
 835                                        break
 836                                        ;;
 837                                esac
 838                        done
 839                        printf '%s %s %s %s\n' "$sha1" "$action" "$prefix" "$rest"
 840                        # if it's a single word, try to resolve to a full sha1 and
 841                        # emit a second copy. This allows us to match on both message
 842                        # and on sha1 prefix
 843                        if test "${rest#* }" = "$rest"; then
 844                                fullsha="$(git rev-parse -q --verify "$rest" 2>/dev/null)"
 845                                if test -n "$fullsha"; then
 846                                        # prefix the action to uniquely identify this line as
 847                                        # intended for full sha1 match
 848                                        echo "$sha1 +$action $prefix $fullsha"
 849                                fi
 850                        fi
 851                esac
 852        done >"$1.sq" <"$1"
 853        test -s "$1.sq" || return
 854
 855        used=
 856        while read -r pick sha1 message
 857        do
 858                case " $used" in
 859                *" $sha1 "*) continue ;;
 860                esac
 861                printf '%s\n' "$pick $sha1 $message"
 862                test -z "${format}" || message=$(git log -n 1 --format="%s" ${sha1})
 863                used="$used$sha1 "
 864                while read -r squash action msg_prefix msg_content
 865                do
 866                        case " $used" in
 867                        *" $squash "*) continue ;;
 868                        esac
 869                        emit=0
 870                        case "$action" in
 871                        +*)
 872                                action="${action#+}"
 873                                # full sha1 prefix test
 874                                case "$msg_content" in "$sha1"*) emit=1;; esac ;;
 875                        *)
 876                                # message prefix test
 877                                case "$message" in "$msg_content"*) emit=1;; esac ;;
 878                        esac
 879                        if test $emit = 1; then
 880                                if test -n "${format}"
 881                                then
 882                                        msg_content=$(git log -n 1 --format="${format}" ${squash})
 883                                else
 884                                        msg_content="$(echo "$msg_prefix" | sed "s/,/! /g")$msg_content"
 885                                fi
 886                                printf '%s\n' "$action $squash $msg_content"
 887                                used="$used$squash "
 888                        fi
 889                done <"$1.sq"
 890        done >"$1.rearranged" <"$1"
 891        cat "$1.rearranged" >"$1"
 892        rm -f "$1.sq" "$1.rearranged"
 893}
 894
 895# Add commands after a pick or after a squash/fixup serie
 896# in the todo list.
 897add_exec_commands () {
 898        {
 899                first=t
 900                while read -r insn rest
 901                do
 902                        case $insn in
 903                        pick)
 904                                test -n "$first" ||
 905                                printf "%s" "$cmd"
 906                                ;;
 907                        esac
 908                        printf "%s %s\n" "$insn" "$rest"
 909                        first=
 910                done
 911                printf "%s" "$cmd"
 912        } <"$1" >"$1.new" &&
 913        mv "$1.new" "$1"
 914}
 915
 916# Check if the SHA-1 passed as an argument is a
 917# correct one, if not then print $2 in "$todo".badsha
 918# $1: the SHA-1 to test
 919# $2: the line number of the input
 920# $3: the input filename
 921check_commit_sha () {
 922        badsha=0
 923        if test -z "$1"
 924        then
 925                badsha=1
 926        else
 927                sha1_verif="$(git rev-parse --verify --quiet $1^{commit})"
 928                if test -z "$sha1_verif"
 929                then
 930                        badsha=1
 931                fi
 932        fi
 933
 934        if test $badsha -ne 0
 935        then
 936                line="$(sed -n -e "${2}p" "$3")"
 937                warn "$(eval_gettext "\
 938Warning: the SHA-1 is missing or isn't a commit in the following line:
 939 - \$line")"
 940                warn
 941        fi
 942
 943        return $badsha
 944}
 945
 946# prints the bad commits and bad commands
 947# from the todolist in stdin
 948check_bad_cmd_and_sha () {
 949        retval=0
 950        lineno=0
 951        while read -r command rest
 952        do
 953                lineno=$(( $lineno + 1 ))
 954                case $command in
 955                "$comment_char"*|''|noop|x|exec)
 956                        # Doesn't expect a SHA-1
 957                        ;;
 958                "$cr")
 959                        # Work around CR left by "read" (e.g. with Git for
 960                        # Windows' Bash).
 961                        ;;
 962                pick|p|drop|d|reword|r|edit|e|squash|s|fixup|f)
 963                        if ! check_commit_sha "${rest%%[        ]*}" "$lineno" "$1"
 964                        then
 965                                retval=1
 966                        fi
 967                        ;;
 968                *)
 969                        line="$(sed -n -e "${lineno}p" "$1")"
 970                        warn "$(eval_gettext "\
 971Warning: the command isn't recognized in the following line:
 972 - \$line")"
 973                        warn
 974                        retval=1
 975                        ;;
 976                esac
 977        done <"$1"
 978        return $retval
 979}
 980
 981# Print the list of the SHA-1 of the commits
 982# from stdin to stdout
 983todo_list_to_sha_list () {
 984        git stripspace --strip-comments |
 985        while read -r command sha1 rest
 986        do
 987                case $command in
 988                "$comment_char"*|''|noop|x|"exec")
 989                        ;;
 990                *)
 991                        long_sha=$(git rev-list --no-walk "$sha1" 2>/dev/null)
 992                        printf "%s\n" "$long_sha"
 993                        ;;
 994                esac
 995        done
 996}
 997
 998# Use warn for each line in stdin
 999warn_lines () {
1000        while read -r line
1001        do
1002                warn " - $line"
1003        done
1004}
1005
1006# Switch to the branch in $into and notify it in the reflog
1007checkout_onto () {
1008        GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $onto_name"
1009        output git checkout $onto || die_abort "$(gettext "could not detach HEAD")"
1010        git update-ref ORIG_HEAD $orig_head
1011}
1012
1013get_missing_commit_check_level () {
1014        check_level=$(git config --get rebase.missingCommitsCheck)
1015        check_level=${check_level:-ignore}
1016        # Don't be case sensitive
1017        printf '%s' "$check_level" | tr 'A-Z' 'a-z'
1018}
1019
1020# Check if the user dropped some commits by mistake
1021# Behaviour determined by rebase.missingCommitsCheck.
1022# Check if there is an unrecognized command or a
1023# bad SHA-1 in a command.
1024check_todo_list () {
1025        raise_error=f
1026
1027        check_level=$(get_missing_commit_check_level)
1028
1029        case "$check_level" in
1030        warn|error)
1031                # Get the SHA-1 of the commits
1032                todo_list_to_sha_list <"$todo".backup >"$todo".oldsha1
1033                todo_list_to_sha_list <"$todo" >"$todo".newsha1
1034
1035                # Sort the SHA-1 and compare them
1036                sort -u "$todo".oldsha1 >"$todo".oldsha1+
1037                mv "$todo".oldsha1+ "$todo".oldsha1
1038                sort -u "$todo".newsha1 >"$todo".newsha1+
1039                mv "$todo".newsha1+ "$todo".newsha1
1040                comm -2 -3 "$todo".oldsha1 "$todo".newsha1 >"$todo".miss
1041
1042                # Warn about missing commits
1043                if test -s "$todo".miss
1044                then
1045                        test "$check_level" = error && raise_error=t
1046
1047                        warn "$(gettext "\
1048Warning: some commits may have been dropped accidentally.
1049Dropped commits (newer to older):")"
1050
1051                        # Make the list user-friendly and display
1052                        opt="--no-walk=sorted --format=oneline --abbrev-commit --stdin"
1053                        git rev-list $opt <"$todo".miss | warn_lines
1054
1055                        warn "$(gettext "\
1056To avoid this message, use \"drop\" to explicitly remove a commit.
1057
1058Use 'git config rebase.missingCommitsCheck' to change the level of warnings.
1059The possible behaviours are: ignore, warn, error.")"
1060                        warn
1061                fi
1062                ;;
1063        ignore)
1064                ;;
1065        *)
1066                warn "$(eval_gettext "Unrecognized setting \$check_level for option rebase.missingCommitsCheck. Ignoring.")"
1067                ;;
1068        esac
1069
1070        if ! check_bad_cmd_and_sha "$todo"
1071        then
1072                raise_error=t
1073        fi
1074
1075        if test $raise_error = t
1076        then
1077                # Checkout before the first commit of the
1078                # rebase: this way git rebase --continue
1079                # will work correctly as it expects HEAD to be
1080                # placed before the commit of the next action
1081                checkout_onto
1082
1083                warn "$(gettext "You can fix this with 'git rebase --edit-todo'.")"
1084                die "$(gettext "Or you can abort the rebase with 'git rebase --abort'.")"
1085        fi
1086}
1087
1088# The whole contents of this file is run by dot-sourcing it from
1089# inside a shell function.  It used to be that "return"s we see
1090# below were not inside any function, and expected to return
1091# to the function that dot-sourced us.
1092#
1093# However, older (9.x) versions of FreeBSD /bin/sh misbehave on such a
1094# construct and continue to run the statements that follow such a "return".
1095# As a work-around, we introduce an extra layer of a function
1096# here, and immediately call it after defining it.
1097git_rebase__interactive () {
1098
1099case "$action" in
1100continue)
1101        # do we have anything to commit?
1102        if git diff-index --cached --quiet HEAD --
1103        then
1104                # Nothing to commit -- skip this commit
1105
1106                test ! -f "$GIT_DIR"/CHERRY_PICK_HEAD ||
1107                rm "$GIT_DIR"/CHERRY_PICK_HEAD ||
1108                die "$(gettext "Could not remove CHERRY_PICK_HEAD")"
1109        else
1110                if ! test -f "$author_script"
1111                then
1112                        gpg_sign_opt_quoted=${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")}
1113                        die "$(eval_gettext "\
1114You have staged changes in your working tree.
1115If these changes are meant to be
1116squashed into the previous commit, run:
1117
1118  git commit --amend \$gpg_sign_opt_quoted
1119
1120If they are meant to go into a new commit, run:
1121
1122  git commit \$gpg_sign_opt_quoted
1123
1124In both case, once you're done, continue with:
1125
1126  git rebase --continue
1127")"
1128                fi
1129                . "$author_script" ||
1130                        die "$(gettext "Error trying to find the author identity to amend commit")"
1131                if test -f "$amend"
1132                then
1133                        current_head=$(git rev-parse --verify HEAD)
1134                        test "$current_head" = $(cat "$amend") ||
1135                        die "$(gettext "\
1136You have uncommitted changes in your working tree. Please commit them
1137first and then run 'git rebase --continue' again.")"
1138                        do_with_author git commit --amend --no-verify -F "$msg" -e \
1139                                ${gpg_sign_opt:+"$gpg_sign_opt"} ||
1140                                die "$(gettext "Could not commit staged changes.")"
1141                else
1142                        do_with_author git commit --no-verify -F "$msg" -e \
1143                                ${gpg_sign_opt:+"$gpg_sign_opt"} ||
1144                                die "$(gettext "Could not commit staged changes.")"
1145                fi
1146        fi
1147
1148        if test -r "$state_dir"/stopped-sha
1149        then
1150                record_in_rewritten "$(cat "$state_dir"/stopped-sha)"
1151        fi
1152
1153        require_clean_work_tree "rebase"
1154        do_rest
1155        return 0
1156        ;;
1157skip)
1158        git rerere clear
1159
1160        do_rest
1161        return 0
1162        ;;
1163edit-todo)
1164        git stripspace --strip-comments <"$todo" >"$todo".new
1165        mv -f "$todo".new "$todo"
1166        collapse_todo_ids
1167        append_todo_help
1168        gettext "
1169You are editing the todo file of an ongoing interactive rebase.
1170To continue rebase after editing, run:
1171    git rebase --continue
1172
1173" | git stripspace --comment-lines >>"$todo"
1174
1175        git_sequence_editor "$todo" ||
1176                die "$(gettext "Could not execute editor")"
1177        expand_todo_ids
1178
1179        exit
1180        ;;
1181esac
1182
1183git var GIT_COMMITTER_IDENT >/dev/null ||
1184        die "$(gettext "You need to set your committer info first")"
1185
1186comment_for_reflog start
1187
1188if test ! -z "$switch_to"
1189then
1190        GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $switch_to"
1191        output git checkout "$switch_to" -- ||
1192                die "$(eval_gettext "Could not checkout \$switch_to")"
1193
1194        comment_for_reflog start
1195fi
1196
1197orig_head=$(git rev-parse --verify HEAD) || die "$(gettext "No HEAD?")"
1198mkdir -p "$state_dir" || die "$(eval_gettext "Could not create temporary \$state_dir")"
1199
1200: > "$state_dir"/interactive || die "$(gettext "Could not mark as interactive")"
1201write_basic_state
1202if test t = "$preserve_merges"
1203then
1204        if test -z "$rebase_root"
1205        then
1206                mkdir "$rewritten" &&
1207                for c in $(git merge-base --all $orig_head $upstream)
1208                do
1209                        echo $onto > "$rewritten"/$c ||
1210                                die "$(gettext "Could not init rewritten commits")"
1211                done
1212        else
1213                mkdir "$rewritten" &&
1214                echo $onto > "$rewritten"/root ||
1215                        die "$(gettext "Could not init rewritten commits")"
1216        fi
1217        # No cherry-pick because our first pass is to determine
1218        # parents to rewrite and skipping dropped commits would
1219        # prematurely end our probe
1220        merges_option=
1221else
1222        merges_option="--no-merges --cherry-pick"
1223fi
1224
1225shorthead=$(git rev-parse --short $orig_head)
1226shortonto=$(git rev-parse --short $onto)
1227if test -z "$rebase_root"
1228        # this is now equivalent to ! -z "$upstream"
1229then
1230        shortupstream=$(git rev-parse --short $upstream)
1231        revisions=$upstream...$orig_head
1232        shortrevisions=$shortupstream..$shorthead
1233else
1234        revisions=$onto...$orig_head
1235        shortrevisions=$shorthead
1236fi
1237format=$(git config --get rebase.instructionFormat)
1238# the 'rev-list .. | sed' requires %m to parse; the instruction requires %H to parse
1239git rev-list $merges_option --format="%m%H ${format:-%s}" \
1240        --reverse --left-right --topo-order \
1241        $revisions ${restrict_revision+^$restrict_revision} | \
1242        sed -n "s/^>//p" |
1243while read -r sha1 rest
1244do
1245
1246        if test -z "$keep_empty" && is_empty_commit $sha1 && ! is_merge_commit $sha1
1247        then
1248                comment_out="$comment_char "
1249        else
1250                comment_out=
1251        fi
1252
1253        if test t != "$preserve_merges"
1254        then
1255                printf '%s\n' "${comment_out}pick $sha1 $rest" >>"$todo"
1256        else
1257                if test -z "$rebase_root"
1258                then
1259                        preserve=t
1260                        for p in $(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-)
1261                        do
1262                                if test -f "$rewritten"/$p
1263                                then
1264                                        preserve=f
1265                                fi
1266                        done
1267                else
1268                        preserve=f
1269                fi
1270                if test f = "$preserve"
1271                then
1272                        touch "$rewritten"/$sha1
1273                        printf '%s\n' "${comment_out}pick $sha1 $rest" >>"$todo"
1274                fi
1275        fi
1276done
1277
1278# Watch for commits that been dropped by --cherry-pick
1279if test t = "$preserve_merges"
1280then
1281        mkdir "$dropped"
1282        # Save all non-cherry-picked changes
1283        git rev-list $revisions --left-right --cherry-pick | \
1284                sed -n "s/^>//p" > "$state_dir"/not-cherry-picks
1285        # Now all commits and note which ones are missing in
1286        # not-cherry-picks and hence being dropped
1287        git rev-list $revisions |
1288        while read rev
1289        do
1290                if test -f "$rewritten"/$rev &&
1291                   ! sane_grep "$rev" "$state_dir"/not-cherry-picks >/dev/null
1292                then
1293                        # Use -f2 because if rev-list is telling us this commit is
1294                        # not worthwhile, we don't want to track its multiple heads,
1295                        # just the history of its first-parent for others that will
1296                        # be rebasing on top of it
1297                        git rev-list --parents -1 $rev | cut -d' ' -s -f2 > "$dropped"/$rev
1298                        sha1=$(git rev-list -1 $rev)
1299                        sane_grep -v "^[a-z][a-z]* $sha1" <"$todo" > "${todo}2" ; mv "${todo}2" "$todo"
1300                        rm "$rewritten"/$rev
1301                fi
1302        done
1303fi
1304
1305test -s "$todo" || echo noop >> "$todo"
1306test -n "$autosquash" && rearrange_squash "$todo"
1307test -n "$cmd" && add_exec_commands "$todo"
1308
1309todocount=$(git stripspace --strip-comments <"$todo" | wc -l)
1310todocount=${todocount##* }
1311
1312cat >>"$todo" <<EOF
1313
1314$comment_char $(eval_ngettext \
1315        "Rebase \$shortrevisions onto \$shortonto (\$todocount command)" \
1316        "Rebase \$shortrevisions onto \$shortonto (\$todocount commands)" \
1317        "$todocount")
1318EOF
1319append_todo_help
1320gettext "
1321However, if you remove everything, the rebase will be aborted.
1322
1323" | git stripspace --comment-lines >>"$todo"
1324
1325if test -z "$keep_empty"
1326then
1327        printf '%s\n' "$comment_char $(gettext "Note that empty commits are commented out")" >>"$todo"
1328fi
1329
1330
1331has_action "$todo" ||
1332        return 2
1333
1334cp "$todo" "$todo".backup
1335collapse_todo_ids
1336git_sequence_editor "$todo" ||
1337        die_abort "$(gettext "Could not execute editor")"
1338
1339has_action "$todo" ||
1340        return 2
1341
1342check_todo_list
1343
1344expand_todo_ids
1345
1346test -d "$rewritten" || test -n "$force_rebase" || skip_unnecessary_picks
1347
1348checkout_onto
1349do_rest
1350
1351}
1352# ... and then we call the whole thing.
1353git_rebase__interactive