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         --set-upstream-to=*)
 879                 __gitcomp "$(__git_refs)" "" "${cur##--set-upstream-to=}"
 880                 ;;
 881         --*)
 882                 __gitcomp "
 883                         --color --no-color --verbose --abbrev= --no-abbrev
 884                         --track --no-track --contains --merged --no-merged
 885                         --set-upstream-to= --edit-description --list
 886                         --unset-upstream
 887                         "
 888                 ;;
 889         *)
 890                 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
 891                         __gitcomp_nl "$(__git_heads)"
 892                 else
 893                         __gitcomp_nl "$(__git_refs)"
 894                 fi
 895                 ;;
 896         esac
 897 }
 898
 899 _git_bundle ()
 900 {
 901         local cmd="${words[2]}"
 902         case "$cword" in
 903         2)
 904                 __gitcomp "create list-heads verify unbundle"
 905                 ;;
 906         3)
 907                 # looking for a file
 908                 ;;
 909         *)
 910                 case "$cmd" in
 911                         create)
 912                                 __git_complete_revlist
 913                         ;;
 914                 esac
 915                 ;;
 916         esac
 917 }
 918
 919 _git_checkout ()
 920 {
 921         __git_has_doubledash && return
 922
 923         case "$cur" in
 924         --conflict=*)
 925                 __gitcomp "diff3 merge" "" "${cur##--conflict=}"
 926                 ;;
 927         --*)
 928                 __gitcomp "
 929                         --quiet --ours --theirs --track --no-track --merge
 930                         --conflict= --orphan --patch
 931                         "
 932                 ;;
 933         *)
 934                 # check if --track, --no-track, or --no-guess was specified
 935                 # if so, disable DWIM mode
 936                 local flags="--track --no-track --no-guess" track=1
 937                 if [ -n "$(__git_find_on_cmdline "$flags")" ]; then
 938                         track=''
 939                 fi
 940                 __gitcomp_nl "$(__git_refs '' $track)"
 941                 ;;
 942         esac
 943 }
 944
 945 _git_cherry ()
 946 {
 947         __gitcomp "$(__git_refs)"
 948 }
 949
 950 _git_cherry_pick ()
 951 {
 952         case "$cur" in
 953         --*)
 954                 __gitcomp "--edit --no-commit"
 955                 ;;
 956         *)
 957                 __gitcomp_nl "$(__git_refs)"
 958                 ;;
 959         esac
 960 }
 961
 962 _git_clean ()
 963 {
 964         __git_has_doubledash && return
 965
 966         case "$cur" in
 967         --*)
 968                 __gitcomp "--dry-run --quiet"
 969                 return
 970                 ;;
 971         esac
 972         COMPREPLY=()
 973 }
 974
 975 _git_clone ()
 976 {
 977         case "$cur" in
 978         --*)
 979                 __gitcomp "
 980                         --local
 981                         --no-hardlinks
 982                         --shared
 983                         --reference
 984                         --quiet
 985                         --no-checkout
 986                         --bare
 987                         --mirror
 988                         --origin
 989                         --upload-pack
 990                         --template=
 991                         --depth
 992                         "
 993                 return
 994                 ;;
 995         esac
 996         COMPREPLY=()
 997 }
 998
 999 _git_commit ()
