contrib/completion/git-completion.bash

   1 #!bash
   2 #
   3 # bash completion support for core Git.
   4 #
   5 # Copyright (C) 2006,2007 Shawn O. Pearce <spearce@spearce.org>
   6 # Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
   7 # Distributed under the GNU General Public License, version 2.0.
   8 #
   9 # The contained completion routines provide support for completing:
  10 #
  11 #    *) local and remote branch names
  12 #    *) local and remote tag names
  13 #    *) .git/remotes file names
  14 #    *) git 'subcommands'
  15 #    *) tree paths within 'ref:path/to/file' expressions
  16 #    *) common --long-options
  17 #
  18 # To use these routines:
  19 #
  20 #    1) Copy this file to somewhere (e.g. ~/.git-completion.sh).
  21 #    2) Added the following line to your .bashrc:
  22 #        source ~/.git-completion.sh
  23 #
  24 #    3) Consider changing your PS1 to also show the current branch:
  25 #        PS1='[\u@\h \W$(__git_ps1 " (%s)")]\$ '
  26 #
  27 #       The argument to __git_ps1 will be displayed only if you
  28 #       are currently in a git repository.  The %s token will be
  29 #       the name of the current branch.
  30 #
  31 #       In addition, if you set GIT_PS1_SHOWDIRTYSTATE to a nonempty
  32 #       value, unstaged (*) and staged (+) changes will be shown next
  33 #       to the branch name.  You can configure this per-repository
  34 #       with the bash.showDirtyState variable, which defaults to true
  35 #       once GIT_PS1_SHOWDIRTYSTATE is enabled.
  36 #
  37 #       You can also see if currently something is stashed, by setting
  38 #       GIT_PS1_SHOWSTASHSTATE to a nonempty value. If something is stashed,
  39 #       then a '$' will be shown next to the branch name.
  40 #
  41 #       If you would like to see if there're untracked files, then you can
  42 #       set GIT_PS1_SHOWUNTRACKEDFILES to a nonempty value. If there're
  43 #       untracked files, then a '%' will be shown next to the branch name.
  44 #
  45 # To submit patches:
  46 #
  47 #    *) Read Documentation/SubmittingPatches
  48 #    *) Send all patches to the current maintainer:
  49 #
  50 #       "Shawn O. Pearce" <spearce@spearce.org>
  51 #
  52 #    *) Always CC the Git mailing list:
  53 #
  54 #       git@vger.kernel.org
  55 #
  56
  57 case "$COMP_WORDBREAKS" in
  58 *:*) : great ;;
  59 *)   COMP_WORDBREAKS="$COMP_WORDBREAKS:"
  60 esac
  61
  62 # __gitdir accepts 0 or 1 arguments (i.e., location)
  63 # returns location of .git repo
  64 __gitdir ()
  65 {
  66         if [ -z "${1-}" ]; then
  67                 if [ -n "${__git_dir-}" ]; then
  68                         echo "$__git_dir"
  69                 elif [ -d .git ]; then
  70                         echo .git
  71                 else
  72                         git rev-parse --git-dir 2>/dev/null
  73                 fi
  74         elif [ -d "$1/.git" ]; then
  75                 echo "$1/.git"
  76         else
  77                 echo "$1"
  78         fi
  79 }
  80
  81 # __git_ps1 accepts 0 or 1 arguments (i.e., format string)
  82 # returns text to add to bash PS1 prompt (includes branch name)
  83 __git_ps1 ()
  84 {
  85         local g="$(__gitdir)"
  86         if [ -n "$g" ]; then
  87                 local r
  88                 local b
  89                 if [ -f "$g/rebase-merge/interactive" ]; then
  90                         r="|REBASE-i"
  91                         b="$(cat "$g/rebase-merge/head-name")"
  92                 elif [ -d "$g/rebase-merge" ]; then
  93                         r="|REBASE-m"
  94                         b="$(cat "$g/rebase-merge/head-name")"
  95                 else
  96                         if [ -d "$g/rebase-apply" ]; then
  97                                 if [ -f "$g/rebase-apply/rebasing" ]; then
  98                                         r="|REBASE"
  99                                 elif [ -f "$g/rebase-apply/applying" ]; then
 100                                         r="|AM"
 101                                 else
 102                                         r="|AM/REBASE"
 103                                 fi
 104                         elif [ -f "$g/MERGE_HEAD" ]; then
 105                                 r="|MERGING"
 106                         elif [ -f "$g/BISECT_LOG" ]; then
 107                                 r="|BISECTING"
 108                         fi
 109
 110                         b="$(git symbolic-ref HEAD 2>/dev/null)" || {
 111
 112                                 b="$(
 113                                 case "${GIT_PS1_DESCRIBE_STYLE-}" in
 114                                 (contains)
 115                                         git describe --contains HEAD ;;
 116                                 (branch)
 117                                         git describe --contains --all HEAD ;;
 118                                 (describe)
 119                                         git describe HEAD ;;
 120                                 (* | default)
 121                                         git describe --exact-match HEAD ;;
 122                                 esac 2>/dev/null)" ||
 123
 124                                 b="$(cut -c1-7 "$g/HEAD" 2>/dev/null)..." ||
 125                                 b="unknown"
 126                                 b="($b)"
 127                         }
 128                 fi
 129
 130                 local w
 131                 local i
 132                 local s
 133                 local u
 134                 local c
 135
 136                 if [ "true" = "$(git rev-parse --is-inside-git-dir 2>/dev/null)" ]; then
 137                         if [ "true" = "$(git rev-parse --is-bare-repository 2>/dev/null)" ]; then
 138                                 c="BARE:"
 139                         else
 140                                 b="GIT_DIR!"
 141                         fi
 142                 elif [ "true" = "$(git rev-parse --is-inside-work-tree 2>/dev/null)" ]; then
 143                         if [ -n "${GIT_PS1_SHOWDIRTYSTATE-}" ]; then
 144                                 if [ "$(git config --bool bash.showDirtyState)" != "false" ]; then
 145                                         git diff --no-ext-diff --quiet --exit-code || w="*"
 146                                         if git rev-parse --quiet --verify HEAD >/dev/null; then
 147                                                 git diff-index --cached --quiet HEAD -- || i="+"
 148                                         else
 149                                                 i="#"
 150                                         fi
 151                                 fi
 152                         fi
 153                         if [ -n "${GIT_PS1_SHOWSTASHSTATE-}" ]; then
 154                                 git rev-parse --verify refs/stash >/dev/null 2>&1 && s="$"
 155                         fi
 156
 157                         if [ -n "${GIT_PS1_SHOWUNTRACKEDFILES-}" ]; then
 158                            if [ -n "$(git ls-files --others --exclude-standard)" ]; then
 159                               u="%"
 160                            fi
 161                         fi
 162                 fi
 163
 164                 local f="$w$i$s$u"
 165                 printf "${1:- (%s)}" "$c${b##refs/heads/}${f:+ $f}$r"
 166         fi
 167 }
 168
 169 # __gitcomp_1 requires 2 arguments
 170 __gitcomp_1 ()
 171 {
 172         local c IFS=' '$'\t'$'\n'
 173         for c in $1; do
 174                 case "$c$2" in
 175                 --*=*) printf %s$'\n' "$c$2" ;;
 176                 *.)    printf %s$'\n' "$c$2" ;;
 177                 *)     printf %s$'\n' "$c$2 " ;;
 178                 esac
 179         done
 180 }
 181
 182 # __gitcomp accepts 1, 2, 3, or 4 arguments
 183 # generates completion reply with compgen
 184 __gitcomp ()
 185 {
 186         local cur="${COMP_WORDS[COMP_CWORD]}"
 187         if [ $# -gt 2 ]; then
 188                 cur="$3"
 189         fi
 190         case "$cur" in
 191         --*=)
 192                 COMPREPLY=()
 193                 ;;
 194         *)
 195                 local IFS=$'\n'
 196                 COMPREPLY=($(compgen -P "${2-}" \
 197                         -W "$(__gitcomp_1 "${1-}" "${4-}")" \
 198                         -- "$cur"))
 199                 ;;
 200         esac
 201 }
 202
 203 # __git_heads accepts 0 or 1 arguments (to pass to __gitdir)
 204 __git_heads ()
 205 {
 206         local cmd i is_hash=y dir="$(__gitdir "${1-}")"
 207         if [ -d "$dir" ]; then
 208                 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
 209                         refs/heads
 210                 return
 211         fi
 212         for i in $(git ls-remote "${1-}" 2>/dev/null); do
 213                 case "$is_hash,$i" in
 214                 y,*) is_hash=n ;;
 215                 n,*^{}) is_hash=y ;;
 216                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
 217                 n,*) is_hash=y; echo "$i" ;;
 218                 esac
 219         done
 220 }
 221
 222 # __git_tags accepts 0 or 1 arguments (to pass to __gitdir)
 223 __git_tags ()
 224 {
 225         local cmd i is_hash=y dir="$(__gitdir "${1-}")"
 226         if [ -d "$dir" ]; then
 227                 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
 228                         refs/tags
 229                 return
 230         fi
 231         for i in $(git ls-remote "${1-}" 2>/dev/null); do
 232                 case "$is_hash,$i" in
 233                 y,*) is_hash=n ;;
 234                 n,*^{}) is_hash=y ;;
 235                 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
 236                 n,*) is_hash=y; echo "$i" ;;
 237                 esac
 238         done
 239 }
 240
 241 # __git_refs accepts 0 or 1 arguments (to pass to __gitdir)
 242 __git_refs ()
 243 {
 244         local i is_hash=y dir="$(__gitdir "${1-}")"
 245         local cur="${COMP_WORDS[COMP_CWORD]}" format refs
 246         if [ -d "$dir" ]; then
 247                 case "$cur" in
 248                 refs|refs/*)
 249                         format="refname"
 250                         refs="${cur%/*}"
 251                         ;;
 252                 *)
 253                         if [ -e "$dir/HEAD" ]; then echo HEAD; fi
 254                         format="refname:short"
 255                         refs="refs/tags refs/heads refs/remotes"
 256                         ;;
 257                 esac
 258                 git --git-dir="$dir" for-each-ref --format="%($format)" \
 259                         $refs
 260                 return
 261         fi
 262         for i in $(git ls-remote "$dir" 2>/dev/null); do
 263                 case "$is_hash,$i" in
 264                 y,*) is_hash=n ;;
 265                 n,*^{}) is_hash=y ;;
 266                 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
 267                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
 268                 n,refs/remotes/*) is_hash=y; echo "${i#refs/remotes/}" ;;
 269                 n,*) is_hash=y; echo "$i" ;;
 270                 esac
 271         done
 272 }
 273
 274 # __git_refs2 requires 1 argument (to pass to __git_refs)
 275 __git_refs2 ()
 276 {
 277         local i
 278         for i in $(__git_refs "$1"); do
 279                 echo "$i:$i"
 280         done
 281 }
 282
 283 # __git_refs_remotes requires 1 argument (to pass to ls-remote)
 284 __git_refs_remotes ()
 285 {
 286         local cmd i is_hash=y
 287         for i in $(git ls-remote "$1" 2>/dev/null); do
 288                 case "$is_hash,$i" in
 289                 n,refs/heads/*)
 290                         is_hash=y
 291                         echo "$i:refs/remotes/$1/${i#refs/heads/}"
 292                         ;;
 293                 y,*) is_hash=n ;;
 294                 n,*^{}) is_hash=y ;;
 295                 n,refs/tags/*) is_hash=y;;
 296                 n,*) is_hash=y; ;;
 297                 esac
 298         done
 299 }
 300
 301 __git_remotes ()
 302 {
 303         local i ngoff IFS=$'\n' d="$(__gitdir)"
 304         shopt -q nullglob || ngoff=1
 305         shopt -s nullglob
 306         for i in "$d/remotes"/*; do
 307                 echo ${i#$d/remotes/}
 308         done
 309         [ "$ngoff" ] && shopt -u nullglob
 310         for i in $(git --git-dir="$d" config --get-regexp 'remote\..*\.url' 2>/dev/null); do
 311                 i="${i#remote.}"
 312                 echo "${i/.url*/}"
 313         done
 314 }
 315
 316 __git_list_merge_strategies ()
 317 {
 318         git merge -s help 2>&1 |
 319         sed -n -e '/[Aa]vailable strategies are: /,/^$/{
 320                 s/\.$//
 321                 s/.*://
 322                 s/^[    ]*//
 323                 s/[     ]*$//
 324                 p
 325         }'
 326 }
 327
 328 __git_merge_strategies=
 329 # 'git merge -s help' (and thus detection of the merge strategy
 330 # list) fails, unfortunately, if run outside of any git working
 331 # tree.  __git_merge_strategies is set to the empty string in
 332 # that case, and the detection will be repeated the next time it
 333 # is needed.
 334 __git_compute_merge_strategies ()
 335 {
 336         : ${__git_merge_strategies:=$(__git_list_merge_strategies)}
 337 }
 338
 339 __git_complete_file ()
 340 {
 341         local pfx ls ref cur="${COMP_WORDS[COMP_CWORD]}"
 342         case "$cur" in
 343         ?*:*)
 344                 ref="${cur%%:*}"
 345                 cur="${cur#*:}"
 346                 case "$cur" in
 347                 ?*/*)
 348                         pfx="${cur%/*}"
 349                         cur="${cur##*/}"
 350                         ls="$ref:$pfx"
 351                         pfx="$pfx/"
 352                         ;;
 353                 *)
 354                         ls="$ref"
 355                         ;;
 356             esac
 357
 358                 case "$COMP_WORDBREAKS" in
 359                 *:*) : great ;;
 360                 *)   pfx="$ref:$pfx" ;;
 361                 esac
 362
 363                 local IFS=$'\n'
 364                 COMPREPLY=($(compgen -P "$pfx" \
 365                         -W "$(git --git-dir="$(__gitdir)" ls-tree "$ls" \
 366                                 | sed '/^100... blob /{
 367                                            s,^.*        ,,
 368                                            s,$, ,
 369                                        }
 370                                        /^120000 blob /{
 371                                            s,^.*        ,,
 372                                            s,$, ,
 373                                        }
 374                                        /^040000 tree /{
 375                                            s,^.*        ,,
 376                                            s,$,/,
 377                                        }
 378                                        s/^.*    //')" \
 379                         -- "$cur"))
 380                 ;;
 381         *)
 382                 __gitcomp "$(__git_refs)"
 383                 ;;
 384         esac
 385 }
 386
 387 __git_complete_revlist ()
 388 {
 389         local pfx cur="${COMP_WORDS[COMP_CWORD]}"
 390         case "$cur" in
 391         *...*)
 392                 pfx="${cur%...*}..."
 393                 cur="${cur#*...}"
 394                 __gitcomp "$(__git_refs)" "$pfx" "$cur"
 395                 ;;
 396         *..*)
 397                 pfx="${cur%..*}.."
 398                 cur="${cur#*..}"
 399                 __gitcomp "$(__git_refs)" "$pfx" "$cur"
 400                 ;;
 401         *)
 402                 __gitcomp "$(__git_refs)"
 403                 ;;
 404         esac
 405 }
 406
 407 __git_complete_remote_or_refspec ()
 408 {
 409         local cmd="${COMP_WORDS[1]}"
 410         local cur="${COMP_WORDS[COMP_CWORD]}"
 411         local i c=2 remote="" pfx="" lhs=1 no_complete_refspec=0
 412         while [ $c -lt $COMP_CWORD ]; do
 413                 i="${COMP_WORDS[c]}"
 414                 case "$i" in
 415                 --mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;;
 416                 --all)
 417                         case "$cmd" in
 418                         push) no_complete_refspec=1 ;;
 419                         fetch)
 420                                 COMPREPLY=()
 421                                 return
 422                                 ;;
 423                         *) ;;
 424                         esac
 425                         ;;
 426                 -*) ;;
 427                 *) remote="$i"; break ;;
 428                 esac
 429                 c=$((++c))
 430         done
 431         if [ -z "$remote" ]; then
 432                 __gitcomp "$(__git_remotes)"
 433                 return
 434         fi
 435         if [ $no_complete_refspec = 1 ]; then
 436                 COMPREPLY=()
 437                 return
 438         fi
 439         [ "$remote" = "." ] && remote=
 440         case "$cur" in
 441         *:*)
 442                 case "$COMP_WORDBREAKS" in
 443                 *:*) : great ;;
 444                 *)   pfx="${cur%%:*}:" ;;
 445                 esac
 446                 cur="${cur#*:}"
 447                 lhs=0
 448                 ;;
 449         +*)
 450                 pfx="+"
 451                 cur="${cur#+}"
 452                 ;;
 453         esac
 454         case "$cmd" in
 455         fetch)
 456                 if [ $lhs = 1 ]; then
 457                         __gitcomp "$(__git_refs2 "$remote")" "$pfx" "$cur"
 458                 else
 459                         __gitcomp "$(__git_refs)" "$pfx" "$cur"
 460                 fi
 461                 ;;
 462         pull)
 463                 if [ $lhs = 1 ]; then
 464                         __gitcomp "$(__git_refs "$remote")" "$pfx" "$cur"
 465                 else
 466                         __gitcomp "$(__git_refs)" "$pfx" "$cur"
 467                 fi
 468                 ;;
 469         push)
 470                 if [ $lhs = 1 ]; then
 471                         __gitcomp "$(__git_refs)" "$pfx" "$cur"
 472                 else
 473                         __gitcomp "$(__git_refs "$remote")" "$pfx" "$cur"
 474                 fi
 475                 ;;
 476         esac
 477 }
 478
 479 __git_complete_strategy ()
 480 {
 481         __git_compute_merge_strategies
 482         case "${COMP_WORDS[COMP_CWORD-1]}" in
 483         -s|--strategy)
 484                 __gitcomp "$__git_merge_strategies"
 485                 return 0
 486         esac
 487         local cur="${COMP_WORDS[COMP_CWORD]}"
 488         case "$cur" in
 489         --strategy=*)
 490                 __gitcomp "$__git_merge_strategies" "" "${cur##--strategy=}"
 491                 return 0
 492                 ;;
 493         esac
 494         return 1
 495 }
 496
 497 __git_list_all_commands ()
 498 {
 499         local i IFS=" "$'\n'
 500         for i in $(git help -a|egrep '^  [a-zA-Z0-9]')
 501         do
 502                 case $i in
 503                 *--*)             : helper pattern;;
 504                 *) echo $i;;
 505                 esac
 506         done
 507 }
 508
 509 __git_all_commands=
 510 __git_compute_all_commands ()
 511 {
 512         : ${__git_all_commands:=$(__git_list_all_commands)}
 513 }
 514
 515 __git_list_porcelain_commands ()
 516 {
 517         local i IFS=" "$'\n'
 518         __git_compute_all_commands
 519         for i in "help" $__git_all_commands
 520         do
 521                 case $i in
 522                 *--*)             : helper pattern;;
 523                 applymbox)        : ask gittus;;
 524                 applypatch)       : ask gittus;;
 525                 archimport)       : import;;
 526                 cat-file)         : plumbing;;
 527                 check-attr)       : plumbing;;
 528                 check-ref-format) : plumbing;;
 529                 checkout-index)   : plumbing;;
 530                 commit-tree)      : plumbing;;
 531                 count-objects)    : infrequent;;
 532                 cvsexportcommit)  : export;;
 533                 cvsimport)        : import;;
 534                 cvsserver)        : daemon;;
 535                 daemon)           : daemon;;
 536                 diff-files)       : plumbing;;
 537                 diff-index)       : plumbing;;
 538                 diff-tree)        : plumbing;;
 539                 fast-import)      : import;;
 540                 fast-export)      : export;;
 541                 fsck-objects)     : plumbing;;
 542                 fetch-pack)       : plumbing;;
 543                 fmt-merge-msg)    : plumbing;;
 544                 for-each-ref)     : plumbing;;
 545                 hash-object)      : plumbing;;
 546                 http-*)           : transport;;
 547                 index-pack)       : plumbing;;
 548                 init-db)          : deprecated;;
 549                 local-fetch)      : plumbing;;
 550                 lost-found)       : infrequent;;
 551                 ls-files)         : plumbing;;
 552                 ls-remote)        : plumbing;;
 553                 ls-tree)          : plumbing;;
 554                 mailinfo)         : plumbing;;
 555                 mailsplit)        : plumbing;;
 556                 merge-*)          : plumbing;;
 557                 mktree)           : plumbing;;
 558                 mktag)            : plumbing;;
 559                 pack-objects)     : plumbing;;
 560                 pack-redundant)   : plumbing;;
 561                 pack-refs)        : plumbing;;
 562                 parse-remote)     : plumbing;;
 563                 patch-id)         : plumbing;;
 564                 peek-remote)      : plumbing;;
 565                 prune)            : plumbing;;
 566                 prune-packed)     : plumbing;;
 567                 quiltimport)      : import;;
 568                 read-tree)        : plumbing;;
 569                 receive-pack)     : plumbing;;
 570                 reflog)           : plumbing;;
 571                 remote-*)         : transport;;
 572                 repo-config)      : deprecated;;
 573                 rerere)           : plumbing;;
 574                 rev-list)         : plumbing;;
 575                 rev-parse)        : plumbing;;
 576                 runstatus)        : plumbing;;
 577                 sh-setup)         : internal;;
 578                 shell)            : daemon;;
 579                 show-ref)         : plumbing;;
 580                 send-pack)        : plumbing;;
 581                 show-index)       : plumbing;;
 582                 ssh-*)            : transport;;
 583                 stripspace)       : plumbing;;
 584                 symbolic-ref)     : plumbing;;
 585                 tar-tree)         : deprecated;;
 586                 unpack-file)      : plumbing;;
 587                 unpack-objects)   : plumbing;;
 588                 update-index)     : plumbing;;
 589                 update-ref)       : plumbing;;
 590                 update-server-info) : daemon;;
 591                 upload-archive)   : plumbing;;
 592                 upload-pack)      : plumbing;;
 593                 write-tree)       : plumbing;;
 594                 var)              : infrequent;;
 595                 verify-pack)      : infrequent;;
 596                 verify-tag)       : plumbing;;
 597                 *) echo $i;;
 598                 esac
 599         done
 600 }
 601
 602 __git_porcelain_commands=
 603 __git_compute_porcelain_commands ()
 604 {
 605         __git_compute_all_commands
 606         : ${__git_porcelain_commands:=$(__git_list_porcelain_commands)}
 607 }
 608
 609 __git_aliases ()
 610 {
 611         local i IFS=$'\n'
 612         for i in $(git --git-dir="$(__gitdir)" config --get-regexp "alias\..*" 2>/dev/null); do
 613                 case "$i" in
 614                 alias.*)
 615                         i="${i#alias.}"
 616                         echo "${i/ */}"
 617                         ;;
 618                 esac
 619         done
 620 }
 621
 622 # __git_aliased_command requires 1 argument
 623 __git_aliased_command ()
 624 {
 625         local word cmdline=$(git --git-dir="$(__gitdir)" \
 626                 config --get "alias.$1")
 627         for word in $cmdline; do
 628                 if [ "${word##-*}" ]; then
 629                         echo $word
 630                         return
 631                 fi
 632         done
 633 }
 634
 635 # __git_find_on_cmdline requires 1 argument
 636 __git_find_on_cmdline ()
 637 {
 638         local word subcommand c=1
 639
 640         while [ $c -lt $COMP_CWORD ]; do
 641                 word="${COMP_WORDS[c]}"
 642                 for subcommand in $1; do
 643                         if [ "$subcommand" = "$word" ]; then
 644                                 echo "$subcommand"
 645                                 return
 646                         fi
 647                 done
 648                 c=$((++c))
 649         done
 650 }
 651
 652 __git_has_doubledash ()
 653 {
 654         local c=1
 655         while [ $c -lt $COMP_CWORD ]; do
 656                 if [ "--" = "${COMP_WORDS[c]}" ]; then
 657                         return 0
 658                 fi
 659                 c=$((++c))
 660         done
 661         return 1
 662 }
 663
 664 __git_whitespacelist="nowarn warn error error-all fix"
 665
 666 _git_am ()
 667 {
 668         local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
 669         if [ -d "$dir"/rebase-apply ]; then
 670                 __gitcomp "--skip --continue --resolved --abort"
 671                 return
 672         fi
 673         case "$cur" in
 674         --whitespace=*)
 675                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 676                 return
 677                 ;;
 678         --*)
 679                 __gitcomp "
 680                         --3way --committer-date-is-author-date --ignore-date
 681                         --ignore-whitespace --ignore-space-change
 682                         --interactive --keep --no-utf8 --signoff --utf8
 683                         --whitespace= --scissors
 684                         "
 685                 return
 686         esac
 687         COMPREPLY=()
 688 }
 689
 690 _git_apply ()
 691 {
 692         local cur="${COMP_WORDS[COMP_CWORD]}"
 693         case "$cur" in
 694         --whitespace=*)
 695                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 696                 return
 697                 ;;
 698         --*)
 699                 __gitcomp "
 700                         --stat --numstat --summary --check --index
 701                         --cached --index-info --reverse --reject --unidiff-zero
 702                         --apply --no-add --exclude=
 703                         --ignore-whitespace --ignore-space-change
 704                         --whitespace= --inaccurate-eof --verbose
 705                         "
 706                 return
 707         esac
 708         COMPREPLY=()
 709 }
 710
 711 _git_add ()
 712 {
 713         __git_has_doubledash && return
 714
 715         local cur="${COMP_WORDS[COMP_CWORD]}"
 716         case "$cur" in
 717         --*)
 718                 __gitcomp "
 719                         --interactive --refresh --patch --update --dry-run
 720                         --ignore-errors --intent-to-add
 721                         "
 722                 return
 723         esac
 724         COMPREPLY=()
 725 }
 726
 727 _git_archive ()
 728 {
 729         local cur="${COMP_WORDS[COMP_CWORD]}"
 730         case "$cur" in
 731         --format=*)
 732                 __gitcomp "$(git archive --list)" "" "${cur##--format=}"
 733                 return
 734                 ;;
 735         --remote=*)
 736                 __gitcomp "$(__git_remotes)" "" "${cur##--remote=}"
 737                 return
 738                 ;;
 739         --*)
 740                 __gitcomp "
 741                         --format= --list --verbose
 742                         --prefix= --remote= --exec=
 743                         "
 744                 return
 745                 ;;
 746         esac
 747         __git_complete_file
 748 }
 749
 750 _git_bisect ()
 751 {
 752         __git_has_doubledash && return
 753
 754         local subcommands="start bad good skip reset visualize replay log run"
 755         local subcommand="$(__git_find_on_cmdline "$subcommands")"
 756         if [ -z "$subcommand" ]; then
 757                 __gitcomp "$subcommands"
 758                 return
 759         fi
 760
 761         case "$subcommand" in
 762         bad|good|reset|skip)
 763                 __gitcomp "$(__git_refs)"
 764                 ;;
 765         *)
 766                 COMPREPLY=()
 767                 ;;
 768         esac
 769 }
 770
 771 _git_branch ()
 772 {
 773         local i c=1 only_local_ref="n" has_r="n"
 774
 775         while [ $c -lt $COMP_CWORD ]; do
 776                 i="${COMP_WORDS[c]}"
 777                 case "$i" in
 778                 -d|-m)  only_local_ref="y" ;;
 779                 -r)     has_r="y" ;;
 780                 esac
 781                 c=$((++c))
 782         done
 783
 784         case "${COMP_WORDS[COMP_CWORD]}" in
 785         --*)
 786                 __gitcomp "
 787                         --color --no-color --verbose --abbrev= --no-abbrev
 788                         --track --no-track --contains --merged --no-merged
 789                         "
 790                 ;;
 791         *)
 792                 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
 793                         __gitcomp "$(__git_heads)"
 794                 else
 795                         __gitcomp "$(__git_refs)"
 796                 fi
 797                 ;;
 798         esac
 799 }
 800
 801 _git_bundle ()
 802 {
 803         local cmd="${COMP_WORDS[2]}"
 804         case "$COMP_CWORD" in
 805         2)
 806                 __gitcomp "create list-heads verify unbundle"
 807                 ;;
 808         3)
 809                 # looking for a file
 810                 ;;
 811         *)
 812                 case "$cmd" in
 813                         create)
 814                                 __git_complete_revlist
 815                         ;;
 816                 esac
 817                 ;;
 818         esac
 819 }
 820
 821 _git_checkout ()
 822 {
 823         __git_has_doubledash && return
 824
 825         local cur="${COMP_WORDS[COMP_CWORD]}"
 826         case "$cur" in
 827         --conflict=*)
 828                 __gitcomp "diff3 merge" "" "${cur##--conflict=}"
 829                 ;;
 830         --*)
 831                 __gitcomp "
 832                         --quiet --ours --theirs --track --no-track --merge
 833                         --conflict= --patch
 834                         "
 835                 ;;
 836         *)
 837                 __gitcomp "$(__git_refs)"
 838                 ;;
 839         esac
 840 }
 841
 842 _git_cherry ()
 843 {
 844         __gitcomp "$(__git_refs)"
 845 }
 846
 847 _git_cherry_pick ()
 848 {
 849         local cur="${COMP_WORDS[COMP_CWORD]}"
 850         case "$cur" in
 851         --*)
 852                 __gitcomp "--edit --no-commit"
 853                 ;;
 854         *)
 855                 __gitcomp "$(__git_refs)"
 856                 ;;
 857         esac
 858 }
 859
 860 _git_clean ()
 861 {
 862         __git_has_doubledash && return
 863
 864         local cur="${COMP_WORDS[COMP_CWORD]}"
 865         case "$cur" in
 866         --*)
 867                 __gitcomp "--dry-run --quiet"
 868                 return
 869                 ;;
 870         esac
 871         COMPREPLY=()
 872 }
 873
 874 _git_clone ()
 875 {
 876         local cur="${COMP_WORDS[COMP_CWORD]}"
 877         case "$cur" in
 878         --*)
 879                 __gitcomp "
 880                         --local
 881                         --no-hardlinks
 882                         --shared
 883                         --reference
 884                         --quiet
 885                         --no-checkout
 886                         --bare
 887                         --mirror
 888                         --origin
 889                         --upload-pack
 890                         --template=
 891                         --depth
 892                         "
 893                 return
 894                 ;;
 895         esac
 896         COMPREPLY=()
 897 }
 898
 899 _git_commit ()
 900 {
 901         __git_has_doubledash && return
 902
 903         local cur="${COMP_WORDS[COMP_CWORD]}"
 904         case "$cur" in
 905         --cleanup=*)
 906                 __gitcomp "default strip verbatim whitespace
 907                         " "" "${cur##--cleanup=}"
 908                 return
 909                 ;;
 910         --reuse-message=*)
 911                 __gitcomp "$(__git_refs)" "" "${cur##--reuse-message=}"
 912                 return
 913                 ;;
 914         --reedit-message=*)
 915                 __gitcomp "$(__git_refs)" "" "${cur##--reedit-message=}"
 916                 return
 917                 ;;
 918         --untracked-files=*)
 919                 __gitcomp "all no normal" "" "${cur##--untracked-files=}"
 920                 return
 921                 ;;
 922         --*)
 923                 __gitcomp "
 924                         --all --author= --signoff --verify --no-verify
 925                         --edit --amend --include --only --interactive
 926                         --dry-run --reuse-message= --reedit-message=
 927                         --reset-author --file= --message= --template=
 928                         --cleanup= --untracked-files --untracked-files=
 929                         --verbose --quiet
 930                         "
 931                 return
 932         esac
 933         COMPREPLY=()
 934 }
 935
 936 _git_describe ()
 937 {
 938         local cur="${COMP_WORDS[COMP_CWORD]}"
 939         case "$cur" in
 940         --*)
 941                 __gitcomp "
 942                         --all --tags --contains --abbrev= --candidates=
 943                         --exact-match --debug --long --match --always
 944                         "
 945                 return
 946         esac
 947         __gitcomp "$(__git_refs)"
 948 }
 949
 950 __git_diff_common_options="--stat --numstat --shortstat --summary
 951                         --patch-with-stat --name-only --name-status --color
 952                         --no-color --color-words --no-renames --check
 953                         --full-index --binary --abbrev --diff-filter=
 954                         --find-copies-harder
 955                         --text --ignore-space-at-eol --ignore-space-change
 956                         --ignore-all-space --exit-code --quiet --ext-diff
 957                         --no-ext-diff
 958                         --no-prefix --src-prefix= --dst-prefix=
 959                         --inter-hunk-context=
 960                         --patience
 961                         --raw
 962                         --dirstat --dirstat= --dirstat-by-file
 963                         --dirstat-by-file= --cumulative
 964 "
 965
 966 _git_diff ()
 967 {
 968         __git_has_doubledash && return
 969
 970         local cur="${COMP_WORDS[COMP_CWORD]}"
 971         case "$cur" in
 972         --*)
 973                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
 974                         --base --ours --theirs
 975                         $__git_diff_common_options
 976                         "
 977                 return
 978                 ;;
 979         esac
 980         __git_complete_file
 981 }
 982
 983 __git_mergetools_common="diffuse ecmerge emerge kdiff3 meld opendiff
 984                         tkdiff vimdiff gvimdiff xxdiff araxis p4merge
 985 "
 986
 987 _git_difftool ()
 988 {
 989         __git_has_doubledash && return
 990
 991         local cur="${COMP_WORDS[COMP_CWORD]}"
 992         case "$cur" in
 993         --tool=*)
 994                 __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
 995                 return
 996                 ;;
 997         --*)
 998                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
 999                         --base --ours --theirs
