contrib/completion/git-completion.bash

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