1000 {
1001         __git_has_doubledash && return
1002
1003         case "$cur" in
1004         --cleanup=*)
1005                 __gitcomp "default strip verbatim whitespace
1006                         " "" "${cur##--cleanup=}"
1007                 return
1008                 ;;
1009         --reuse-message=*|--reedit-message=*|\
1010         --fixup=*|--squash=*)
1011                 __gitcomp_nl "$(__git_refs)" "" "${cur#*=}"
1012                 return
1013                 ;;
1014         --untracked-files=*)
1015                 __gitcomp "all no normal" "" "${cur##--untracked-files=}"
1016                 return
1017                 ;;
1018         --*)
1019                 __gitcomp "
1020                         --all --author= --signoff --verify --no-verify
1021                         --edit --no-edit
1022                         --amend --include --only --interactive
1023                         --dry-run --reuse-message= --reedit-message=
1024                         --reset-author --file= --message= --template=
1025                         --cleanup= --untracked-files --untracked-files=
1026                         --verbose --quiet --fixup= --squash=
1027                         "
1028                 return
1029         esac
1030         COMPREPLY=()
1031 }
1032
1033 _git_describe ()
1034 {
1035         case "$cur" in
1036         --*)
1037                 __gitcomp "
1038                         --all --tags --contains --abbrev= --candidates=
1039                         --exact-match --debug --long --match --always
1040                         "
1041                 return
1042         esac
1043         __gitcomp_nl "$(__git_refs)"
1044 }
1045
1046 __git_diff_common_options="--stat --numstat --shortstat --summary
1047                         --patch-with-stat --name-only --name-status --color
1048                         --no-color --color-words --no-renames --check
1049                         --full-index --binary --abbrev --diff-filter=
1050                         --find-copies-harder
1051                         --text --ignore-space-at-eol --ignore-space-change
1052                         --ignore-all-space --exit-code --quiet --ext-diff
1053                         --no-ext-diff
1054                         --no-prefix --src-prefix= --dst-prefix=
1055                         --inter-hunk-context=
1056                         --patience
1057                         --raw
1058                         --dirstat --dirstat= --dirstat-by-file
1059                         --dirstat-by-file= --cumulative
1060 "
1061
1062 _git_diff ()
1063 {
1064         __git_has_doubledash && return
1065
1066         case "$cur" in
1067         --*)
1068                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1069                         --base --ours --theirs --no-index
1070                         $__git_diff_common_options
1071                         "
1072                 return
1073                 ;;
1074         esac
1075         __git_complete_revlist_file
1076 }
1077
1078 __git_mergetools_common="diffuse ecmerge emerge kdiff3 meld opendiff
1079                         tkdiff vimdiff gvimdiff xxdiff araxis p4merge bc3 codecompare
1080 "
1081
1082 _git_difftool ()
1083 {
1084         __git_has_doubledash && return
1085
1086         case "$cur" in
1087         --tool=*)
1088                 __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
1089                 return
1090                 ;;
1091         --*)
1092                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1093                         --base --ours --theirs
1094                         --no-renames --diff-filter= --find-copies-harder
1095                         --relative --ignore-submodules
1096                         --tool="
1097                 return
1098                 ;;
1099         esac
1100         __git_complete_file
1101 }
1102
1103 __git_fetch_options="
1104         --quiet --verbose --append --upload-pack --force --keep --depth=
1105         --tags --no-tags --all --prune --dry-run
1106 "
1107
1108 _git_fetch ()
1109 {
1110         case "$cur" in
1111         --*)
1112                 __gitcomp "$__git_fetch_options"
1113                 return
1114                 ;;
1115         esac
1116         __git_complete_remote_or_refspec
1117 }
1118
1119 _git_format_patch ()
1120 {
1121         case "$cur" in
1122         --thread=*)
1123                 __gitcomp "
1124                         deep shallow
1125                         " "" "${cur##--thread=}"
1126                 return
1127                 ;;
1128         --*)
1129                 __gitcomp "
1130                         --stdout --attach --no-attach --thread --thread=
1131                         --output-directory
1132                         --numbered --start-number
1133                         --numbered-files
1134                         --keep-subject
1135                         --signoff --signature --no-signature
1136                         --in-reply-to= --cc=
1137                         --full-index --binary
1138                         --not --all
1139                         --cover-letter
1140                         --no-prefix --src-prefix= --dst-prefix=
1141                         --inline --suffix= --ignore-if-in-upstream
1142                         --subject-prefix=
1143                         "
1144                 return
1145                 ;;
1146         esac
1147         __git_complete_revlist
1148 }
1149
1150 _git_fsck ()
1151 {
1152         case "$cur" in
1153         --*)
1154                 __gitcomp "
1155                         --tags --root --unreachable --cache --no-reflogs --full
1156                         --strict --verbose --lost-found
1157                         "
1158                 return
1159                 ;;
1160         esac
1161         COMPREPLY=()
1162 }
1163
1164 _git_gc ()
1165 {
1166         case "$cur" in
1167         --*)
1168                 __gitcomp "--prune --aggressive"
1169                 return
1170                 ;;
1171         esac
1172         COMPREPLY=()
1173 }
1174
1175 _git_gitk ()
1176 {
1177         _gitk
1178 }
1179
1180 __git_match_ctag() {
1181         awk "/^${1////\\/}/ { print \$1 }" "$2"
1182 }
1183
1184 _git_grep ()
1185 {
1186         __git_has_doubledash && return
1187
1188         case "$cur" in
1189         --*)
1190                 __gitcomp "
1191                         --cached
1192                         --text --ignore-case --word-regexp --invert-match
1193                         --full-name --line-number
1194                         --extended-regexp --basic-regexp --fixed-strings
1195                         --perl-regexp
1196                         --files-with-matches --name-only
1197                         --files-without-match
1198                         --max-depth
1199                         --count
1200                         --and --or --not --all-match
1201                         "
1202                 return
1203                 ;;
1204         esac
1205
1206         case "$cword,$prev" in
1207         2,*|*,-*)
1208                 if test -r tags; then
1209                         __gitcomp_nl "$(__git_match_ctag "$cur" tags)"
1210                         return
1211                 fi
1212                 ;;
1213         esac
1214
1215         __gitcomp_nl "$(__git_refs)"
1216 }
1217
1218 _git_help ()
1219 {
1220         case "$cur" in
1221         --*)
1222                 __gitcomp "--all --info --man --web"
1223                 return
1224                 ;;
1225         esac
1226         __git_compute_all_commands
1227         __gitcomp "$__git_all_commands $(__git_aliases)
1228                 attributes cli core-tutorial cvs-migration
1229                 diffcore gitk glossary hooks ignore modules
1230                 namespaces repository-layout tutorial tutorial-2
1231                 workflows
1232                 "
1233 }
1234
1235 _git_init ()
1236 {
1237         case "$cur" in
1238         --shared=*)
1239                 __gitcomp "
1240                         false true umask group all world everybody
1241                         " "" "${cur##--shared=}"
1242                 return
1243                 ;;
1244         --*)
1245                 __gitcomp "--quiet --bare --template= --shared --shared="
1246                 return
1247                 ;;
1248         esac
1249         COMPREPLY=()
1250 }
1251
1252 _git_ls_files ()
1253 {
1254         __git_has_doubledash && return
1255
1256         case "$cur" in
1257         --*)
1258                 __gitcomp "--cached --deleted --modified --others --ignored
1259                         --stage --directory --no-empty-directory --unmerged
1260                         --killed --exclude= --exclude-from=
1261                         --exclude-per-directory= --exclude-standard
1262                         --error-unmatch --with-tree= --full-name
1263                         --abbrev --ignored --exclude-per-directory
1264                         "
1265                 return
1266                 ;;
1267         esac
1268         COMPREPLY=()
1269 }
1270
1271 _git_ls_remote ()
1272 {
1273         __gitcomp_nl "$(__git_remotes)"
1274 }
1275
1276 _git_ls_tree ()
1277 {
1278         __git_complete_file
1279 }
1280
1281 # Options that go well for log, shortlog and gitk
1282 __git_log_common_options="
1283         --not --all
1284         --branches --tags --remotes
1285         --first-parent --merges --no-merges
1286         --max-count=
1287         --max-age= --since= --after=
1288         --min-age= --until= --before=
1289         --min-parents= --max-parents=
1290         --no-min-parents --no-max-parents
1291 "
1292 # Options that go well for log and gitk (not shortlog)
1293 __git_log_gitk_options="
1294         --dense --sparse --full-history
1295         --simplify-merges --simplify-by-decoration
1296         --left-right --notes --no-notes
1297 "
1298 # Options that go well for log and shortlog (not gitk)
1299 __git_log_shortlog_options="
1300         --author= --committer= --grep=
1301         --all-match
1302 "
1303
1304 __git_log_pretty_formats="oneline short medium full fuller email raw format:"
1305 __git_log_date_formats="relative iso8601 rfc2822 short local default raw"
1306
1307 _git_log ()
1308 {
1309         __git_has_doubledash && return
1310
1311         local g="$(git rev-parse --git-dir 2>/dev/null)"
1312         local merge=""
1313         if [ -f "$g/MERGE_HEAD" ]; then
1314                 merge="--merge"
1315         fi
1316         case "$cur" in
1317         --pretty=*|--format=*)
1318                 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
1319                         " "" "${cur#*=}"
1320                 return
1321                 ;;
1322         --date=*)
1323                 __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
1324                 return
1325                 ;;
1326         --decorate=*)
1327                 __gitcomp "long short" "" "${cur##--decorate=}"
1328                 return
1329                 ;;
1330         --*)
1331                 __gitcomp "
1332                         $__git_log_common_options
1333                         $__git_log_shortlog_options
1334                         $__git_log_gitk_options
1335                         --root --topo-order --date-order --reverse
1336                         --follow --full-diff
1337                         --abbrev-commit --abbrev=
1338                         --relative-date --date=
1339                         --pretty= --format= --oneline
1340                         --cherry-pick
1341                         --graph
1342                         --decorate --decorate=
1343                         --walk-reflogs
1344                         --parents --children
1345                         $merge
1346                         $__git_diff_common_options
1347                         --pickaxe-all --pickaxe-regex
1348                         "
1349                 return
1350                 ;;
1351         esac
1352         __git_complete_revlist
1353 }
1354
1355 __git_merge_options="
1356         --no-commit --no-stat --log --no-log --squash --strategy
1357         --commit --stat --no-squash --ff --no-ff --ff-only --edit --no-edit
1358 "
1359
1360 _git_merge ()
1361 {
1362         __git_complete_strategy && return
1363
1364         case "$cur" in
1365         --*)
1366                 __gitcomp "$__git_merge_options"
1367                 return
1368         esac
1369         __gitcomp_nl "$(__git_refs)"
1370 }
1371
1372 _git_mergetool ()
1373 {
1374         case "$cur" in
1375         --tool=*)
1376                 __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
1377                 return
1378                 ;;
1379         --*)
1380                 __gitcomp "--tool="
1381                 return
1382                 ;;
1383         esac
1384         COMPREPLY=()
1385 }
1386
1387 _git_merge_base ()
1388 {
1389         __gitcomp_nl "$(__git_refs)"
1390 }
1391
1392 _git_mv ()
1393 {
1394         case "$cur" in
1395         --*)
1396                 __gitcomp "--dry-run"
1397                 return
1398                 ;;
1399         esac
1400         COMPREPLY=()
1401 }
1402
1403 _git_name_rev ()
1404 {
1405         __gitcomp "--tags --all --stdin"
1406 }
1407
1408 _git_notes ()
1409 {
1410         local subcommands='add append copy edit list prune remove show'
1411         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1412
1413         case "$subcommand,$cur" in
1414         ,--*)
1415                 __gitcomp '--ref'
1416                 ;;
1417         ,*)
1418                 case "$prev" in
1419                 --ref)
1420                         __gitcomp_nl "$(__git_refs)"
1421                         ;;
1422                 *)
1423                         __gitcomp "$subcommands --ref"
1424                         ;;
1425                 esac
1426                 ;;
1427         add,--reuse-message=*|append,--reuse-message=*|\
1428         add,--reedit-message=*|append,--reedit-message=*)
1429                 __gitcomp_nl "$(__git_refs)" "" "${cur#*=}"
1430                 ;;
1431         add,--*|append,--*)
1432                 __gitcomp '--file= --message= --reedit-message=
1433                                 --reuse-message='
1434                 ;;
1435         copy,--*)
1436                 __gitcomp '--stdin'
1437                 ;;
1438         prune,--*)
1439                 __gitcomp '--dry-run --verbose'
1440                 ;;
1441         prune,*)
1442                 ;;
1443         *)
1444                 case "$prev" in
1445                 -m|-F)
1446                         ;;
1447                 *)
1448                         __gitcomp_nl "$(__git_refs)"
1449                         ;;
1450                 esac
1451                 ;;
1452         esac
1453 }
1454
1455 _git_pull ()
1456 {
1457         __git_complete_strategy && return
1458
1459         case "$cur" in
1460         --*)
1461                 __gitcomp "
1462                         --rebase --no-rebase
1463                         $__git_merge_options
1464                         $__git_fetch_options
1465                 "
1466                 return
1467                 ;;
1468         esac
1469         __git_complete_remote_or_refspec
1470 }
1471
1472 _git_push ()
1473 {
1474         case "$prev" in
1475         --repo)
1476                 __gitcomp_nl "$(__git_remotes)"
1477                 return
1478         esac
1479         case "$cur" in
1480         --repo=*)
1481                 __gitcomp_nl "$(__git_remotes)" "" "${cur##--repo=}"
1482                 return
1483                 ;;
1484         --*)
1485                 __gitcomp "
1486                         --all --mirror --tags --dry-run --force --verbose
1487                         --receive-pack= --repo= --set-upstream
1488                 "
1489                 return
1490                 ;;
1491         esac
1492         __git_complete_remote_or_refspec
1493 }
1494
1495 _git_rebase ()
1496 {
1497         local dir="$(__gitdir)"
1498         if [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
1499                 __gitcomp "--continue --skip --abort"
1500                 return
1501         fi
1502         __git_complete_strategy && return
1503         case "$cur" in
1504         --whitespace=*)
1505                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1506                 return
1507                 ;;
1508         --*)
1509                 __gitcomp "
1510                         --onto --merge --strategy --interactive
1511                         --preserve-merges --stat --no-stat
1512                         --committer-date-is-author-date --ignore-date
1513                         --ignore-whitespace --whitespace=
1514                         --autosquash
1515                         "
1516
1517                 return
1518         esac
1519         __gitcomp_nl "$(__git_refs)"
1520 }
1521
1522 _git_reflog ()
1523 {
1524         local subcommands="show delete expire"
1525         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1526
1527         if [ -z "$subcommand" ]; then
1528                 __gitcomp "$subcommands"
1529         else
1530                 __gitcomp_nl "$(__git_refs)"
1531         fi
1532 }
1533
1534 __git_send_email_confirm_options="always never auto cc compose"
1535 __git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
1536
1537 _git_send_email ()
1538 {
1539         case "$cur" in
1540         --confirm=*)
1541                 __gitcomp "
1542                         $__git_send_email_confirm_options
1543                         " "" "${cur##--confirm=}"
1544                 return
1545                 ;;
1546         --suppress-cc=*)
1547                 __gitcomp "
1548                         $__git_send_email_suppresscc_options
1549                         " "" "${cur##--suppress-cc=}"
1550
1551                 return
1552                 ;;
1553         --smtp-encryption=*)
1554                 __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
1555                 return
1556                 ;;
1557         --*)
1558                 __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
1559                         --compose --confirm= --dry-run --envelope-sender
1560                         --from --identity
1561                         --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
1562                         --no-suppress-from --no-thread --quiet
1563                         --signed-off-by-cc --smtp-pass --smtp-server
1564                         --smtp-server-port --smtp-encryption= --smtp-user
1565                         --subject --suppress-cc= --suppress-from --thread --to
1566                         --validate --no-validate"
1567                 return
1568                 ;;
1569         esac
1570         COMPREPLY=()
1571 }
1572
1573 _git_stage ()
1574 {
1575         _git_add
1576 }
1577
1578 __git_config_get_set_variables ()
1579 {
1580         local prevword word config_file= c=$cword
1581         while [ $c -gt 1 ]; do
1582                 word="${words[c]}"
1583                 case "$word" in
1584                 --global|--system|--file=*)
1585                         config_file="$word"
1586                         break
1587                         ;;
1588                 -f|--file)
1589                         config_file="$word $prevword"
1590                         break
1591                         ;;
1592                 esac
1593                 prevword=$word
1594                 c=$((--c))
1595         done
1596
1597         git --git-dir="$(__gitdir)" config $config_file --list 2>/dev/null |
1598         while read -r line
1599         do
1600                 case "$line" in
1601                 *.*=*)
1602                         echo "${line/=*/}"
1603                         ;;
1604                 esac
1605         done
1606 }
1607
1608 _git_config ()
1609 {
1610         case "$prev" in
1611         branch.*.remote)
1612                 __gitcomp_nl "$(__git_remotes)"
1613                 return
1614                 ;;
1615         branch.*.merge)
1616                 __gitcomp_nl "$(__git_refs)"
1617                 return
1618                 ;;
1619         remote.*.fetch)
1620                 local remote="${prev#remote.}"
1621                 remote="${remote%.fetch}"
1622                 if [ -z "$cur" ]; then
1623                         COMPREPLY=("refs/heads/")
1624                         return
1625                 fi
1626                 __gitcomp_nl "$(__git_refs_remotes "$remote")"
1627                 return
1628                 ;;
1629         remote.*.push)
1630                 local remote="${prev#remote.}"
1631                 remote="${remote%.push}"
1632                 __gitcomp_nl "$(git --git-dir="$(__gitdir)" \
1633                         for-each-ref --format='%(refname):%(refname)' \
1634                         refs/heads)"
1635                 return
1636                 ;;
1637         pull.twohead|pull.octopus)
1638                 __git_compute_merge_strategies
1639                 __gitcomp "$__git_merge_strategies"
1640                 return
1641                 ;;
1642         color.branch|color.diff|color.interactive|\
1643         color.showbranch|color.status|color.ui)
1644                 __gitcomp "always never auto"
1645                 return
1646                 ;;
1647         color.pager)
1648                 __gitcomp "false true"
1649                 return
1650                 ;;
1651         color.*.*)
1652                 __gitcomp "
1653                         normal black red green yellow blue magenta cyan white
1654                         bold dim ul blink reverse
1655                         "
1656                 return
1657                 ;;
1658         help.format)
1659                 __gitcomp "man info web html"
1660                 return
1661                 ;;
1662         log.date)
1663                 __gitcomp "$__git_log_date_formats"
1664                 return
1665                 ;;
1666         sendemail.aliasesfiletype)
1667                 __gitcomp "mutt mailrc pine elm gnus"
1668                 return
1669                 ;;
1670         sendemail.confirm)
1671                 __gitcomp "$__git_send_email_confirm_options"
1672                 return
1673                 ;;
1674         sendemail.suppresscc)
1675                 __gitcomp "$__git_send_email_suppresscc_options"
1676                 return
1677                 ;;
1678         --get|--get-all|--unset|--unset-all)
1679                 __gitcomp_nl "$(__git_config_get_set_variables)"
1680                 return
1681                 ;;
1682         *.*)
1683                 COMPREPLY=()
1684                 return
1685                 ;;
1686         esac
1687         case "$cur" in
1688         --*)
1689                 __gitcomp "
1690                         --global --system --file=
1691                         --list --replace-all
1692                         --get --get-all --get-regexp
1693                         --add --unset --unset-all
1694                         --remove-section --rename-section
1695                         "
1696                 return
1697                 ;;
1698         branch.*.*)
1699                 local pfx="${cur%.*}." cur_="${cur##*.}"
1700                 __gitcomp "remote merge mergeoptions rebase" "$pfx" "$cur_"
1701                 return
1702                 ;;
1703         branch.*)
1704                 local pfx="${cur%.*}." cur_="${cur#*.}"
1705                 __gitcomp_nl "$(__git_heads)" "$pfx" "$cur_" "."
1706                 return
1707                 ;;
1708         guitool.*.*)
1709                 local pfx="${cur%.*}." cur_="${cur##*.}"
1710                 __gitcomp "
1711                         argprompt cmd confirm needsfile noconsole norescan
1712                         prompt revprompt revunmerged title
1713                         " "$pfx" "$cur_"
1714                 return
1715                 ;;
1716         difftool.*.*)
1717                 local pfx="${cur%.*}." cur_="${cur##*.}"
1718                 __gitcomp "cmd path" "$pfx" "$cur_"
1719                 return
1720                 ;;
1721         man.*.*)
1722                 local pfx="${cur%.*}." cur_="${cur##*.}"
1723                 __gitcomp "cmd path" "$pfx" "$cur_"
1724                 return
1725                 ;;
1726         mergetool.*.*)
1727                 local pfx="${cur%.*}." cur_="${cur##*.}"
1728                 __gitcomp "cmd path trustExitCode" "$pfx" "$cur_"
1729                 return
1730                 ;;
1731         pager.*)
1732                 local pfx="${cur%.*}." cur_="${cur#*.}"
1733                 __git_compute_all_commands
1734                 __gitcomp_nl "$__git_all_commands" "$pfx" "$cur_"
1735                 return
1736                 ;;
1737         remote.*.*)
1738                 local pfx="${cur%.*}." cur_="${cur##*.}"
1739                 __gitcomp "
1740                         url proxy fetch push mirror skipDefaultUpdate
1741                         receivepack uploadpack tagopt pushurl
1742                         " "$pfx" "$cur_"
1743                 return
1744                 ;;
1745         remote.*)
1746                 local pfx="${cur%.*}." cur_="${cur#*.}"
1747                 __gitcomp_nl "$(__git_remotes)" "$pfx" "$cur_" "."
1748                 return
1749                 ;;
1750         url.*.*)
1751                 local pfx="${cur%.*}." cur_="${cur##*.}"
1752                 __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur_"
1753                 return
1754                 ;;
1755         esac
1756         __gitcomp "
1757                 add.ignoreErrors
1758                 advice.commitBeforeMerge
1759                 advice.detachedHead
1760                 advice.implicitIdentity
1761                 advice.pushNonFastForward
1762                 advice.resolveConflict
1763                 advice.statusHints
1764                 alias.
1765                 am.keepcr
1766                 apply.ignorewhitespace
1767                 apply.whitespace
1768                 branch.autosetupmerge
1769                 branch.autosetuprebase
1770                 browser.
1771                 clean.requireForce
1772                 color.branch
1773                 color.branch.current
1774                 color.branch.local
1775                 color.branch.plain
1776                 color.branch.remote
1777                 color.decorate.HEAD
1778                 color.decorate.branch
1779                 color.decorate.remoteBranch
1780                 color.decorate.stash
1781                 color.decorate.tag
1782                 color.diff
1783                 color.diff.commit
1784                 color.diff.frag
1785                 color.diff.func
1786                 color.diff.meta
1787                 color.diff.new
1788                 color.diff.old
1789                 color.diff.plain
1790                 color.diff.whitespace
1791                 color.grep
1792                 color.grep.context
1793                 color.grep.filename
1794                 color.grep.function
1795                 color.grep.linenumber
1796                 color.grep.match
1797                 color.grep.selected
1798                 color.grep.separator
1799                 color.interactive
1800                 color.interactive.error
1801                 color.interactive.header
1802                 color.interactive.help
1803                 color.interactive.prompt
1804                 color.pager
1805                 color.showbranch
1806                 color.status
1807                 color.status.added
1808                 color.status.changed
1809                 color.status.header
1810                 color.status.nobranch
1811                 color.status.untracked
1812                 color.status.updated
1813                 color.ui
1814                 commit.status
1815                 commit.template
1816                 core.abbrev
1817                 core.askpass
1818                 core.attributesfile
1819                 core.autocrlf
1820                 core.bare
1821                 core.bigFileThreshold
1822                 core.compression
1823                 core.createObject
1824                 core.deltaBaseCacheLimit
1825                 core.editor
1826                 core.eol
1827                 core.excludesfile
1828                 core.fileMode
1829                 core.fsyncobjectfiles
1830                 core.gitProxy
1831                 core.ignoreCygwinFSTricks
1832                 core.ignoreStat
1833                 core.ignorecase
1834                 core.logAllRefUpdates
1835                 core.loosecompression
1836                 core.notesRef
1837                 core.packedGitLimit
1838                 core.packedGitWindowSize
1839                 core.pager
1840                 core.preferSymlinkRefs
1841                 core.preloadindex
1842                 core.quotepath
1843                 core.repositoryFormatVersion
1844                 core.safecrlf
1845                 core.sharedRepository
1846                 core.sparseCheckout
1847                 core.symlinks
1848                 core.trustctime
1849                 core.warnAmbiguousRefs
1850                 core.whitespace
1851                 core.worktree
1852                 diff.autorefreshindex
1853                 diff.statGraphWidth
1854                 diff.external
1855                 diff.ignoreSubmodules
1856                 diff.mnemonicprefix
1857                 diff.noprefix
1858                 diff.renameLimit
1859                 diff.renames
1860                 diff.suppressBlankEmpty
1861                 diff.tool
1862                 diff.wordRegex
1863                 difftool.
1864                 difftool.prompt
1865                 fetch.recurseSubmodules
1866                 fetch.unpackLimit
1867                 format.attach
1868                 format.cc
1869                 format.headers
1870                 format.numbered
1871                 format.pretty
1872                 format.signature
1873                 format.signoff
1874                 format.subjectprefix
1875                 format.suffix
1876                 format.thread
1877                 format.to
1878                 gc.
1879                 gc.aggressiveWindow
1880                 gc.auto
1881                 gc.autopacklimit
1882                 gc.packrefs
1883                 gc.pruneexpire
1884                 gc.reflogexpire
1885                 gc.reflogexpireunreachable
1886                 gc.rerereresolved
1887                 gc.rerereunresolved
1888                 gitcvs.allbinary
1889                 gitcvs.commitmsgannotation
1890                 gitcvs.dbTableNamePrefix
1891                 gitcvs.dbdriver
1892                 gitcvs.dbname
1893                 gitcvs.dbpass
1894                 gitcvs.dbuser
1895                 gitcvs.enabled
1896                 gitcvs.logfile
1897                 gitcvs.usecrlfattr
1898                 guitool.
1899                 gui.blamehistoryctx
1900                 gui.commitmsgwidth
1901                 gui.copyblamethreshold
1902                 gui.diffcontext
1903                 gui.encoding
1904                 gui.fastcopyblame
1905                 gui.matchtrackingbranch
1906                 gui.newbranchtemplate
1907                 gui.pruneduringfetch
1908                 gui.spellingdictionary
1909                 gui.trustmtime
1910                 help.autocorrect
1911                 help.browser
1912                 help.format
1913                 http.lowSpeedLimit
1914                 http.lowSpeedTime
1915                 http.maxRequests
1916                 http.minSessions
1917                 http.noEPSV
1918                 http.postBuffer
1919                 http.proxy
1920                 http.sslCAInfo
1921                 http.sslCAPath
1922                 http.sslCert
1923                 http.sslCertPasswordProtected
1924                 http.sslKey
1925                 http.sslVerify
1926                 http.useragent
1927                 i18n.commitEncoding
1928                 i18n.logOutputEncoding
1929                 imap.authMethod
1930                 imap.folder
1931                 imap.host
1932                 imap.pass
1933                 imap.port
1934                 imap.preformattedHTML
1935                 imap.sslverify
1936                 imap.tunnel
1937                 imap.user
1938                 init.templatedir
1939                 instaweb.browser
1940                 instaweb.httpd
1941                 instaweb.local
1942                 instaweb.modulepath
1943                 instaweb.port
1944                 interactive.singlekey
1945                 log.date
1946                 log.decorate
1947                 log.showroot
1948                 mailmap.file
1949                 man.
1950                 man.viewer
1951                 merge.
1952                 merge.conflictstyle
1953                 merge.log
1954                 merge.renameLimit
1955                 merge.renormalize
1956                 merge.stat
1957                 merge.tool
1958                 merge.verbosity
1959                 mergetool.
1960                 mergetool.keepBackup
1961                 mergetool.keepTemporaries
1962                 mergetool.prompt
1963                 notes.displayRef
1964                 notes.rewrite.
1965                 notes.rewrite.amend
1966                 notes.rewrite.rebase
1967                 notes.rewriteMode
1968                 notes.rewriteRef
1969                 pack.compression
1970                 pack.deltaCacheLimit
1971                 pack.deltaCacheSize
1972                 pack.depth
1973                 pack.indexVersion
1974                 pack.packSizeLimit
1975                 pack.threads
1976                 pack.window
1977                 pack.windowMemory
1978                 pager.
1979                 pretty.
1980                 pull.octopus
1981                 pull.twohead
1982                 push.default
1983                 rebase.autosquash
1984                 rebase.stat
1985                 receive.autogc
1986                 receive.denyCurrentBranch
1987                 receive.denyDeleteCurrent
1988                 receive.denyDeletes
1989                 receive.denyNonFastForwards
1990                 receive.fsckObjects
1991                 receive.unpackLimit
1992                 receive.updateserverinfo
1993                 remotes.
1994                 repack.usedeltabaseoffset
1995                 rerere.autoupdate
1996                 rerere.enabled
1997                 sendemail.
1998                 sendemail.aliasesfile
1999                 sendemail.aliasfiletype
2000                 sendemail.bcc
2001                 sendemail.cc
2002                 sendemail.cccmd
2003                 sendemail.chainreplyto
2004                 sendemail.confirm
2005                 sendemail.envelopesender
2006                 sendemail.from
2007                 sendemail.identity
2008                 sendemail.multiedit
2009                 sendemail.signedoffbycc
2010                 sendemail.smtpdomain
2011                 sendemail.smtpencryption
2012                 sendemail.smtppass
2013                 sendemail.smtpserver
2014                 sendemail.smtpserveroption
2015                 sendemail.smtpserverport
2016                 sendemail.smtpuser
2017                 sendemail.suppresscc
2018                 sendemail.suppressfrom
2019                 sendemail.thread
2020                 sendemail.to
2021                 sendemail.validate
2022                 showbranch.default
2023                 status.relativePaths
2024                 status.showUntrackedFiles
2025                 status.submodulesummary
2026                 submodule.
2027                 tar.umask
2028                 transfer.unpackLimit
2029                 url.
2030                 user.email
2031                 user.name
2032                 user.signingkey
2033                 web.browser
2034                 branch. remote.
2035         "
2036 }
2037
2038 _git_remote ()
2039 {
2040         local subcommands="add rename remove set-head set-branches set-url show prune update"
2041         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2042         if [ -z "$subcommand" ]; then
2043                 __gitcomp "$subcommands"
2044                 return
2045         fi
2046
2047         case "$subcommand" in
2048         rename|remove|set-url|show|prune)
2049                 __gitcomp_nl "$(__git_remotes)"
2050                 ;;
2051         set-head|set-branches)
2052                 __git_complete_remote_or_refspec
2053                 ;;
2054         update)
2055                 local i c='' IFS=$'\n'
2056                 for i in $(git --git-dir="$(__gitdir)" config --get-regexp "remotes\..*" 2>/dev/null); do
2057                         i="${i#remotes.}"
2058                         c="$c ${i/ */}"
2059                 done
2060                 __gitcomp "$c"
2061                 ;;
2062         *)
2063                 COMPREPLY=()
2064                 ;;
2065         esac
2066 }
2067
2068 _git_replace ()
2069 {
2070         __gitcomp_nl "$(__git_refs)"
2071 }
2072
2073 _git_reset ()
2074 {
2075         __git_has_doubledash && return
2076
2077         case "$cur" in
2078         --*)
2079                 __gitcomp "--merge --mixed --hard --soft --patch"
2080                 return
2081                 ;;
2082         esac
2083         __gitcomp_nl "$(__git_refs)"
2084 }
2085
2086 _git_revert ()
2087 {
2088         case "$cur" in
2089         --*)
2090                 __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
2091                 return
2092                 ;;
2093         esac
2094         __gitcomp_nl "$(__git_refs)"
2095 }
2096
2097 _git_rm ()
2098 {
2099         __git_has_doubledash && return
2100
2101         case "$cur" in
2102         --*)
2103                 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
2104                 return
2105                 ;;
2106         esac
2107         COMPREPLY=()
2108 }
2109
2110 _git_shortlog ()
2111 {
2112         __git_has_doubledash && return
2113
2114         case "$cur" in
2115         --*)
2116                 __gitcomp "
2117                         $__git_log_common_options
2118                         $__git_log_shortlog_options
2119                         --numbered --summary
2120                         "
2121                 return
2122                 ;;
2123         esac
2124         __git_complete_revlist
2125 }
2126
2127 _git_show ()
2128 {
2129         __git_has_doubledash && return
2130
2131         case "$cur" in
2132         --pretty=*|--format=*)
2133                 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
2134                         " "" "${cur#*=}"
2135                 return
2136                 ;;
2137         --*)
2138                 __gitcomp "--pretty= --format= --abbrev-commit --oneline
2139                         $__git_diff_common_options
2140                         "
2141                 return
2142                 ;;
2143         esac
2144         __git_complete_file
2145 }
2146
2147 _git_show_branch ()
2148 {
2149         case "$cur" in
2150         --*)
2151                 __gitcomp "
2152                         --all --remotes --topo-order --current --more=
2153                         --list --independent --merge-base --no-name
2154                         --color --no-color
2155                         --sha1-name --sparse --topics --reflog
2156                         "
2157                 return
2158                 ;;
2159         esac
2160         __git_complete_revlist
2161 }
2162
2163 _git_stash ()
2164 {
2165         local save_opts='--keep-index --no-keep-index --quiet --patch'
2166         local subcommands='save list show apply clear drop pop create branch'
2167         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2168         if [ -z "$subcommand" ]; then
2169                 case "$cur" in
2170                 --*)
2171                         __gitcomp "$save_opts"
2172                         ;;
2173                 *)
2174                         if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2175                                 __gitcomp "$subcommands"
2176                         else
2177                                 COMPREPLY=()
2178                         fi
2179                         ;;
2180                 esac
2181         else
2182                 case "$subcommand,$cur" in
2183                 save,--*)
2184                         __gitcomp "$save_opts"
2185                         ;;
2186                 apply,--*|pop,--*)
2187                         __gitcomp "--index --quiet"
2188                         ;;
2189                 show,--*|drop,--*|branch,--*)
2190                         COMPREPLY=()
2191                         ;;
2192                 show,*|apply,*|drop,*|pop,*|branch,*)
2193                         __gitcomp_nl "$(git --git-dir="$(__gitdir)" stash list \
2194                                         | sed -n -e 's/:.*//p')"
2195                         ;;
2196                 *)
2197                         COMPREPLY=()
2198                         ;;
2199                 esac
2200         fi
2201 }
2202
2203 _git_submodule ()
2204 {
2205         __git_has_doubledash && return
2206
2207         local subcommands="add status init update summary foreach sync"
2208         if [ -z "$(__git_find_on_cmdline "$subcommands")" ]; then
2209                 case "$cur" in
2210                 --*)
2211                         __gitcomp "--quiet --cached"
2212                         ;;
2213                 *)
2214                         __gitcomp "$subcommands"
2215                         ;;
2216                 esac
2217                 return
2218         fi
2219 }
2220
2221 _git_svn ()
2222 {
2223         local subcommands="
2224                 init fetch clone rebase dcommit log find-rev
2225                 set-tree commit-diff info create-ignore propget
2226                 proplist show-ignore show-externals branch tag blame
2227                 migrate mkdirs reset gc
2228                 "
2229         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2230         if [ -z "$subcommand" ]; then
2231                 __gitcomp "$subcommands"
2232         else
2233                 local remote_opts="--username= --config-dir= --no-auth-cache"
2234                 local fc_opts="
2235                         --follow-parent --authors-file= --repack=
2236                         --no-metadata --use-svm-props --use-svnsync-props
2237                         --log-window-size= --no-checkout --quiet
2238                         --repack-flags --use-log-author --localtime
2239                         --ignore-paths= $remote_opts
2240                         "
2241                 local init_opts="
2242                         --template= --shared= --trunk= --tags=
2243                         --branches= --stdlayout --minimize-url
2244                         --no-metadata --use-svm-props --use-svnsync-props
2245                         --rewrite-root= --prefix= --use-log-author
2246                         --add-author-from $remote_opts
2247                         "
2248                 local cmt_opts="
2249                         --edit --rmdir --find-copies-harder --copy-similarity=
2250                         "
2251
2252                 case "$subcommand,$cur" in
2253                 fetch,--*)
2254                         __gitcomp "--revision= --fetch-all $fc_opts"
2255                         ;;
2256                 clone,--*)
2257                         __gitcomp "--revision= $fc_opts $init_opts"
2258                         ;;
2259                 init,--*)
2260                         __gitcomp "$init_opts"
2261                         ;;
2262                 dcommit,--*)
2263                         __gitcomp "
2264                                 --merge --strategy= --verbose --dry-run
2265                                 --fetch-all --no-rebase --commit-url
2266                                 --revision --interactive $cmt_opts $fc_opts
2267                                 "
2268                         ;;
2269                 set-tree,--*)
2270                         __gitcomp "--stdin $cmt_opts $fc_opts"
2271                         ;;
2272                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
2273                 show-externals,--*|mkdirs,--*)
2274                         __gitcomp "--revision="
2275                         ;;
2276                 log,--*)
2277                         __gitcomp "
2278                                 --limit= --revision= --verbose --incremental
2279                                 --oneline --show-commit --non-recursive
2280                                 --authors-file= --color
2281                                 "
2282                         ;;
2283                 rebase,--*)
2284                         __gitcomp "
2285                                 --merge --verbose --strategy= --local
2286                                 --fetch-all --dry-run $fc_opts
2287                                 "
2288                         ;;
2289                 commit-diff,--*)
2290                         __gitcomp "--message= --file= --revision= $cmt_opts"
2291                         ;;
2292                 info,--*)
2293                         __gitcomp "--url"
2294                         ;;
2295                 branch,--*)
2296                         __gitcomp "--dry-run --message --tag"
2297                         ;;
2298                 tag,--*)
2299                         __gitcomp "--dry-run --message"
2300                         ;;
2301                 blame,--*)
2302                         __gitcomp "--git-format"
2303                         ;;
2304                 migrate,--*)
2305                         __gitcomp "
2306                                 --config-dir= --ignore-paths= --minimize
2307                                 --no-auth-cache --username=
2308                                 "
2309                         ;;
2310                 reset,--*)
2311                         __gitcomp "--revision= --parent"
2312                         ;;
2313                 *)
2314                         COMPREPLY=()
2315                         ;;
2316                 esac
2317         fi
2318 }
2319
2320 _git_tag ()
2321 {
2322         local i c=1 f=0
2323         while [ $c -lt $cword ]; do
2324                 i="${words[c]}"
2325                 case "$i" in
2326                 -d|-v)
2327                         __gitcomp_nl "$(__git_tags)"
2328                         return
2329                         ;;
2330                 -f)
2331                         f=1
2332                         ;;
2333                 esac
2334                 ((c++))
2335         done
2336
2337         case "$prev" in
2338         -m|-F)
2339                 COMPREPLY=()
2340                 ;;
2341         -*|tag)
2342                 if [ $f = 1 ]; then
2343                         __gitcomp_nl "$(__git_tags)"
2344                 else
2345                         COMPREPLY=()
2346                 fi
2347                 ;;
2348         *)
2349                 __gitcomp_nl "$(__git_refs)"
2350                 ;;
2351         esac
2352 }
2353
2354 _git_whatchanged ()
2355 {
2356         _git_log
2357 }
2358
2359 __git_main ()
2360 {
2361         local i c=1 command __git_dir
2362
2363         while [ $c -lt $cword ]; do
2364                 i="${words[c]}"
2365                 case "$i" in
2366                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
2367                 --bare)      __git_dir="." ;;
2368                 --help) command="help"; break ;;
2369                 -c) c=$((++c)) ;;
2370                 -*) ;;
2371                 *) command="$i"; break ;;
2372                 esac
2373                 ((c++))
2374         done
2375
2376         if [ -z "$command" ]; then
2377                 case "$cur" in
2378                 --*)   __gitcomp "
2379                         --paginate
2380                         --no-pager
2381                         --git-dir=
2382                         --bare
2383                         --version
2384                         --exec-path
2385                         --exec-path=
2386                         --html-path
2387                         --info-path
2388                         --work-tree=
2389                         --namespace=
2390                         --no-replace-objects
2391                         --help
2392                         "
2393                         ;;
2394                 *)     __git_compute_porcelain_commands
2395                        __gitcomp "$__git_porcelain_commands $(__git_aliases)" ;;
2396                 esac
2397                 return
2398         fi
2399
2400         local completion_func="_git_${command//-/_}"
2401         declare -f $completion_func >/dev/null && $completion_func && return
2402
2403         local expansion=$(__git_aliased_command "$command")
2404         if [ -n "$expansion" ]; then
2405                 completion_func="_git_${expansion//-/_}"
2406                 declare -f $completion_func >/dev/null && $completion_func
2407         fi
2408 }
2409
2410 __gitk_main ()
2411 {
2412         __git_has_doubledash && return
2413
2414         local g="$(__gitdir)"
2415         local merge=""
2416         if [ -f "$g/MERGE_HEAD" ]; then
2417                 merge="--merge"
2418         fi
2419         case "$cur" in
2420         --*)
2421                 __gitcomp "
2422                         $__git_log_common_options
2423                         $__git_log_gitk_options
2424                         $merge
2425                         "
2426                 return
2427                 ;;
2428         esac
2429         __git_complete_revlist
2430 }
2431
2432 __git_func_wrap ()
2433 {
2434         if [[ -n ${ZSH_VERSION-} ]]; then
2435                 emulate -L bash
2436                 setopt KSH_TYPESET
2437
2438                 # workaround zsh's bug that leaves 'words' as a special
2439                 # variable in versions < 4.3.12
2440                 typeset -h words
2441
2442                 # workaround zsh's bug that quotes spaces in the COMPREPLY
2443                 # array if IFS doesn't contain spaces.
2444                 typeset -h IFS
2445         fi
2446         local cur words cword prev
2447         _get_comp_words_by_ref -n =: cur words cword prev
2448         $1
2449 }
2450
2451 # Setup completion for certain functions defined above by setting common
2452 # variables and workarounds.
2453 # This is NOT a public function; use at your own risk.
2454 __git_complete ()
2455 {
2456         local wrapper="__git_wrap${2}"
2457         eval "$wrapper () { __git_func_wrap $2 ; }"
2458         complete -o bashdefault -o default -o nospace -F $wrapper $1 2>/dev/null \
2459                 || complete -o default -o nospace -F $wrapper $1
2460 }
2461
2462 # wrapper for backwards compatibility
2463 _git ()
2464 {
2465         __git_wrap__git_main
2466 }
2467
2468 # wrapper for backwards compatibility
2469 _gitk ()
2470 {
2471         __git_wrap__gitk_main
2472 }
2473
2474 __git_complete git __git_main
2475 __git_complete gitk __gitk_main
2476
2477 # The following are necessary only for Cygwin, and only are needed
2478 # when the user has tab-completed the executable name and consequently
2479 # included the '.exe' suffix.
2480 #
2481 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
2482 __git_complete git.exe __git_main
2483 fi