contrib/completion/git-completion.bash

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