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