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