ebf445223ceb39175260663648f410fef8ca58f2
   1#!/bin/sh
   2
   3USAGE='[help|start|bad|good|new|old|terms|skip|next|reset|visualize|view|replay|log|run]'
   4LONG_USAGE='git bisect help
   5        print this long help message.
   6git bisect start [--term-{old,good}=<term> --term-{new,bad}=<term>]
   7                 [--no-checkout] [<bad> [<good>...]] [--] [<pathspec>...]
   8        reset bisect state and start bisection.
   9git bisect (bad|new) [<rev>]
  10        mark <rev> a known-bad revision/
  11                a revision after change in a given property.
  12git bisect (good|old) [<rev>...]
  13        mark <rev>... known-good revisions/
  14                revisions before change in a given property.
  15git bisect terms [--term-good | --term-bad]
  16        show the terms used for old and new commits (default: bad, good)
  17git bisect skip [(<rev>|<range>)...]
  18        mark <rev>... untestable revisions.
  19git bisect next
  20        find next bisection to test and check it out.
  21git bisect reset [<commit>]
  22        finish bisection search and go back to commit.
  23git bisect (visualize|view)
  24        show bisect status in gitk.
  25git bisect replay <logfile>
  26        replay bisection log.
  27git bisect log
  28        show bisect log.
  29git bisect run <cmd>...
  30        use <cmd>... to automatically bisect.
  31
  32Please use "git help bisect" to get the full man page.'
  33
  34OPTIONS_SPEC=
  35. git-sh-setup
  36
  37_x40='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'
  38_x40="$_x40$_x40$_x40$_x40$_x40$_x40$_x40$_x40"
  39TERM_BAD=bad
  40TERM_GOOD=good
  41
  42bisect_head()
  43{
  44        if test -f "$GIT_DIR/BISECT_HEAD"
  45        then
  46                echo BISECT_HEAD
  47        else
  48                echo HEAD
  49        fi
  50}
  51
  52bisect_autostart() {
  53        test -s "$GIT_DIR/BISECT_START" || {
  54                gettextln "You need to start by \"git bisect start\"" >&2
  55                if test -t 0
  56                then
  57                        # TRANSLATORS: Make sure to include [Y] and [n] in your
  58                        # translation. The program will only accept English input
  59                        # at this point.
  60                        gettext "Do you want me to do it for you [Y/n]? " >&2
  61                        read yesno
  62                        case "$yesno" in
  63                        [Nn]*)
  64                                exit ;;
  65                        esac
  66                        bisect_start
  67                else
  68                        exit 1
  69                fi
  70        }
  71}
  72
  73bisect_start() {
  74        #
  75        # Check for one bad and then some good revisions.
  76        #
  77        has_double_dash=0
  78        for arg; do
  79                case "$arg" in --) has_double_dash=1; break ;; esac
  80        done
  81        orig_args=$(git rev-parse --sq-quote "$@")
  82        bad_seen=0
  83        eval=''
  84        must_write_terms=0
  85        revs=''
  86        if test "z$(git rev-parse --is-bare-repository)" != zfalse
  87        then
  88                mode=--no-checkout
  89        else
  90                mode=''
  91        fi
  92        while [ $# -gt 0 ]; do
  93                arg="$1"
  94                case "$arg" in
  95                --)
  96                        shift
  97                        break
  98                ;;
  99                --no-checkout)
 100                        mode=--no-checkout
 101                        shift ;;
 102                --term-good|--term-old)
 103                        shift
 104                        must_write_terms=1
 105                        TERM_GOOD=$1
 106                        shift ;;
 107                --term-good=*|--term-old=*)
 108                        must_write_terms=1
 109                        TERM_GOOD=${1#*=}
 110                        shift ;;
 111                --term-bad|--term-new)
 112                        shift
 113                        must_write_terms=1
 114                        TERM_BAD=$1
 115                        shift ;;
 116                --term-bad=*|--term-new=*)
 117                        must_write_terms=1
 118                        TERM_BAD=${1#*=}
 119                        shift ;;
 120                --*)
 121                        die "$(eval_gettext "unrecognised option: '\$arg'")" ;;
 122                *)
 123                        rev=$(git rev-parse -q --verify "$arg^{commit}") || {
 124                                test $has_double_dash -eq 1 &&
 125                                die "$(eval_gettext "'\$arg' does not appear to be a valid revision")"
 126                                break
 127                        }
 128                        revs="$revs $rev"
 129                        shift
 130                        ;;
 131                esac
 132        done
 133
 134        for rev in $revs
 135        do
 136                # The user ran "git bisect start <sha1>
 137                # <sha1>", hence did not explicitly specify
 138                # the terms, but we are already starting to
 139                # set references named with the default terms,
 140                # and won't be able to change afterwards.
 141                must_write_terms=1
 142
 143                case $bad_seen in
 144                0) state=$TERM_BAD ; bad_seen=1 ;;
 145                *) state=$TERM_GOOD ;;
 146                esac
 147                eval="$eval git bisect--helper --bisect-write '$state' '$rev' '$TERM_GOOD' '$TERM_BAD' 'nolog' &&"
 148        done
 149        #
 150        # Verify HEAD.
 151        #
 152        head=$(GIT_DIR="$GIT_DIR" git symbolic-ref -q HEAD) ||
 153        head=$(GIT_DIR="$GIT_DIR" git rev-parse --verify HEAD) ||
 154        die "$(gettext "Bad HEAD - I need a HEAD")"
 155
 156        #
 157        # Check if we are bisecting.
 158        #
 159        start_head=''
 160        if test -s "$GIT_DIR/BISECT_START"
 161        then
 162                # Reset to the rev from where we started.
 163                start_head=$(cat "$GIT_DIR/BISECT_START")
 164                if test "z$mode" != "z--no-checkout"
 165                then
 166                        git checkout "$start_head" -- ||
 167                        die "$(eval_gettext "Checking out '\$start_head' failed. Try 'git bisect reset <valid-branch>'.")"
 168                fi
 169        else
 170                # Get rev from where we start.
 171                case "$head" in
 172                refs/heads/*|$_x40)
 173                        # This error message should only be triggered by
 174                        # cogito usage, and cogito users should understand
 175                        # it relates to cg-seek.
 176                        [ -s "$GIT_DIR/head-name" ] &&
 177                                die "$(gettext "won't bisect on cg-seek'ed tree")"
 178                        start_head="${head#refs/heads/}"
 179                        ;;
 180                *)
 181                        die "$(gettext "Bad HEAD - strange symbolic ref")"
 182                        ;;
 183                esac
 184        fi
 185
 186        #
 187        # Get rid of any old bisect state.
 188        #
 189        git bisect--helper --bisect-clean-state || exit
 190
 191        #
 192        # Change state.
 193        # In case of mistaken revs or checkout error, or signals received,
 194        # "bisect_auto_next" below may exit or misbehave.
 195        # We have to trap this to be able to clean up using
 196        # "bisect_clean_state".
 197        #
 198        trap 'git bisect--helper --bisect-clean-state' 0
 199        trap 'exit 255' 1 2 3 15
 200
 201        #
 202        # Write new start state.
 203        #
 204        echo "$start_head" >"$GIT_DIR/BISECT_START" && {
 205                test "z$mode" != "z--no-checkout" ||
 206                git update-ref --no-deref BISECT_HEAD "$start_head"
 207        } &&
 208        git rev-parse --sq-quote "$@" >"$GIT_DIR/BISECT_NAMES" &&
 209        eval "$eval true" &&
 210        if test $must_write_terms -eq 1
 211        then
 212                git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
 213        fi &&
 214        echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
 215        #
 216        # Check if we can proceed to the next bisect state.
 217        #
 218        bisect_auto_next
 219
 220        trap '-' 0
 221}
 222
 223bisect_skip() {
 224        all=''
 225        for arg in "$@"
 226        do
 227                case "$arg" in
 228                *..*)
 229                        revs=$(git rev-list "$arg") || die "$(eval_gettext "Bad rev input: \$arg")" ;;
 230                *)
 231                        revs=$(git rev-parse --sq-quote "$arg") ;;
 232                esac
 233                all="$all $revs"
 234        done
 235        eval bisect_state 'skip' $all
 236}
 237
 238bisect_state() {
 239        bisect_autostart
 240        state=$1
 241        check_and_set_terms $state
 242        case "$#,$state" in
 243        0,*)
 244                die "Please call 'bisect_state' with at least one argument." ;;
 245        1,"$TERM_BAD"|1,"$TERM_GOOD"|1,skip)
 246                bisected_head=$(bisect_head)
 247                rev=$(git rev-parse --verify "$bisected_head") ||
 248                        die "$(eval_gettext "Bad rev input: \$bisected_head")"
 249                git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
 250                git bisect--helper --check-expected-revs "$rev" ;;
 251        2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
 252                shift
 253                hash_list=''
 254                for rev in "$@"
 255                do
 256                        sha=$(git rev-parse --verify "$rev^{commit}") ||
 257                                die "$(eval_gettext "Bad rev input: \$rev")"
 258                        hash_list="$hash_list $sha"
 259                done
 260                for rev in $hash_list
 261                do
 262                        git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
 263                done
 264                git bisect--helper --check-expected-revs $hash_list ;;
 265        *,"$TERM_BAD")
 266                die "$(eval_gettext "'git bisect \$TERM_BAD' can take only one argument.")" ;;
 267        *)
 268                usage ;;
 269        esac
 270        bisect_auto_next
 271}
 272
 273bisect_next_check() {
 274        missing_good= missing_bad=
 275        git show-ref -q --verify refs/bisect/$TERM_BAD || missing_bad=t
 276        test -n "$(git for-each-ref "refs/bisect/$TERM_GOOD-*")" || missing_good=t
 277
 278        case "$missing_good,$missing_bad,$1" in
 279        ,,*)
 280                : have both $TERM_GOOD and $TERM_BAD - ok
 281                ;;
 282        *,)
 283                # do not have both but not asked to fail - just report.
 284                false
 285                ;;
 286        t,,"$TERM_GOOD")
 287                # have bad (or new) but not good (or old).  we could bisect although
 288                # this is less optimum.
 289                eval_gettextln "Warning: bisecting only with a \$TERM_BAD commit." >&2
 290                if test -t 0
 291                then
 292                        # TRANSLATORS: Make sure to include [Y] and [n] in your
 293                        # translation. The program will only accept English input
 294                        # at this point.
 295                        gettext "Are you sure [Y/n]? " >&2
 296                        read yesno
 297                        case "$yesno" in [Nn]*) exit 1 ;; esac
 298                fi
 299                : bisect without $TERM_GOOD...
 300                ;;
 301        *)
 302                bad_syn=$(bisect_voc bad)
 303                good_syn=$(bisect_voc good)
 304                if test -s "$GIT_DIR/BISECT_START"
 305                then
 306
 307                        eval_gettextln "You need to give me at least one \$bad_syn and one \$good_syn revision.
 308(You can use \"git bisect \$bad_syn\" and \"git bisect \$good_syn\" for that.)" >&2
 309                else
 310                        eval_gettextln "You need to start by \"git bisect start\".
 311You then need to give me at least one \$good_syn and one \$bad_syn revision.
 312(You can use \"git bisect \$bad_syn\" and \"git bisect \$good_syn\" for that.)" >&2
 313                fi
 314                exit 1 ;;
 315        esac
 316}
 317
 318bisect_auto_next() {
 319        bisect_next_check && bisect_next || :
 320}
 321
 322bisect_next() {
 323        case "$#" in 0) ;; *) usage ;; esac
 324        bisect_autostart
 325        bisect_next_check $TERM_GOOD
 326
 327        # Perform all bisection computation, display and checkout
 328        git bisect--helper --next-all $(test -f "$GIT_DIR/BISECT_HEAD" && echo --no-checkout)
 329        res=$?
 330
 331        # Check if we should exit because bisection is finished
 332        if test $res -eq 10
 333        then
 334                bad_rev=$(git show-ref --hash --verify refs/bisect/$TERM_BAD)
 335                bad_commit=$(git show-branch $bad_rev)
 336                echo "# first $TERM_BAD commit: $bad_commit" >>"$GIT_DIR/BISECT_LOG"
 337                exit 0
 338        elif test $res -eq 2
 339        then
 340                echo "# only skipped commits left to test" >>"$GIT_DIR/BISECT_LOG"
 341                good_revs=$(git for-each-ref --format="%(objectname)" "refs/bisect/$TERM_GOOD-*")
 342                for skipped in $(git rev-list refs/bisect/$TERM_BAD --not $good_revs)
 343                do
 344                        skipped_commit=$(git show-branch $skipped)
 345                        echo "# possible first $TERM_BAD commit: $skipped_commit" >>"$GIT_DIR/BISECT_LOG"
 346                done
 347                exit $res
 348        fi
 349
 350        # Check for an error in the bisection process
 351        test $res -ne 0 && exit $res
 352
 353        return 0
 354}
 355
 356bisect_visualize() {
 357        bisect_next_check fail
 358
 359        if test $# = 0
 360        then
 361                if test -n "${DISPLAY+set}${SESSIONNAME+set}${MSYSTEM+set}${SECURITYSESSIONID+set}" &&
 362                        type gitk >/dev/null 2>&1
 363                then
 364                        set gitk
 365                else
 366                        set git log
 367                fi
 368        else
 369                case "$1" in
 370                git*|tig) ;;
 371                -*)     set git log "$@" ;;
 372                *)      set git "$@" ;;
 373                esac
 374        fi
 375
 376        eval '"$@"' --bisect -- $(cat "$GIT_DIR/BISECT_NAMES")
 377}
 378
 379bisect_replay () {
 380        file="$1"
 381        test "$#" -eq 1 || die "$(gettext "No logfile given")"
 382        test -r "$file" || die "$(eval_gettext "cannot read \$file for replaying")"
 383        git bisect--helper --bisect-reset || exit
 384        while read git bisect command rev
 385        do
 386                test "$git $bisect" = "git bisect" || test "$git" = "git-bisect" || continue
 387                if test "$git" = "git-bisect"
 388                then
 389                        rev="$command"
 390                        command="$bisect"
 391                fi
 392                get_terms
 393                check_and_set_terms "$command"
 394                case "$command" in
 395                start)
 396                        cmd="bisect_start $rev"
 397                        eval "$cmd" ;;
 398                "$TERM_GOOD"|"$TERM_BAD"|skip)
 399                        git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
 400                terms)
 401                        bisect_terms $rev ;;
 402                *)
 403                        die "$(gettext "?? what are you talking about?")" ;;
 404                esac
 405        done <"$file"
 406        bisect_auto_next
 407}
 408
 409bisect_run () {
 410        bisect_next_check fail
 411
 412        test -n "$*" || die "$(gettext "bisect run failed: no command provided.")"
 413
 414        while true
 415        do
 416                command="$@"
 417                eval_gettextln "running \$command"
 418                "$@"
 419                res=$?
 420
 421                # Check for really bad run error.
 422                if [ $res -lt 0 -o $res -ge 128 ]
 423                then
 424                        eval_gettextln "bisect run failed:
 425exit code \$res from '\$command' is < 0 or >= 128" >&2
 426                        exit $res
 427                fi
 428
 429                # Find current state depending on run success or failure.
 430                # A special exit code of 125 means cannot test.
 431                if [ $res -eq 125 ]
 432                then
 433                        state='skip'
 434                elif [ $res -gt 0 ]
 435                then
 436                        state="$TERM_BAD"
 437                else
 438                        state="$TERM_GOOD"
 439                fi
 440
 441                # We have to use a subshell because "bisect_state" can exit.
 442                ( bisect_state $state >"$GIT_DIR/BISECT_RUN" )
 443                res=$?
 444
 445                cat "$GIT_DIR/BISECT_RUN"
 446
 447                if sane_grep "first $TERM_BAD commit could be any of" "$GIT_DIR/BISECT_RUN" \
 448                        >/dev/null
 449                then
 450                        gettextln "bisect run cannot continue any more" >&2
 451                        exit $res
 452                fi
 453
 454                if [ $res -ne 0 ]
 455                then
 456                        eval_gettextln "bisect run failed:
 457'bisect_state \$state' exited with error code \$res" >&2
 458                        exit $res
 459                fi
 460
 461                if sane_grep "is the first $TERM_BAD commit" "$GIT_DIR/BISECT_RUN" >/dev/null
 462                then
 463                        gettextln "bisect run success"
 464                        exit 0;
 465                fi
 466
 467        done
 468}
 469
 470bisect_log () {
 471        test -s "$GIT_DIR/BISECT_LOG" || die "$(gettext "We are not bisecting.")"
 472        cat "$GIT_DIR/BISECT_LOG"
 473}
 474
 475get_terms () {
 476        if test -s "$GIT_DIR/BISECT_TERMS"
 477        then
 478                {
 479                read TERM_BAD
 480                read TERM_GOOD
 481                } <"$GIT_DIR/BISECT_TERMS"
 482        fi
 483}
 484
 485check_and_set_terms () {
 486        cmd="$1"
 487        case "$cmd" in
 488        skip|start|terms) ;;
 489        *)
 490                if test -s "$GIT_DIR/BISECT_TERMS" && test "$cmd" != "$TERM_BAD" && test "$cmd" != "$TERM_GOOD"
 491                then
 492                        die "$(eval_gettext "Invalid command: you're currently in a \$TERM_BAD/\$TERM_GOOD bisect.")"
 493                fi
 494                case "$cmd" in
 495                bad|good)
 496                        if ! test -s "$GIT_DIR/BISECT_TERMS"
 497                        then
 498                                TERM_BAD=bad
 499                                TERM_GOOD=good
 500                                git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
 501                        fi
 502                        ;;
 503                new|old)
 504                        if ! test -s "$GIT_DIR/BISECT_TERMS"
 505                        then
 506                                TERM_BAD=new
 507                                TERM_GOOD=old
 508                                git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
 509                        fi
 510                        ;;
 511                esac ;;
 512        esac
 513}
 514
 515bisect_voc () {
 516        case "$1" in
 517        bad) echo "bad|new" ;;
 518        good) echo "good|old" ;;
 519        esac
 520}
 521
 522bisect_terms () {
 523        get_terms
 524        if ! test -s "$GIT_DIR/BISECT_TERMS"
 525        then
 526                die "$(gettext "no terms defined")"
 527        fi
 528        case "$#" in
 529        0)
 530                gettextln "Your current terms are $TERM_GOOD for the old state
 531and $TERM_BAD for the new state."
 532                ;;
 533        1)
 534                arg=$1
 535                case "$arg" in
 536                        --term-good|--term-old)
 537                                printf '%s\n' "$TERM_GOOD"
 538                                ;;
 539                        --term-bad|--term-new)
 540                                printf '%s\n' "$TERM_BAD"
 541                                ;;
 542                        *)
 543                                die "$(eval_gettext "invalid argument \$arg for 'git bisect terms'.
 544Supported options are: --term-good|--term-old and --term-bad|--term-new.")"
 545                                ;;
 546                esac
 547                ;;
 548        *)
 549                usage ;;
 550        esac
 551}
 552
 553case "$#" in
 5540)
 555        usage ;;
 556*)
 557        cmd="$1"
 558        get_terms
 559        shift
 560        case "$cmd" in
 561        help)
 562                git bisect -h ;;
 563        start)
 564                bisect_start "$@" ;;
 565        bad|good|new|old|"$TERM_BAD"|"$TERM_GOOD")
 566                bisect_state "$cmd" "$@" ;;
 567        skip)
 568                bisect_skip "$@" ;;
 569        next)
 570                # Not sure we want "next" at the UI level anymore.
 571                bisect_next "$@" ;;
 572        visualize|view)
 573                bisect_visualize "$@" ;;
 574        reset)
 575                git bisect--helper --bisect-reset "$@" ;;
 576        replay)
 577                bisect_replay "$@" ;;
 578        log)
 579                bisect_log ;;
 580        run)
 581                bisect_run "$@" ;;
 582        terms)
 583                bisect_terms "$@" ;;
 584        *)
 585                usage ;;
 586        esac
 587esac