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