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