c0bf7aade66b4d434653c885e52d6814d9cdf1c7
   1#
   2# bash completion support for core Git.
   3#
   4# Copyright (C) 2006,2007 Shawn O. Pearce <spearce@spearce.org>
   5# Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
   6# Distributed under the GNU General Public License, version 2.0.
   7#
   8# The contained completion routines provide support for completing:
   9#
  10#    *) local and remote branch names
  11#    *) local and remote tag names
  12#    *) .git/remotes file names
  13#    *) git 'subcommands'
  14#    *) tree paths within 'ref:path/to/file' expressions
  15#    *) common --long-options
  16#
  17# To use these routines:
  18#
  19#    1) Copy this file to somewhere (e.g. ~/.git-completion.sh).
  20#    2) Added the following line to your .bashrc:
  21#        source ~/.git-completion.sh
  22#
  23#    3) You may want to make sure the git executable is available
  24#       in your PATH before this script is sourced, as some caching
  25#       is performed while the script loads.  If git isn't found
  26#       at source time then all lookups will be done on demand,
  27#       which may be slightly slower.
  28#
  29#    4) Consider changing your PS1 to also show the current branch:
  30#        PS1='[\u@\h \W$(__git_ps1 " (%s)")]\$ '
  31#
  32#       The argument to __git_ps1 will be displayed only if you
  33#       are currently in a git repository.  The %s token will be
  34#       the name of the current branch.
  35#
  36# To submit patches:
  37#
  38#    *) Read Documentation/SubmittingPatches
  39#    *) Send all patches to the current maintainer:
  40#
  41#       "Shawn O. Pearce" <spearce@spearce.org>
  42#
  43#    *) Always CC the Git mailing list:
  44#
  45#       git@vger.kernel.org
  46#
  47
  48case "$COMP_WORDBREAKS" in
  49*:*) : great ;;
  50*)   COMP_WORDBREAKS="$COMP_WORDBREAKS:"
  51esac
  52
  53__gitdir ()
  54{
  55        if [ -z "$1" ]; then
  56                if [ -n "$__git_dir" ]; then
  57                        echo "$__git_dir"
  58                elif [ -d .git ]; then
  59                        echo .git
  60                else
  61                        git rev-parse --git-dir 2>/dev/null
  62                fi
  63        elif [ -d "$1/.git" ]; then
  64                echo "$1/.git"
  65        else
  66                echo "$1"
  67        fi
  68}
  69
  70__git_ps1 ()
  71{
  72        local g="$(git rev-parse --git-dir 2>/dev/null)"
  73        if [ -n "$g" ]; then
  74                local r
  75                local b
  76                if [ -d "$g/rebase-apply" ]
  77                then
  78                        if test -f "$g/rebase-apply/rebasing"
  79                        then
  80                                r="|REBASE"
  81                        elif test -f "$g/rebase-apply/applying"
  82                        then
  83                                r="|AM"
  84                        else
  85                                r="|AM/REBASE"
  86                        fi
  87                        b="$(git symbolic-ref HEAD 2>/dev/null)"
  88                elif [ -f "$g/rebase-merge/interactive" ]
  89                then
  90                        r="|REBASE-i"
  91                        b="$(cat "$g/rebase-merge/head-name")"
  92                elif [ -d "$g/rebase-merge" ]
  93                then
  94                        r="|REBASE-m"
  95                        b="$(cat "$g/rebase-merge/head-name")"
  96                elif [ -f "$g/MERGE_HEAD" ]
  97                then
  98                        r="|MERGING"
  99                        b="$(git symbolic-ref HEAD 2>/dev/null)"
 100                else
 101                        if [ -f "$g/BISECT_LOG" ]
 102                        then
 103                                r="|BISECTING"
 104                        fi
 105                        if ! b="$(git symbolic-ref HEAD 2>/dev/null)"
 106                        then
 107                                if ! b="$(git describe --exact-match HEAD 2>/dev/null)"
 108                                then
 109                                        b="$(cut -c1-7 "$g/HEAD")..."
 110                                fi
 111                        fi
 112                fi
 113
 114                if [ -n "$1" ]; then
 115                        printf "$1" "${b##refs/heads/}$r"
 116                else
 117                        printf " (%s)" "${b##refs/heads/}$r"
 118                fi
 119        fi
 120}
 121
 122__gitcomp_1 ()
 123{
 124        local c IFS=' '$'\t'$'\n'
 125        for c in $1; do
 126                case "$c$2" in
 127                --*=*) printf %s$'\n' "$c$2" ;;
 128                *.)    printf %s$'\n' "$c$2" ;;
 129                *)     printf %s$'\n' "$c$2 " ;;
 130                esac
 131        done
 132}
 133
 134__gitcomp ()
 135{
 136        local cur="${COMP_WORDS[COMP_CWORD]}"
 137        if [ $# -gt 2 ]; then
 138                cur="$3"
 139        fi
 140        case "$cur" in
 141        --*=)
 142                COMPREPLY=()
 143                ;;
 144        *)
 145                local IFS=$'\n'
 146                COMPREPLY=($(compgen -P "$2" \
 147                        -W "$(__gitcomp_1 "$1" "$4")" \
 148                        -- "$cur"))
 149                ;;
 150        esac
 151}
 152
 153__git_heads ()
 154{
 155        local cmd i is_hash=y dir="$(__gitdir "$1")"
 156        if [ -d "$dir" ]; then
 157                for i in $(git --git-dir="$dir" \
 158                        for-each-ref --format='%(refname)' \
 159                        refs/heads ); do
 160                        echo "${i#refs/heads/}"
 161                done
 162                return
 163        fi
 164        for i in $(git ls-remote "$1" 2>/dev/null); do
 165                case "$is_hash,$i" in
 166                y,*) is_hash=n ;;
 167                n,*^{}) is_hash=y ;;
 168                n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
 169                n,*) is_hash=y; echo "$i" ;;
 170                esac
 171        done
 172}
 173
 174__git_tags ()
 175{
 176        local cmd i is_hash=y dir="$(__gitdir "$1")"
 177        if [ -d "$dir" ]; then
 178                for i in $(git --git-dir="$dir" \
 179                        for-each-ref --format='%(refname)' \
 180                        refs/tags ); do
 181                        echo "${i#refs/tags/}"
 182                done
 183                return
 184        fi
 185        for i in $(git ls-remote "$1" 2>/dev/null); do
 186                case "$is_hash,$i" in
 187                y,*) is_hash=n ;;
 188                n,*^{}) is_hash=y ;;
 189                n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
 190                n,*) is_hash=y; echo "$i" ;;
 191                esac
 192        done
 193}
 194
 195__git_refs ()
 196{
 197        local cmd i is_hash=y dir="$(__gitdir "$1")"
 198        if [ -d "$dir" ]; then
 199                if [ -e "$dir/HEAD" ]; then echo HEAD; fi
 200                for i in $(git --git-dir="$dir" \
 201                        for-each-ref --format='%(refname)' \
 202                        refs/tags refs/heads refs/remotes); do
 203                        case "$i" in
 204                                refs/tags/*)    echo "${i#refs/tags/}" ;;
 205                                refs/heads/*)   echo "${i#refs/heads/}" ;;
 206                                refs/remotes/*) echo "${i#refs/remotes/}" ;;
 207                                *)              echo "$i" ;;
 208                        esac
 209                done
 210                return
 211        fi
 212        for i in $(git ls-remote "$dir" 2>/dev/null); do
 213                case "$is_hash,$i" in
 214                y,*) is_hash=n ;;
 215                n,*^{}) is_hash=y ;;
 216                n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
 217                n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
 218                n,refs/remotes/*) is_hash=y; echo "${i#refs/remotes/}" ;;
 219                n,*) is_hash=y; echo "$i" ;;
 220                esac
 221        done
 222}
 223
 224__git_refs2 ()
 225{
 226        local i
 227        for i in $(__git_refs "$1"); do
 228                echo "$i:$i"
 229        done
 230}
 231
 232__git_refs_remotes ()
 233{
 234        local cmd i is_hash=y
 235        for i in $(git ls-remote "$1" 2>/dev/null); do
 236                case "$is_hash,$i" in
 237                n,refs/heads/*)
 238                        is_hash=y
 239                        echo "$i:refs/remotes/$1/${i#refs/heads/}"
 240                        ;;
 241                y,*) is_hash=n ;;
 242                n,*^{}) is_hash=y ;;
 243                n,refs/tags/*) is_hash=y;;
 244                n,*) is_hash=y; ;;
 245                esac
 246        done
 247}
 248
 249__git_remotes ()
 250{
 251        local i ngoff IFS=$'\n' d="$(__gitdir)"
 252        shopt -q nullglob || ngoff=1
 253        shopt -s nullglob
 254        for i in "$d/remotes"/*; do
 255                echo ${i#$d/remotes/}
 256        done
 257        [ "$ngoff" ] && shopt -u nullglob
 258        for i in $(git --git-dir="$d" config --list); do
 259                case "$i" in
 260                remote.*.url=*)
 261                        i="${i#remote.}"
 262                        echo "${i/.url=*/}"
 263                        ;;
 264                esac
 265        done
 266}
 267
 268__git_merge_strategies ()
 269{
 270        if [ -n "$__git_merge_strategylist" ]; then
 271                echo "$__git_merge_strategylist"
 272                return
 273        fi
 274        sed -n "/^all_strategies='/{
 275                s/^all_strategies='//
 276                s/'//
 277                p
 278                q
 279                }" "$(git --exec-path)/git-merge"
 280}
 281__git_merge_strategylist=
 282__git_merge_strategylist="$(__git_merge_strategies 2>/dev/null)"
 283
 284__git_complete_file ()
 285{
 286        local pfx ls ref cur="${COMP_WORDS[COMP_CWORD]}"
 287        case "$cur" in
 288        ?*:*)
 289                ref="${cur%%:*}"
 290                cur="${cur#*:}"
 291                case "$cur" in
 292                ?*/*)
 293                        pfx="${cur%/*}"
 294                        cur="${cur##*/}"
 295                        ls="$ref:$pfx"
 296                        pfx="$pfx/"
 297                        ;;
 298                *)
 299                        ls="$ref"
 300                        ;;
 301            esac
 302
 303                case "$COMP_WORDBREAKS" in
 304                *:*) : great ;;
 305                *)   pfx="$ref:$pfx" ;;
 306                esac
 307
 308                local IFS=$'\n'
 309                COMPREPLY=($(compgen -P "$pfx" \
 310                        -W "$(git --git-dir="$(__gitdir)" ls-tree "$ls" \
 311                                | sed '/^100... blob /{
 312                                           s,^.*        ,,
 313                                           s,$, ,
 314                                       }
 315                                       /^120000 blob /{
 316                                           s,^.*        ,,
 317                                           s,$, ,
 318                                       }
 319                                       /^040000 tree /{
 320                                           s,^.*        ,,
 321                                           s,$,/,
 322                                       }
 323                                       s/^.*    //')" \
 324                        -- "$cur"))
 325                ;;
 326        *)
 327                __gitcomp "$(__git_refs)"
 328                ;;
 329        esac
 330}
 331
 332__git_complete_revlist ()
 333{
 334        local pfx cur="${COMP_WORDS[COMP_CWORD]}"
 335        case "$cur" in
 336        *...*)
 337                pfx="${cur%...*}..."
 338                cur="${cur#*...}"
 339                __gitcomp "$(__git_refs)" "$pfx" "$cur"
 340                ;;
 341        *..*)
 342                pfx="${cur%..*}.."
 343                cur="${cur#*..}"
 344                __gitcomp "$(__git_refs)" "$pfx" "$cur"
 345                ;;
 346        *)
 347                __gitcomp "$(__git_refs)"
 348                ;;
 349        esac
 350}
 351
 352__git_all_commands ()
 353{
 354        if [ -n "$__git_all_commandlist" ]; then
 355                echo "$__git_all_commandlist"
 356                return
 357        fi
 358        local i IFS=" "$'\n'
 359        for i in $(git help -a|egrep '^ ')
 360        do
 361                case $i in
 362                *--*)             : helper pattern;;
 363                *) echo $i;;
 364                esac
 365        done
 366}
 367__git_all_commandlist=
 368__git_all_commandlist="$(__git_all_commands 2>/dev/null)"
 369
 370__git_porcelain_commands ()
 371{
 372        if [ -n "$__git_porcelain_commandlist" ]; then
 373                echo "$__git_porcelain_commandlist"
 374                return
 375        fi
 376        local i IFS=" "$'\n'
 377        for i in "help" $(__git_all_commands)
 378        do
 379                case $i in
 380                *--*)             : helper pattern;;
 381                applymbox)        : ask gittus;;
 382                applypatch)       : ask gittus;;
 383                archimport)       : import;;
 384                cat-file)         : plumbing;;
 385                check-attr)       : plumbing;;
 386                check-ref-format) : plumbing;;
 387                commit-tree)      : plumbing;;
 388                cvsexportcommit)  : export;;
 389                cvsimport)        : import;;
 390                cvsserver)        : daemon;;
 391                daemon)           : daemon;;
 392                diff-files)       : plumbing;;
 393                diff-index)       : plumbing;;
 394                diff-tree)        : plumbing;;
 395                fast-import)      : import;;
 396                fsck-objects)     : plumbing;;
 397                fetch-pack)       : plumbing;;
 398                fmt-merge-msg)    : plumbing;;
 399                for-each-ref)     : plumbing;;
 400                hash-object)      : plumbing;;
 401                http-*)           : transport;;
 402                index-pack)       : plumbing;;
 403                init-db)          : deprecated;;
 404                local-fetch)      : plumbing;;
 405                mailinfo)         : plumbing;;
 406                mailsplit)        : plumbing;;
 407                merge-*)          : plumbing;;
 408                mktree)           : plumbing;;
 409                mktag)            : plumbing;;
 410                pack-objects)     : plumbing;;
 411                pack-redundant)   : plumbing;;
 412                pack-refs)        : plumbing;;
 413                parse-remote)     : plumbing;;
 414                patch-id)         : plumbing;;
 415                peek-remote)      : plumbing;;
 416                prune)            : plumbing;;
 417                prune-packed)     : plumbing;;
 418                quiltimport)      : import;;
 419                read-tree)        : plumbing;;
 420                receive-pack)     : plumbing;;
 421                reflog)           : plumbing;;
 422                repo-config)      : deprecated;;
 423                rerere)           : plumbing;;
 424                rev-list)         : plumbing;;
 425                rev-parse)        : plumbing;;
 426                runstatus)        : plumbing;;
 427                sh-setup)         : internal;;
 428                shell)            : daemon;;
 429                send-pack)        : plumbing;;
 430                show-index)       : plumbing;;
 431                ssh-*)            : transport;;
 432                stripspace)       : plumbing;;
 433                symbolic-ref)     : plumbing;;
 434                tar-tree)         : deprecated;;
 435                unpack-file)      : plumbing;;
 436                unpack-objects)   : plumbing;;
 437                update-index)     : plumbing;;
 438                update-ref)       : plumbing;;
 439                update-server-info) : daemon;;
 440                upload-archive)   : plumbing;;
 441                upload-pack)      : plumbing;;
 442                write-tree)       : plumbing;;
 443                verify-tag)       : plumbing;;
 444                *) echo $i;;
 445                esac
 446        done
 447}
 448__git_porcelain_commandlist=
 449__git_porcelain_commandlist="$(__git_porcelain_commands 2>/dev/null)"
 450
 451__git_aliases ()
 452{
 453        local i IFS=$'\n'
 454        for i in $(git --git-dir="$(__gitdir)" config --list); do
 455                case "$i" in
 456                alias.*)
 457                        i="${i#alias.}"
 458                        echo "${i/=*/}"
 459                        ;;
 460                esac
 461        done
 462}
 463
 464__git_aliased_command ()
 465{
 466        local word cmdline=$(git --git-dir="$(__gitdir)" \
 467                config --get "alias.$1")
 468        for word in $cmdline; do
 469                if [ "${word##-*}" ]; then
 470                        echo $word
 471                        return
 472                fi
 473        done
 474}
 475
 476__git_find_subcommand ()
 477{
 478        local word subcommand c=1
 479
 480        while [ $c -lt $COMP_CWORD ]; do
 481                word="${COMP_WORDS[c]}"
 482                for subcommand in $1; do
 483                        if [ "$subcommand" = "$word" ]; then
 484                                echo "$subcommand"
 485                                return
 486                        fi
 487                done
 488                c=$((++c))
 489        done
 490}
 491
 492__git_has_doubledash ()
 493{
 494        local c=1
 495        while [ $c -lt $COMP_CWORD ]; do
 496                if [ "--" = "${COMP_WORDS[c]}" ]; then
 497                        return 0
 498                fi
 499                c=$((++c))
 500        done
 501        return 1
 502}
 503
 504__git_whitespacelist="nowarn warn error error-all fix"
 505
 506_git_am ()
 507{
 508        local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
 509        if [ -d "$dir"/rebase-apply ]; then
 510                __gitcomp "--skip --resolved --abort"
 511                return
 512        fi
 513        case "$cur" in
 514        --whitespace=*)
 515                __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 516                return
 517                ;;
 518        --*)
 519                __gitcomp "
 520                        --signoff --utf8 --binary --3way --interactive
 521                        --whitespace=
 522                        "
 523                return
 524        esac
 525        COMPREPLY=()
 526}
 527
 528_git_apply ()
 529{
 530        local cur="${COMP_WORDS[COMP_CWORD]}"
 531        case "$cur" in
 532        --whitespace=*)
 533                __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 534                return
 535                ;;
 536        --*)
 537                __gitcomp "
 538                        --stat --numstat --summary --check --index
 539                        --cached --index-info --reverse --reject --unidiff-zero
 540                        --apply --no-add --exclude=
 541                        --whitespace= --inaccurate-eof --verbose
 542                        "
 543                return
 544        esac
 545        COMPREPLY=()
 546}
 547
 548_git_add ()
 549{
 550        __git_has_doubledash && return
 551
 552        local cur="${COMP_WORDS[COMP_CWORD]}"
 553        case "$cur" in
 554        --*)
 555                __gitcomp "
 556                        --interactive --refresh --patch --update --dry-run
 557                        --ignore-errors
 558                        "
 559                return
 560        esac
 561        COMPREPLY=()
 562}
 563
 564_git_archive ()
 565{
 566        local cur="${COMP_WORDS[COMP_CWORD]}"
 567        case "$cur" in
 568        --format=*)
 569                __gitcomp "$(git archive --list)" "" "${cur##--format=}"
 570                return
 571                ;;
 572        --remote=*)
 573                __gitcomp "$(__git_remotes)" "" "${cur##--remote=}"
 574                return
 575                ;;
 576        --*)
 577                __gitcomp "
 578                        --format= --list --verbose
 579                        --prefix= --remote= --exec=
 580                        "
 581                return
 582                ;;
 583        esac
 584        __git_complete_file
 585}
 586
 587_git_bisect ()
 588{
 589        __git_has_doubledash && return
 590
 591        local subcommands="start bad good skip reset visualize replay log run"
 592        local subcommand="$(__git_find_subcommand "$subcommands")"
 593        if [ -z "$subcommand" ]; then
 594                __gitcomp "$subcommands"
 595                return
 596        fi
 597
 598        case "$subcommand" in
 599        bad|good|reset|skip)
 600                __gitcomp "$(__git_refs)"
 601                ;;
 602        *)
 603                COMPREPLY=()
 604                ;;
 605        esac
 606}
 607
 608_git_branch ()
 609{
 610        local i c=1 only_local_ref="n" has_r="n"
 611
 612        while [ $c -lt $COMP_CWORD ]; do
 613                i="${COMP_WORDS[c]}"
 614                case "$i" in
 615                -d|-m)  only_local_ref="y" ;;
 616                -r)     has_r="y" ;;
 617                esac
 618                c=$((++c))
 619        done
 620
 621        case "${COMP_WORDS[COMP_CWORD]}" in
 622        --*=*)  COMPREPLY=() ;;
 623        --*)
 624                __gitcomp "
 625                        --color --no-color --verbose --abbrev= --no-abbrev
 626                        --track --no-track --contains --merged --no-merged
 627                        "
 628                ;;
 629        *)
 630                if [ $only_local_ref = "y" -a $has_r = "n" ]; then
 631                        __gitcomp "$(__git_heads)"
 632                else
 633                        __gitcomp "$(__git_refs)"
 634                fi
 635                ;;
 636        esac
 637}
 638
 639_git_bundle ()
 640{
 641        local mycword="$COMP_CWORD"
 642        case "${COMP_WORDS[0]}" in
 643        git)
 644                local cmd="${COMP_WORDS[2]}"
 645                mycword="$((mycword-1))"
 646                ;;
 647        git-bundle*)
 648                local cmd="${COMP_WORDS[1]}"
 649                ;;
 650        esac
 651        case "$mycword" in
 652        1)
 653                __gitcomp "create list-heads verify unbundle"
 654                ;;
 655        2)
 656                # looking for a file
 657                ;;
 658        *)
 659                case "$cmd" in
 660                        create)
 661                                __git_complete_revlist
 662                        ;;
 663                esac
 664                ;;
 665        esac
 666}
 667
 668_git_checkout ()
 669{
 670        __git_has_doubledash && return
 671
 672        __gitcomp "$(__git_refs)"
 673}
 674
 675_git_cherry ()
 676{
 677        __gitcomp "$(__git_refs)"
 678}
 679
 680_git_cherry_pick ()
 681{
 682        local cur="${COMP_WORDS[COMP_CWORD]}"
 683        case "$cur" in
 684        --*)
 685                __gitcomp "--edit --no-commit"
 686                ;;
 687        *)
 688                __gitcomp "$(__git_refs)"
 689                ;;
 690        esac
 691}
 692
 693_git_clean ()
 694{
 695        __git_has_doubledash && return
 696
 697        local cur="${COMP_WORDS[COMP_CWORD]}"
 698        case "$cur" in
 699        --*)
 700                __gitcomp "--dry-run --quiet"
 701                return
 702                ;;
 703        esac
 704        COMPREPLY=()
 705}
 706
 707_git_clone ()
 708{
 709        local cur="${COMP_WORDS[COMP_CWORD]}"
 710        case "$cur" in
 711        --*)
 712                __gitcomp "
 713                        --local
 714                        --no-hardlinks
 715                        --shared
 716                        --reference
 717                        --quiet
 718                        --no-checkout
 719                        --bare
 720                        --mirror
 721                        --origin
 722                        --upload-pack
 723                        --template=
 724                        --depth
 725                        "
 726                return
 727                ;;
 728        esac
 729        COMPREPLY=()
 730}
 731
 732_git_commit ()
 733{
 734        __git_has_doubledash && return
 735
 736        local cur="${COMP_WORDS[COMP_CWORD]}"
 737        case "$cur" in
 738        --*)
 739                __gitcomp "
 740                        --all --author= --signoff --verify --no-verify
 741                        --edit --amend --include --only
 742                        "
 743                return
 744        esac
 745        COMPREPLY=()
 746}
 747
 748_git_describe ()
 749{
 750        local cur="${COMP_WORDS[COMP_CWORD]}"
 751        case "$cur" in
 752        --*)
 753                __gitcomp "
 754                        --all --tags --contains --abbrev= --candidates=
 755                        --exact-match --debug --long --match --always
 756                        "
 757                return
 758        esac
 759        __gitcomp "$(__git_refs)"
 760}
 761
 762_git_diff ()
 763{
 764        __git_has_doubledash && return
 765
 766        local cur="${COMP_WORDS[COMP_CWORD]}"
 767        case "$cur" in
 768        --*)
 769                __gitcomp "--cached --stat --numstat --shortstat --summary
 770                        --patch-with-stat --name-only --name-status --color
 771                        --no-color --color-words --no-renames --check
 772                        --full-index --binary --abbrev --diff-filter
 773                        --find-copies-harder --pickaxe-all --pickaxe-regex
 774                        --text --ignore-space-at-eol --ignore-space-change
 775                        --ignore-all-space --exit-code --quiet --ext-diff
 776                        --no-ext-diff
 777                        --no-prefix --src-prefix= --dst-prefix=
 778                        --base --ours --theirs
 779                        "
 780                return
 781                ;;
 782        esac
 783        __git_complete_file
 784}
 785
 786_git_fetch ()
 787{
 788        local cur="${COMP_WORDS[COMP_CWORD]}"
 789
 790        case "${COMP_WORDS[0]},$COMP_CWORD" in
 791        git-fetch*,1)
 792                __gitcomp "$(__git_remotes)"
 793                ;;
 794        git,2)
 795                __gitcomp "$(__git_remotes)"
 796                ;;
 797        *)
 798                case "$cur" in
 799                *:*)
 800                        local pfx=""
 801                        case "$COMP_WORDBREAKS" in
 802                        *:*) : great ;;
 803                        *)   pfx="${cur%%:*}:" ;;
 804                        esac
 805                        __gitcomp "$(__git_refs)" "$pfx" "${cur#*:}"
 806                        ;;
 807                *)
 808                        local remote
 809                        case "${COMP_WORDS[0]}" in
 810                        git-fetch) remote="${COMP_WORDS[1]}" ;;
 811                        git)       remote="${COMP_WORDS[2]}" ;;
 812                        esac
 813                        __gitcomp "$(__git_refs2 "$remote")"
 814                        ;;
 815                esac
 816                ;;
 817        esac
 818}
 819
 820_git_format_patch ()
 821{
 822        local cur="${COMP_WORDS[COMP_CWORD]}"
 823        case "$cur" in
 824        --*)
 825                __gitcomp "
 826                        --stdout --attach --thread
 827                        --output-directory
 828                        --numbered --start-number
 829                        --numbered-files
 830                        --keep-subject
 831                        --signoff
 832                        --in-reply-to=
 833                        --full-index --binary
 834                        --not --all
 835                        --cover-letter
 836                        --no-prefix --src-prefix= --dst-prefix=
 837                        "
 838                return
 839                ;;
 840        esac
 841        __git_complete_revlist
 842}
 843
 844_git_gc ()
 845{
 846        local cur="${COMP_WORDS[COMP_CWORD]}"
 847        case "$cur" in
 848        --*)
 849                __gitcomp "--prune --aggressive"
 850                return
 851                ;;
 852        esac
 853        COMPREPLY=()
 854}
 855
 856_git_grep ()
 857{
 858        __git_has_doubledash && return
 859
 860        local cur="${COMP_WORDS[COMP_CWORD]}"
 861        case "$cur" in
 862        --*)
 863                __gitcomp "
 864                        --cached
 865                        --text --ignore-case --word-regexp --invert-match
 866                        --full-name
 867                        --extended-regexp --basic-regexp --fixed-strings
 868                        --files-with-matches --name-only
 869                        --files-without-match
 870                        --count
 871                        --and --or --not --all-match
 872                        "
 873                return
 874                ;;
 875        esac
 876        COMPREPLY=()
 877}
 878
 879_git_help ()
 880{
 881        local cur="${COMP_WORDS[COMP_CWORD]}"
 882        case "$cur" in
 883        --*)
 884                __gitcomp "--all --info --man --web"
 885                return
 886                ;;
 887        esac
 888        __gitcomp "$(__git_all_commands)"
 889}
 890
 891_git_init ()
 892{
 893        local cur="${COMP_WORDS[COMP_CWORD]}"
 894        case "$cur" in
 895        --shared=*)
 896                __gitcomp "
 897                        false true umask group all world everybody
 898                        " "" "${cur##--shared=}"
 899                return
 900                ;;
 901        --*)
 902                __gitcomp "--quiet --bare --template= --shared --shared="
 903                return
 904                ;;
 905        esac
 906        COMPREPLY=()
 907}
 908
 909_git_ls_files ()
 910{
 911        __git_has_doubledash && return
 912
 913        local cur="${COMP_WORDS[COMP_CWORD]}"
 914        case "$cur" in
 915        --*)
 916                __gitcomp "--cached --deleted --modified --others --ignored
 917                        --stage --directory --no-empty-directory --unmerged
 918                        --killed --exclude= --exclude-from=
 919                        --exclude-per-directory= --exclude-standard
 920                        --error-unmatch --with-tree= --full-name
 921                        --abbrev --ignored --exclude-per-directory
 922                        "
 923                return
 924                ;;
 925        esac
 926        COMPREPLY=()
 927}
 928
 929_git_ls_remote ()
 930{
 931        __gitcomp "$(__git_remotes)"
 932}
 933
 934_git_ls_tree ()
 935{
 936        __git_complete_file
 937}
 938
 939_git_log ()
 940{
 941        __git_has_doubledash && return
 942
 943        local cur="${COMP_WORDS[COMP_CWORD]}"
 944        case "$cur" in
 945        --pretty=*)
 946                __gitcomp "
 947                        oneline short medium full fuller email raw
 948                        " "" "${cur##--pretty=}"
 949                return
 950                ;;
 951        --date=*)
 952                __gitcomp "
 953                        relative iso8601 rfc2822 short local default
 954                " "" "${cur##--date=}"
 955                return
 956                ;;
 957        --*)
 958                __gitcomp "
 959                        --max-count= --max-age= --since= --after=
 960                        --min-age= --before= --until=
 961                        --root --topo-order --date-order --reverse
 962                        --no-merges --follow
 963                        --abbrev-commit --abbrev=
 964                        --relative-date --date=
 965                        --author= --committer= --grep=
 966                        --all-match
 967                        --pretty= --name-status --name-only --raw
 968                        --not --all
 969                        --left-right --cherry-pick
 970                        --graph
 971                        --stat --numstat --shortstat
 972                        --decorate --diff-filter=
 973                        --color-words --walk-reflogs
 974                        --parents --children --full-history
 975                        --merge
 976                        "
 977                return
 978                ;;
 979        esac
 980        __git_complete_revlist
 981}
 982
 983_git_merge ()
 984{
 985        local cur="${COMP_WORDS[COMP_CWORD]}"
 986        case "${COMP_WORDS[COMP_CWORD-1]}" in
 987        -s|--strategy)
 988                __gitcomp "$(__git_merge_strategies)"
 989                return
 990        esac
 991        case "$cur" in
 992        --strategy=*)
 993                __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
 994                return
 995                ;;
 996        --*)
 997                __gitcomp "
 998                        --no-commit --no-stat --log --no-log --squash --strategy
 999                        "
