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

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