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