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

   1 # bash/zsh completion support for core Git.
   2 #
   3 # Copyright (C) 2006,2007 Shawn O. Pearce <spearce@spearce.org>
   4 # Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
   5 # Distributed under the GNU General Public License, version 2.0.
   6 #
   7 # The contained completion routines provide support for completing:
   8 #
   9 #    *) local and remote branch names
  10 #    *) local and remote tag names
  11 #    *) .git/remotes file names
  12 #    *) git 'subcommands'
  13 #    *) git email aliases for git-send-email
  14 #    *) tree paths within 'ref:path/to/file' expressions
  15 #    *) file paths within current working directory and index
  16 #    *) common --long-options
  17 #
  18 # To use these routines:
  19 #
  20 #    1) Copy this file to somewhere (e.g. ~/.git-completion.bash).
  21 #    2) Add the following line to your .bashrc/.zshrc:
  22 #        source ~/.git-completion.bash
  23 #    3) Consider changing your PS1 to also show the current branch,
  24 #       see git-prompt.sh for details.
  25 #
  26 # If you use complex aliases of form '!f() { ... }; f', you can use the null
  27 # command ':' as the first command in the function body to declare the desired
  28 # completion style.  For example '!f() { : git commit ; ... }; f' will
  29 # tell the completion to use commit completion.  This also works with aliases
  30 # of form "!sh -c '...'".  For example, "!sh -c ': git commit ; ... '".
  31 #
  32 # You can set the following environment variables to influence the behavior of
  33 # the completion routines:
  34 #
  35 #   GIT_COMPLETION_CHECKOUT_NO_GUESS
  36 #
  37 #     When set to "1", do not include "DWIM" suggestions in git-checkout
  38 #     completion (e.g., completing "foo" when "origin/foo" exists).
  39
  40 case "$COMP_WORDBREAKS" in
  41 *:*) : great ;;
  42 *)   COMP_WORDBREAKS="$COMP_WORDBREAKS:"
  43 esac
  44
  45 # Discovers the path to the git repository taking any '--git-dir=<path>' and
  46 # '-C <path>' options into account and stores it in the $__git_repo_path
  47 # variable.
  48 __git_find_repo_path ()
  49 {
  50         if [ -n "$__git_repo_path" ]; then
  51                 # we already know where it is
  52                 return
  53         fi
  54
  55         if [ -n "${__git_C_args-}" ]; then
  56                 __git_repo_path="$(git "${__git_C_args[@]}" \
  57                         ${__git_dir:+--git-dir="$__git_dir"} \
  58                         rev-parse --absolute-git-dir 2>/dev/null)"
  59         elif [ -n "${__git_dir-}" ]; then
  60                 test -d "$__git_dir" &&
  61                 __git_repo_path="$__git_dir"
  62         elif [ -n "${GIT_DIR-}" ]; then
  63                 test -d "${GIT_DIR-}" &&
  64                 __git_repo_path="$GIT_DIR"
  65         elif [ -d .git ]; then
  66                 __git_repo_path=.git
  67         else
  68                 __git_repo_path="$(git rev-parse --git-dir 2>/dev/null)"
  69         fi
  70 }
  71
  72 # Deprecated: use __git_find_repo_path() and $__git_repo_path instead
  73 # __gitdir accepts 0 or 1 arguments (i.e., location)
  74 # returns location of .git repo
  75 __gitdir ()
  76 {
  77         if [ -z "${1-}" ]; then
  78                 __git_find_repo_path || return 1
  79                 echo "$__git_repo_path"
  80         elif [ -d "$1/.git" ]; then
  81                 echo "$1/.git"
  82         else
  83                 echo "$1"
  84         fi
  85 }
  86
  87 # Runs git with all the options given as argument, respecting any
  88 # '--git-dir=<path>' and '-C <path>' options present on the command line
  89 __git ()
  90 {
  91         git ${__git_C_args:+"${__git_C_args[@]}"} \
  92                 ${__git_dir:+--git-dir="$__git_dir"} "$@" 2>/dev/null
  93 }
  94
  95 # The following function is based on code from:
  96 #
  97 #   bash_completion - programmable completion functions for bash 3.2+
  98 #
  99 #   Copyright © 2006-2008, Ian Macdonald <ian@caliban.org>
 100 #             © 2009-2010, Bash Completion Maintainers
 101 #                     <bash-completion-devel@lists.alioth.debian.org>
 102 #
 103 #   This program is free software; you can redistribute it and/or modify
 104 #   it under the terms of the GNU General Public License as published by
 105 #   the Free Software Foundation; either version 2, or (at your option)
 106 #   any later version.
 107 #
 108 #   This program is distributed in the hope that it will be useful,
 109 #   but WITHOUT ANY WARRANTY; without even the implied warranty of
 110 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 111 #   GNU General Public License for more details.
 112 #
 113 #   You should have received a copy of the GNU General Public License
 114 #   along with this program; if not, 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
 194 if ! 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 }
 222 fi
 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                         --branch