1000                return
1001        esac
1002        __gitcomp "$(__git_refs)"
1003}
1004
1005_git_mergetool ()
1006{
1007        local cur="${COMP_WORDS[COMP_CWORD]}"
1008        case "$cur" in
1009        --tool=*)
1010                __gitcomp "
1011                        kdiff3 tkdiff meld xxdiff emerge
1012                        vimdiff gvimdiff ecmerge opendiff
1013                        " "" "${cur##--tool=}"
1014                return
1015                ;;
1016        --*)
1017                __gitcomp "--tool="
1018                return
1019                ;;
1020        esac
1021        COMPREPLY=()
1022}
1023
1024_git_merge_base ()
1025{
1026        __gitcomp "$(__git_refs)"
1027}
1028
1029_git_mv ()
1030{
1031        local cur="${COMP_WORDS[COMP_CWORD]}"
1032        case "$cur" in
1033        --*)
1034                __gitcomp "--dry-run"
1035                return
1036                ;;
1037        esac
1038        COMPREPLY=()
1039}
1040
1041_git_name_rev ()
1042{
1043        __gitcomp "--tags --all --stdin"
1044}
1045
1046_git_pull ()
1047{
1048        local cur="${COMP_WORDS[COMP_CWORD]}"
1049
1050        case "${COMP_WORDS[0]},$COMP_CWORD" in
1051        git-pull*,1)
1052                __gitcomp "$(__git_remotes)"
1053                ;;
1054        git,2)
1055                __gitcomp "$(__git_remotes)"
1056                ;;
1057        *)
1058                local remote
1059                case "${COMP_WORDS[0]}" in
1060                git-pull)  remote="${COMP_WORDS[1]}" ;;
1061                git)       remote="${COMP_WORDS[2]}" ;;
1062                esac
1063                __gitcomp "$(__git_refs "$remote")"
1064                ;;
1065        esac
1066}
1067
1068_git_push ()
1069{
1070        local cur="${COMP_WORDS[COMP_CWORD]}"
1071
1072        case "${COMP_WORDS[0]},$COMP_CWORD" in
1073        git-push*,1)
1074                __gitcomp "$(__git_remotes)"
1075                ;;
1076        git,2)
1077                __gitcomp "$(__git_remotes)"
1078                ;;
1079        *)
1080                case "$cur" in
1081                *:*)
1082                        local remote
1083                        case "${COMP_WORDS[0]}" in
1084                        git-push)  remote="${COMP_WORDS[1]}" ;;
1085                        git)       remote="${COMP_WORDS[2]}" ;;
1086                        esac
1087
1088                        local pfx=""
1089                        case "$COMP_WORDBREAKS" in
1090                        *:*) : great ;;
1091                        *)   pfx="${cur%%:*}:" ;;
1092                        esac
1093
1094                        __gitcomp "$(__git_refs "$remote")" "$pfx" "${cur#*:}"
1095                        ;;
1096                +*)
1097                        __gitcomp "$(__git_refs)" + "${cur#+}"
1098                        ;;
1099                *)
1100                        __gitcomp "$(__git_refs)"
1101                        ;;
1102                esac
1103                ;;
1104        esac
1105}
1106
1107_git_rebase ()
1108{
1109        local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
1110        if [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
1111                __gitcomp "--continue --skip --abort"
1112                return
1113        fi
1114        case "${COMP_WORDS[COMP_CWORD-1]}" in
1115        -s|--strategy)
1116                __gitcomp "$(__git_merge_strategies)"
1117                return
1118        esac
1119        case "$cur" in
1120        --strategy=*)
1121                __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
1122                return
1123                ;;
1124        --*)
1125                __gitcomp "--onto --merge --strategy --interactive"
1126                return
1127        esac
1128        __gitcomp "$(__git_refs)"
1129}
1130
1131_git_send_email ()
1132{
1133        local cur="${COMP_WORDS[COMP_CWORD]}"
1134        case "$cur" in
1135        --*)
1136                __gitcomp "--bcc --cc --cc-cmd --chain-reply-to --compose
1137                        --dry-run --envelope-sender --from --identity
1138                        --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
1139                        --no-suppress-from --no-thread --quiet
1140                        --signed-off-by-cc --smtp-pass --smtp-server
1141                        --smtp-server-port --smtp-ssl --smtp-user --subject
1142                        --suppress-cc --suppress-from --thread --to"
1143                return
1144                ;;
1145        esac
1146        COMPREPLY=()
1147}
1148
1149_git_config ()
1150{
1151        local cur="${COMP_WORDS[COMP_CWORD]}"
1152        local prv="${COMP_WORDS[COMP_CWORD-1]}"
1153        case "$prv" in
1154        branch.*.remote)
1155                __gitcomp "$(__git_remotes)"
1156                return
1157                ;;
1158        branch.*.merge)
1159                __gitcomp "$(__git_refs)"
1160                return
1161                ;;
1162        remote.*.fetch)
1163                local remote="${prv#remote.}"
1164                remote="${remote%.fetch}"
1165                __gitcomp "$(__git_refs_remotes "$remote")"
1166                return
1167                ;;
1168        remote.*.push)
1169                local remote="${prv#remote.}"
1170                remote="${remote%.push}"
1171                __gitcomp "$(git --git-dir="$(__gitdir)" \
1172                        for-each-ref --format='%(refname):%(refname)' \
1173                        refs/heads)"
1174                return
1175                ;;
1176        pull.twohead|pull.octopus)
1177                __gitcomp "$(__git_merge_strategies)"
1178                return
1179                ;;
1180        color.branch|color.diff|color.status)
1181                __gitcomp "always never auto"
1182                return
1183                ;;
1184        color.*.*)
1185                __gitcomp "
1186                        black red green yellow blue magenta cyan white
1187                        bold dim ul blink reverse
1188                        "
1189                return
1190                ;;
1191        *.*)
1192                COMPREPLY=()
1193                return
1194                ;;
1195        esac
1196        case "$cur" in
1197        --*)
1198                __gitcomp "
1199                        --global --system --file=
1200                        --list --replace-all
1201                        --get --get-all --get-regexp
1202                        --add --unset --unset-all
1203                        --remove-section --rename-section
1204                        "
1205                return
1206                ;;
1207        branch.*.*)
1208                local pfx="${cur%.*}."
1209                cur="${cur##*.}"
1210                __gitcomp "remote merge" "$pfx" "$cur"
1211                return
1212                ;;
1213        branch.*)
1214                local pfx="${cur%.*}."
1215                cur="${cur#*.}"
1216                __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
1217                return
1218                ;;
1219        remote.*.*)
1220                local pfx="${cur%.*}."
1221                cur="${cur##*.}"
1222                __gitcomp "
1223                        url fetch push skipDefaultUpdate
1224                        receivepack uploadpack tagopt
1225                        " "$pfx" "$cur"
1226                return
1227                ;;
1228        remote.*)
1229                local pfx="${cur%.*}."
1230                cur="${cur#*.}"
1231                __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
1232                return
1233                ;;
1234        esac
1235        __gitcomp "
1236                apply.whitespace
1237                core.fileMode
1238                core.gitProxy
1239                core.ignoreStat
1240                core.preferSymlinkRefs
1241                core.logAllRefUpdates
1242                core.loosecompression
1243                core.repositoryFormatVersion
1244                core.sharedRepository
1245                core.warnAmbiguousRefs
1246                core.compression
1247                core.packedGitWindowSize
1248                core.packedGitLimit
1249                clean.requireForce
1250                color.branch
1251                color.branch.current
1252                color.branch.local
1253                color.branch.remote
1254                color.branch.plain
1255                color.diff
1256                color.diff.plain
1257                color.diff.meta
1258                color.diff.frag
1259                color.diff.old
1260                color.diff.new
1261                color.diff.commit
1262                color.diff.whitespace
1263                color.pager
1264                color.status
1265                color.status.header
1266                color.status.added
1267                color.status.changed
1268                color.status.untracked
1269                diff.renameLimit
1270                diff.renames
1271                fetch.unpackLimit
1272                format.headers
1273                format.subjectprefix
1274                gitcvs.enabled
1275                gitcvs.logfile
1276                gitcvs.allbinary
1277                gitcvs.dbname gitcvs.dbdriver gitcvs.dbuser gitcvs.dbpass
1278                gitcvs.dbtablenameprefix
1279                gc.packrefs
1280                gc.reflogexpire
1281                gc.reflogexpireunreachable
1282                gc.rerereresolved
1283                gc.rerereunresolved
1284                http.sslVerify
1285                http.sslCert
1286                http.sslKey
1287                http.sslCAInfo
1288                http.sslCAPath
1289                http.maxRequests
1290                http.lowSpeedLimit
1291                http.lowSpeedTime
1292                http.noEPSV
1293                i18n.commitEncoding
1294                i18n.logOutputEncoding
1295                log.showroot
1296                merge.tool
1297                merge.summary
1298                merge.verbosity
1299                pack.window
1300                pack.depth
1301                pack.windowMemory
1302                pack.compression
1303                pack.deltaCacheSize
1304                pack.deltaCacheLimit
1305                pull.octopus
1306                pull.twohead
1307                repack.useDeltaBaseOffset
1308                showbranch.default
1309                tar.umask
1310                transfer.unpackLimit
1311                receive.unpackLimit
1312                receive.denyNonFastForwards
1313                user.name
1314                user.email
1315                user.signingkey
1316                branch. remote.
1317        "
1318}
1319
1320_git_remote ()
1321{
1322        local subcommands="add rm show prune update"
1323        local subcommand="$(__git_find_subcommand "$subcommands")"
1324        if [ -z "$subcommand" ]; then
1325                __gitcomp "$subcommands"
1326                return
1327        fi
1328
1329        case "$subcommand" in
1330        rm|show|prune)
1331                __gitcomp "$(__git_remotes)"
1332                ;;
1333        update)
1334                local i c='' IFS=$'\n'
1335                for i in $(git --git-dir="$(__gitdir)" config --list); do
1336                        case "$i" in
1337                        remotes.*)
1338                                i="${i#remotes.}"
1339                                c="$c ${i/=*/}"
1340                                ;;
1341                        esac
1342                done
1343                __gitcomp "$c"
1344                ;;
1345        *)
1346                COMPREPLY=()
1347                ;;
1348        esac
1349}
1350
1351_git_reset ()
1352{
1353        __git_has_doubledash && return
1354
1355        local cur="${COMP_WORDS[COMP_CWORD]}"
1356        case "$cur" in
1357        --*)
1358                __gitcomp "--mixed --hard --soft"
1359                return
1360                ;;
1361        esac
1362        __gitcomp "$(__git_refs)"
1363}
1364
1365_git_revert ()
1366{
1367        local cur="${COMP_WORDS[COMP_CWORD]}"
1368        case "$cur" in
1369        --*)
1370                __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
1371                return
1372                ;;
1373        esac
1374        COMPREPLY=()
1375}
1376
1377_git_rm ()
1378{
1379        __git_has_doubledash && return
1380
1381        local cur="${COMP_WORDS[COMP_CWORD]}"
1382        case "$cur" in
1383        --*)
1384                __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
1385                return
1386                ;;
1387        esac
1388        COMPREPLY=()
1389}
1390
1391_git_shortlog ()
1392{
1393        __git_has_doubledash && return
1394
1395        local cur="${COMP_WORDS[COMP_CWORD]}"
1396        case "$cur" in
1397        --*)
1398                __gitcomp "
1399                        --max-count= --max-age= --since= --after=
1400                        --min-age= --before= --until=
1401                        --no-merges
1402                        --author= --committer= --grep=
1403                        --all-match
1404                        --not --all
1405                        --numbered --summary
1406                        "
1407                return
1408                ;;
1409        esac
1410        __git_complete_revlist
1411}
1412
1413_git_show ()
1414{
1415        local cur="${COMP_WORDS[COMP_CWORD]}"
1416        case "$cur" in
1417        --pretty=*)
1418                __gitcomp "
1419                        oneline short medium full fuller email raw
1420                        " "" "${cur##--pretty=}"
1421                return
1422                ;;
1423        --*)
1424                __gitcomp "--pretty="
1425                return
1426                ;;
1427        esac
1428        __git_complete_file
1429}
1430
1431_git_show_branch ()
1432{
1433        local cur="${COMP_WORDS[COMP_CWORD]}"
1434        case "$cur" in
1435        --*)
1436                __gitcomp "
1437                        --all --remotes --topo-order --current --more=
1438                        --list --independent --merge-base --no-name
1439                        --sha1-name --topics --reflog
1440                        "
1441                return
1442                ;;
1443        esac
1444        __git_complete_revlist
1445}
1446
1447_git_stash ()
1448{
1449        local subcommands='save list show apply clear drop pop create branch'
1450        local subcommand="$(__git_find_subcommand "$subcommands")"
1451        if [ -z "$subcommand" ]; then
1452                __gitcomp "$subcommands"
1453        else
1454                local cur="${COMP_WORDS[COMP_CWORD]}"
1455                case "$subcommand,$cur" in
1456                save,--*)
1457                        __gitcomp "--keep-index"
1458                        ;;
1459                apply,--*)
1460                        __gitcomp "--index"
1461                        ;;
1462                show,--*|drop,--*|pop,--*|branch,--*)
1463                        COMPREPLY=()
1464                        ;;
1465                show,*|apply,*|drop,*|pop,*|branch,*)
1466                        __gitcomp "$(git --git-dir="$(__gitdir)" stash list \
1467                                        | sed -n -e 's/:.*//p')"
1468                        ;;
1469                *)
1470                        COMPREPLY=()
1471                        ;;
1472                esac
1473        fi
1474}
1475
1476_git_submodule ()
1477{
1478        __git_has_doubledash && return
1479
1480        local subcommands="add status init update"
1481        if [ -z "$(__git_find_subcommand "$subcommands")" ]; then
1482                local cur="${COMP_WORDS[COMP_CWORD]}"
1483                case "$cur" in
1484                --*)
1485                        __gitcomp "--quiet --cached"
1486                        ;;
1487                *)
1488                        __gitcomp "$subcommands"
1489                        ;;
1490                esac
1491                return
1492        fi
1493}
1494
1495_git_svn ()
1496{
1497        local subcommands="
1498                init fetch clone rebase dcommit log find-rev
1499                set-tree commit-diff info create-ignore propget
1500                proplist show-ignore show-externals
1501                "
1502        local subcommand="$(__git_find_subcommand "$subcommands")"
1503        if [ -z "$subcommand" ]; then
1504                __gitcomp "$subcommands"
1505        else
1506                local remote_opts="--username= --config-dir= --no-auth-cache"
1507                local fc_opts="
1508                        --follow-parent --authors-file= --repack=
1509                        --no-metadata --use-svm-props --use-svnsync-props
1510                        --log-window-size= --no-checkout --quiet
1511                        --repack-flags --user-log-author $remote_opts
1512                        "
1513                local init_opts="
1514                        --template= --shared= --trunk= --tags=
1515                        --branches= --stdlayout --minimize-url
1516                        --no-metadata --use-svm-props --use-svnsync-props
1517                        --rewrite-root= $remote_opts
1518                        "
1519                local cmt_opts="
1520                        --edit --rmdir --find-copies-harder --copy-similarity=
1521                        "
1522
1523                local cur="${COMP_WORDS[COMP_CWORD]}"
1524                case "$subcommand,$cur" in
1525                fetch,--*)
1526                        __gitcomp "--revision= --fetch-all $fc_opts"
1527                        ;;
1528                clone,--*)
1529                        __gitcomp "--revision= $fc_opts $init_opts"
1530                        ;;
1531                init,--*)
1532                        __gitcomp "$init_opts"
1533                        ;;
1534                dcommit,--*)
1535                        __gitcomp "
1536                                --merge --strategy= --verbose --dry-run
1537                                --fetch-all --no-rebase $cmt_opts $fc_opts
1538                                "
1539                        ;;
1540                set-tree,--*)
1541                        __gitcomp "--stdin $cmt_opts $fc_opts"
1542                        ;;
1543                create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
1544                show-externals,--*)
1545                        __gitcomp "--revision="
1546                        ;;
1547                log,--*)
1548                        __gitcomp "
1549                                --limit= --revision= --verbose --incremental
1550                                --oneline --show-commit --non-recursive
1551                                --authors-file=
1552                                "
1553                        ;;
1554                rebase,--*)
1555                        __gitcomp "
1556                                --merge --verbose --strategy= --local
1557                                --fetch-all $fc_opts
1558                                "
1559                        ;;
1560                commit-diff,--*)
1561                        __gitcomp "--message= --file= --revision= $cmt_opts"
1562                        ;;
1563                info,--*)
1564                        __gitcomp "--url"
1565                        ;;
1566                *)
1567                        COMPREPLY=()
1568                        ;;
1569                esac
1570        fi
1571}
1572
1573_git_tag ()
1574{
1575        local i c=1 f=0
1576        while [ $c -lt $COMP_CWORD ]; do
1577                i="${COMP_WORDS[c]}"
1578                case "$i" in
1579                -d|-v)
1580                        __gitcomp "$(__git_tags)"
1581                        return
1582                        ;;
1583                -f)
1584                        f=1
1585                        ;;
1586                esac
1587                c=$((++c))
1588        done
1589
1590        case "${COMP_WORDS[COMP_CWORD-1]}" in
1591        -m|-F)
1592                COMPREPLY=()
1593                ;;
1594        -*|tag|git-tag)
1595                if [ $f = 1 ]; then
1596                        __gitcomp "$(__git_tags)"
1597                else
1598                        COMPREPLY=()
1599                fi
1600                ;;
1601        *)
1602                __gitcomp "$(__git_refs)"
1603                ;;
1604        esac
1605}
1606
1607_git ()
1608{
1609        local i c=1 command __git_dir
1610
1611        while [ $c -lt $COMP_CWORD ]; do
1612                i="${COMP_WORDS[c]}"
1613                case "$i" in
1614                --git-dir=*) __git_dir="${i#--git-dir=}" ;;
1615                --bare)      __git_dir="." ;;
1616                --version|-p|--paginate) ;;
1617                --help) command="help"; break ;;
1618                *) command="$i"; break ;;
1619                esac
1620                c=$((++c))
1621        done
1622
1623        if [ -z "$command" ]; then
1624                case "${COMP_WORDS[COMP_CWORD]}" in
1625                --*=*) COMPREPLY=() ;;
1626                --*)   __gitcomp "
1627                        --paginate
1628                        --no-pager
1629                        --git-dir=
1630                        --bare
1631                        --version
1632                        --exec-path
1633                        --work-tree=
1634                        --help
1635                        "
1636                        ;;
1637                *)     __gitcomp "$(__git_porcelain_commands) $(__git_aliases)" ;;
1638                esac
1639                return
1640        fi
1641
1642        local expansion=$(__git_aliased_command "$command")
1643        [ "$expansion" ] && command="$expansion"
1644
1645        case "$command" in
1646        am)          _git_am ;;
1647        add)         _git_add ;;
1648        apply)       _git_apply ;;
1649        archive)     _git_archive ;;
1650        bisect)      _git_bisect ;;
1651        bundle)      _git_bundle ;;
1652        branch)      _git_branch ;;
1653        checkout)    _git_checkout ;;
1654        cherry)      _git_cherry ;;
1655        cherry-pick) _git_cherry_pick ;;
1656        clean)       _git_clean ;;
1657        clone)       _git_clone ;;
1658        commit)      _git_commit ;;
1659        config)      _git_config ;;
1660        describe)    _git_describe ;;
1661        diff)        _git_diff ;;
1662        fetch)       _git_fetch ;;
1663        format-patch) _git_format_patch ;;
1664        gc)          _git_gc ;;
1665        grep)        _git_grep ;;
1666        help)        _git_help ;;
1667        init)        _git_init ;;
1668        log)         _git_log ;;
1669        ls-files)    _git_ls_files ;;
1670        ls-remote)   _git_ls_remote ;;
1671        ls-tree)     _git_ls_tree ;;
1672        merge)       _git_merge;;
1673        mergetool)   _git_mergetool;;
1674        merge-base)  _git_merge_base ;;
1675        mv)          _git_mv ;;
1676        name-rev)    _git_name_rev ;;
1677        pull)        _git_pull ;;
1678        push)        _git_push ;;
1679        rebase)      _git_rebase ;;
1680        remote)      _git_remote ;;
1681        reset)       _git_reset ;;
1682        revert)      _git_revert ;;
1683        rm)          _git_rm ;;
1684        send-email)  _git_send_email ;;
1685        shortlog)    _git_shortlog ;;
1686        show)        _git_show ;;
1687        show-branch) _git_show_branch ;;
1688        stash)       _git_stash ;;
1689        submodule)   _git_submodule ;;
1690        svn)         _git_svn ;;
1691        tag)         _git_tag ;;
1692        whatchanged) _git_log ;;
1693        *)           COMPREPLY=() ;;
1694        esac
1695}
1696
1697_gitk ()
1698{
1699        __git_has_doubledash && return
1700
1701        local cur="${COMP_WORDS[COMP_CWORD]}"
1702        local g="$(git rev-parse --git-dir 2>/dev/null)"
1703        local merge=""
1704        if [ -f $g/MERGE_HEAD ]; then
1705                merge="--merge"
1706        fi
1707        case "$cur" in
1708        --*)
1709                __gitcomp "--not --all $merge"
1710                return
1711                ;;
1712        esac
1713        __git_complete_revlist
1714}
1715
1716complete -o default -o nospace -F _git git
1717complete -o default -o nospace -F _gitk gitk
1718
1719# The following are necessary only for Cygwin, and only are needed
1720# when the user has tab-completed the executable name and consequently
1721# included the '.exe' suffix.
1722#
1723if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
1724complete -o default -o nospace -F _git git.exe
1725fi