git.oblomov.eu Git - git/blob - 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                 -d|--delete) [ "$cmd" = "push" ] && lhs=0 ;;
 713                 --all)
 714                         case "$cmd" in
 715                         push) no_complete_refspec=1 ;;
 716                         fetch)
 717                                 return
 718                                 ;;
 719                         *) ;;
 720                         esac
 721                         ;;
 722                 -*) ;;
 723                 *) remote="$i"; break ;;
 724                 esac
 725                 ((c++))
 726         done
 727         if [ -z "$remote" ]; then
 728                 __gitcomp_nl "$(__git_remotes)"
 729                 return
 730         fi
 731         if [ $no_complete_refspec = 1 ]; then
 732                 return
 733         fi
 734         [ "$remote" = "." ] && remote=
 735         case "$cur_" in
 736         *:*)
 737                 case "$COMP_WORDBREAKS" in
 738                 *:*) : great ;;
 739                 *)   pfx="${cur_%%:*}:" ;;
 740                 esac
 741                 cur_="${cur_#*:}"
 742                 lhs=0
 743                 ;;
 744         +*)
 745                 pfx="+"
 746                 cur_="${cur_#+}"
 747                 ;;
 748         esac
 749         case "$cmd" in
 750         fetch)
 751                 if [ $lhs = 1 ]; then
 752                         __git_complete_fetch_refspecs "$remote" "$pfx" "$cur_"
 753                 else
 754                         __git_complete_refs --pfx="$pfx" --cur="$cur_"
 755                 fi
 756                 ;;
 757         pull|remote)
 758                 if [ $lhs = 1 ]; then
 759                         __git_complete_refs --remote="$remote" --pfx="$pfx" --cur="$cur_"
 760                 else
 761                         __git_complete_refs --pfx="$pfx" --cur="$cur_"
 762                 fi
 763                 ;;
 764         push)
 765                 if [ $lhs = 1 ]; then
 766                         __git_complete_refs --pfx="$pfx" --cur="$cur_"
 767                 else
 768                         __git_complete_refs --remote="$remote" --pfx="$pfx" --cur="$cur_"
 769                 fi
 770                 ;;
 771         esac
 772 }
 773
 774 __git_complete_strategy ()
 775 {
 776         __git_compute_merge_strategies
 777         case "$prev" in
 778         -s|--strategy)
 779                 __gitcomp "$__git_merge_strategies"
 780                 return 0
 781         esac
 782         case "$cur" in
 783         --strategy=*)
 784                 __gitcomp "$__git_merge_strategies" "" "${cur##--strategy=}"
 785                 return 0
 786                 ;;
 787         esac
 788         return 1
 789 }
 790
 791 __git_commands () {
 792         if test -n "${GIT_TESTING_COMMAND_COMPLETION:-}"
 793         then
 794                 printf "%s" "${GIT_TESTING_COMMAND_COMPLETION}"
 795         else
 796                 git help -a|egrep '^  [a-zA-Z0-9]'
 797         fi
 798 }
 799
 800 __git_list_all_commands ()
 801 {
 802         local i IFS=" "$'\n'
 803         for i in $(__git_commands)
 804         do
 805                 case $i in
 806                 *--*)             : helper pattern;;
 807                 *) echo $i;;
 808                 esac
 809         done
 810 }
 811
 812 __git_all_commands=
 813 __git_compute_all_commands ()
 814 {
 815         test -n "$__git_all_commands" ||
 816         __git_all_commands=$(__git_list_all_commands)
 817 }
 818
 819 __git_list_porcelain_commands ()
 820 {
 821         local i IFS=" "$'\n'
 822         __git_compute_all_commands
 823         for i in $__git_all_commands
 824         do
 825                 case $i in
 826                 *--*)             : helper pattern;;
 827                 applymbox)        : ask gittus;;
 828                 applypatch)       : ask gittus;;
 829                 archimport)       : import;;
 830                 cat-file)         : plumbing;;
 831                 check-attr)       : plumbing;;
 832                 check-ignore)     : plumbing;;
 833                 check-mailmap)    : plumbing;;
 834                 check-ref-format) : plumbing;;
 835                 checkout-index)   : plumbing;;
 836                 column)           : internal helper;;
 837                 commit-tree)      : plumbing;;
 838                 count-objects)    : infrequent;;
 839                 credential)       : credentials;;
 840                 credential-*)     : credentials helper;;
 841                 cvsexportcommit)  : export;;
 842                 cvsimport)        : import;;
 843                 cvsserver)        : daemon;;
 844                 daemon)           : daemon;;
 845                 diff-files)       : plumbing;;
 846                 diff-index)       : plumbing;;
 847                 diff-tree)        : plumbing;;
 848                 fast-import)      : import;;
 849                 fast-export)      : export;;
 850                 fsck-objects)     : plumbing;;
 851                 fetch-pack)       : plumbing;;
 852                 fmt-merge-msg)    : plumbing;;
 853                 for-each-ref)     : plumbing;;
 854                 hash-object)      : plumbing;;
 855                 http-*)           : transport;;
 856                 index-pack)       : plumbing;;
 857                 init-db)          : deprecated;;
 858                 local-fetch)      : plumbing;;
 859                 ls-files)         : plumbing;;
 860                 ls-remote)        : plumbing;;
 861                 ls-tree)          : plumbing;;
 862                 mailinfo)         : plumbing;;
 863                 mailsplit)        : plumbing;;
 864                 merge-*)          : plumbing;;
 865                 mktree)           : plumbing;;
 866                 mktag)            : plumbing;;
 867                 pack-objects)     : plumbing;;
 868                 pack-redundant)   : plumbing;;
 869                 pack-refs)        : plumbing;;
 870                 parse-remote)     : plumbing;;
 871                 patch-id)         : plumbing;;
 872                 prune)            : plumbing;;
 873                 prune-packed)     : plumbing;;
 874                 quiltimport)      : import;;
 875                 read-tree)        : plumbing;;
 876                 receive-pack)     : plumbing;;
 877                 remote-*)         : transport;;
 878                 rerere)           : plumbing;;
 879                 rev-list)         : plumbing;;
 880                 rev-parse)        : plumbing;;
 881                 runstatus)        : plumbing;;
 882                 sh-setup)         : internal;;
 883                 shell)            : daemon;;
 884                 show-ref)         : plumbing;;
 885                 send-pack)        : plumbing;;
 886                 show-index)       : plumbing;;
 887                 ssh-*)            : transport;;
 888                 stripspace)       : plumbing;;
 889                 symbolic-ref)     : plumbing;;
 890                 unpack-file)      : plumbing;;
 891                 unpack-objects)   : plumbing;;
 892                 update-index)     : plumbing;;
 893                 update-ref)       : plumbing;;
 894                 update-server-info) : daemon;;
 895                 upload-archive)   : plumbing;;
 896                 upload-pack)      : plumbing;;
 897                 write-tree)       : plumbing;;
 898                 var)              : infrequent;;
 899                 verify-pack)      : infrequent;;
 900                 verify-tag)       : plumbing;;
 901                 *) echo $i;;
 902                 esac
 903         done
 904 }
 905
 906 __git_porcelain_commands=
 907 __git_compute_porcelain_commands ()
 908 {
 909         test -n "$__git_porcelain_commands" ||
 910         __git_porcelain_commands=$(__git_list_porcelain_commands)
 911 }
 912
 913 # Lists all set config variables starting with the given section prefix,
 914 # with the prefix removed.
 915 __git_get_config_variables ()
 916 {
 917         local section="$1" i IFS=$'\n'
 918         for i in $(__git config --name-only --get-regexp "^$section\..*"); do
 919                 echo "${i#$section.}"
 920         done
 921 }
 922
 923 __git_pretty_aliases ()
 924 {
 925         __git_get_config_variables "pretty"
 926 }
 927
 928 __git_aliases ()
 929 {
 930         __git_get_config_variables "alias"
 931 }
 932
 933 # __git_aliased_command requires 1 argument
 934 __git_aliased_command ()
 935 {
 936         local word cmdline=$(__git config --get "alias.$1")
 937         for word in $cmdline; do
 938                 case "$word" in
 939                 \!gitk|gitk)
 940                         echo "gitk"
 941                         return
 942                         ;;
 943                 \!*)    : shell command alias ;;
 944                 -*)     : option ;;
 945                 *=*)    : setting env ;;
 946                 git)    : git itself ;;
 947                 \(\))   : skip parens of shell function definition ;;
 948                 {)      : skip start of shell helper function ;;
 949                 :)      : skip null command ;;
 950                 \'*)    : skip opening quote after sh -c ;;
 951                 *)
 952                         echo "$word"
 953                         return
 954                 esac
 955         done
 956 }
 957
 958 # __git_find_on_cmdline requires 1 argument
 959 __git_find_on_cmdline ()
 960 {
 961         local word subcommand c=1
 962         while [ $c -lt $cword ]; do
 963                 word="${words[c]}"
 964                 for subcommand in $1; do
 965                         if [ "$subcommand" = "$word" ]; then
 966                                 echo "$subcommand"
 967                                 return
 968                         fi
 969                 done
 970                 ((c++))
 971         done
 972 }
 973
 974 # Echo the value of an option set on the command line or config
 975 #
 976 # $1: short option name
 977 # $2: long option name including =
 978 # $3: list of possible values
 979 # $4: config string (optional)
 980 #
 981 # example:
 982 # result="$(__git_get_option_value "-d" "--do-something=" \
 983 #     "yes no" "core.doSomething")"
 984 #
 985 # result is then either empty (no option set) or "yes" or "no"
 986 #
 987 # __git_get_option_value requires 3 arguments
 988 __git_get_option_value ()
 989 {
 990         local c short_opt long_opt val
 991         local result= values config_key word
 992
 993         short_opt="$1"
 994         long_opt="$2"
 995         values="$3"
 996         config_key="$4"
 997
 998         ((c = $cword - 1))
 999         while [ $c -ge 0 ]; do
1000                 word="${words[c]}"
1001                 for val in $values; do
1002                         if [ "$short_opt$val" = "$word" ] ||
1003                            [ "$long_opt$val"  = "$word" ]; then
1004                                 result="$val"
1005                                 break 2
1006                         fi
1007                 done
1008                 ((c--))
1009         done
1010
1011         if [ -n "$config_key" ] && [ -z "$result" ]; then
1012                 result="$(__git config "$config_key")"
1013         fi
1014
1015         echo "$result"
1016 }
1017
1018 __git_has_doubledash ()
1019 {
1020         local c=1
1021         while [ $c -lt $cword ]; do
1022                 if [ "--" = "${words[c]}" ]; then
1023                         return 0
1024                 fi
1025                 ((c++))
1026         done
1027         return 1
1028 }
1029
1030 # Try to count non option arguments passed on the command line for the
1031 # specified git command.
1032 # When options are used, it is necessary to use the special -- option to
1033 # tell the implementation were non option arguments begin.
1034 # XXX this can not be improved, since options can appear everywhere, as
1035 # an example:
1036 #       git mv x -n y
1037 #
1038 # __git_count_arguments requires 1 argument: the git command executed.
1039 __git_count_arguments ()
1040 {
1041         local word i c=0
1042
1043         # Skip "git" (first argument)
1044         for ((i=1; i < ${#words[@]}; i++)); do
1045                 word="${words[i]}"
1046
1047                 case "$word" in
1048                         --)
1049                                 # Good; we can assume that the following are only non
1050                                 # option arguments.
1051                                 ((c = 0))
1052                                 ;;
1053                         "$1")
1054                                 # Skip the specified git command and discard git
1055                                 # main options
1056                                 ((c = 0))
1057                                 ;;
1058                         ?*)
1059                                 ((c++))
1060                                 ;;
1061                 esac
1062         done
1063
1064         printf "%d" $c
1065 }
1066
1067 __git_whitespacelist="nowarn warn error error-all fix"
1068
1069 _git_am ()
1070 {
1071         __git_find_repo_path
1072         if [ -d "$__git_repo_path"/rebase-apply ]; then
1073                 __gitcomp "--skip --continue --resolved --abort"
1074                 return
1075         fi
1076         case "$cur" in
1077         --whitespace=*)
1078                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1079                 return
1080                 ;;
1081         --*)
1082                 __gitcomp "
1083                         --3way --committer-date-is-author-date --ignore-date
1084                         --ignore-whitespace --ignore-space-change
1085                         --interactive --keep --no-utf8 --signoff --utf8
1086                         --whitespace= --scissors
1087                         "
1088                 return
1089         esac
1090 }
1091
1092 _git_apply ()
1093 {
1094         case "$cur" in
1095         --whitespace=*)
1096                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1097                 return
1098                 ;;
1099         --*)
1100                 __gitcomp "
1101                         --stat --numstat --summary --check --index
1102                         --cached --index-info --reverse --reject --unidiff-zero
1103                         --apply --no-add --exclude=
1104                         --ignore-whitespace --ignore-space-change
1105                         --whitespace= --inaccurate-eof --verbose
1106                         --recount --directory=
1107                         "
1108                 return
1109         esac
1110 }
1111
1112 _git_add ()
1113 {
1114         case "$cur" in
1115         --*)
1116                 __gitcomp "
1117                         --interactive --refresh --patch --update --dry-run
1118                         --ignore-errors --intent-to-add --force --edit --chmod=
1119                         "
1120                 return
1121         esac
1122
1123         local complete_opt="--others --modified --directory --no-empty-directory"
1124         if test -n "$(__git_find_on_cmdline "-u --update")"
1125         then
1126                 complete_opt="--modified"
1127         fi
1128         __git_complete_index_file "$complete_opt"
1129 }
1130
1131 _git_archive ()
1132 {
1133         case "$cur" in
1134         --format=*)
1135                 __gitcomp "$(git archive --list)" "" "${cur##--format=}"
1136                 return
1137                 ;;
1138         --remote=*)
1139                 __gitcomp_nl "$(__git_remotes)" "" "${cur##--remote=}"
1140                 return
1141                 ;;
1142         --*)
1143                 __gitcomp "
1144                         --format= --list --verbose
1145                         --prefix= --remote= --exec= --output
1146                         "
1147                 return
1148                 ;;
1149         esac
1150         __git_complete_file
1151 }
1152
1153 _git_bisect ()
1154 {
1155         __git_has_doubledash && return
1156
1157         local subcommands="start bad good skip reset visualize replay log run"
1158         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1159         if [ -z "$subcommand" ]; then
1160                 __git_find_repo_path
1161                 if [ -f "$__git_repo_path"/BISECT_START ]; then
1162                         __gitcomp "$subcommands"
1163                 else
1164                         __gitcomp "replay start"
1165                 fi
1166                 return
1167         fi
1168
1169         case "$subcommand" in
1170         bad|good|reset|skip|start)
1171                 __git_complete_refs
1172                 ;;
1173         *)
1174                 ;;
1175         esac
1176 }
1177
1178 _git_branch ()
1179 {
1180         local i c=1 only_local_ref="n" has_r="n"
1181
1182         while [ $c -lt $cword ]; do
1183                 i="${words[c]}"
1184                 case "$i" in
1185                 -d|--delete|-m|--move)  only_local_ref="y" ;;
1186                 -r|--remotes)           has_r="y" ;;
1187                 esac
1188                 ((c++))
1189         done
1190
1191         case "$cur" in
1192         --set-upstream-to=*)
1193                 __git_complete_refs --cur="${cur##--set-upstream-to=}"
1194                 ;;
1195         --*)
1196                 __gitcomp "
1197                         --color --no-color --verbose --abbrev= --no-abbrev
1198                         --track --no-track --contains --no-contains --merged --no-merged
1199                         --set-upstream-to= --edit-description --list
1200                         --unset-upstream --delete --move --remotes
1201                         --column --no-column --sort= --points-at
1202                         "
1203                 ;;
1204         *)
1205                 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
1206                         __gitcomp_direct "$(__git_heads "" "$cur" " ")"
1207                 else
1208                         __git_complete_refs
1209                 fi
1210                 ;;
1211         esac
1212 }
1213
1214 _git_bundle ()
1215 {
1216         local cmd="${words[2]}"
1217         case "$cword" in
1218         2)
1219                 __gitcomp "create list-heads verify unbundle"
1220                 ;;
1221         3)
1222                 # looking for a file
1223                 ;;
1224         *)
1225                 case "$cmd" in
1226                         create)
1227                                 __git_complete_revlist
1228                         ;;
1229                 esac
1230                 ;;
1231         esac
1232 }
1233
1234 _git_checkout ()
1235 {
1236         __git_has_doubledash && return
1237
1238         case "$cur" in
1239         --conflict=*)
1240                 __gitcomp "diff3 merge" "" "${cur##--conflict=}"
1241                 ;;
1242         --*)
1243                 __gitcomp "
1244                         --quiet --ours --theirs --track --no-track --merge
1245                         --conflict= --orphan --patch
1246                         "
1247                 ;;
1248         *)
1249                 # check if --track, --no-track, or --no-guess was specified
1250                 # if so, disable DWIM mode
1251                 local flags="--track --no-track --no-guess" track_opt="--track"
1252                 if [ -n "$(__git_find_on_cmdline "$flags")" ]; then
1253                         track_opt=''
1254                 fi
1255                 __git_complete_refs $track_opt
1256                 ;;
1257         esac
1258 }
1259
1260 _git_cherry ()
1261 {
1262         __git_complete_refs
1263 }
1264
1265 _git_cherry_pick ()
1266 {
1267         __git_find_repo_path
1268         if [ -f "$__git_repo_path"/CHERRY_PICK_HEAD ]; then
1269                 __gitcomp "--continue --quit --abort"
1270                 return
1271         fi
1272         case "$cur" in
1273         --*)
1274                 __gitcomp "--edit --no-commit --signoff --strategy= --mainline"
1275                 ;;
1276         *)
1277                 __git_complete_refs
1278                 ;;
1279         esac
1280 }
1281
1282 _git_clean ()
1283 {
1284         case "$cur" in
1285         --*)
1286                 __gitcomp "--dry-run --quiet"
1287                 return
1288                 ;;
1289         esac
1290
1291         # XXX should we check for -x option ?
1292         __git_complete_index_file "--others --directory"
1293 }
1294
1295 _git_clone ()
1296 {
1297         case "$cur" in
1298         --*)
1299                 __gitcomp "
1300                         --local
1301                         --no-hardlinks
1302                         --shared
1303                         --reference
1304                         --quiet
1305                         --no-checkout
1306                         --bare
1307                         --mirror
1308                         --origin
1309                         --upload-pack
1310                         --template=
1311                         --depth
1312                         --single-branch
1313                         --branch
1314                         --recurse-submodules
1315                         --no-single-branch
1316                         --shallow-submodules
1317                         "
1318                 return
1319                 ;;
1320         esac
1321 }
1322
1323 __git_untracked_file_modes="all no normal"
1324
1325 _git_commit ()
1326 {
1327         case "$prev" in
1328         -c|-C)
1329                 __git_complete_refs
1330                 return
1331                 ;;
1332         esac
1333
1334         case "$cur" in
1335         --cleanup=*)
1336                 __gitcomp "default scissors strip verbatim whitespace
1337                         " "" "${cur##--cleanup=}"
1338                 return
1339                 ;;
1340         --reuse-message=*|--reedit-message=*|\
1341         --fixup=*|--squash=*)
1342                 __git_complete_refs --cur="${cur#*=}"
1343                 return
1344                 ;;
1345         --untracked-files=*)
1346                 __gitcomp "$__git_untracked_file_modes" "" "${cur##--untracked-files=}"
1347                 return
1348                 ;;
1349         --*)
1350                 __gitcomp "
1351                         --all --author= --signoff --verify --no-verify
1352                         --edit --no-edit
1353                         --amend --include --only --interactive
1354                         --dry-run --reuse-message= --reedit-message=
1355                         --reset-author --file= --message= --template=
1356                         --cleanup= --untracked-files --untracked-files=
1357                         --verbose --quiet --fixup= --squash=
1358                         --patch --short --date --allow-empty
1359                         "
1360                 return
1361         esac
1362
1363         if __git rev-parse --verify --quiet HEAD >/dev/null; then
1364                 __git_complete_index_file "--committable"
1365         else
1366                 # This is the first commit
1367                 __git_complete_index_file "--cached"
1368         fi
1369 }
1370
1371 _git_describe ()
1372 {
1373         case "$cur" in
1374         --*)
1375                 __gitcomp "
1376                         --all --tags --contains --abbrev= --candidates=
1377                         --exact-match --debug --long --match --always --first-parent
1378                         --exclude
1379                         "
1380                 return
1381         esac
1382         __git_complete_refs
1383 }
1384
1385 __git_diff_algorithms="myers minimal patience histogram"
1386
1387 __git_diff_submodule_formats="diff log short"
1388
1389 __git_diff_common_options="--stat --numstat --shortstat --summary
1390                         --patch-with-stat --name-only --name-status --color
1391                         --no-color --color-words --no-renames --check
1392                         --full-index --binary --abbrev --diff-filter=
1393                         --find-copies-harder
1394                         --text --ignore-space-at-eol --ignore-space-change
1395                         --ignore-all-space --ignore-blank-lines --exit-code
1396                         --quiet --ext-diff --no-ext-diff
1397                         --no-prefix --src-prefix= --dst-prefix=
1398                         --inter-hunk-context=
1399                         --patience --histogram --minimal
1400                         --raw --word-diff --word-diff-regex=
1401                         --dirstat --dirstat= --dirstat-by-file
1402                         --dirstat-by-file= --cumulative
1403                         --diff-algorithm=
1404                         --submodule --submodule=
1405 "
1406
1407 _git_diff ()
1408 {
1409         __git_has_doubledash && return
1410
1411         case "$cur" in
1412         --diff-algorithm=*)
1413                 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
1414                 return
1415                 ;;
1416         --submodule=*)
1417                 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
1418                 return
1419                 ;;
1420         --*)
1421                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1422                         --base --ours --theirs --no-index
1423                         $__git_diff_common_options
1424                         "
1425                 return
1426                 ;;
1427         esac
1428         __git_complete_revlist_file
1429 }
1430
1431 __git_mergetools_common="diffuse diffmerge ecmerge emerge kdiff3 meld opendiff
1432                         tkdiff vimdiff gvimdiff xxdiff araxis p4merge bc codecompare
1433 "
1434
1435 _git_difftool ()
1436 {
1437         __git_has_doubledash && return
1438
1439         case "$cur" in
1440         --tool=*)
1441                 __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
1442                 return
1443                 ;;
1444         --*)
1445                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1446                         --base --ours --theirs
1447                         --no-renames --diff-filter= --find-copies-harder
1448                         --relative --ignore-submodules
1449                         --tool="
1450                 return
1451                 ;;
1452         esac
1453         __git_complete_revlist_file
1454 }
1455
1456 __git_fetch_recurse_submodules="yes on-demand no"
1457
1458 __git_fetch_options="
1459         --quiet --verbose --append --upload-pack --force --keep --depth=
1460         --tags --no-tags --all --prune --dry-run --recurse-submodules=
1461         --unshallow --update-shallow
1462 "
1463
1464 _git_fetch ()
1465 {
1466         case "$cur" in
1467         --recurse-submodules=*)
1468                 __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
1469                 return
1470                 ;;
1471         --*)
1472                 __gitcomp "$__git_fetch_options"
1473                 return
1474                 ;;
1475         esac
1476         __git_complete_remote_or_refspec
1477 }
1478
1479 __git_format_patch_options="
1480         --stdout --attach --no-attach --thread --thread= --no-thread
1481         --numbered --start-number --numbered-files --keep-subject --signoff
1482         --signature --no-signature --in-reply-to= --cc= --full-index --binary
1483         --not --all --cover-letter --no-prefix --src-prefix= --dst-prefix=
1484         --inline --suffix= --ignore-if-in-upstream --subject-prefix=
1485         --output-directory --reroll-count --to= --quiet --notes
1486 "
1487
1488 _git_format_patch ()
1489 {
1490         case "$cur" in
1491         --thread=*)
1492                 __gitcomp "
1493                         deep shallow
1494                         " "" "${cur##--thread=}"
1495                 return
1496                 ;;
1497         --*)
1498                 __gitcomp "$__git_format_patch_options"
1499                 return
1500                 ;;
1501         esac
1502         __git_complete_revlist
1503 }
1504
1505 _git_fsck ()
1506 {
1507         case "$cur" in
1508         --*)
1509                 __gitcomp "
1510                         --tags --root --unreachable --cache --no-reflogs --full
1511                         --strict --verbose --lost-found --name-objects
1512                         "
1513                 return
1514                 ;;
1515         esac
1516 }
1517
1518 _git_gc ()
1519 {
1520         case "$cur" in
1521         --*)
1522                 __gitcomp "--prune --aggressive"
1523                 return
1524                 ;;
1525         esac
1526 }
1527
1528 _git_gitk ()
1529 {
1530         _gitk
1531 }
1532
1533 # Lists matching symbol names from a tag (as in ctags) file.
1534 # 1: List symbol names matching this word.
1535 # 2: The tag file to list symbol names from.
1536 # 3: A prefix to be added to each listed symbol name (optional).
1537 # 4: A suffix to be appended to each listed symbol name (optional).
1538 __git_match_ctag () {
1539         awk -v pfx="${3-}" -v sfx="${4-}" "
1540                 /^${1//\//\\/}/ { print pfx \$1 sfx }
1541                 " "$2"
1542 }
1543
1544 # Complete symbol names from a tag file.
1545 # Usage: __git_complete_symbol [<option>]...
1546 # --tags=<file>: The tag file to list symbol names from instead of the
1547 #                default "tags".
1548 # --pfx=<prefix>: A prefix to be added to each symbol name.
1549 # --cur=<word>: The current symbol name to be completed.  Defaults to
1550 #               the current word to be completed.
1551 # --sfx=<suffix>: A suffix to be appended to each symbol name instead
1552 #                 of the default space.
1553 __git_complete_symbol () {
1554         local tags=tags pfx="" cur_="${cur-}" sfx=" "
1555
1556         while test $# != 0; do
1557                 case "$1" in
1558                 --tags=*)       tags="${1##--tags=}" ;;
1559                 --pfx=*)        pfx="${1##--pfx=}" ;;
1560                 --cur=*)        cur_="${1##--cur=}" ;;
1561                 --sfx=*)        sfx="${1##--sfx=}" ;;
1562                 *)              return 1 ;;
1563                 esac
1564                 shift
1565         done
1566
1567         if test -r "$tags"; then
1568                 __gitcomp_direct "$(__git_match_ctag "$cur_" "$tags" "$pfx" "$sfx")"
1569         fi
1570 }
1571
1572 _git_grep ()
1573 {
1574         __git_has_doubledash && return
1575
1576         case "$cur" in
1577         --*)
1578                 __gitcomp "
1579                         --cached
1580                         --text --ignore-case --word-regexp --invert-match
1581                         --full-name --line-number
1582                         --extended-regexp --basic-regexp --fixed-strings
1583                         --perl-regexp
1584                         --threads
1585                         --files-with-matches --name-only
1586                         --files-without-match
1587                         --max-depth
1588                         --count
1589                         --and --or --not --all-match
1590                         --break --heading --show-function --function-context
1591                         --untracked --no-index
1592                         "
1593                 return
1594                 ;;
1595         esac
1596
1597         case "$cword,$prev" in
1598         2,*|*,-*)
1599                 __git_complete_symbol && return
1600                 ;;
1601         esac
1602
1603         __git_complete_refs
1604 }
1605
1606 _git_help ()
1607 {
1608         case "$cur" in
1609         --*)
1610                 __gitcomp "--all --guides --info --man --web"
1611                 return
1612                 ;;
1613         esac
1614         __git_compute_all_commands
1615         __gitcomp "$__git_all_commands $(__git_aliases)
1616                 attributes cli core-tutorial cvs-migration
1617                 diffcore everyday gitk glossary hooks ignore modules
1618                 namespaces repository-layout revisions tutorial tutorial-2
1619                 workflows
1620                 "
1621 }
1622
1623 _git_init ()
1624 {
1625         case "$cur" in
1626         --shared=*)
1627                 __gitcomp "
1628                         false true umask group all world everybody
1629                         " "" "${cur##--shared=}"
1630                 return
1631                 ;;
1632         --*)
1633                 __gitcomp "--quiet --bare --template= --shared --shared="
1634                 return
1635                 ;;
1636         esac
1637 }
1638
1639 _git_ls_files ()
1640 {
1641         case "$cur" in
1642         --*)
1643                 __gitcomp "--cached --deleted --modified --others --ignored
1644                         --stage --directory --no-empty-directory --unmerged
1645                         --killed --exclude= --exclude-from=
1646                         --exclude-per-directory= --exclude-standard
1647                         --error-unmatch --with-tree= --full-name
1648                         --abbrev --ignored --exclude-per-directory
1649                         "
1650                 return
1651                 ;;
1652         esac
1653
1654         # XXX ignore options like --modified and always suggest all cached
1655         # files.
1656         __git_complete_index_file "--cached"
1657 }
1658
1659 _git_ls_remote ()
1660 {
1661         case "$cur" in
1662         --*)
1663                 __gitcomp "--heads --tags --refs --get-url --symref"
1664                 return
1665                 ;;
1666         esac
1667         __gitcomp_nl "$(__git_remotes)"
1668 }
1669
1670 _git_ls_tree ()
1671 {
1672         __git_complete_file
1673 }
1674
1675 # Options that go well for log, shortlog and gitk
1676 __git_log_common_options="
1677         --not --all
1678         --branches --tags --remotes
1679         --first-parent --merges --no-merges
1680         --max-count=
1681         --max-age= --since= --after=
1682         --min-age= --until= --before=
1683         --min-parents= --max-parents=
1684         --no-min-parents --no-max-parents
1685 "
1686 # Options that go well for log and gitk (not shortlog)
1687 __git_log_gitk_options="
1688         --dense --sparse --full-history
1689         --simplify-merges --simplify-by-decoration
1690         --left-right --notes --no-notes
1691 "
1692 # Options that go well for log and shortlog (not gitk)
1693 __git_log_shortlog_options="
1694         --author= --committer= --grep=
1695         --all-match --invert-grep
1696 "
1697
1698 __git_log_pretty_formats="oneline short medium full fuller email raw format:"
1699 __git_log_date_formats="relative iso8601 rfc2822 short local default raw"
1700
1701 _git_log ()
1702 {
1703         __git_has_doubledash && return
1704         __git_find_repo_path
1705
1706         local merge=""
1707         if [ -f "$__git_repo_path/MERGE_HEAD" ]; then
1708                 merge="--merge"
1709         fi
1710         case "$prev,$cur" in
1711         -L,:*:*)
1712                 return  # fall back to Bash filename completion
1713                 ;;
1714         -L,:*)
1715                 __git_complete_symbol --cur="${cur#:}" --sfx=":"
1716                 return
1717                 ;;
1718         -G,*|-S,*)
1719                 __git_complete_symbol
1720                 return
1721                 ;;
1722         esac
1723         case "$cur" in
1724         --pretty=*|--format=*)
1725                 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
1726                         " "" "${cur#*=}"
1727                 return
1728                 ;;
1729         --date=*)
1730                 __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
1731                 return
1732                 ;;
1733         --decorate=*)
1734                 __gitcomp "full short no" "" "${cur##--decorate=}"
1735                 return
1736                 ;;
1737         --diff-algorithm=*)
1738                 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
1739                 return
1740                 ;;
1741         --submodule=*)
1742                 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
1743                 return
1744                 ;;
1745         --*)
1746                 __gitcomp "
1747                         $__git_log_common_options
1748                         $__git_log_shortlog_options
1749                         $__git_log_gitk_options
1750                         --root --topo-order --date-order --reverse
1751                         --follow --full-diff
1752                         --abbrev-commit --abbrev=
1753                         --relative-date --date=
1754                         --pretty= --format= --oneline
1755                         --show-signature
1756                         --cherry-mark
1757                         --cherry-pick
1758                         --graph
1759                         --decorate --decorate=
1760                         --walk-reflogs
1761                         --parents --children
1762                         $merge
1763                         $__git_diff_common_options
1764                         --pickaxe-all --pickaxe-regex
1765                         "
1766                 return
1767                 ;;
1768         -L:*:*)
1769                 return  # fall back to Bash filename completion
1770                 ;;
1771         -L:*)
1772                 __git_complete_symbol --cur="${cur#-L:}" --sfx=":"
1773                 return
1774                 ;;
1775         -G*)
1776                 __git_complete_symbol --pfx="-G" --cur="${cur#-G}"
1777                 return
1778                 ;;
1779         -S*)
1780                 __git_complete_symbol --pfx="-S" --cur="${cur#-S}"
1781                 return
1782                 ;;
1783         esac
1784         __git_complete_revlist
1785 }
1786
1787 # Common merge options shared by git-merge(1) and git-pull(1).
1788 __git_merge_options="
1789         --no-commit --no-stat --log --no-log --squash --strategy
1790         --commit --stat --no-squash --ff --no-ff --ff-only --edit --no-edit
1791         --verify-signatures --no-verify-signatures --gpg-sign
1792         --quiet --verbose --progress --no-progress
1793 "
1794
1795 _git_merge ()
1796 {
1797         __git_complete_strategy && return
1798
1799         case "$cur" in
1800         --*)
1801                 __gitcomp "$__git_merge_options
1802                         --rerere-autoupdate --no-rerere-autoupdate --abort --continue"
1803                 return
1804         esac
1805         __git_complete_refs
1806 }
1807
1808 _git_mergetool ()
1809 {
1810         case "$cur" in
1811         --tool=*)
1812                 __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
1813                 return
1814                 ;;
1815         --*)
1816                 __gitcomp "--tool= --prompt --no-prompt"
1817                 return
1818                 ;;
1819         esac
1820 }
1821
1822 _git_merge_base ()
1823 {
1824         case "$cur" in
1825         --*)
1826                 __gitcomp "--octopus --independent --is-ancestor --fork-point"
1827                 return
1828                 ;;
1829         esac
1830         __git_complete_refs
1831 }
1832
1833 _git_mv ()
1834 {
1835         case "$cur" in
1836         --*)
1837                 __gitcomp "--dry-run"
1838                 return
1839                 ;;
1840         esac
1841
1842         if [ $(__git_count_arguments "mv") -gt 0 ]; then
1843                 # We need to show both cached and untracked files (including
1844                 # empty directories) since this may not be the last argument.
1845                 __git_complete_index_file "--cached --others --directory"
1846         else
1847                 __git_complete_index_file "--cached"
1848         fi
1849 }
1850
1851 _git_name_rev ()
1852 {
1853         __gitcomp "--tags --all --stdin"
1854 }
1855
1856 _git_notes ()
1857 {
1858         local subcommands='add append copy edit list prune remove show'
1859         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1860
1861         case "$subcommand,$cur" in
1862         ,--*)
1863                 __gitcomp '--ref'
1864                 ;;
1865         ,*)
1866                 case "$prev" in
1867                 --ref)
1868                         __git_complete_refs
1869                         ;;
1870                 *)
1871                         __gitcomp "$subcommands --ref"
1872                         ;;
1873                 esac
1874                 ;;
1875         add,--reuse-message=*|append,--reuse-message=*|\
1876         add,--reedit-message=*|append,--reedit-message=*)
1877                 __git_complete_refs --cur="${cur#*=}"
1878                 ;;
1879         add,--*|append,--*)
1880                 __gitcomp '--file= --message= --reedit-message=
1881                                 --reuse-message='
1882                 ;;
1883         copy,--*)
1884                 __gitcomp '--stdin'
1885                 ;;
1886         prune,--*)
1887                 __gitcomp '--dry-run --verbose'
1888                 ;;
1889         prune,*)
1890                 ;;
1891         *)
1892                 case "$prev" in
1893                 -m|-F)
1894                         ;;
1895                 *)
1896                         __git_complete_refs
1897                         ;;
1898                 esac
1899                 ;;
1900         esac
1901 }
1902
1903 _git_pull ()
1904 {
1905         __git_complete_strategy && return
1906
1907         case "$cur" in
1908         --recurse-submodules=*)
1909                 __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
1910                 return
1911                 ;;
1912         --*)
1913                 __gitcomp "
1914                         --rebase --no-rebase
1915                         $__git_merge_options
1916                         $__git_fetch_options
1917                 "
1918                 return
1919                 ;;
1920         esac
1921         __git_complete_remote_or_refspec
1922 }
1923
1924 __git_push_recurse_submodules="check on-demand only"
1925
1926 __git_complete_force_with_lease ()
1927 {
1928         local cur_=$1
1929
1930         case "$cur_" in
1931         --*=)
1932                 ;;
1933         *:*)
1934                 __git_complete_refs --cur="${cur_#*:}"
1935                 ;;
1936         *)
1937                 __git_complete_refs --cur="$cur_"
1938                 ;;
1939         esac
1940 }
1941
1942 _git_push ()
1943 {
1944         case "$prev" in
1945         --repo)
1946                 __gitcomp_nl "$(__git_remotes)"
1947                 return
1948                 ;;
1949         --recurse-submodules)
1950                 __gitcomp "$__git_push_recurse_submodules"
1951                 return
1952                 ;;
1953         esac
1954         case "$cur" in
1955         --repo=*)
1956                 __gitcomp_nl "$(__git_remotes)" "" "${cur##--repo=}"
1957                 return
1958                 ;;
1959         --recurse-submodules=*)
1960                 __gitcomp "$__git_push_recurse_submodules" "" "${cur##--recurse-submodules=}"
1961                 return
1962                 ;;
1963         --force-with-lease=*)
1964                 __git_complete_force_with_lease "${cur##--force-with-lease=}"
1965                 return
1966                 ;;
1967         --*)
1968                 __gitcomp "
1969                         --all --mirror --tags --dry-run --force --verbose
1970                         --quiet --prune --delete --follow-tags
1971                         --receive-pack= --repo= --set-upstream
1972                         --force-with-lease --force-with-lease= --recurse-submodules=
1973                 "
1974                 return
1975                 ;;
1976         esac
1977         __git_complete_remote_or_refspec
1978 }
1979
1980 _git_rebase ()
1981 {
1982         __git_find_repo_path
1983         if [ -f "$__git_repo_path"/rebase-merge/interactive ]; then
1984                 __gitcomp "--continue --skip --abort --quit --edit-todo"
1985                 return
1986         elif [ -d "$__git_repo_path"/rebase-apply ] || \
1987              [ -d "$__git_repo_path"/rebase-merge ]; then
1988                 __gitcomp "--continue --skip --abort --quit"
1989                 return
1990         fi
1991         __git_complete_strategy && return
1992         case "$cur" in
1993         --whitespace=*)
1994                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1995                 return
1996                 ;;
1997         --*)
1998                 __gitcomp "
1999                         --onto --merge --strategy --interactive
2000                         --preserve-merges --stat --no-stat
2001                         --committer-date-is-author-date --ignore-date
2002                         --ignore-whitespace --whitespace=
2003                         --autosquash --no-autosquash
2004                         --fork-point --no-fork-point
2005                         --autostash --no-autostash
2006                         --verify --no-verify
2007                         --keep-empty --root --force-rebase --no-ff
2008                         --exec
2009                         "
2010
2011                 return
2012         esac
2013         __git_complete_refs
2014 }
2015
2016 _git_reflog ()
2017 {
2018         local subcommands="show delete expire"
2019         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2020
2021         if [ -z "$subcommand" ]; then
2022                 __gitcomp "$subcommands"
2023         else
2024                 __git_complete_refs
2025         fi
2026 }
2027
2028 __git_send_email_confirm_options="always never auto cc compose"
2029 __git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
2030
2031 _git_send_email ()
2032 {
2033         case "$prev" in
2034         --to|--cc|--bcc|--from)
2035                 __gitcomp "$(__git send-email --dump-aliases)"
2036                 return
2037                 ;;
2038         esac
2039
2040         case "$cur" in
2041         --confirm=*)
2042                 __gitcomp "
2043                         $__git_send_email_confirm_options
2044                         " "" "${cur##--confirm=}"
2045                 return
2046                 ;;
2047         --suppress-cc=*)
2048                 __gitcomp "
2049                         $__git_send_email_suppresscc_options
2050                         " "" "${cur##--suppress-cc=}"
2051
2052                 return
2053                 ;;
2054         --smtp-encryption=*)
2055                 __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
2056                 return
2057                 ;;
2058         --thread=*)
2059                 __gitcomp "
2060                         deep shallow
2061                         " "" "${cur##--thread=}"
2062                 return
2063                 ;;
2064         --to=*|--cc=*|--bcc=*|--from=*)
2065                 __gitcomp "$(__git send-email --dump-aliases)" "" "${cur#--*=}"
2066                 return
2067                 ;;
2068         --*)
2069                 __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
2070                         --compose --confirm= --dry-run --envelope-sender
2071                         --from --identity
2072                         --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
2073                         --no-suppress-from --no-thread --quiet
2074                         --signed-off-by-cc --smtp-pass --smtp-server
2075                         --smtp-server-port --smtp-encryption= --smtp-user
2076                         --subject --suppress-cc= --suppress-from --thread --to
2077                         --validate --no-validate
2078                         $__git_format_patch_options"
2079                 return
2080                 ;;
2081         esac
2082         __git_complete_revlist
2083 }
2084
2085 _git_stage ()
2086 {
2087         _git_add
2088 }
2089
2090 _git_status ()
2091 {
2092         local complete_opt
2093         local untracked_state
2094
2095         case "$cur" in
2096         --ignore-submodules=*)
2097                 __gitcomp "none untracked dirty all" "" "${cur##--ignore-submodules=}"
2098                 return
2099                 ;;
2100         --untracked-files=*)
2101                 __gitcomp "$__git_untracked_file_modes" "" "${cur##--untracked-files=}"
2102                 return
2103                 ;;
2104         --column=*)
2105                 __gitcomp "
2106                         always never auto column row plain dense nodense
2107                         " "" "${cur##--column=}"
2108                 return
2109                 ;;
2110         --*)
2111                 __gitcomp "
2112                         --short --branch --porcelain --long --verbose
2113                         --untracked-files= --ignore-submodules= --ignored
2114                         --column= --no-column
2115                         "
2116                 return
2117                 ;;
2118         esac
2119
2120         untracked_state="$(__git_get_option_value "-u" "--untracked-files=" \
2121                 "$__git_untracked_file_modes" "status.showUntrackedFiles")"
2122
2123         case "$untracked_state" in
2124         no)
2125                 # --ignored option does not matter
2126                 complete_opt=
2127                 ;;
2128         all|normal|*)
2129                 complete_opt="--cached --directory --no-empty-directory --others"
2130
2131                 if [ -n "$(__git_find_on_cmdline "--ignored")" ]; then
2132                         complete_opt="$complete_opt --ignored --exclude=*"
2133                 fi
2134                 ;;
2135         esac
2136
2137         __git_complete_index_file "$complete_opt"
2138 }
2139
2140 __git_config_get_set_variables ()
2141 {
2142         local prevword word config_file= c=$cword
2143         while [ $c -gt 1 ]; do
2144                 word="${words[c]}"
2145                 case "$word" in
2146                 --system|--global|--local|--file=*)
2147                         config_file="$word"
2148                         break
2149                         ;;
2150                 -f|--file)
2151                         config_file="$word $prevword"
2152                         break
2153                         ;;
2154                 esac
2155                 prevword=$word
2156                 c=$((--c))
2157         done
2158
2159         __git config $config_file --name-only --list
2160 }
2161
2162 _git_config ()
2163 {
2164         case "$prev" in
2165         branch.*.remote|branch.*.pushremote)
2166                 __gitcomp_nl "$(__git_remotes)"
2167                 return
2168                 ;;
2169         branch.*.merge)
2170                 __git_complete_refs
2171                 return
2172                 ;;
2173         branch.*.rebase)
2174                 __gitcomp "false true preserve interactive"
2175                 return
2176                 ;;
2177         remote.pushdefault)
2178                 __gitcomp_nl "$(__git_remotes)"
2179                 return
2180                 ;;
2181         remote.*.fetch)
2182                 local remote="${prev#remote.}"
2183                 remote="${remote%.fetch}"
2184                 if [ -z "$cur" ]; then
2185                         __gitcomp_nl "refs/heads/" "" "" ""
2186                         return
2187                 fi
2188                 __gitcomp_nl "$(__git_refs_remotes "$remote")"
2189                 return
2190                 ;;
2191         remote.*.push)
2192                 local remote="${prev#remote.}"
2193                 remote="${remote%.push}"
2194                 __gitcomp_nl "$(__git for-each-ref \
2195                         --format='%(refname):%(refname)' refs/heads)"
2196                 return
2197                 ;;
2198         pull.twohead|pull.octopus)
2199                 __git_compute_merge_strategies
2200                 __gitcomp "$__git_merge_strategies"
2201                 return
2202                 ;;
2203         color.branch|color.diff|color.interactive|\
2204         color.showbranch|color.status|color.ui)
2205                 __gitcomp "always never auto"
2206                 return
2207                 ;;
2208         color.pager)
2209                 __gitcomp "false true"
2210                 return
2211                 ;;
2212         color.*.*)
2213                 __gitcomp "
2214                         normal black red green yellow blue magenta cyan white
2215                         bold dim ul blink reverse
2216                         "
2217                 return
2218                 ;;
2219         diff.submodule)
2220                 __gitcomp "log short"
2221                 return
2222                 ;;
2223         help.format)
2224                 __gitcomp "man info web html"
2225                 return
2226                 ;;
2227         log.date)
2228                 __gitcomp "$__git_log_date_formats"
2229                 return
2230                 ;;
2231         sendemail.aliasesfiletype)
2232                 __gitcomp "mutt mailrc pine elm gnus"
2233                 return
2234                 ;;
2235         sendemail.confirm)
2236                 __gitcomp "$__git_send_email_confirm_options"
2237                 return
2238                 ;;
2239         sendemail.suppresscc)
2240                 __gitcomp "$__git_send_email_suppresscc_options"
2241                 return
2242                 ;;
2243         sendemail.transferencoding)
2244                 __gitcomp "7bit 8bit quoted-printable base64"
2245                 return
2246                 ;;
2247         --get|--get-all|--unset|--unset-all)
2248                 __gitcomp_nl "$(__git_config_get_set_variables)"
2249                 return
2250                 ;;
2251         *.*)
2252                 return
2253                 ;;
2254         esac
2255         case "$cur" in
2256         --*)
2257                 __gitcomp "
2258                         --system --global --local --file=
2259                         --list --replace-all
2260                         --get --get-all --get-regexp
2261                         --add --unset --unset-all
2262                         --remove-section --rename-section
2263                         --name-only
2264                         "
2265                 return
2266                 ;;
2267         branch.*.*)
2268                 local pfx="${cur%.*}." cur_="${cur##*.}"
2269                 __gitcomp "remote pushremote merge mergeoptions rebase" "$pfx" "$cur_"
2270                 return
2271                 ;;
2272         branch.*)
2273                 local pfx="${cur%.*}." cur_="${cur#*.}"
2274                 __gitcomp_direct "$(__git_heads "$pfx" "$cur_" ".")"
2275                 __gitcomp_nl_append $'autosetupmerge\nautosetuprebase\n' "$pfx" "$cur_"
2276                 return
2277                 ;;
2278         guitool.*.*)
2279                 local pfx="${cur%.*}." cur_="${cur##*.}"
2280                 __gitcomp "
2281                         argprompt cmd confirm needsfile noconsole norescan
2282                         prompt revprompt revunmerged title
2283                         " "$pfx" "$cur_"
2284                 return
2285                 ;;
2286         difftool.*.*)
2287                 local pfx="${cur%.*}." cur_="${cur##*.}"
2288                 __gitcomp "cmd path" "$pfx" "$cur_"
2289                 return
2290                 ;;
2291         man.*.*)
2292                 local pfx="${cur%.*}." cur_="${cur##*.}"
2293                 __gitcomp "cmd path" "$pfx" "$cur_"
2294                 return
2295                 ;;
2296         mergetool.*.*)
2297                 local pfx="${cur%.*}." cur_="${cur##*.}"
2298                 __gitcomp "cmd path trustExitCode" "$pfx" "$cur_"
2299                 return
2300                 ;;
2301         pager.*)
2302                 local pfx="${cur%.*}." cur_="${cur#*.}"
2303                 __git_compute_all_commands
2304                 __gitcomp_nl "$__git_all_commands" "$pfx" "$cur_"
2305                 return
2306                 ;;
2307         remote.*.*)
2308                 local pfx="${cur%.*}." cur_="${cur##*.}"
2309                 __gitcomp "
2310                         url proxy fetch push mirror skipDefaultUpdate
2311                         receivepack uploadpack tagopt pushurl
2312                         " "$pfx" "$cur_"
2313                 return
2314                 ;;
2315         remote.*)
2316                 local pfx="${cur%.*}." cur_="${cur#*.}"
2317                 __gitcomp_nl "$(__git_remotes)" "$pfx" "$cur_" "."
2318                 __gitcomp_nl_append "pushdefault" "$pfx" "$cur_"
2319                 return
2320                 ;;
2321         url.*.*)
2322                 local pfx="${cur%.*}." cur_="${cur##*.}"
2323                 __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur_"
2324                 return
2325                 ;;
2326         esac
2327         __gitcomp "
2328                 add.ignoreErrors
2329                 advice.commitBeforeMerge
2330                 advice.detachedHead
2331                 advice.implicitIdentity
2332                 advice.pushNonFastForward
2333                 advice.resolveConflict
2334                 advice.statusHints
2335                 alias.
2336                 am.keepcr
2337                 apply.ignorewhitespace
2338                 apply.whitespace
2339                 branch.autosetupmerge
2340                 branch.autosetuprebase
2341                 browser.
2342                 clean.requireForce
2343                 color.branch
2344                 color.branch.current
2345                 color.branch.local
2346                 color.branch.plain
2347                 color.branch.remote
2348                 color.decorate.HEAD
2349                 color.decorate.branch
2350                 color.decorate.remoteBranch
2351                 color.decorate.stash
2352                 color.decorate.tag
2353                 color.diff
2354                 color.diff.commit
2355                 color.diff.frag
2356                 color.diff.func
2357                 color.diff.meta
2358                 color.diff.new
2359                 color.diff.old
2360                 color.diff.plain
2361                 color.diff.whitespace
2362                 color.grep
2363                 color.grep.context
2364                 color.grep.filename
2365                 color.grep.function
2366                 color.grep.linenumber
2367                 color.grep.match
2368                 color.grep.selected
2369                 color.grep.separator
2370                 color.interactive
2371                 color.interactive.error
2372                 color.interactive.header
2373                 color.interactive.help
2374                 color.interactive.prompt
2375                 color.pager
2376                 color.showbranch
2377                 color.status
2378                 color.status.added
2379                 color.status.changed
2380                 color.status.header
2381                 color.status.localBranch
2382                 color.status.nobranch
2383                 color.status.remoteBranch
2384                 color.status.unmerged
2385                 color.status.untracked
2386                 color.status.updated
2387                 color.ui
2388                 commit.status
2389                 commit.template
2390                 core.abbrev
2391                 core.askpass
2392                 core.attributesfile
2393                 core.autocrlf
2394                 core.bare
2395                 core.bigFileThreshold
2396                 core.compression
2397                 core.createObject
2398                 core.deltaBaseCacheLimit
2399                 core.editor
2400                 core.eol
2401                 core.excludesfile
2402                 core.fileMode
2403                 core.fsyncobjectfiles
2404                 core.gitProxy
2405                 core.ignoreStat
2406                 core.ignorecase
2407                 core.logAllRefUpdates
2408                 core.loosecompression
2409                 core.notesRef
2410                 core.packedGitLimit
2411                 core.packedGitWindowSize
2412                 core.pager
2413                 core.preferSymlinkRefs
2414                 core.preloadindex
2415                 core.quotepath
2416                 core.repositoryFormatVersion
2417                 core.safecrlf
2418                 core.sharedRepository
2419                 core.sparseCheckout
2420                 core.symlinks
2421                 core.trustctime
2422                 core.untrackedCache
2423                 core.warnAmbiguousRefs
2424                 core.whitespace
2425                 core.worktree
2426                 diff.autorefreshindex
2427                 diff.external
2428                 diff.ignoreSubmodules
2429                 diff.mnemonicprefix
2430                 diff.noprefix
2431                 diff.renameLimit
2432                 diff.renames
2433                 diff.statGraphWidth
2434                 diff.submodule
2435                 diff.suppressBlankEmpty
2436                 diff.tool
2437                 diff.wordRegex
2438                 diff.algorithm
2439                 difftool.
2440                 difftool.prompt
2441                 fetch.recurseSubmodules
2442                 fetch.unpackLimit
2443                 format.attach
2444                 format.cc
2445                 format.coverLetter
2446                 format.from
2447                 format.headers
2448                 format.numbered
2449                 format.pretty
2450                 format.signature
2451                 format.signoff
2452                 format.subjectprefix
2453                 format.suffix
2454                 format.thread
2455                 format.to
2456                 gc.
2457                 gc.aggressiveWindow
2458                 gc.auto
2459                 gc.autopacklimit
2460                 gc.packrefs
2461                 gc.pruneexpire
2462                 gc.reflogexpire
2463                 gc.reflogexpireunreachable
2464                 gc.rerereresolved
2465                 gc.rerereunresolved
2466                 gitcvs.allbinary
2467                 gitcvs.commitmsgannotation
2468                 gitcvs.dbTableNamePrefix
2469                 gitcvs.dbdriver
2470                 gitcvs.dbname
2471                 gitcvs.dbpass
2472                 gitcvs.dbuser
2473                 gitcvs.enabled
2474                 gitcvs.logfile
2475                 gitcvs.usecrlfattr
2476                 guitool.
2477                 gui.blamehistoryctx
2478                 gui.commitmsgwidth
2479                 gui.copyblamethreshold
2480                 gui.diffcontext
2481                 gui.encoding
2482                 gui.fastcopyblame
2483                 gui.matchtrackingbranch
2484                 gui.newbranchtemplate
2485                 gui.pruneduringfetch
2486                 gui.spellingdictionary
2487                 gui.trustmtime
2488                 help.autocorrect
2489                 help.browser
2490                 help.format
2491                 http.lowSpeedLimit
2492                 http.lowSpeedTime
2493                 http.maxRequests
2494                 http.minSessions
2495                 http.noEPSV
2496                 http.postBuffer
2497                 http.proxy
2498                 http.sslCipherList
2499                 http.sslVersion
2500                 http.sslCAInfo
2501                 http.sslCAPath
2502                 http.sslCert
2503                 http.sslCertPasswordProtected
2504                 http.sslKey
2505                 http.sslVerify
2506                 http.useragent
2507                 i18n.commitEncoding
2508                 i18n.logOutputEncoding
2509                 imap.authMethod
2510                 imap.folder
2511                 imap.host
2512                 imap.pass
2513                 imap.port
2514                 imap.preformattedHTML
2515                 imap.sslverify
2516                 imap.tunnel
2517                 imap.user
2518                 init.templatedir
2519                 instaweb.browser
2520                 instaweb.httpd
2521                 instaweb.local
2522                 instaweb.modulepath
2523                 instaweb.port
2524                 interactive.singlekey
2525                 log.date
2526                 log.decorate
2527                 log.showroot
2528                 mailmap.file
2529                 man.
2530                 man.viewer
2531                 merge.
2532                 merge.conflictstyle
2533                 merge.log
2534                 merge.renameLimit
2535                 merge.renormalize
2536                 merge.stat
2537                 merge.tool
2538                 merge.verbosity
2539                 mergetool.
2540                 mergetool.keepBackup
2541                 mergetool.keepTemporaries
2542                 mergetool.prompt
2543                 notes.displayRef
2544                 notes.rewrite.
2545                 notes.rewrite.amend
2546                 notes.rewrite.rebase
2547                 notes.rewriteMode
2548                 notes.rewriteRef
2549                 pack.compression
2550                 pack.deltaCacheLimit
2551                 pack.deltaCacheSize
2552                 pack.depth
2553                 pack.indexVersion
2554                 pack.packSizeLimit
2555                 pack.threads
2556                 pack.window
2557                 pack.windowMemory
2558                 pager.
2559                 pretty.
2560                 pull.octopus
2561                 pull.twohead
2562                 push.default
2563                 push.followTags
2564                 rebase.autosquash
2565                 rebase.stat
2566                 receive.autogc
2567                 receive.denyCurrentBranch
2568                 receive.denyDeleteCurrent
2569                 receive.denyDeletes
2570                 receive.denyNonFastForwards
2571                 receive.fsckObjects
2572                 receive.unpackLimit
2573                 receive.updateserverinfo
2574                 remote.pushdefault
2575                 remotes.
2576                 repack.usedeltabaseoffset
2577                 rerere.autoupdate
2578                 rerere.enabled
2579                 sendemail.
2580                 sendemail.aliasesfile
2581                 sendemail.aliasfiletype
2582                 sendemail.bcc
2583                 sendemail.cc
2584                 sendemail.cccmd
2585                 sendemail.chainreplyto
2586                 sendemail.confirm
2587                 sendemail.envelopesender
2588                 sendemail.from
2589                 sendemail.identity
2590                 sendemail.multiedit
2591                 sendemail.signedoffbycc
2592                 sendemail.smtpdomain
2593                 sendemail.smtpencryption
2594                 sendemail.smtppass
2595                 sendemail.smtpserver
2596                 sendemail.smtpserveroption
2597                 sendemail.smtpserverport
2598                 sendemail.smtpuser
2599                 sendemail.suppresscc
2600                 sendemail.suppressfrom
2601                 sendemail.thread
2602                 sendemail.to
2603                 sendemail.validate
2604                 showbranch.default
2605                 status.relativePaths
2606                 status.showUntrackedFiles
2607                 status.submodulesummary
2608                 submodule.
2609                 tar.umask
2610                 transfer.unpackLimit
2611                 url.
2612                 user.email
2613                 user.name
2614                 user.signingkey
2615                 web.browser
2616                 branch. remote.
2617         "
2618 }
2619
2620 _git_remote ()
2621 {
2622         local subcommands="
2623                 add rename remove set-head set-branches
2624                 get-url set-url show prune update
2625                 "
2626         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2627         if [ -z "$subcommand" ]; then
2628                 case "$cur" in
2629                 --*)
2630                         __gitcomp "--verbose"
2631                         ;;
2632                 *)
2633                         __gitcomp "$subcommands"
2634                         ;;
2635                 esac
2636                 return
2637         fi
2638
2639         case "$subcommand,$cur" in
2640         add,--*)
2641                 __gitcomp "--track --master --fetch --tags --no-tags --mirror="
2642                 ;;
2643         add,*)
2644                 ;;
2645         set-head,--*)
2646                 __gitcomp "--auto --delete"
2647                 ;;
2648         set-branches,--*)
2649                 __gitcomp "--add"
2650                 ;;
2651         set-head,*|set-branches,*)
2652                 __git_complete_remote_or_refspec
2653                 ;;
2654         update,--*)
2655                 __gitcomp "--prune"
2656                 ;;
2657         update,*)
2658                 __gitcomp "$(__git_get_config_variables "remotes")"
2659                 ;;
2660         set-url,--*)
2661                 __gitcomp "--push --add --delete"
2662                 ;;
2663         get-url,--*)
2664                 __gitcomp "--push --all"
2665                 ;;
2666         prune,--*)
2667                 __gitcomp "--dry-run"
2668                 ;;
2669         *)
2670                 __gitcomp_nl "$(__git_remotes)"
2671                 ;;
2672         esac
2673 }
2674
2675 _git_replace ()
2676 {
2677         case "$cur" in
2678         --*)
2679                 __gitcomp "--edit --graft --format= --list --delete"
2680                 return
2681                 ;;
2682         esac
2683         __git_complete_refs
2684 }
2685
2686 _git_rerere ()
2687 {
2688         local subcommands="clear forget diff remaining status gc"
2689         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2690         if test -z "$subcommand"
2691         then
2692                 __gitcomp "$subcommands"
2693                 return
2694         fi
2695 }
2696
2697 _git_reset ()
2698 {
2699         __git_has_doubledash && return
2700
2701         case "$cur" in
2702         --*)
2703                 __gitcomp "--merge --mixed --hard --soft --patch --keep"
2704                 return
2705                 ;;
2706         esac
2707         __git_complete_refs
2708 }
2709
2710 _git_revert ()
2711 {
2712         __git_find_repo_path
2713         if [ -f "$__git_repo_path"/REVERT_HEAD ]; then
2714                 __gitcomp "--continue --quit --abort"
2715                 return
2716         fi
2717         case "$cur" in
2718         --*)
2719                 __gitcomp "
2720                         --edit --mainline --no-edit --no-commit --signoff
2721                         --strategy= --strategy-option=
2722                         "
2723                 return
2724                 ;;
2725         esac
2726         __git_complete_refs
2727 }
2728
2729 _git_rm ()
2730 {
2731         case "$cur" in
2732         --*)
2733                 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
2734                 return
2735                 ;;
2736         esac
2737
2738         __git_complete_index_file "--cached"
2739 }
2740
2741 _git_shortlog ()
2742 {
2743         __git_has_doubledash && return
2744
2745         case "$cur" in
2746         --*)
2747                 __gitcomp "
2748                         $__git_log_common_options
2749                         $__git_log_shortlog_options
2750                         --numbered --summary --email
2751                         "
2752                 return
2753                 ;;
2754         esac
2755         __git_complete_revlist
2756 }
2757
2758 _git_show ()
2759 {
2760         __git_has_doubledash && return
2761
2762         case "$cur" in
2763         --pretty=*|--format=*)
2764                 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
2765                         " "" "${cur#*=}"
2766                 return
2767                 ;;
2768         --diff-algorithm=*)
2769                 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
2770                 return
2771                 ;;
2772         --submodule=*)
2773                 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
2774                 return
2775                 ;;
2776         --*)
2777                 __gitcomp "--pretty= --format= --abbrev-commit --oneline
2778                         --show-signature
2779                         $__git_diff_common_options
2780                         "
2781                 return
2782                 ;;
2783         esac
2784         __git_complete_revlist_file
2785 }
2786
2787 _git_show_branch ()
2788 {
2789         case "$cur" in
2790         --*)
2791                 __gitcomp "
2792                         --all --remotes --topo-order --date-order --current --more=
2793                         --list --independent --merge-base --no-name
2794                         --color --no-color
2795                         --sha1-name --sparse --topics --reflog
2796                         "
2797                 return
2798                 ;;
2799         esac
2800         __git_complete_revlist
2801 }
2802
2803 _git_stash ()
2804 {
2805         local save_opts='--all --keep-index --no-keep-index --quiet --patch --include-untracked'
2806         local subcommands='save list show apply clear drop pop create branch'
2807         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2808         if [ -z "$subcommand" ]; then
2809                 case "$cur" in
2810                 --*)
2811                         __gitcomp "$save_opts"
2812                         ;;
2813                 *)
2814                         if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2815                                 __gitcomp "$subcommands"
2816                         fi
2817                         ;;
2818                 esac
2819         else
2820                 case "$subcommand,$cur" in
2821                 save,--*)
2822                         __gitcomp "$save_opts"
2823                         ;;
2824                 apply,--*|pop,--*)
2825                         __gitcomp "--index --quiet"
2826                         ;;
2827                 drop,--*)
2828                         __gitcomp "--quiet"
2829                         ;;
2830                 show,--*|branch,--*)
2831                         ;;
2832                 branch,*)
2833                         if [ $cword -eq 3 ]; then
2834                                 __git_complete_refs
2835                         else
2836                                 __gitcomp_nl "$(__git stash list \
2837                                                 | sed -n -e 's/:.*//p')"
2838                         fi
2839                         ;;
2840                 show,*|apply,*|drop,*|pop,*)
2841                         __gitcomp_nl "$(__git stash list \
2842                                         | sed -n -e 's/:.*//p')"
2843                         ;;
2844                 *)
2845                         ;;
2846                 esac
2847         fi
2848 }
2849
2850 _git_submodule ()
2851 {
2852         __git_has_doubledash && return
2853
2854         local subcommands="add status init deinit update summary foreach sync"
2855         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2856         if [ -z "$subcommand" ]; then
2857                 case "$cur" in
2858                 --*)
2859                         __gitcomp "--quiet"
2860                         ;;
2861                 *)
2862                         __gitcomp "$subcommands"
2863                         ;;
2864                 esac
2865                 return
2866         fi
2867
2868         case "$subcommand,$cur" in
2869         add,--*)
2870                 __gitcomp "--branch --force --name --reference --depth"
2871                 ;;
2872         status,--*)
2873                 __gitcomp "--cached --recursive"
2874                 ;;
2875         deinit,--*)
2876                 __gitcomp "--force --all"
2877                 ;;
2878         update,--*)
2879                 __gitcomp "
2880                         --init --remote --no-fetch
2881                         --recommend-shallow --no-recommend-shallow
2882                         --force --rebase --merge --reference --depth --recursive --jobs
2883                 "
2884                 ;;
2885         summary,--*)
2886                 __gitcomp "--cached --files --summary-limit"
2887                 ;;
2888         foreach,--*|sync,--*)
2889                 __gitcomp "--recursive"
2890                 ;;
2891         *)
2892                 ;;
2893         esac
2894 }
2895
2896 _git_svn ()
2897 {
2898         local subcommands="
2899                 init fetch clone rebase dcommit log find-rev
2900                 set-tree commit-diff info create-ignore propget
2901                 proplist show-ignore show-externals branch tag blame
2902                 migrate mkdirs reset gc
2903                 "
2904         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2905         if [ -z "$subcommand" ]; then
2906                 __gitcomp "$subcommands"
2907         else
2908                 local remote_opts="--username= --config-dir= --no-auth-cache"
2909                 local fc_opts="
2910                         --follow-parent --authors-file= --repack=
2911                         --no-metadata --use-svm-props --use-svnsync-props
2912                         --log-window-size= --no-checkout --quiet
2913                         --repack-flags --use-log-author --localtime
2914                         --add-author-from
2915                         --ignore-paths= --include-paths= $remote_opts
2916                         "
2917                 local init_opts="
2918                         --template= --shared= --trunk= --tags=
2919                         --branches= --stdlayout --minimize-url
2920                         --no-metadata --use-svm-props --use-svnsync-props
2921                         --rewrite-root= --prefix= $remote_opts
2922                         "
2923                 local cmt_opts="
2924                         --edit --rmdir --find-copies-harder --copy-similarity=
2925                         "
2926
2927                 case "$subcommand,$cur" in
2928                 fetch,--*)
2929                         __gitcomp "--revision= --fetch-all $fc_opts"
2930                         ;;
2931                 clone,--*)
2932                         __gitcomp "--revision= $fc_opts $init_opts"
2933                         ;;
2934                 init,--*)
2935                         __gitcomp "$init_opts"
2936                         ;;
2937                 dcommit,--*)
2938                         __gitcomp "
2939                                 --merge --strategy= --verbose --dry-run
2940                                 --fetch-all --no-rebase --commit-url
2941                                 --revision --interactive $cmt_opts $fc_opts
2942                                 "
2943                         ;;
2944                 set-tree,--*)
2945                         __gitcomp "--stdin $cmt_opts $fc_opts"
2946                         ;;
2947                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
2948                 show-externals,--*|mkdirs,--*)
2949                         __gitcomp "--revision="
2950                         ;;
2951                 log,--*)
2952                         __gitcomp "
2953                                 --limit= --revision= --verbose --incremental
2954                                 --oneline --show-commit --non-recursive
2955                                 --authors-file= --color
2956                                 "
2957                         ;;
2958                 rebase,--*)
2959                         __gitcomp "
2960                                 --merge --verbose --strategy= --local
2961                                 --fetch-all --dry-run $fc_opts
2962                                 "
2963                         ;;
2964                 commit-diff,--*)
2965                         __gitcomp "--message= --file= --revision= $cmt_opts"
2966                         ;;
2967                 info,--*)
2968                         __gitcomp "--url"
2969                         ;;
2970                 branch,--*)
2971                         __gitcomp "--dry-run --message --tag"
2972                         ;;
2973                 tag,--*)
2974                         __gitcomp "--dry-run --message"
2975                         ;;
2976                 blame,--*)
2977                         __gitcomp "--git-format"
2978                         ;;
2979                 migrate,--*)
2980                         __gitcomp "
2981                                 --config-dir= --ignore-paths= --minimize
2982                                 --no-auth-cache --username=
2983                                 "
2984                         ;;
2985                 reset,--*)
2986                         __gitcomp "--revision= --parent"
2987                         ;;
2988                 *)
2989                         ;;
2990                 esac
2991         fi
2992 }
2993
2994 _git_tag ()
2995 {
2996         local i c=1 f=0
2997         while [ $c -lt $cword ]; do
2998                 i="${words[c]}"
2999                 case "$i" in
3000                 -d|-v)
3001                         __gitcomp_direct "$(__git_tags "" "$cur" " ")"
3002                         return
3003                         ;;
3004                 -f)
3005                         f=1
3006                         ;;
3007                 esac
3008                 ((c++))
3009         done
3010
3011         case "$prev" in
3012         -m|-F)
3013                 ;;
3014         -*|tag)
3015                 if [ $f = 1 ]; then
3016                         __gitcomp_direct "$(__git_tags "" "$cur" " ")"
3017                 fi
3018                 ;;
3019         *)
3020                 __git_complete_refs
3021                 ;;
3022         esac
3023
3024         case "$cur" in
3025         --*)
3026                 __gitcomp "
3027                         --list --delete --verify --annotate --message --file
3028                         --sign --cleanup --local-user --force --column --sort=
3029                         --contains --no-contains --points-at --merged --no-merged --create-reflog
3030                         "
3031                 ;;
3032         esac
3033 }
3034
3035 _git_whatchanged ()
3036 {
3037         _git_log
3038 }
3039
3040 _git_worktree ()
3041 {
3042         local subcommands="add list lock prune unlock"
3043         local subcommand="$(__git_find_on_cmdline "$subcommands")"
3044         if [ -z "$subcommand" ]; then
3045                 __gitcomp "$subcommands"
3046         else
3047                 case "$subcommand,$cur" in
3048                 add,--*)
3049                         __gitcomp "--detach"
3050                         ;;
3051                 list,--*)
3052                         __gitcomp "--porcelain"
3053                         ;;
3054                 lock,--*)
3055                         __gitcomp "--reason"
3056                         ;;
3057                 prune,--*)
3058                         __gitcomp "--dry-run --expire --verbose"
3059                         ;;
3060                 *)
3061                         ;;
3062                 esac
3063         fi
3064 }
3065
3066 __git_main ()
3067 {
3068         local i c=1 command __git_dir __git_repo_path
3069         local __git_C_args C_args_count=0
3070
3071         while [ $c -lt $cword ]; do
3072                 i="${words[c]}"
3073                 case "$i" in
3074                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
3075                 --git-dir)   ((c++)) ; __git_dir="${words[c]}" ;;
3076                 --bare)      __git_dir="." ;;
3077                 --help) command="help"; break ;;
3078                 -c|--work-tree|--namespace) ((c++)) ;;
3079                 -C)     __git_C_args[C_args_count++]=-C
3080                         ((c++))
3081                         __git_C_args[C_args_count++]="${words[c]}"
3082                         ;;
3083                 -*) ;;
3084                 *) command="$i"; break ;;
3085                 esac
3086                 ((c++))
3087         done
3088
3089         if [ -z "$command" ]; then
3090                 case "$prev" in
3091                 --git-dir|-C|--work-tree)
3092                         # these need a path argument, let's fall back to
3093                         # Bash filename completion
3094                         return
3095                         ;;
3096                 -c|--namespace)
3097                         # we don't support completing these options' arguments
3098                         return
3099                         ;;
3100                 esac
3101                 case "$cur" in
3102                 --*)   __gitcomp "
3103                         --paginate
3104                         --no-pager
3105                         --git-dir=
3106                         --bare
3107                         --version
3108                         --exec-path
3109                         --exec-path=
3110                         --html-path
3111                         --man-path
3112                         --info-path
3113                         --work-tree=
3114                         --namespace=
3115                         --no-replace-objects
3116                         --help
3117                         "
3118                         ;;
3119                 *)     __git_compute_porcelain_commands
3120                        __gitcomp "$__git_porcelain_commands $(__git_aliases)" ;;
3121                 esac
3122                 return
3123         fi
3124
3125         local completion_func="_git_${command//-/_}"
3126         declare -f $completion_func >/dev/null 2>/dev/null && $completion_func && return
3127
3128         local expansion=$(__git_aliased_command "$command")
3129         if [ -n "$expansion" ]; then
3130                 words[1]=$expansion
3131                 completion_func="_git_${expansion//-/_}"
3132                 declare -f $completion_func >/dev/null 2>/dev/null && $completion_func
3133         fi
3134 }
3135
3136 __gitk_main ()
3137 {
3138         __git_has_doubledash && return
3139
3140         local __git_repo_path
3141         __git_find_repo_path
3142
3143         local merge=""
3144         if [ -f "$__git_repo_path/MERGE_HEAD" ]; then
3145                 merge="--merge"
3146         fi
3147         case "$cur" in
3148         --*)
3149                 __gitcomp "
3150                         $__git_log_common_options
3151                         $__git_log_gitk_options
3152                         $merge
3153                         "
3154                 return
3155                 ;;
3156         esac
3157         __git_complete_revlist
3158 }
3159
3160 if [[ -n ${ZSH_VERSION-} ]]; then
3161         echo "WARNING: this script is deprecated, please see git-completion.zsh" 1>&2
3162
3163         autoload -U +X compinit && compinit
3164
3165         __gitcomp ()
3166         {
3167                 emulate -L zsh
3168
3169                 local cur_="${3-$cur}"
3170
3171                 case "$cur_" in
3172                 --*=)
3173                         ;;
3174                 *)
3175                         local c IFS=$' \t\n'
3176                         local -a array
3177                         for c in ${=1}; do
3178                                 c="$c${4-}"
3179                                 case $c in
3180                                 --*=*|*.) ;;
3181                                 *) c="$c " ;;
3182                                 esac
3183                                 array[${#array[@]}+1]="$c"
3184                         done
3185                         compset -P '*[=:]'
3186                         compadd -Q -S '' -p "${2-}" -a -- array && _ret=0
3187                         ;;
3188                 esac
3189         }
3190
3191         __gitcomp_direct ()
3192         {
3193                 emulate -L zsh
3194
3195                 local IFS=$'\n'
3196                 compset -P '*[=:]'
3197                 compadd -Q -- ${=1} && _ret=0
3198         }
3199
3200         __gitcomp_nl ()
3201         {
3202                 emulate -L zsh
3203
3204                 local IFS=$'\n'
3205                 compset -P '*[=:]'
3206                 compadd -Q -S "${4- }" -p "${2-}" -- ${=1} && _ret=0
3207         }
3208
3209         __gitcomp_file ()
3210         {
3211                 emulate -L zsh
3212
3213                 local IFS=$'\n'
3214                 compset -P '*[=:]'
3215                 compadd -Q -p "${2-}" -f -- ${=1} && _ret=0
3216         }
3217
3218         _git ()
3219         {
3220                 local _ret=1 cur cword prev
3221                 cur=${words[CURRENT]}
3222                 prev=${words[CURRENT-1]}
3223                 let cword=CURRENT-1
3224                 emulate ksh -c __${service}_main
3225                 let _ret && _default && _ret=0
3226                 return _ret
3227         }
3228
3229         compdef _git git gitk
3230         return
3231 fi
3232
3233 __git_func_wrap ()
3234 {
3235         local cur words cword prev
3236         _get_comp_words_by_ref -n =: cur words cword prev
3237         $1
3238 }
3239
3240 # Setup completion for certain functions defined above by setting common
3241 # variables and workarounds.
3242 # This is NOT a public function; use at your own risk.
3243 __git_complete ()
3244 {
3245         local wrapper="__git_wrap${2}"
3246         eval "$wrapper () { __git_func_wrap $2 ; }"
3247         complete -o bashdefault -o default -o nospace -F $wrapper $1 2>/dev/null \
3248                 || complete -o default -o nospace -F $wrapper $1
3249 }
3250
3251 # wrapper for backwards compatibility
3252 _git ()
3253 {
3254         __git_wrap__git_main
3255 }
3256
3257 # wrapper for backwards compatibility
3258 _gitk ()
3259 {
3260         __git_wrap__gitk_main
3261 }
3262
3263 __git_complete git __git_main
3264 __git_complete gitk __gitk_main
3265
3266 # The following are necessary only for Cygwin, and only are needed
3267 # when the user has tab-completed the executable name and consequently
3268 # included the '.exe' suffix.
3269 #
3270 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
3271 __git_complete git.exe __git_main
3272 fi