git.oblomov.eu Git - git/blob - contrib/completion/git-completion.bash

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