1323                         --recurse-submodules
1324                         --no-single-branch
1325                         --shallow-submodules
1326                         "
1327                 return
1328                 ;;
1329         esac
1330 }
1331
1332 __git_untracked_file_modes="all no normal"
1333
1334 _git_commit ()
1335 {
1336         case "$prev" in
1337         -c|-C)
1338                 __git_complete_refs
1339                 return
1340                 ;;
1341         esac
1342
1343         case "$cur" in
1344         --cleanup=*)
1345                 __gitcomp "default scissors strip verbatim whitespace
1346                         " "" "${cur##--cleanup=}"
1347                 return
1348                 ;;
1349         --reuse-message=*|--reedit-message=*|\
1350         --fixup=*|--squash=*)
1351                 __git_complete_refs --cur="${cur#*=}"
1352                 return
1353                 ;;
1354         --untracked-files=*)
1355                 __gitcomp "$__git_untracked_file_modes" "" "${cur##--untracked-files=}"
1356                 return
1357                 ;;
1358         --*)
1359                 __gitcomp "
1360                         --all --author= --signoff --verify --no-verify
1361                         --edit --no-edit
1362                         --amend --include --only --interactive
1363                         --dry-run --reuse-message= --reedit-message=
1364                         --reset-author --file= --message= --template=
1365                         --cleanup= --untracked-files --untracked-files=
1366                         --verbose --quiet --fixup= --squash=
1367                         --patch --short --date --allow-empty
1368                         "
1369                 return
1370         esac
1371
1372         if __git rev-parse --verify --quiet HEAD >/dev/null; then
1373                 __git_complete_index_file "--committable"
1374         else
1375                 # This is the first commit
1376                 __git_complete_index_file "--cached"
1377         fi
1378 }
1379
1380 _git_describe ()
1381 {
1382         case "$cur" in
1383         --*)
1384                 __gitcomp "
1385                         --all --tags --contains --abbrev= --candidates=
1386                         --exact-match --debug --long --match --always --first-parent
1387                         --exclude
1388                         "
1389                 return
1390         esac
1391         __git_complete_refs
1392 }
1393
1394 __git_diff_algorithms="myers minimal patience histogram"
1395
1396 __git_diff_submodule_formats="diff log short"
1397
1398 __git_diff_common_options="--stat --numstat --shortstat --summary
1399                         --patch-with-stat --name-only --name-status --color
1400                         --no-color --color-words --no-renames --check
1401                         --full-index --binary --abbrev --diff-filter=
1402                         --find-copies-harder
1403                         --text --ignore-space-at-eol --ignore-space-change
1404                         --ignore-all-space --ignore-blank-lines --exit-code
1405                         --quiet --ext-diff --no-ext-diff
1406                         --no-prefix --src-prefix= --dst-prefix=
1407                         --inter-hunk-context=
1408                         --patience --histogram --minimal
1409                         --raw --word-diff --word-diff-regex=
1410                         --dirstat --dirstat= --dirstat-by-file
1411                         --dirstat-by-file= --cumulative
1412                         --diff-algorithm=
1413                         --submodule --submodule=
1414 "
1415
1416 _git_diff ()
1417 {
1418         __git_has_doubledash && return
1419
1420         case "$cur" in
1421         --diff-algorithm=*)
1422                 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
1423                 return
1424                 ;;
1425         --submodule=*)
1426                 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
1427                 return
1428                 ;;
1429         --*)
1430                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1431                         --base --ours --theirs --no-index
1432                         $__git_diff_common_options
1433                         "
1434                 return
1435                 ;;
1436         esac
1437         __git_complete_revlist_file
1438 }
1439
1440 __git_mergetools_common="diffuse diffmerge ecmerge emerge kdiff3 meld opendiff
1441                         tkdiff vimdiff gvimdiff xxdiff araxis p4merge bc codecompare
1442 "
1443
1444 _git_difftool ()
1445 {
1446         __git_has_doubledash && return
1447
1448         case "$cur" in
1449         --tool=*)
1450                 __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
1451                 return
1452                 ;;
1453         --*)
1454                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1455                         --base --ours --theirs
1456                         --no-renames --diff-filter= --find-copies-harder
1457                         --relative --ignore-submodules
1458                         --tool="
1459                 return
1460                 ;;
1461         esac
1462         __git_complete_revlist_file
1463 }
1464
1465 __git_fetch_recurse_submodules="yes on-demand no"
1466
1467 __git_fetch_options="
1468         --quiet --verbose --append --upload-pack --force --keep --depth=
1469         --tags --no-tags --all --prune --dry-run --recurse-submodules=
1470         --unshallow --update-shallow
1471 "
1472
1473 _git_fetch ()
1474 {
1475         case "$cur" in
1476         --recurse-submodules=*)
1477                 __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
1478                 return
1479                 ;;
1480         --*)
1481                 __gitcomp "$__git_fetch_options"
1482                 return
1483                 ;;
1484         esac
1485         __git_complete_remote_or_refspec
1486 }
1487
1488 __git_format_patch_options="
1489         --stdout --attach --no-attach --thread --thread= --no-thread
1490         --numbered --start-number --numbered-files --keep-subject --signoff
1491         --signature --no-signature --in-reply-to= --cc= --full-index --binary
1492         --not --all --cover-letter --no-prefix --src-prefix= --dst-prefix=
1493         --inline --suffix= --ignore-if-in-upstream --subject-prefix=
1494         --output-directory --reroll-count --to= --quiet --notes
1495 "
1496
1497 _git_format_patch ()
1498 {
1499         case "$cur" in
1500         --thread=*)
1501                 __gitcomp "
1502                         deep shallow
1503                         " "" "${cur##--thread=}"
1504                 return
1505                 ;;
1506         --*)
1507                 __gitcomp "$__git_format_patch_options"
1508                 return
1509                 ;;
1510         esac
1511         __git_complete_revlist
1512 }
1513
1514 _git_fsck ()
1515 {
1516         case "$cur" in
1517         --*)
1518                 __gitcomp "
1519                         --tags --root --unreachable --cache --no-reflogs --full
1520                         --strict --verbose --lost-found --name-objects
1521                         "
1522                 return
1523                 ;;
1524         esac
1525 }
1526
1527 _git_gc ()
1528 {
1529         case "$cur" in
1530         --*)
1531                 __gitcomp "--prune --aggressive"
1532                 return
1533                 ;;
1534         esac
1535 }
1536
1537 _git_gitk ()
1538 {
1539         _gitk
1540 }
1541
1542 # Lists matching symbol names from a tag (as in ctags) file.
1543 # 1: List symbol names matching this word.
1544 # 2: The tag file to list symbol names from.
1545 # 3: A prefix to be added to each listed symbol name (optional).
1546 # 4: A suffix to be appended to each listed symbol name (optional).
1547 __git_match_ctag () {
1548         awk -v pfx="${3-}" -v sfx="${4-}" "
1549                 /^${1//\//\\/}/ { print pfx \$1 sfx }
1550                 " "$2"
1551 }
1552
1553 # Complete symbol names from a tag file.
1554 # Usage: __git_complete_symbol [<option>]...
1555 # --tags=<file>: The tag file to list symbol names from instead of the
1556 #                default "tags".
1557 # --pfx=<prefix>: A prefix to be added to each symbol name.
1558 # --cur=<word>: The current symbol name to be completed.  Defaults to
1559 #               the current word to be completed.
1560 # --sfx=<suffix>: A suffix to be appended to each symbol name instead
1561 #                 of the default space.
1562 __git_complete_symbol () {
1563         local tags=tags pfx="" cur_="${cur-}" sfx=" "
1564
1565         while test $# != 0; do
1566                 case "$1" in
1567                 --tags=*)       tags="${1##--tags=}" ;;
1568                 --pfx=*)        pfx="${1##--pfx=}" ;;
1569                 --cur=*)        cur_="${1##--cur=}" ;;
1570                 --sfx=*)        sfx="${1##--sfx=}" ;;
1571                 *)              return 1 ;;
1572                 esac
1573                 shift
1574         done
1575
1576         if test -r "$tags"; then
1577                 __gitcomp_direct "$(__git_match_ctag "$cur_" "$tags" "$pfx" "$sfx")"
1578         fi
1579 }
1580
1581 _git_grep ()
1582 {
1583         __git_has_doubledash && return
1584
1585         case "$cur" in
1586         --*)
1587                 __gitcomp "
1588                         --cached
1589                         --text --ignore-case --word-regexp --invert-match
1590                         --full-name --line-number
1591                         --extended-regexp --basic-regexp --fixed-strings
1592                         --perl-regexp
1593                         --threads
1594                         --files-with-matches --name-only
1595                         --files-without-match
1596                         --max-depth
1597                         --count
1598                         --and --or --not --all-match
1599                         --break --heading --show-function --function-context
1600                         --untracked --no-index
1601                         "
1602                 return
1603                 ;;
1604         esac
1605
1606         case "$cword,$prev" in
1607         2,*|*,-*)
1608                 __git_complete_symbol && return
1609                 ;;
1610         esac
1611
1612         __git_complete_refs
1613 }
1614
1615 _git_help ()
1616 {
1617         case "$cur" in
1618         --*)
1619                 __gitcomp "--all --guides --info --man --web"
1620                 return
1621                 ;;
1622         esac
1623         __git_compute_all_commands
1624         __gitcomp "$__git_all_commands $(__git_aliases)
1625                 attributes cli core-tutorial cvs-migration
1626                 diffcore everyday gitk glossary hooks ignore modules
1627                 namespaces repository-layout revisions tutorial tutorial-2
1628                 workflows
1629                 "
1630 }
1631
1632 _git_init ()
1633 {
1634         case "$cur" in
1635         --shared=*)
1636                 __gitcomp "
1637                         false true umask group all world everybody
1638                         " "" "${cur##--shared=}"
1639                 return
1640                 ;;
1641         --*)
1642                 __gitcomp "--quiet --bare --template= --shared --shared="
1643                 return
1644                 ;;
1645         esac
1646 }
1647
1648 _git_ls_files ()
1649 {
1650         case "$cur" in
1651         --*)
1652                 __gitcomp "--cached --deleted --modified --others --ignored
1653                         --stage --directory --no-empty-directory --unmerged
1654                         --killed --exclude= --exclude-from=
1655                         --exclude-per-directory= --exclude-standard
1656                         --error-unmatch --with-tree= --full-name
1657                         --abbrev --ignored --exclude-per-directory
1658                         "
1659                 return
1660                 ;;
1661         esac
1662
1663         # XXX ignore options like --modified and always suggest all cached
1664         # files.
1665         __git_complete_index_file "--cached"
1666 }
1667
1668 _git_ls_remote ()
1669 {
1670         case "$cur" in
1671         --*)
1672                 __gitcomp "--heads --tags --refs --get-url --symref"
1673                 return
1674                 ;;
1675         esac
1676         __gitcomp_nl "$(__git_remotes)"
1677 }
1678
1679 _git_ls_tree ()
1680 {
1681         __git_complete_file
1682 }
1683
1684 # Options that go well for log, shortlog and gitk
1685 __git_log_common_options="
1686         --not --all
1687         --branches --tags --remotes
1688         --first-parent --merges --no-merges
1689         --max-count=
1690         --max-age= --since= --after=
1691         --min-age= --until= --before=
1692         --min-parents= --max-parents=
1693         --no-min-parents --no-max-parents
1694 "
1695 # Options that go well for log and gitk (not shortlog)
1696 __git_log_gitk_options="
1697         --dense --sparse --full-history
1698         --simplify-merges --simplify-by-decoration
1699         --left-right --notes --no-notes
1700 "
1701 # Options that go well for log and shortlog (not gitk)
1702 __git_log_shortlog_options="
1703         --author= --committer= --grep=
1704         --all-match --invert-grep
1705 "
1706
1707 __git_log_pretty_formats="oneline short medium full fuller email raw format:"
1708 __git_log_date_formats="relative iso8601 rfc2822 short local default raw"
1709
1710 _git_log ()
1711 {
1712         __git_has_doubledash && return
1713         __git_find_repo_path
1714
1715         local merge=""
1716         if [ -f "$__git_repo_path/MERGE_HEAD" ]; then
1717                 merge="--merge"
1718         fi
1719         case "$prev,$cur" in
1720         -L,:*:*)
1721                 return  # fall back to Bash filename completion
1722                 ;;
1723         -L,:*)
1724                 __git_complete_symbol --cur="${cur#:}" --sfx=":"
1725                 return
1726                 ;;
1727         -G,*|-S,*)
1728                 __git_complete_symbol
1729                 return
1730                 ;;
1731         esac
1732         case "$cur" in
1733         --pretty=*|--format=*)
1734                 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
1735                         " "" "${cur#*=}"
1736                 return
1737                 ;;
1738         --date=*)
1739                 __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
1740                 return
1741                 ;;
1742         --decorate=*)
1743                 __gitcomp "full short no" "" "${cur##--decorate=}"
1744                 return
1745                 ;;
1746         --diff-algorithm=*)
1747                 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
1748                 return
1749                 ;;
1750         --submodule=*)
1751                 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
1752                 return
1753                 ;;
1754         --*)
1755                 __gitcomp "
1756                         $__git_log_common_options
1757                         $__git_log_shortlog_options
1758                         $__git_log_gitk_options
1759                         --root --topo-order --date-order --reverse
1760                         --follow --full-diff
1761                         --abbrev-commit --abbrev=
1762                         --relative-date --date=
1763                         --pretty= --format= --oneline
1764                         --show-signature
1765                         --cherry-mark
1766                         --cherry-pick
1767                         --graph
1768                         --decorate --decorate=
1769                         --walk-reflogs
1770                         --parents --children
1771                         $merge
1772                         $__git_diff_common_options
1773                         --pickaxe-all --pickaxe-regex
1774                         "
1775                 return
1776                 ;;
1777         -L:*:*)
1778                 return  # fall back to Bash filename completion
1779                 ;;
1780         -L:*)
1781                 __git_complete_symbol --cur="${cur#-L:}" --sfx=":"
1782                 return
1783                 ;;
1784         -G*)
1785                 __git_complete_symbol --pfx="-G" --cur="${cur#-G}"
1786                 return
1787                 ;;
1788         -S*)
1789                 __git_complete_symbol --pfx="-S" --cur="${cur#-S}"
1790                 return
1791                 ;;
1792         esac
1793         __git_complete_revlist
1794 }
1795
1796 # Common merge options shared by git-merge(1) and git-pull(1).
1797 __git_merge_options="
1798         --no-commit --no-stat --log --no-log --squash --strategy
1799         --commit --stat --no-squash --ff --no-ff --ff-only --edit --no-edit
1800         --verify-signatures --no-verify-signatures --gpg-sign
1801         --quiet --verbose --progress --no-progress
1802 "
1803
1804 _git_merge ()
1805 {
1806         __git_complete_strategy && return
1807
1808         case "$cur" in
1809         --*)
1810                 __gitcomp "$__git_merge_options
1811                         --rerere-autoupdate --no-rerere-autoupdate --abort --continue"
1812                 return
1813         esac
1814         __git_complete_refs
1815 }
1816
1817 _git_mergetool ()
1818 {
1819         case "$cur" in
1820         --tool=*)
1821                 __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
1822                 return
1823                 ;;
1824         --*)
1825                 __gitcomp "--tool= --prompt --no-prompt"
1826                 return
1827                 ;;
1828         esac
1829 }
1830
1831 _git_merge_base ()
1832 {
1833         case "$cur" in
1834         --*)
1835                 __gitcomp "--octopus --independent --is-ancestor --fork-point"
1836                 return
1837                 ;;
1838         esac
1839         __git_complete_refs
1840 }
1841
1842 _git_mv ()
1843 {
1844         case "$cur" in
1845         --*)
1846                 __gitcomp "--dry-run"
1847                 return
1848                 ;;
1849         esac
1850
1851         if [ $(__git_count_arguments "mv") -gt 0 ]; then
1852                 # We need to show both cached and untracked files (including
1853                 # empty directories) since this may not be the last argument.
1854                 __git_complete_index_file "--cached --others --directory"
1855         else
1856                 __git_complete_index_file "--cached"
1857         fi
1858 }
1859
1860 _git_name_rev ()
1861 {
1862         __gitcomp "--tags --all --stdin"
1863 }
1864
1865 _git_notes ()
1866 {
1867         local subcommands='add append copy edit list prune remove show'
1868         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1869
1870         case "$subcommand,$cur" in
1871         ,--*)
1872                 __gitcomp '--ref'
1873                 ;;
1874         ,*)
1875                 case "$prev" in
1876                 --ref)
1877                         __git_complete_refs
1878                         ;;
1879                 *)
1880                         __gitcomp "$subcommands --ref"
1881                         ;;
1882                 esac
1883                 ;;
1884         add,--reuse-message=*|append,--reuse-message=*|\
1885         add,--reedit-message=*|append,--reedit-message=*)
1886                 __git_complete_refs --cur="${cur#*=}"
1887                 ;;
1888         add,--*|append,--*)
1889                 __gitcomp '--file= --message= --reedit-message=
1890                                 --reuse-message='
1891                 ;;
1892         copy,--*)
1893                 __gitcomp '--stdin'
1894                 ;;
1895         prune,--*)
1896                 __gitcomp '--dry-run --verbose'
1897                 ;;
1898         prune,*)
1899                 ;;
1900         *)
1901                 case "$prev" in
1902                 -m|-F)
1903                         ;;
1904                 *)
1905                         __git_complete_refs
1906                         ;;
1907                 esac
1908                 ;;
1909         esac
1910 }
1911
1912 _git_pull ()
1913 {
1914         __git_complete_strategy && return
1915
1916         case "$cur" in
1917         --recurse-submodules=*)
1918                 __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
1919                 return
1920                 ;;
1921         --*)
1922                 __gitcomp "
1923                         --rebase --no-rebase
1924                         $__git_merge_options
1925                         $__git_fetch_options
1926                 "
1927                 return
1928                 ;;
1929         esac
1930         __git_complete_remote_or_refspec
1931 }
1932
1933 __git_push_recurse_submodules="check on-demand only"
1934
1935 __git_complete_force_with_lease ()
1936 {
1937         local cur_=$1
1938
1939         case "$cur_" in
1940         --*=)
1941                 ;;
1942         *:*)
1943                 __git_complete_refs --cur="${cur_#*:}"
1944                 ;;
1945         *)
1946                 __git_complete_refs --cur="$cur_"
1947                 ;;
1948         esac
1949 }
1950
1951 _git_push ()
1952 {
1953         case "$prev" in
1954         --repo)
1955                 __gitcomp_nl "$(__git_remotes)"
1956                 return
1957                 ;;
1958         --recurse-submodules)
1959                 __gitcomp "$__git_push_recurse_submodules"
1960                 return
1961                 ;;
1962         esac
1963         case "$cur" in
1964         --repo=*)
1965                 __gitcomp_nl "$(__git_remotes)" "" "${cur##--repo=}"
1966                 return
1967                 ;;
1968         --recurse-submodules=*)
1969                 __gitcomp "$__git_push_recurse_submodules" "" "${cur##--recurse-submodules=}"
1970                 return
1971                 ;;
1972         --force-with-lease=*)
1973                 __git_complete_force_with_lease "${cur##--force-with-lease=}"
1974                 return
1975                 ;;
1976         --*)
1977                 __gitcomp "
1978                         --all --mirror --tags --dry-run --force --verbose
1979                         --quiet --prune --delete --follow-tags
1980                         --receive-pack= --repo= --set-upstream
1981                         --force-with-lease --force-with-lease= --recurse-submodules=
1982                 "
1983                 return
1984                 ;;
1985         esac
1986         __git_complete_remote_or_refspec
1987 }
1988
1989 _git_rebase ()
1990 {
1991         __git_find_repo_path
1992         if [ -f "$__git_repo_path"/rebase-merge/interactive ]; then
1993                 __gitcomp "--continue --skip --abort --quit --edit-todo"
1994                 return
1995         elif [ -d "$__git_repo_path"/rebase-apply ] || \
1996              [ -d "$__git_repo_path"/rebase-merge ]; then
1997                 __gitcomp "--continue --skip --abort --quit"
1998                 return
1999         fi
2000         __git_complete_strategy && return
2001         case "$cur" in
2002         --whitespace=*)
2003                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
2004                 return
2005                 ;;
2006         --*)
2007                 __gitcomp "
2008                         --onto --merge --strategy --interactive
2009                         --preserve-merges --stat --no-stat
2010                         --committer-date-is-author-date --ignore-date
2011                         --ignore-whitespace --whitespace=
2012                         --autosquash --no-autosquash
2013                         --fork-point --no-fork-point
2014                         --autostash --no-autostash
2015                         --verify --no-verify
2016                         --keep-empty --root --force-rebase --no-ff
2017                         --exec
2018                         "
2019
2020                 return
2021         esac
2022         __git_complete_refs
2023 }
2024
2025 _git_reflog ()
2026 {
2027         local subcommands="show delete expire"
2028         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2029
2030         if [ -z "$subcommand" ]; then
2031                 __gitcomp "$subcommands"
2032         else
2033                 __git_complete_refs
2034         fi
2035 }
2036
2037 __git_send_email_confirm_options="always never auto cc compose"
2038 __git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
2039
2040 _git_send_email ()
2041 {
2042         case "$prev" in
2043         --to|--cc|--bcc|--from)
2044                 __gitcomp "$(__git send-email --dump-aliases)"
2045                 return
2046                 ;;
2047         esac
2048
2049         case "$cur" in
2050         --confirm=*)
2051                 __gitcomp "
2052                         $__git_send_email_confirm_options
2053                         " "" "${cur##--confirm=}"
2054                 return
2055                 ;;
2056         --suppress-cc=*)
2057                 __gitcomp "
2058                         $__git_send_email_suppresscc_options
2059                         " "" "${cur##--suppress-cc=}"
2060
2061                 return
2062                 ;;
2063         --smtp-encryption=*)
2064                 __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
2065                 return
2066                 ;;
2067         --thread=*)
2068                 __gitcomp "
2069                         deep shallow
2070                         " "" "${cur##--thread=}"
2071                 return
2072                 ;;
2073         --to=*|--cc=*|--bcc=*|--from=*)
2074                 __gitcomp "$(__git send-email --dump-aliases)" "" "${cur#--*=}"
2075                 return
2076                 ;;
2077         --*)
2078                 __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
2079                         --compose --confirm= --dry-run --envelope-sender
2080                         --from --identity
2081                         --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
2082                         --no-suppress-from --no-thread --quiet
2083                         --signed-off-by-cc --smtp-pass --smtp-server
2084                         --smtp-server-port --smtp-encryption= --smtp-user
2085                         --subject --suppress-cc= --suppress-from --thread --to
2086                         --validate --no-validate
2087                         $__git_format_patch_options"
2088                 return
2089                 ;;
2090         esac
2091         __git_complete_revlist
2092 }
2093
2094 _git_stage ()
2095 {
2096         _git_add
2097 }
2098
2099 _git_status ()
2100 {
2101         local complete_opt
2102         local untracked_state
2103
2104         case "$cur" in
2105         --ignore-submodules=*)
2106                 __gitcomp "none untracked dirty all" "" "${cur##--ignore-submodules=}"
2107                 return
2108                 ;;
2109         --untracked-files=*)
2110                 __gitcomp "$__git_untracked_file_modes" "" "${cur##--untracked-files=}"
2111                 return
2112                 ;;
2113         --column=*)
2114                 __gitcomp "
2115                         always never auto column row plain dense nodense
2116                         " "" "${cur##--column=}"
2117                 return
2118                 ;;
2119         --*)
2120                 __gitcomp "
2121                         --short --branch --porcelain --long --verbose
2122                         --untracked-files= --ignore-submodules= --ignored
2123                         --column= --no-column
2124                         "
2125                 return
2126                 ;;
2127         esac
2128
2129         untracked_state="$(__git_get_option_value "-u" "--untracked-files=" \
2130                 "$__git_untracked_file_modes" "status.showUntrackedFiles")"
2131
2132         case "$untracked_state" in
2133         no)
2134                 # --ignored option does not matter
2135                 complete_opt=
2136                 ;;
2137         all|normal|*)
2138                 complete_opt="--cached --directory --no-empty-directory --others"
2139
2140                 if [ -n "$(__git_find_on_cmdline "--ignored")" ]; then
2141                         complete_opt="$complete_opt --ignored --exclude=*"
2142                 fi
2143                 ;;
2144         esac
2145
2146         __git_complete_index_file "$complete_opt"
2147 }
2148
2149 __git_config_get_set_variables ()
2150 {
2151         local prevword word config_file= c=$cword
2152         while [ $c -gt 1 ]; do
2153                 word="${words[c]}"
2154                 case "$word" in
2155                 --system|--global|--local|--file=*)
2156                         config_file="$word"
2157                         break
2158                         ;;
2159                 -f|--file)
2160                         config_file="$word $prevword"
2161                         break
2162                         ;;
2163                 esac
2164                 prevword=$word
2165                 c=$((--c))
2166         done
2167
2168         __git config $config_file --name-only --list
2169 }
2170
2171 _git_config ()
2172 {
2173         case "$prev" in
2174         branch.*.remote|branch.*.pushremote)
2175                 __gitcomp_nl "$(__git_remotes)"
2176                 return
2177                 ;;
2178         branch.*.merge)
2179                 __git_complete_refs
2180                 return
2181                 ;;
2182         branch.*.rebase)
2183                 __gitcomp "false true preserve interactive"
2184                 return
2185                 ;;
2186         remote.pushdefault)
2187                 __gitcomp_nl "$(__git_remotes)"
2188                 return
2189                 ;;
2190         remote.*.fetch)
2191                 local remote="${prev#remote.}"
2192                 remote="${remote%.fetch}"
2193                 if [ -z "$cur" ]; then
2194                         __gitcomp_nl "refs/heads/" "" "" ""
2195                         return
2196                 fi
2197                 __gitcomp_nl "$(__git_refs_remotes "$remote")"
2198                 return
2199                 ;;
2200         remote.*.push)
2201                 local remote="${prev#remote.}"
2202                 remote="${remote%.push}"
2203                 __gitcomp_nl "$(__git for-each-ref \
2204                         --format='%(refname):%(refname)' refs/heads)"
2205                 return
2206                 ;;
2207         pull.twohead|pull.octopus)
2208                 __git_compute_merge_strategies
2209                 __gitcomp "$__git_merge_strategies"
2210                 return
2211                 ;;
2212         color.branch|color.diff|color.interactive|\
2213         color.showbranch|color.status|color.ui)
2214                 __gitcomp "always never auto"
2215                 return
2216                 ;;
2217         color.pager)
2218                 __gitcomp "false true"
2219                 return
2220                 ;;
2221         color.*.*)
2222                 __gitcomp "
2223                         normal black red green yellow blue magenta cyan white
2224                         bold dim ul blink reverse
2225                         "
2226                 return
2227                 ;;
2228         diff.submodule)
2229                 __gitcomp "log short"
2230                 return
2231                 ;;
2232         help.format)
2233                 __gitcomp "man info web html"
2234                 return
2235                 ;;
2236         log.date)
2237                 __gitcomp "$__git_log_date_formats"
2238                 return
2239                 ;;
2240         sendemail.aliasesfiletype)
2241                 __gitcomp "mutt mailrc pine elm gnus"
2242                 return
2243                 ;;
2244         sendemail.confirm)
2245                 __gitcomp "$__git_send_email_confirm_options"
2246                 return
2247                 ;;
2248         sendemail.suppresscc)
2249                 __gitcomp "$__git_send_email_suppresscc_options"
2250                 return
2251                 ;;
2252         sendemail.transferencoding)
2253                 __gitcomp "7bit 8bit quoted-printable base64"
2254                 return
2255                 ;;
2256         --get|--get-all|--unset|--unset-all)
2257                 __gitcomp_nl "$(__git_config_get_set_variables)"
2258                 return
2259                 ;;
2260         *.*)
2261                 return
2262                 ;;
2263         esac
2264         case "$cur" in
2265         --*)
2266                 __gitcomp "
2267                         --system --global --local --file=
2268                         --list --replace-all
2269                         --get --get-all --get-regexp
2270                         --add --unset --unset-all
2271                         --remove-section --rename-section
2272                         --name-only
2273                         "
2274                 return
2275                 ;;
2276         branch.*.*)
2277                 local pfx="${cur%.*}." cur_="${cur##*.}"
2278                 __gitcomp "remote pushremote merge mergeoptions rebase" "$pfx" "$cur_"
2279                 return
2280                 ;;
2281         branch.*)
2282                 local pfx="${cur%.*}." cur_="${cur#*.}"
2283                 __gitcomp_direct "$(__git_heads "$pfx" "$cur_" ".")"
2284                 __gitcomp_nl_append $'autosetupmerge\nautosetuprebase\n' "$pfx" "$cur_"
2285                 return
2286                 ;;
2287         guitool.*.*)
2288                 local pfx="${cur%.*}." cur_="${cur##*.}"
2289                 __gitcomp "
2290                         argprompt cmd confirm needsfile noconsole norescan
2291                         prompt revprompt revunmerged title
2292                         " "$pfx" "$cur_"
2293                 return
2294                 ;;
2295         difftool.*.*)
2296                 local pfx="${cur%.*}." cur_="${cur##*.}"
2297                 __gitcomp "cmd path" "$pfx" "$cur_"
2298                 return
2299                 ;;
2300         man.*.*)
2301                 local pfx="${cur%.*}." cur_="${cur##*.}"
2302                 __gitcomp "cmd path" "$pfx" "$cur_"
2303                 return
2304                 ;;
2305         mergetool.*.*)
2306                 local pfx="${cur%.*}." cur_="${cur##*.}"
2307                 __gitcomp "cmd path trustExitCode" "$pfx" "$cur_"
2308                 return
2309                 ;;
2310         pager.*)
2311                 local pfx="${cur%.*}." cur_="${cur#*.}"
2312                 __git_compute_all_commands
2313                 __gitcomp_nl "$__git_all_commands" "$pfx" "$cur_"
2314                 return
2315                 ;;
2316         remote.*.*)
2317                 local pfx="${cur%.*}." cur_="${cur##*.}"
2318                 __gitcomp "
2319                         url proxy fetch push mirror skipDefaultUpdate
2320                         receivepack uploadpack tagopt pushurl
2321                         " "$pfx" "$cur_"
2322                 return
2323                 ;;
2324         remote.*)
2325                 local pfx="${cur%.*}." cur_="${cur#*.}"
2326                 __gitcomp_nl "$(__git_remotes)" "$pfx" "$cur_" "."
2327                 __gitcomp_nl_append "pushdefault" "$pfx" "$cur_"
2328                 return
2329                 ;;
2330         url.*.*)
2331                 local pfx="${cur%.*}." cur_="${cur##*.}"
2332                 __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur_"
2333                 return
2334                 ;;
2335         esac
2336         __gitcomp "
2337                 add.ignoreErrors
2338                 advice.commitBeforeMerge
2339                 advice.detachedHead
2340                 advice.implicitIdentity
2341                 advice.pushNonFastForward
2342                 advice.resolveConflict
2343                 advice.statusHints
2344                 alias.
2345                 am.keepcr
2346                 apply.ignorewhitespace
2347                 apply.whitespace
2348                 branch.autosetupmerge
2349                 branch.autosetuprebase
2350                 browser.
2351                 clean.requireForce
2352                 color.branch
2353                 color.branch.current
2354                 color.branch.local
2355                 color.branch.plain
2356                 color.branch.remote
2357                 color.decorate.HEAD
2358                 color.decorate.branch
2359                 color.decorate.remoteBranch
2360                 color.decorate.stash
2361                 color.decorate.tag
2362                 color.diff
2363                 color.diff.commit
2364                 color.diff.frag
2365                 color.diff.func
2366                 color.diff.meta
2367                 color.diff.new
2368                 color.diff.old
2369                 color.diff.plain
2370                 color.diff.whitespace
2371                 color.grep
2372                 color.grep.context
2373                 color.grep.filename
2374                 color.grep.function
2375                 color.grep.linenumber
2376                 color.grep.match
2377                 color.grep.selected
2378                 color.grep.separator
2379                 color.interactive
2380                 color.interactive.error
2381                 color.interactive.header
2382                 color.interactive.help
2383                 color.interactive.prompt
2384                 color.pager
2385                 color.showbranch
2386                 color.status
2387                 color.status.added
2388                 color.status.changed
2389                 color.status.header
2390                 color.status.nobranch
2391                 color.status.unmerged
2392                 color.status.untracked
2393                 color.status.updated
2394                 color.ui
2395                 commit.status
2396                 commit.template
2397                 core.abbrev
2398                 core.askpass
2399                 core.attributesfile
2400                 core.autocrlf
2401                 core.bare
2402                 core.bigFileThreshold
2403                 core.compression
2404                 core.createObject
2405                 core.deltaBaseCacheLimit
2406                 core.editor
2407                 core.eol
2408                 core.excludesfile
2409                 core.fileMode
2410                 core.fsyncobjectfiles
2411                 core.gitProxy
2412                 core.ignoreStat
2413                 core.ignorecase
2414                 core.logAllRefUpdates
2415                 core.loosecompression
2416                 core.notesRef
2417                 core.packedGitLimit
2418                 core.packedGitWindowSize
2419                 core.pager
2420                 core.preferSymlinkRefs
2421                 core.preloadindex
2422                 core.quotepath
2423                 core.repositoryFormatVersion
2424                 core.safecrlf
2425                 core.sharedRepository
2426                 core.sparseCheckout
2427                 core.symlinks
2428                 core.trustctime
2429                 core.untrackedCache
2430                 core.warnAmbiguousRefs
2431                 core.whitespace
2432                 core.worktree
2433                 diff.autorefreshindex
2434                 diff.external
2435                 diff.ignoreSubmodules
2436                 diff.mnemonicprefix
2437                 diff.noprefix
2438                 diff.renameLimit
2439                 diff.renames
2440                 diff.statGraphWidth
2441                 diff.submodule
2442                 diff.suppressBlankEmpty
2443                 diff.tool
2444                 diff.wordRegex
2445                 diff.algorithm
2446                 difftool.
2447                 difftool.prompt
2448                 fetch.recurseSubmodules
2449                 fetch.unpackLimit
2450                 format.attach
2451                 format.cc
2452                 format.coverLetter
2453                 format.from
2454                 format.headers
2455                 format.numbered
2456                 format.pretty
2457                 format.signature
2458                 format.signoff
2459                 format.subjectprefix
2460                 format.suffix
2461                 format.thread
2462                 format.to
2463                 gc.
2464                 gc.aggressiveWindow
2465                 gc.auto
2466                 gc.autopacklimit
2467                 gc.packrefs
2468                 gc.pruneexpire
2469                 gc.reflogexpire
2470                 gc.reflogexpireunreachable
2471                 gc.rerereresolved
2472                 gc.rerereunresolved
2473                 gitcvs.allbinary
2474                 gitcvs.commitmsgannotation
2475                 gitcvs.dbTableNamePrefix
2476                 gitcvs.dbdriver
2477                 gitcvs.dbname
2478                 gitcvs.dbpass
2479                 gitcvs.dbuser
2480                 gitcvs.enabled
2481                 gitcvs.logfile
2482                 gitcvs.usecrlfattr
2483                 guitool.
2484                 gui.blamehistoryctx
2485                 gui.commitmsgwidth
2486                 gui.copyblamethreshold
2487                 gui.diffcontext
2488                 gui.encoding
2489                 gui.fastcopyblame
2490                 gui.matchtrackingbranch
2491                 gui.newbranchtemplate
2492                 gui.pruneduringfetch
2493                 gui.spellingdictionary
2494                 gui.trustmtime
2495                 help.autocorrect
2496                 help.browser
2497                 help.format
2498                 http.lowSpeedLimit
2499                 http.lowSpeedTime
2500                 http.maxRequests
2501                 http.minSessions
2502                 http.noEPSV
2503                 http.postBuffer
2504                 http.proxy
2505                 http.sslCipherList
2506                 http.sslVersion
2507                 http.sslCAInfo
2508                 http.sslCAPath
2509                 http.sslCert
2510                 http.sslCertPasswordProtected
2511                 http.sslKey
2512                 http.sslVerify
2513                 http.useragent
2514                 i18n.commitEncoding
2515                 i18n.logOutputEncoding
2516                 imap.authMethod
2517                 imap.folder
2518                 imap.host
2519                 imap.pass
2520                 imap.port
2521                 imap.preformattedHTML
2522                 imap.sslverify
2523                 imap.tunnel
2524                 imap.user
2525                 init.templatedir
2526                 instaweb.browser
2527                 instaweb.httpd
2528                 instaweb.local
2529                 instaweb.modulepath
2530                 instaweb.port
2531                 interactive.singlekey
2532                 log.date
2533                 log.decorate
2534                 log.showroot
2535                 mailmap.file
2536                 man.
2537                 man.viewer
2538                 merge.
2539                 merge.conflictstyle
2540                 merge.log
2541                 merge.renameLimit
2542                 merge.renormalize
2543                 merge.stat
2544                 merge.tool
2545                 merge.verbosity
2546                 mergetool.
2547                 mergetool.keepBackup
2548                 mergetool.keepTemporaries
2549                 mergetool.prompt
2550                 notes.displayRef
2551                 notes.rewrite.
2552                 notes.rewrite.amend
2553                 notes.rewrite.rebase
2554                 notes.rewriteMode
2555                 notes.rewriteRef
2556                 pack.compression
2557                 pack.deltaCacheLimit
2558                 pack.deltaCacheSize
2559                 pack.depth
2560                 pack.indexVersion
2561                 pack.packSizeLimit
2562                 pack.threads
2563                 pack.window
2564                 pack.windowMemory
2565                 pager.
2566                 pretty.
2567                 pull.octopus
2568                 pull.twohead
2569                 push.default
2570                 push.followTags
2571                 rebase.autosquash
2572                 rebase.stat
2573                 receive.autogc
2574                 receive.denyCurrentBranch
2575                 receive.denyDeleteCurrent
2576                 receive.denyDeletes
2577                 receive.denyNonFastForwards
2578                 receive.fsckObjects
2579                 receive.unpackLimit
2580                 receive.updateserverinfo
2581                 remote.pushdefault
2582                 remotes.
2583                 repack.usedeltabaseoffset
2584                 rerere.autoupdate
2585                 rerere.enabled
2586                 sendemail.
2587                 sendemail.aliasesfile
2588                 sendemail.aliasfiletype
2589                 sendemail.bcc
2590                 sendemail.cc
2591                 sendemail.cccmd
2592                 sendemail.chainreplyto
2593                 sendemail.confirm
2594                 sendemail.envelopesender
2595                 sendemail.from
2596                 sendemail.identity
2597                 sendemail.multiedit
2598                 sendemail.signedoffbycc
2599                 sendemail.smtpdomain
2600                 sendemail.smtpencryption
2601                 sendemail.smtppass
2602                 sendemail.smtpserver
2603                 sendemail.smtpserveroption
2604                 sendemail.smtpserverport
2605                 sendemail.smtpuser
2606                 sendemail.suppresscc
2607                 sendemail.suppressfrom
2608                 sendemail.thread
2609                 sendemail.to
2610                 sendemail.validate
2611                 showbranch.default
2612                 status.relativePaths
2613                 status.showUntrackedFiles
2614                 status.submodulesummary
2615                 submodule.
2616                 tar.umask
2617                 transfer.unpackLimit
2618                 url.
2619                 user.email
2620                 user.name
2621                 user.signingkey
2622                 web.browser
2623                 branch. remote.
2624         "
2625 }
2626
2627 _git_remote ()
2628 {
2629         local subcommands="
2630                 add rename remove set-head set-branches
2631                 get-url set-url show prune update
2632                 "
2633         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2634         if [ -z "$subcommand" ]; then
2635                 case "$cur" in
2636                 --*)
2637                         __gitcomp "--verbose"
2638                         ;;
2639                 *)
2640                         __gitcomp "$subcommands"
2641                         ;;
2642                 esac
2643                 return
2644         fi
2645
2646         case "$subcommand,$cur" in
2647         add,--*)
2648                 __gitcomp "--track --master --fetch --tags --no-tags --mirror="
2649                 ;;
2650         add,*)
2651                 ;;
2652         set-head,--*)
2653                 __gitcomp "--auto --delete"
2654                 ;;
2655         set-branches,--*)
2656                 __gitcomp "--add"
2657                 ;;
2658         set-head,*|set-branches,*)
2659                 __git_complete_remote_or_refspec
2660                 ;;
2661         update,--*)
2662                 __gitcomp "--prune"
2663                 ;;
2664         update,*)
2665                 __gitcomp "$(__git_get_config_variables "remotes")"
2666                 ;;
2667         set-url,--*)
2668                 __gitcomp "--push --add --delete"
2669                 ;;
2670         get-url,--*)
2671                 __gitcomp "--push --all"
2672                 ;;
2673         prune,--*)
2674                 __gitcomp "--dry-run"
2675                 ;;
2676         *)
2677                 __gitcomp_nl "$(__git_remotes)"
2678                 ;;
2679         esac
2680 }
2681
2682 _git_replace ()
2683 {
2684         case "$cur" in
2685         --*)
2686                 __gitcomp "--edit --graft --format= --list --delete"
2687                 return
2688                 ;;
2689         esac
2690         __git_complete_refs
2691 }
2692
2693 _git_rerere ()
2694 {
2695         local subcommands="clear forget diff remaining status gc"
2696         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2697         if test -z "$subcommand"
2698         then
2699                 __gitcomp "$subcommands"
2700                 return
2701         fi
2702 }
2703
2704 _git_reset ()
2705 {
2706         __git_has_doubledash && return
2707
2708         case "$cur" in
2709         --*)
2710                 __gitcomp "--merge --mixed --hard --soft --patch --keep"
2711                 return
2712                 ;;
2713         esac
2714         __git_complete_refs
2715 }
2716
2717 _git_revert ()
2718 {
2719         __git_find_repo_path
2720         if [ -f "$__git_repo_path"/REVERT_HEAD ]; then
2721                 __gitcomp "--continue --quit --abort"
2722                 return
2723         fi
2724         case "$cur" in
2725         --*)
2726                 __gitcomp "
2727                         --edit --mainline --no-edit --no-commit --signoff
2728                         --strategy= --strategy-option=
2729                         "
2730                 return
2731                 ;;
2732         esac
2733         __git_complete_refs
2734 }
2735
2736 _git_rm ()
2737 {
2738         case "$cur" in
2739         --*)
2740                 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
2741                 return
2742                 ;;
2743         esac
2744
2745         __git_complete_index_file "--cached"
2746 }
2747
2748 _git_shortlog ()
2749 {
2750         __git_has_doubledash && return
2751
2752         case "$cur" in
2753         --*)
2754                 __gitcomp "
2755                         $__git_log_common_options
2756                         $__git_log_shortlog_options
2757                         --numbered --summary --email
2758                         "
2759                 return
2760                 ;;
2761         esac
2762         __git_complete_revlist
2763 }
2764
2765 _git_show ()
2766 {
2767         __git_has_doubledash && return
2768
2769         case "$cur" in
2770         --pretty=*|--format=*)
2771                 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
2772                         " "" "${cur#*=}"
2773                 return
2774                 ;;
2775         --diff-algorithm=*)
2776                 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
2777                 return
2778                 ;;
2779         --submodule=*)
2780                 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
2781                 return
2782                 ;;
2783         --*)
2784                 __gitcomp "--pretty= --format= --abbrev-commit --oneline
2785                         --show-signature
2786                         $__git_diff_common_options
2787                         "
2788                 return
2789                 ;;
2790         esac
2791         __git_complete_revlist_file
2792 }
2793
2794 _git_show_branch ()
2795 {
2796         case "$cur" in
2797         --*)
2798                 __gitcomp "
2799                         --all --remotes --topo-order --date-order --current --more=
2800                         --list --independent --merge-base --no-name
2801                         --color --no-color
2802                         --sha1-name --sparse --topics --reflog
2803                         "
2804                 return
2805                 ;;
2806         esac
2807         __git_complete_revlist
2808 }
2809
2810 _git_stash ()
2811 {
2812         local save_opts='--all --keep-index --no-keep-index --quiet --patch --include-untracked'
2813         local subcommands='push save list show apply clear drop pop create branch'
2814         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2815         if [ -z "$subcommand" ]; then
2816                 case "$cur" in
2817                 --*)
2818                         __gitcomp "$save_opts"
2819                         ;;
2820                 *)
2821                         if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2822                                 __gitcomp "$subcommands"
2823                         fi
2824                         ;;
2825                 esac
2826         else
2827                 case "$subcommand,$cur" in
2828                 push,--*)
2829                         __gitcomp "$save_opts --message"
2830                         ;;
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
3170 if [[ -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
3241 fi
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 #
3280 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
3281 __git_complete git.exe __git_main
3282 fi