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