1000                         --no-renames --diff-filter= --find-copies-harder
1001                         --relative --ignore-submodules
1002                         --tool="
1003                 return
1004                 ;;
1005         esac
1006         __git_complete_file
1007 }
1008
1009 __git_fetch_options="
1010         --quiet --verbose --append --upload-pack --force --keep --depth=
1011         --tags --no-tags --all --prune --dry-run
1012 "
1013
1014 _git_fetch ()
1015 {
1016         local cur="${COMP_WORDS[COMP_CWORD]}"
1017         case "$cur" in
1018         --*)
1019                 __gitcomp "$__git_fetch_options"
1020                 return
1021                 ;;
1022         esac
1023         __git_complete_remote_or_refspec
1024 }
1025
1026 _git_format_patch ()
1027 {
1028         local cur="${COMP_WORDS[COMP_CWORD]}"
1029         case "$cur" in
1030         --thread=*)
1031                 __gitcomp "
1032                         deep shallow
1033                         " "" "${cur##--thread=}"
1034                 return
1035                 ;;
1036         --*)
1037                 __gitcomp "
1038                         --stdout --attach --no-attach --thread --thread=
1039                         --output-directory
1040                         --numbered --start-number
1041                         --numbered-files
1042                         --keep-subject
1043                         --signoff
1044                         --in-reply-to= --cc=
1045                         --full-index --binary
1046                         --not --all
1047                         --cover-letter
1048                         --no-prefix --src-prefix= --dst-prefix=
1049                         --inline --suffix= --ignore-if-in-upstream
1050                         --subject-prefix=
1051                         "
1052                 return
1053                 ;;
1054         esac
1055         __git_complete_revlist
1056 }
1057
1058 _git_fsck ()
1059 {
1060         local cur="${COMP_WORDS[COMP_CWORD]}"
1061         case "$cur" in
1062         --*)
1063                 __gitcomp "
1064                         --tags --root --unreachable --cache --no-reflogs --full
1065                         --strict --verbose --lost-found
1066                         "
1067                 return
1068                 ;;
1069         esac
1070         COMPREPLY=()
1071 }
1072
1073 _git_gc ()
1074 {
1075         local cur="${COMP_WORDS[COMP_CWORD]}"
1076         case "$cur" in
1077         --*)
1078                 __gitcomp "--prune --aggressive"
1079                 return
1080                 ;;
1081         esac
1082         COMPREPLY=()
1083 }
1084
1085 _git_grep ()
1086 {
1087         __git_has_doubledash && return
1088
1089         local cur="${COMP_WORDS[COMP_CWORD]}"
1090         case "$cur" in
1091         --*)
1092                 __gitcomp "
1093                         --cached
1094                         --text --ignore-case --word-regexp --invert-match
1095                         --full-name
1096                         --extended-regexp --basic-regexp --fixed-strings
1097                         --files-with-matches --name-only
1098                         --files-without-match
1099                         --max-depth
1100                         --count
1101                         --and --or --not --all-match
1102                         "
1103                 return
1104                 ;;
1105         esac
1106
1107         __gitcomp "$(__git_refs)"
1108 }
1109
1110 _git_help ()
1111 {
1112         local cur="${COMP_WORDS[COMP_CWORD]}"
1113         case "$cur" in
1114         --*)
1115                 __gitcomp "--all --info --man --web"
1116                 return
1117                 ;;
1118         esac
1119         __git_compute_all_commands
1120         __gitcomp "$__git_all_commands
1121                 attributes cli core-tutorial cvs-migration
1122                 diffcore gitk glossary hooks ignore modules
1123                 repository-layout tutorial tutorial-2
1124                 workflows
1125                 "
1126 }
1127
1128 _git_init ()
1129 {
1130         local cur="${COMP_WORDS[COMP_CWORD]}"
1131         case "$cur" in
1132         --shared=*)
1133                 __gitcomp "
1134                         false true umask group all world everybody
1135                         " "" "${cur##--shared=}"
1136                 return
1137                 ;;
1138         --*)
1139                 __gitcomp "--quiet --bare --template= --shared --shared="
1140                 return
1141                 ;;
1142         esac
1143         COMPREPLY=()
1144 }
1145
1146 _git_ls_files ()
1147 {
1148         __git_has_doubledash && return
1149
1150         local cur="${COMP_WORDS[COMP_CWORD]}"
1151         case "$cur" in
1152         --*)
1153                 __gitcomp "--cached --deleted --modified --others --ignored
1154                         --stage --directory --no-empty-directory --unmerged
1155                         --killed --exclude= --exclude-from=
1156                         --exclude-per-directory= --exclude-standard
1157                         --error-unmatch --with-tree= --full-name
1158                         --abbrev --ignored --exclude-per-directory
1159                         "
1160                 return
1161                 ;;
1162         esac
1163         COMPREPLY=()
1164 }
1165
1166 _git_ls_remote ()
1167 {
1168         __gitcomp "$(__git_remotes)"
1169 }
1170
1171 _git_ls_tree ()
1172 {
1173         __git_complete_file
1174 }
1175
1176 # Options that go well for log, shortlog and gitk
1177 __git_log_common_options="
1178         --not --all
1179         --branches --tags --remotes
1180         --first-parent --merges --no-merges
1181         --max-count=
1182         --max-age= --since= --after=
1183         --min-age= --until= --before=
1184 "
1185 # Options that go well for log and gitk (not shortlog)
1186 __git_log_gitk_options="
1187         --dense --sparse --full-history
1188         --simplify-merges --simplify-by-decoration
1189         --left-right
1190 "
1191 # Options that go well for log and shortlog (not gitk)
1192 __git_log_shortlog_options="
1193         --author= --committer= --grep=
1194         --all-match
1195 "
1196
1197 __git_log_pretty_formats="oneline short medium full fuller email raw format:"
1198 __git_log_date_formats="relative iso8601 rfc2822 short local default raw"
1199
1200 _git_log ()
1201 {
1202         __git_has_doubledash && return
1203
1204         local cur="${COMP_WORDS[COMP_CWORD]}"
1205         local g="$(git rev-parse --git-dir 2>/dev/null)"
1206         local merge=""
1207         if [ -f "$g/MERGE_HEAD" ]; then
1208                 merge="--merge"
1209         fi
1210         case "$cur" in
1211         --pretty=*)
1212                 __gitcomp "$__git_log_pretty_formats
1213                         " "" "${cur##--pretty=}"
1214                 return
1215                 ;;
1216         --format=*)
1217                 __gitcomp "$__git_log_pretty_formats
1218                         " "" "${cur##--format=}"
1219                 return
1220                 ;;
1221         --date=*)
1222                 __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
1223                 return
1224                 ;;
1225         --decorate=*)
1226                 __gitcomp "long short" "" "${cur##--decorate=}"
1227                 return
1228                 ;;
1229         --*)
1230                 __gitcomp "
1231                         $__git_log_common_options
1232                         $__git_log_shortlog_options
1233                         $__git_log_gitk_options
1234                         --root --topo-order --date-order --reverse
1235                         --follow --full-diff
1236                         --abbrev-commit --abbrev=
1237                         --relative-date --date=
1238                         --pretty= --format= --oneline
1239                         --cherry-pick
1240                         --graph
1241                         --decorate --decorate=
1242                         --walk-reflogs
1243                         --parents --children
1244                         $merge
1245                         $__git_diff_common_options
1246                         --pickaxe-all --pickaxe-regex
1247                         "
1248                 return
1249                 ;;
1250         esac
1251         __git_complete_revlist
1252 }
1253
1254 __git_merge_options="
1255         --no-commit --no-stat --log --no-log --squash --strategy
1256         --commit --stat --no-squash --ff --no-ff --ff-only
1257 "
1258
1259 _git_merge ()
1260 {
1261         __git_complete_strategy && return
1262
1263         local cur="${COMP_WORDS[COMP_CWORD]}"
1264         case "$cur" in
1265         --*)
1266                 __gitcomp "$__git_merge_options"
1267                 return
1268         esac
1269         __gitcomp "$(__git_refs)"
1270 }
1271
1272 _git_mergetool ()
1273 {
1274         local cur="${COMP_WORDS[COMP_CWORD]}"
1275         case "$cur" in
1276         --tool=*)
1277                 __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
1278                 return
1279                 ;;
1280         --*)
1281                 __gitcomp "--tool="
1282                 return
1283                 ;;
1284         esac
1285         COMPREPLY=()
1286 }
1287
1288 _git_merge_base ()
1289 {
1290         __gitcomp "$(__git_refs)"
1291 }
1292
1293 _git_mv ()
1294 {
1295         local cur="${COMP_WORDS[COMP_CWORD]}"
1296         case "$cur" in
1297         --*)
1298                 __gitcomp "--dry-run"
1299                 return
1300                 ;;
1301         esac
1302         COMPREPLY=()
1303 }
1304
1305 _git_name_rev ()
1306 {
1307         __gitcomp "--tags --all --stdin"
1308 }
1309
1310 _git_notes ()
1311 {
1312         local subcommands="edit show"
1313         if [ -z "$(__git_find_on_cmdline "$subcommands")" ]; then
1314                 __gitcomp "$subcommands"
1315                 return
1316         fi
1317
1318         case "${COMP_WORDS[COMP_CWORD-1]}" in
1319         -m|-F)
1320                 COMPREPLY=()
1321                 ;;
1322         *)
1323                 __gitcomp "$(__git_refs)"
1324                 ;;
1325         esac
1326 }
1327
1328 _git_pull ()
1329 {
1330         __git_complete_strategy && return
1331
1332         local cur="${COMP_WORDS[COMP_CWORD]}"
1333         case "$cur" in
1334         --*)
1335                 __gitcomp "
1336                         --rebase --no-rebase
1337                         $__git_merge_options
1338                         $__git_fetch_options
1339                 "
1340                 return
1341                 ;;
1342         esac
1343         __git_complete_remote_or_refspec
1344 }
1345
1346 _git_push ()
1347 {
1348         local cur="${COMP_WORDS[COMP_CWORD]}"
1349         case "${COMP_WORDS[COMP_CWORD-1]}" in
1350         --repo)
1351                 __gitcomp "$(__git_remotes)"
1352                 return
1353         esac
1354         case "$cur" in
1355         --repo=*)
1356                 __gitcomp "$(__git_remotes)" "" "${cur##--repo=}"
1357                 return
1358                 ;;
1359         --*)
1360                 __gitcomp "
1361                         --all --mirror --tags --dry-run --force --verbose
1362                         --receive-pack= --repo=
1363                 "
1364                 return
1365                 ;;
1366         esac
1367         __git_complete_remote_or_refspec
1368 }
1369
1370 _git_rebase ()
1371 {
1372         local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
1373         if [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
1374                 __gitcomp "--continue --skip --abort"
1375                 return
1376         fi
1377         __git_complete_strategy && return
1378         case "$cur" in
1379         --whitespace=*)
1380                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1381                 return
1382                 ;;
1383         --*)
1384                 __gitcomp "
1385                         --onto --merge --strategy --interactive
1386                         --preserve-merges --stat --no-stat
1387                         --committer-date-is-author-date --ignore-date
1388                         --ignore-whitespace --whitespace=
1389                         --autosquash
1390                         "
1391
1392                 return
1393         esac
1394         __gitcomp "$(__git_refs)"
1395 }
1396
1397 __git_send_email_confirm_options="always never auto cc compose"
1398 __git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
1399
1400 _git_send_email ()
1401 {
1402         local cur="${COMP_WORDS[COMP_CWORD]}"
1403         case "$cur" in
1404         --confirm=*)
1405                 __gitcomp "
1406                         $__git_send_email_confirm_options
1407                         " "" "${cur##--confirm=}"
1408                 return
1409                 ;;
1410         --suppress-cc=*)
1411                 __gitcomp "
1412                         $__git_send_email_suppresscc_options
1413                         " "" "${cur##--suppress-cc=}"
1414
1415                 return
1416                 ;;
1417         --smtp-encryption=*)
1418                 __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
1419                 return
1420                 ;;
1421         --*)
1422                 __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
1423                         --compose --confirm= --dry-run --envelope-sender
1424                         --from --identity
1425                         --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
1426                         --no-suppress-from --no-thread --quiet
1427                         --signed-off-by-cc --smtp-pass --smtp-server
1428                         --smtp-server-port --smtp-encryption= --smtp-user
1429                         --subject --suppress-cc= --suppress-from --thread --to
1430                         --validate --no-validate"
1431                 return
1432                 ;;
1433         esac
1434         COMPREPLY=()
1435 }
1436
1437 __git_config_get_set_variables ()
1438 {
1439         local prevword word config_file= c=$COMP_CWORD
1440         while [ $c -gt 1 ]; do
1441                 word="${COMP_WORDS[c]}"
1442                 case "$word" in
1443                 --global|--system|--file=*)
1444                         config_file="$word"
1445                         break
1446                         ;;
1447                 -f|--file)
1448                         config_file="$word $prevword"
1449                         break
1450                         ;;
1451                 esac
1452                 prevword=$word
1453                 c=$((--c))
1454         done
1455
1456         git --git-dir="$(__gitdir)" config $config_file --list 2>/dev/null |
1457         while read line
1458         do
1459                 case "$line" in
1460                 *.*=*)
1461                         echo "${line/=*/}"
1462                         ;;
1463                 esac
1464         done
1465 }
1466
1467 _git_config ()
1468 {
1469         local cur="${COMP_WORDS[COMP_CWORD]}"
1470         local prv="${COMP_WORDS[COMP_CWORD-1]}"
1471         case "$prv" in
1472         branch.*.remote)
1473                 __gitcomp "$(__git_remotes)"
1474                 return
1475                 ;;
1476         branch.*.merge)
1477                 __gitcomp "$(__git_refs)"
1478                 return
1479                 ;;
1480         remote.*.fetch)
1481                 local remote="${prv#remote.}"
1482                 remote="${remote%.fetch}"
1483                 __gitcomp "$(__git_refs_remotes "$remote")"
1484                 return
1485                 ;;
1486         remote.*.push)
1487                 local remote="${prv#remote.}"
1488                 remote="${remote%.push}"
1489                 __gitcomp "$(git --git-dir="$(__gitdir)" \
1490                         for-each-ref --format='%(refname):%(refname)' \
1491                         refs/heads)"
1492                 return
1493                 ;;
1494         pull.twohead|pull.octopus)
1495                 __git_compute_merge_strategies
1496                 __gitcomp "$__git_merge_strategies"
1497                 return
1498                 ;;
1499         color.branch|color.diff|color.interactive|\
1500         color.showbranch|color.status|color.ui)
1501                 __gitcomp "always never auto"
1502                 return
1503                 ;;
1504         color.pager)
1505                 __gitcomp "false true"
1506                 return
1507                 ;;
1508         color.*.*)
1509                 __gitcomp "
1510                         normal black red green yellow blue magenta cyan white
1511                         bold dim ul blink reverse
1512                         "
1513                 return
1514                 ;;
1515         help.format)
1516                 __gitcomp "man info web html"
1517                 return
1518                 ;;
1519         log.date)
1520                 __gitcomp "$__git_log_date_formats"
1521                 return
1522                 ;;
1523         sendemail.aliasesfiletype)
1524                 __gitcomp "mutt mailrc pine elm gnus"
1525                 return
1526                 ;;
1527         sendemail.confirm)
1528                 __gitcomp "$__git_send_email_confirm_options"
1529                 return
1530                 ;;
1531         sendemail.suppresscc)
1532                 __gitcomp "$__git_send_email_suppresscc_options"
1533                 return
1534                 ;;
1535         --get|--get-all|--unset|--unset-all)
1536                 __gitcomp "$(__git_config_get_set_variables)"
1537                 return
1538                 ;;
1539         *.*)
1540                 COMPREPLY=()
1541                 return
1542                 ;;
1543         esac
1544         case "$cur" in
1545         --*)
1546                 __gitcomp "
1547                         --global --system --file=
1548                         --list --replace-all
1549                         --get --get-all --get-regexp
1550                         --add --unset --unset-all
1551                         --remove-section --rename-section
1552                         "
1553                 return
1554                 ;;
1555         branch.*.*)
1556                 local pfx="${cur%.*}."
1557                 cur="${cur##*.}"
1558                 __gitcomp "remote merge mergeoptions rebase" "$pfx" "$cur"
1559                 return
1560                 ;;
1561         branch.*)
1562                 local pfx="${cur%.*}."
1563                 cur="${cur#*.}"
1564                 __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
1565                 return
1566                 ;;
1567         guitool.*.*)
1568                 local pfx="${cur%.*}."
1569                 cur="${cur##*.}"
1570                 __gitcomp "
1571                         argprompt cmd confirm needsfile noconsole norescan
1572                         prompt revprompt revunmerged title
1573                         " "$pfx" "$cur"
1574                 return
1575                 ;;
1576         difftool.*.*)
1577                 local pfx="${cur%.*}."
1578                 cur="${cur##*.}"
1579                 __gitcomp "cmd path" "$pfx" "$cur"
1580                 return
1581                 ;;
1582         man.*.*)
1583                 local pfx="${cur%.*}."
1584                 cur="${cur##*.}"
1585                 __gitcomp "cmd path" "$pfx" "$cur"
1586                 return
1587                 ;;
1588         mergetool.*.*)
1589                 local pfx="${cur%.*}."
1590                 cur="${cur##*.}"
1591                 __gitcomp "cmd path trustExitCode" "$pfx" "$cur"
1592                 return
1593                 ;;
1594         pager.*)
1595                 local pfx="${cur%.*}."
1596                 cur="${cur#*.}"
1597                 __git_compute_all_commands
1598                 __gitcomp "$__git_all_commands" "$pfx" "$cur"
1599                 return
1600                 ;;
1601         remote.*.*)
1602                 local pfx="${cur%.*}."
1603                 cur="${cur##*.}"
1604                 __gitcomp "
1605                         url proxy fetch push mirror skipDefaultUpdate
1606                         receivepack uploadpack tagopt pushurl
1607                         " "$pfx" "$cur"
1608                 return
1609                 ;;
1610         remote.*)
1611                 local pfx="${cur%.*}."
1612                 cur="${cur#*.}"
1613                 __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
1614                 return
1615                 ;;
1616         url.*.*)
1617                 local pfx="${cur%.*}."
1618                 cur="${cur##*.}"
1619                 __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur"
1620                 return
1621                 ;;
1622         esac
1623         __gitcomp "
1624                 add.ignore-errors
1625                 alias.
1626                 apply.ignorewhitespace
1627                 apply.whitespace
1628                 branch.autosetupmerge
1629                 branch.autosetuprebase
1630                 clean.requireForce
1631                 color.branch
1632                 color.branch.current
1633                 color.branch.local
1634                 color.branch.plain
1635                 color.branch.remote
1636                 color.diff
1637                 color.diff.commit
1638                 color.diff.frag
1639                 color.diff.meta
1640                 color.diff.new
1641                 color.diff.old
1642                 color.diff.plain
1643                 color.diff.whitespace
1644                 color.grep
1645                 color.grep.external
1646                 color.grep.match
1647                 color.interactive
1648                 color.interactive.header
1649                 color.interactive.help
1650                 color.interactive.prompt
1651                 color.pager
1652                 color.showbranch
1653                 color.status
1654                 color.status.added
1655                 color.status.changed
1656                 color.status.header
1657                 color.status.nobranch
1658                 color.status.untracked
1659                 color.status.updated
1660                 color.ui
1661                 commit.template
1662                 core.autocrlf
1663                 core.bare
1664                 core.compression
1665                 core.createObject
1666                 core.deltaBaseCacheLimit
1667                 core.editor
1668                 core.excludesfile
1669                 core.fileMode
1670                 core.fsyncobjectfiles
1671                 core.gitProxy
1672                 core.ignoreCygwinFSTricks
1673                 core.ignoreStat
1674                 core.logAllRefUpdates
1675                 core.loosecompression
1676                 core.packedGitLimit
1677                 core.packedGitWindowSize
1678                 core.pager
1679                 core.preferSymlinkRefs
1680                 core.preloadindex
1681                 core.quotepath
1682                 core.repositoryFormatVersion
1683                 core.safecrlf
1684                 core.sharedRepository
1685                 core.symlinks
1686                 core.trustctime
1687                 core.warnAmbiguousRefs
1688                 core.whitespace
1689                 core.worktree
1690                 diff.autorefreshindex
1691                 diff.external
1692                 diff.mnemonicprefix
1693                 diff.renameLimit
1694                 diff.renameLimit.
1695                 diff.renames
1696                 diff.suppressBlankEmpty
1697                 diff.tool
1698                 diff.wordRegex
1699                 difftool.
1700                 difftool.prompt
1701                 fetch.unpackLimit
1702                 format.attach
1703                 format.cc
1704                 format.headers
1705                 format.numbered
1706                 format.pretty
1707                 format.signoff
1708                 format.subjectprefix
1709                 format.suffix
1710                 format.thread
1711                 gc.aggressiveWindow
1712                 gc.auto
1713                 gc.autopacklimit
1714                 gc.packrefs
1715                 gc.pruneexpire
1716                 gc.reflogexpire
1717                 gc.reflogexpireunreachable
1718                 gc.rerereresolved
1719                 gc.rerereunresolved
1720                 gitcvs.allbinary
1721                 gitcvs.commitmsgannotation
1722                 gitcvs.dbTableNamePrefix
1723                 gitcvs.dbdriver
1724                 gitcvs.dbname
1725                 gitcvs.dbpass
1726                 gitcvs.dbuser
1727                 gitcvs.enabled
1728                 gitcvs.logfile
1729                 gitcvs.usecrlfattr
1730                 guitool.
1731                 gui.blamehistoryctx
1732                 gui.commitmsgwidth
1733                 gui.copyblamethreshold
1734                 gui.diffcontext
1735                 gui.encoding
1736                 gui.fastcopyblame
1737                 gui.matchtrackingbranch
1738                 gui.newbranchtemplate
1739                 gui.pruneduringfetch
1740                 gui.spellingdictionary
1741                 gui.trustmtime
1742                 help.autocorrect
1743                 help.browser
1744                 help.format
1745                 http.lowSpeedLimit
1746                 http.lowSpeedTime
1747                 http.maxRequests
1748                 http.noEPSV
1749                 http.proxy
1750                 http.sslCAInfo
1751                 http.sslCAPath
1752                 http.sslCert
1753                 http.sslKey
1754                 http.sslVerify
1755                 i18n.commitEncoding
1756                 i18n.logOutputEncoding
1757                 imap.folder
1758                 imap.host
1759                 imap.pass
1760                 imap.port
1761                 imap.preformattedHTML
1762                 imap.sslverify
1763                 imap.tunnel
1764                 imap.user
1765                 instaweb.browser
1766                 instaweb.httpd
1767                 instaweb.local
1768                 instaweb.modulepath
1769                 instaweb.port
1770                 interactive.singlekey
1771                 log.date
1772                 log.showroot
1773                 mailmap.file
1774                 man.
1775                 man.viewer
1776                 merge.conflictstyle
1777                 merge.log
1778                 merge.renameLimit
1779                 merge.stat
1780                 merge.tool
1781                 merge.verbosity
1782                 mergetool.
1783                 mergetool.keepBackup
1784                 mergetool.prompt
1785                 pack.compression
1786                 pack.deltaCacheLimit
1787                 pack.deltaCacheSize
1788                 pack.depth
1789                 pack.indexVersion
1790                 pack.packSizeLimit
1791                 pack.threads
1792                 pack.window
1793                 pack.windowMemory
1794                 pager.
1795                 pull.octopus
1796                 pull.twohead
1797                 push.default
1798                 rebase.stat
1799                 receive.denyCurrentBranch
1800                 receive.denyDeletes
1801                 receive.denyNonFastForwards
1802                 receive.fsckObjects
1803                 receive.unpackLimit
1804                 repack.usedeltabaseoffset
1805                 rerere.autoupdate
1806                 rerere.enabled
1807                 sendemail.aliasesfile
1808                 sendemail.aliasesfiletype
1809                 sendemail.bcc
1810                 sendemail.cc
1811                 sendemail.cccmd
1812                 sendemail.chainreplyto
1813                 sendemail.confirm
1814                 sendemail.envelopesender
1815                 sendemail.multiedit
1816                 sendemail.signedoffbycc
1817                 sendemail.smtpencryption
1818                 sendemail.smtppass
1819                 sendemail.smtpserver
1820                 sendemail.smtpserverport
1821                 sendemail.smtpuser
1822                 sendemail.suppresscc
1823                 sendemail.suppressfrom
1824                 sendemail.thread
1825                 sendemail.to
1826                 sendemail.validate
1827                 showbranch.default
1828                 status.relativePaths
1829                 status.showUntrackedFiles
1830                 tar.umask
1831                 transfer.unpackLimit
1832                 url.
1833                 user.email
1834                 user.name
1835                 user.signingkey
1836                 web.browser
1837                 branch. remote.
1838         "
1839 }
1840
1841 _git_remote ()
1842 {
1843         local subcommands="add rename rm show prune update set-head"
1844         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1845         if [ -z "$subcommand" ]; then
1846                 __gitcomp "$subcommands"
1847                 return
1848         fi
1849
1850         case "$subcommand" in
1851         rename|rm|show|prune)
1852                 __gitcomp "$(__git_remotes)"
1853                 ;;
1854         update)
1855                 local i c='' IFS=$'\n'
1856                 for i in $(git --git-dir="$(__gitdir)" config --get-regexp "remotes\..*" 2>/dev/null); do
1857                         i="${i#remotes.}"
1858                         c="$c ${i/ */}"
1859                 done
1860                 __gitcomp "$c"
1861                 ;;
1862         *)
1863                 COMPREPLY=()
1864                 ;;
1865         esac
1866 }
1867
1868 _git_replace ()
1869 {
1870         __gitcomp "$(__git_refs)"
1871 }
1872
1873 _git_reset ()
1874 {
1875         __git_has_doubledash && return
1876
1877         local cur="${COMP_WORDS[COMP_CWORD]}"
1878         case "$cur" in
1879         --*)
1880                 __gitcomp "--merge --mixed --hard --soft --patch"
1881                 return
1882                 ;;
1883         esac
1884         __gitcomp "$(__git_refs)"
1885 }
1886
1887 _git_revert ()
1888 {
1889         local cur="${COMP_WORDS[COMP_CWORD]}"
1890         case "$cur" in
1891         --*)
1892                 __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
1893                 return
1894                 ;;
1895         esac
1896         __gitcomp "$(__git_refs)"
1897 }
1898
1899 _git_rm ()
1900 {
1901         __git_has_doubledash && return
1902
1903         local cur="${COMP_WORDS[COMP_CWORD]}"
1904         case "$cur" in
1905         --*)
1906                 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
1907                 return
1908                 ;;
1909         esac
1910         COMPREPLY=()
1911 }
1912
1913 _git_shortlog ()
1914 {
1915         __git_has_doubledash && return
1916
1917         local cur="${COMP_WORDS[COMP_CWORD]}"
1918         case "$cur" in
1919         --*)
1920                 __gitcomp "
1921                         $__git_log_common_options
1922                         $__git_log_shortlog_options
1923                         --numbered --summary
1924                         "
1925                 return
1926                 ;;
1927         esac
1928         __git_complete_revlist
1929 }
1930
1931 _git_show ()
1932 {
1933         __git_has_doubledash && return
1934
1935         local cur="${COMP_WORDS[COMP_CWORD]}"
1936         case "$cur" in
1937         --pretty=*)
1938                 __gitcomp "$__git_log_pretty_formats
1939                         " "" "${cur##--pretty=}"
1940                 return
1941                 ;;
1942         --format=*)
1943                 __gitcomp "$__git_log_pretty_formats
1944                         " "" "${cur##--format=}"
1945                 return
1946                 ;;
1947         --*)
1948                 __gitcomp "--pretty= --format= --abbrev-commit --oneline
1949                         $__git_diff_common_options
1950                         "
1951                 return
1952                 ;;
1953         esac
1954         __git_complete_file
1955 }
1956
1957 _git_show_branch ()
1958 {
1959         local cur="${COMP_WORDS[COMP_CWORD]}"
1960         case "$cur" in
1961         --*)
1962                 __gitcomp "
1963                         --all --remotes --topo-order --current --more=
1964                         --list --independent --merge-base --no-name
1965                         --color --no-color
1966                         --sha1-name --sparse --topics --reflog
1967                         "
1968                 return
1969                 ;;
1970         esac
1971         __git_complete_revlist
1972 }
1973
1974 _git_stash ()
1975 {
1976         local cur="${COMP_WORDS[COMP_CWORD]}"
1977         local save_opts='--keep-index --no-keep-index --quiet --patch'
1978         local subcommands='save list show apply clear drop pop create branch'
1979         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1980         if [ -z "$subcommand" ]; then
1981                 case "$cur" in
1982                 --*)
1983                         __gitcomp "$save_opts"
1984                         ;;
1985                 *)
1986                         if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
1987                                 __gitcomp "$subcommands"
1988                         else
1989                                 COMPREPLY=()
1990                         fi
1991                         ;;
1992                 esac
1993         else
1994                 case "$subcommand,$cur" in
1995                 save,--*)
1996                         __gitcomp "$save_opts"
1997                         ;;
1998                 apply,--*|pop,--*)
1999                         __gitcomp "--index --quiet"
2000                         ;;
2001                 show,--*|drop,--*|branch,--*)
2002                         COMPREPLY=()
2003                         ;;
2004                 show,*|apply,*|drop,*|pop,*|branch,*)
2005                         __gitcomp "$(git --git-dir="$(__gitdir)" stash list \
2006                                         | sed -n -e 's/:.*//p')"
2007                         ;;
2008                 *)
2009                         COMPREPLY=()
2010                         ;;
2011                 esac
2012         fi
2013 }
2014
2015 _git_submodule ()
2016 {
2017         __git_has_doubledash && return
2018
2019         local subcommands="add status init update summary foreach sync"
2020         if [ -z "$(__git_find_on_cmdline "$subcommands")" ]; then
2021                 local cur="${COMP_WORDS[COMP_CWORD]}"
2022                 case "$cur" in
2023                 --*)
2024                         __gitcomp "--quiet --cached"
2025                         ;;
2026                 *)
2027                         __gitcomp "$subcommands"
2028                         ;;
2029                 esac
2030                 return
2031         fi
2032 }
2033
2034 _git_svn ()
2035 {
2036         local subcommands="
2037                 init fetch clone rebase dcommit log find-rev
2038                 set-tree commit-diff info create-ignore propget
2039                 proplist show-ignore show-externals branch tag blame
2040                 migrate mkdirs reset gc
2041                 "
2042         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2043         if [ -z "$subcommand" ]; then
2044                 __gitcomp "$subcommands"
2045         else
2046                 local remote_opts="--username= --config-dir= --no-auth-cache"
2047                 local fc_opts="
2048                         --follow-parent --authors-file= --repack=
2049                         --no-metadata --use-svm-props --use-svnsync-props
2050                         --log-window-size= --no-checkout --quiet
2051                         --repack-flags --use-log-author --localtime
2052                         --ignore-paths= $remote_opts
2053                         "
2054                 local init_opts="
2055                         --template= --shared= --trunk= --tags=
2056                         --branches= --stdlayout --minimize-url
2057                         --no-metadata --use-svm-props --use-svnsync-props
2058                         --rewrite-root= --prefix= --use-log-author
2059                         --add-author-from $remote_opts
2060                         "
2061                 local cmt_opts="
2062                         --edit --rmdir --find-copies-harder --copy-similarity=
2063                         "
2064
2065                 local cur="${COMP_WORDS[COMP_CWORD]}"
2066                 case "$subcommand,$cur" in
2067                 fetch,--*)
2068                         __gitcomp "--revision= --fetch-all $fc_opts"
2069                         ;;
2070                 clone,--*)
2071                         __gitcomp "--revision= $fc_opts $init_opts"
2072                         ;;
2073                 init,--*)
2074                         __gitcomp "$init_opts"
2075                         ;;
2076                 dcommit,--*)
2077                         __gitcomp "
2078                                 --merge --strategy= --verbose --dry-run
2079                                 --fetch-all --no-rebase --commit-url
2080                                 --revision $cmt_opts $fc_opts
2081                                 "
2082                         ;;
2083                 set-tree,--*)
2084                         __gitcomp "--stdin $cmt_opts $fc_opts"
2085                         ;;
2086                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
2087                 show-externals,--*|mkdirs,--*)
2088                         __gitcomp "--revision="
2089                         ;;
2090                 log,--*)
2091                         __gitcomp "
2092                                 --limit= --revision= --verbose --incremental
2093                                 --oneline --show-commit --non-recursive
2094                                 --authors-file= --color
2095                                 "
2096                         ;;
2097                 rebase,--*)
2098                         __gitcomp "
2099                                 --merge --verbose --strategy= --local
2100                                 --fetch-all --dry-run $fc_opts
2101                                 "
2102                         ;;
2103                 commit-diff,--*)
2104                         __gitcomp "--message= --file= --revision= $cmt_opts"
2105                         ;;
2106                 info,--*)
2107                         __gitcomp "--url"
2108                         ;;
2109                 branch,--*)
2110                         __gitcomp "--dry-run --message --tag"
2111                         ;;
2112                 tag,--*)
2113                         __gitcomp "--dry-run --message"
2114                         ;;
2115                 blame,--*)
2116                         __gitcomp "--git-format"
2117                         ;;
2118                 migrate,--*)
2119                         __gitcomp "
2120                                 --config-dir= --ignore-paths= --minimize
2121                                 --no-auth-cache --username=
2122                                 "
2123                         ;;
2124                 reset,--*)
2125                         __gitcomp "--revision= --parent"
2126                         ;;
2127                 *)
2128                         COMPREPLY=()
2129                         ;;
2130                 esac
2131         fi
2132 }
2133
2134 _git_tag ()
2135 {
2136         local i c=1 f=0
2137         while [ $c -lt $COMP_CWORD ]; do
2138                 i="${COMP_WORDS[c]}"
2139                 case "$i" in
2140                 -d|-v)
2141                         __gitcomp "$(__git_tags)"
2142                         return
2143                         ;;
2144                 -f)
2145                         f=1
2146                         ;;
2147                 esac
2148                 c=$((++c))
2149         done
2150
2151         case "${COMP_WORDS[COMP_CWORD-1]}" in
2152         -m|-F)
2153                 COMPREPLY=()
2154                 ;;
2155         -*|tag)
2156                 if [ $f = 1 ]; then
2157                         __gitcomp "$(__git_tags)"
2158                 else
2159                         COMPREPLY=()
2160                 fi
2161                 ;;
2162         *)
2163                 __gitcomp "$(__git_refs)"
2164                 ;;
2165         esac
2166 }
2167
2168 _git ()
2169 {
2170         local i c=1 command __git_dir
2171
2172         while [ $c -lt $COMP_CWORD ]; do
2173                 i="${COMP_WORDS[c]}"
2174                 case "$i" in
2175                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
2176                 --bare)      __git_dir="." ;;
2177                 --version|-p|--paginate) ;;
2178                 --help) command="help"; break ;;
2179                 *) command="$i"; break ;;
2180                 esac
2181                 c=$((++c))
2182         done
2183
2184         if [ -z "$command" ]; then
2185                 case "${COMP_WORDS[COMP_CWORD]}" in
2186                 --*)   __gitcomp "
2187                         --paginate
2188                         --no-pager
2189                         --git-dir=
2190                         --bare
2191                         --version
2192                         --exec-path
2193                         --html-path
2194                         --work-tree=
2195                         --help
2196                         "
2197                         ;;
2198                 *)     __git_compute_porcelain_commands
2199                        __gitcomp "$__git_porcelain_commands $(__git_aliases)" ;;
2200                 esac
2201                 return
2202         fi
2203
2204         local expansion=$(__git_aliased_command "$command")
2205         [ "$expansion" ] && command="$expansion"
2206
2207         case "$command" in
2208         am)          _git_am ;;
2209         add)         _git_add ;;
2210         apply)       _git_apply ;;
2211         archive)     _git_archive ;;
2212         bisect)      _git_bisect ;;
2213         bundle)      _git_bundle ;;
2214         branch)      _git_branch ;;
2215         checkout)    _git_checkout ;;
2216         cherry)      _git_cherry ;;
2217         cherry-pick) _git_cherry_pick ;;
2218         clean)       _git_clean ;;
2219         clone)       _git_clone ;;
2220         commit)      _git_commit ;;
2221         config)      _git_config ;;
2222         describe)    _git_describe ;;
2223         diff)        _git_diff ;;
2224         difftool)    _git_difftool ;;
2225         fetch)       _git_fetch ;;
2226         format-patch) _git_format_patch ;;
2227         fsck)        _git_fsck ;;
2228         gc)          _git_gc ;;
2229         grep)        _git_grep ;;
2230         help)        _git_help ;;
2231         init)        _git_init ;;
2232         log)         _git_log ;;
2233         ls-files)    _git_ls_files ;;
2234         ls-remote)   _git_ls_remote ;;
2235         ls-tree)     _git_ls_tree ;;
2236         merge)       _git_merge;;
2237         mergetool)   _git_mergetool;;
2238         merge-base)  _git_merge_base ;;
2239         mv)          _git_mv ;;
2240         name-rev)    _git_name_rev ;;
2241         notes)       _git_notes ;;
2242         pull)        _git_pull ;;
2243         push)        _git_push ;;
2244         rebase)      _git_rebase ;;
2245         remote)      _git_remote ;;
2246         replace)     _git_replace ;;
2247         reset)       _git_reset ;;
2248         revert)      _git_revert ;;
2249         rm)          _git_rm ;;
2250         send-email)  _git_send_email ;;
2251         shortlog)    _git_shortlog ;;
2252         show)        _git_show ;;
2253         show-branch) _git_show_branch ;;
2254         stash)       _git_stash ;;
2255         stage)       _git_add ;;
2256         submodule)   _git_submodule ;;
2257         svn)         _git_svn ;;
2258         tag)         _git_tag ;;
2259         whatchanged) _git_log ;;
2260         *)           COMPREPLY=() ;;
2261         esac
2262 }
2263
2264 _gitk ()
2265 {
2266         __git_has_doubledash && return
2267
2268         local cur="${COMP_WORDS[COMP_CWORD]}"
2269         local g="$(__gitdir)"
2270         local merge=""
2271         if [ -f "$g/MERGE_HEAD" ]; then
2272                 merge="--merge"
2273         fi
2274         case "$cur" in
2275         --*)
2276                 __gitcomp "
2277                         $__git_log_common_options
2278                         $__git_log_gitk_options
2279                         $merge
2280                         "
2281                 return
2282                 ;;
2283         esac
2284         __git_complete_revlist
2285 }
2286
2287 complete -o bashdefault -o default -o nospace -F _git git 2>/dev/null \
2288         || complete -o default -o nospace -F _git git
2289 complete -o bashdefault -o default -o nospace -F _gitk gitk 2>/dev/null \
2290         || complete -o default -o nospace -F _gitk gitk
2291
2292 # The following are necessary only for Cygwin, and only are needed
2293 # when the user has tab-completed the executable name and consequently
2294 # included the '.exe' suffix.
2295 #
2296 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
2297 complete -o bashdefault -o default -o nospace -F _git git.exe 2>/dev/null \
2298         || complete -o default -o nospace -F _git git.exe
2299 fi