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