# -*- shell-script -*- # # bash_completion - programmable completion functions for bash 4.2+ # # Copyright © 2006-2008, Ian Macdonald # © 2009-2020, Bash Completion Maintainers # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. # # The latest version of this software can be obtained here: # # https://github.com/scop/bash-completion BASH_COMPLETION_VERSINFO=(2 11 0) if [[ $- == *v* ]]; then _comp__init_original_set_v="-v" else _comp__init_original_set_v="+v" fi if [[ ${BASH_COMPLETION_DEBUG-} ]]; then set -v else set +v fi # Turn on extended globbing and programmable completion shopt -s extglob progcomp # Declare a compatibility function name # @param $1 Version of bash-completion where the deprecation occurred # @param $2 Old function name # @param $3 New function name # @since 2.12 _comp_deprecate_func() { if (($# != 3)); then printf 'bash_completion: %s: usage: %s OLD_NAME NEW_NAME DEPRECATION_VERSION\n' "$FUNCNAME" "$FUNCNAME" return 2 fi if [[ $2 != [a-zA-Z_]*([a-zA-Z_0-9]) ]]; then printf 'bash_completion: %s: %s\n' "$FUNCNAME" "\$2: invalid function name '$1'" >&2 return 2 elif [[ $3 != [a-zA-Z_]*([a-zA-Z_0-9]) ]]; then printf 'bash_completion: %s: %s\n' "$FUNCNAME" "\$3: invalid function name '$2'" >&2 return 2 fi eval -- "$2() { $3 \"\$@\"; }" } # A lot of the following one-liners were taken directly from the # completion examples provided with the bash 2.04 source distribution # start of section containing compspecs that can be handled within bash # user commands see only users complete -u groups slay w sux # bg completes with stopped jobs complete -A stopped -P '"%' -S '"' bg # other job commands complete -j -P '"%' -S '"' fg jobs disown # readonly and unset complete with shell variables complete -v readonly unset # set completes with set options complete -A setopt set # shopt completes with shopt options complete -A shopt shopt # unalias completes with aliases complete -a unalias # type and which complete on commands complete -c command type which # builtin completes on builtins complete -b builtin # start of section containing completion functions called by other functions # Check if we're running on the given userland # @param $1 userland to check for # @since 2.12 _comp_userland() { local userland=$(uname -s) [[ $userland == @(Linux|GNU/*) ]] && userland=GNU [[ $userland == "$1" ]] } # This function sets correct SysV init directories # # @since 2.12 _comp_sysvdirs() { sysvdirs=() [[ -d /etc/rc.d/init.d ]] && sysvdirs+=(/etc/rc.d/init.d) [[ -d /etc/init.d ]] && sysvdirs+=(/etc/init.d) # Slackware uses /etc/rc.d [[ -f /etc/slackware-version ]] && sysvdirs=(/etc/rc.d) return 0 } # This function checks whether we have a given program on the system. # # @since 2.12 _comp_have_command() { # Completions for system administrator commands are installed as well in # case completion is attempted via `sudo command ...'. PATH=$PATH:/usr/sbin:/sbin:/usr/local/sbin type "$1" &>/dev/null } # This function checks whether a given readline variable # is `on'. # # @since 2.12 _comp_readline_variable_on() { [[ $(bind -v) == *$1+([[:space:]])on* ]] } # This function shell-quotes the argument # @param $1 String to be quoted # @var[out] ret Resulting string # @since 2.12 _comp_quote() { ret=\'${1//\'/\'\\\'\'}\' } # shellcheck disable=SC1003 _comp_dequote__initialize() { unset -f "$FUNCNAME" local regex_param='\$([_a-zA-Z][_a-zA-Z0-9]*|[-*@#?$!0-9_])|\$\{[!#]?([_a-zA-Z][_a-zA-Z0-9]*(\[([0-9]+|[*@])\])?|[-*@#?$!0-9_])\}' local regex_quoted='\\.|'\''[^'\'']*'\''|\$?"([^\"$`!]|'$regex_param'|\\.)*"|\$'\''([^\'\'']|\\.)*'\''' _comp_dequote__regex_safe_word='^([^\'\''"$`;&|<>()!]|'$regex_quoted'|'$regex_param')*$' } _comp_dequote__initialize # This function expands a word using `eval` in a safe way. This function can # be typically used to get the expanded value of `${word[i]}` as # `_comp_dequote "${word[i]}"`. When the word contains unquoted shell special # characters, command substitutions, and other unsafe strings, the function # call fails before applying `eval`. Otherwise, `eval` is applied to the # string to generate the result. # # @param $1 String to be expanded. A safe word consists of the following # sequence of substrings: # # - Shell non-special characters: [^\'"$`;&|<>()!]. # - Parameter expansions of the forms $PARAM, ${!PARAM}, # ${#PARAM}, ${NAME[INDEX]}, ${!NAME[INDEX]}, ${#NAME[INDEX]} # where INDEX is an integer, `*` or `@`, NAME is a valid # variable name [_a-zA-Z][_a-zA-Z0-9]*, and PARAM is NAME or a # parameter [-*@#?$!0-9_]. # - Quotes \?, '...', "...", $'...', and $"...". In the double # quotations, parameter expansions are allowed. # # @var[out] ret Array that contains the expanded results. Multiple words or no # words may be generated through pathname expansions. # # Note: This function allows parameter expansions as safe strings, which might # cause unexpected results: # # * This allows execution of arbitrary commands through extra expansions of # array subscripts in name references. For example, # # declare -n v='dummy[$(echo xxx >/dev/tty)]' # echo "$v" # This line executes the command 'echo xxx'. # _comp_dequote '"$v"' # This line also executes it. # # * This may change the internal state of the variable that has side effects. # For example, the state of the random number generator of RANDOM can change: # # RANDOM=1234 # Set seed # echo "$RANDOM" # This produces 30658. # RANDOM=1234 # Reset seed # _comp_dequote '"$RANDOM"' # This line changes the internal state. # echo "$RANDOM" # This fails to reproduce 30658. # # We allow these parameter expansions as a part of safe strings assuming the # referential transparency of the simple parameter expansions and the sane # setup of the variables by the user or other frameworks that the user loads. # @since 2.12 _comp_dequote() { ret=() # fallback value for unsafe word and failglob [[ $1 =~ $_comp_dequote__regex_safe_word ]] || return 1 eval "ret=($1)" 2>/dev/null # may produce failglob } # Unset the given variables across a scope boundary. Useful for unshadowing # global scoped variables. Note that simply calling unset on a local variable # will not unshadow the global variable. Rather, the result will be a local # variable in an unset state. # Usage: local IFS='|'; _comp_unlocal IFS # @param $* Variable names to be unset # @since 2.12 _comp_unlocal() { if ((BASH_VERSINFO[0] >= 5)) && shopt -q localvar_unset; then shopt -u localvar_unset unset -v "$@" shopt -s localvar_unset else unset -v "$@" fi } # Assign variables one scope above the caller # Usage: local varname [varname ...] && # _comp_upvars [-v varname value] | [-aN varname [value ...]] ... # Available OPTIONS: # -aN Assign next N values to varname as array # -v Assign single value to varname # @return 1 if error occurs # @see https://fvue.nl/wiki/Bash:_Passing_variables_by_reference # @since 2.12 _comp_upvars() { if ! (($#)); then echo "bash_completion: $FUNCNAME: usage: $FUNCNAME" \ "[-v varname value] | [-aN varname [value ...]] ..." >&2 return 2 fi while (($#)); do case $1 in -a*) # Error checking [[ ${1#-a} ]] || { echo "bash_completion: $FUNCNAME:" \ "\`$1': missing number specifier" >&2 return 1 } printf %d "${1#-a}" &>/dev/null || { echo bash_completion: \ "$FUNCNAME: \`$1': invalid number specifier" >&2 return 1 } # Assign array of -aN elements # shellcheck disable=SC2015,SC2140 # TODO [[ $2 ]] && unset -v "$2" && eval "$2"=\(\"\$"{@:3:${1#-a}}"\"\) && shift $((${1#-a} + 2)) || { echo bash_completion: \ "$FUNCNAME: \`$1${2+ }$2': missing argument(s)" \ >&2 return 1 } ;; -v) # Assign single value # shellcheck disable=SC2015 # TODO [[ $2 ]] && unset -v "$2" && eval "$2"=\"\$3\" && shift 3 || { echo "bash_completion: $FUNCNAME: $1:" \ "missing argument(s)" >&2 return 1 } ;; *) echo "bash_completion: $FUNCNAME: $1: invalid option" >&2 return 1 ;; esac done } # Get the list of filenames that match with the specified glob pattern. # This function does the globbing in a controlled environment, avoiding # interference from user's shell options/settings or environment variables. # @param $1 array_name Array name # The array name should not start with an underscore "_", which is internally # used. The array name should not be "GLOBIGNORE". # @param $2 pattern Pattern string to be evaluated. # This pattern string will be evaluated using "eval", so brace expansions, # parameter expansions, command substitutions, and other expansions will be # processed. The user-provided strings should not be directly specified to # this argument. # @since 2.12 _comp_expand_glob() { if (($# != 2)); then printf 'bash-completion: %s: unexpected number of arguments\n' "$FUNCNAME" >&2 printf 'usage: %s ARRAY_NAME PATTERN\n' "$FUNCNAME" >&2 return 2 elif [[ $1 == @(GLOBIGNORE|_*|*[^_a-zA-Z0-9]*|[0-9]*|'') ]]; then printf 'bash-completion: %s: invalid array name "%s"\n' "$FUNCNAME" "$1" >&2 return 2 fi # Save and adjust the settings. local _original_opts=$SHELLOPTS:$BASHOPTS set +o noglob shopt -s nullglob shopt -u failglob dotglob # Also the user's GLOBIGNORE may affect the result of pathname expansions. local GLOBIGNORE= eval -- "$1=()" # a fallback in case that the next line fails. eval -- "$1=($2)" # Restore the settings. Note: Changing GLOBIGNORE affects the state of # "shopt -q dotglob", so we need to explicitly restore the original state # of "shopt -q dotglob". _comp_unlocal GLOBIGNORE if [[ :$_original_opts: == *:dotglob:* ]]; then shopt -s dotglob else shopt -u dotglob fi [[ :$_original_opts: == *:nullglob:* ]] || shopt -u nullglob [[ :$_original_opts: == *:failglob:* ]] && shopt -s failglob [[ :$_original_opts: == *:noglob:* ]] && set -o noglob return 0 } # Split a string and assign to an array. This function basically performs # `IFS=; =()` but properly handles saving/restoring the # state of `IFS` and the shell option `noglob`. A naive splitting by # `arr=(...)` suffers from unexpected IFS and pathname expansions, so one # should prefer this function to such naive splitting. # OPTIONS # -a Append to the array # -F sep Set a set of separator characters (used as IFS). The default # separator is $' \t\n' # -l The same as -F $'\n' # @param $1 array_name The array name # The array name should not start with an underscores "_", which is # internally used. The array name should not be either "IFS" or # "OPT{IND,ARG,ERR}". # @param $2 text The string to split # @return 2 when the usage is wrong, 0 when one or more completions are # generated, or 1 when the execution succeeds but no candidates are # generated. # @since 2.12 _comp_split() { local _append="" IFS=$' \t\n' local OPTIND=1 OPTARG="" OPTERR=0 _opt while getopts ':alF:' _opt "$@"; do case $_opt in a) _append=set ;; l) IFS=$'\n' ;; F) IFS=$OPTARG ;; *) echo "bash_completion: $FUNCNAME: usage error" >&2 return 2 ;; esac done shift "$((OPTIND - 1))" if (($# != 2)); then printf '%s\n' "bash_completion: $FUNCNAME: unexpected number of arguments" >&2 printf '%s\n' "usage: $FUNCNAME [-a] [-F SEP] ARRAY_NAME TEXT" >&2 return 2 elif [[ $1 == @(*[^_a-zA-Z0-9]*|[0-9]*|''|_*|IFS|OPTIND|OPTARG|OPTERR) ]]; then printf '%s\n' "bash_completion: $FUNCNAME: invalid array name '$1'" >&2 return 2 fi local _original_opts=$SHELLOPTS set -o noglob local _old_size _new_size if [[ $_append ]]; then eval "$1+=()" # in case $1 is unset eval "_old_size=\${#$1[@]}" eval "$1+=(\$2)" else _old_size=0 eval "$1=(\$2)" fi eval "_new_size=\${#$1[@]}" [[ :$_original_opts: == *:noglob:* ]] || set +o noglob ((_new_size > _old_size)) } # Helper function for _comp_compgen # @var[in] $? # @var[in] _var # @var[in] _append # @return original $? _comp_compgen__error_fallback() { local _status=$? if [[ $_append ]]; then # make sure existence of variable eval -- "$_var+=()" else eval -- "$_var=()" fi return "$_status" } # Provide a common interface to generate completion candidates in COMPREPLY or # in a specified array. # OPTIONS # -a Append to the array # -v arr Store the results to the array ARR. The default is `COMPREPLY`. # The array name should not start with an underscores "_", which is # internally used. The array name should not be either "IFS" or # "OPT{IND,ARG,ERR}". # -c cur Set a word used as a prefix to filter the completions. The default # is ${cur-}. # -R The same as -c ''. Use raw outputs without filtering. # -C dir Evaluate compgen/generator in the specified directory. # @var[in,opt] cur Used as the default value of a prefix to filter the # completions. # # Usage #1: _comp_compgen [-alR|-F sep|-v arr|-c cur|-C dir] -- options... # Call `compgen` with the specified arguments and store the results in the # specified array. This function essentially performs arr=($(compgen args...)) # but properly handles shell options, IFS, etc. using _comp_split. This # function is equivalent to `_comp_split [-a] -l arr "$(IFS=sep; compgen # args... -- cur)"`, but this pattern is frequent in the codebase and is good # to separate out as a function for the possible future implementation change. # OPTIONS # -F sep Set a set of separator characters (used as IFS in evaluating # `compgen'). The default separator is $' \t\n'. Note that this is # not the set of separators to delimit output of `compgen', but the # separators in evaluating the expansions of `-W '...'`, etc. The # delimiter of the output of `compgen` is always a newline. # -l The same as -F $'\n'. Use lines as words in evaluating compgen. # @param $1... options Arguments that are passed to compgen (if $1 starts with # a hyphen `-`). # # Note: References to positional parameters $1, $2, ... (such as -W '$1') # will not work as expected because these reference the arguments of # `_comp_compgen' instead of those of the caller function. When there are # needs to reference them, save the arguments to an array and reference the # array instead. # # Note: The array option `-V arr` in bash >= 5.3 should be instead specified # as `-v arr` as a part of the `_comp_compgen` options. # @return True (0) if at least one completion is generated, False (1) if no # completion is generated, or 2 with an incorrect usage. # # Usage #2: _comp_compgen [-aR|-v arr|-c cur|-C dir|-i cmd|-x cmd] name args... # Call the generator `_comp_compgen_NAME ARGS...` with the specified options. # This provides a common interface to call the functions `_comp_compgen_NAME`, # which produce completion candidates, with custom options [-alR|-v arr|-c # cur]. The option `-F sep` is not used with this usage. # OPTIONS # -x cmd Call exported generator `_comp_xfunc_CMD_compgen_NAME` # -i cmd Call internal generator `_comp_cmd_CMD__compgen_NAME` # @param $1... name args Calls the function _comp_compgen_NAME with the # specified ARGS (if $1 does not start with a hyphen `-`). The options # [-alR|-v arr|-c cur] are inherited by the child calls of `_comp_compgen` # inside `_comp_compgen_NAME` unless the child call `_comp_compgen` receives # overriding options. # @var[in,opt,internal] _comp_compgen__append # @var[in,opt,internal] _comp_compgen__var # @var[in,opt,internal] _comp_compgen__cur # These variables are internally used to pass the effect of the options # [-alR|-v arr|-c cur] to the child calls of `_comp_compgen` in # `_comp_compgen_NAME`. # @return Exit status of the generator. # # @remarks When no options are supplied to _comp_compgen, `_comp_compgen NAME # args` is equivalent to the direct call `_comp_compgen_NAME args`. As the # direct call is slightly more efficient, the direct call is preferred over # calling it through `_comp_compgen`. # # @remarks Design `_comp_compgen_NAME`: a function that produce completions can # be defined with the name _comp_compgen_NAME. The function is supposed to # generate completions by calling `_comp_compgen`. To reflect the options # specified to the outer calls of `_comp_compgen`, the function should not # directly modify `COMPREPLY`. To add words, one can call # # _comp_compgen -- -W '"${words[@]}"' # # To directly add words without filtering by `cur`, one can call # # _comp_compgen -R -- -W '"${words[@]}"' # # or use the utility `_comp_compgen_set`: # # _comp_compgen_set "${words[@]}" # # Other nested calls of _comp_compgen can also be used. The function is # supposed to replace the existing content of the array by default to allow the # caller control whether to replace or append by the option `-a`. # # @since 2.12 _comp_compgen() { local _append=${_comp_compgen__append-} local _var=${_comp_compgen__var-COMPREPLY} local _cur=${_comp_compgen__cur-${cur-}} local _dir="" local _ifs=$' \t\n' _has_ifs="" local _icmd="" _xcmd="" local _old_nocasematch="" if shopt -q nocasematch; then _old_nocasematch=set shopt -u nocasematch fi local OPTIND=1 OPTARG="" OPTERR=0 _opt while getopts ':av:Rc:C:lF:i:x:' _opt "$@"; do case $_opt in a) _append=set ;; v) if [[ $OPTARG == @(*[^_a-zA-Z0-9]*|[0-9]*|''|_*|IFS|OPTIND|OPTARG|OPTERR) ]]; then printf 'bash_completion: %s: -v: invalid array name `%s'\''\n' "$FUNCNAME" "$OPTARG" >&2 return 2 fi _var=$OPTARG ;; c) _cur=$OPTARG ;; R) _cur="" ;; C) if [[ ! $OPTARG ]]; then printf 'bash_completion: %s: -C: invalid directory name `%s'\''\n' "$FUNCNAME" "$OPTARG" >&2 return 2 fi _dir=$OPTARG ;; l) _has_ifs=set _ifs=$'\n' ;; F) _has_ifs=set _ifs=$OPTARG ;; [ix]) if [[ ! $OPTARG ]]; then printf 'bash_completion: %s: -%s: invalid command name `%s'\''\n' "$FUNCNAME" "$_opt" "$OPTARG" >&2 return 2 elif [[ $_icmd ]]; then printf 'bash_completion: %s: -%s: `-i %s'\'' is already specified\n' "$FUNCNAME" "$_opt" "$_icmd" >&2 return 2 elif [[ $_xcmd ]]; then printf 'bash_completion: %s: -%s: `-x %s'\'' is already specified\n' "$FUNCNAME" "$_opt" "$_xcmd" >&2 return 2 fi ;;& i) _icmd=$OPTARG ;; x) _xcmd=$OPTARG ;; *) printf 'bash_completion: %s: usage error\n' "$FUNCNAME" >&2 return 2 ;; esac done [[ $_old_nocasematch ]] && shopt -s nocasematch shift "$((OPTIND - 1))" if (($# == 0)); then printf 'bash_completion: %s: unexpected number of arguments\n' "$FUNCNAME" >&2 printf 'usage: %s [-alR|-F SEP|-v ARR|-c CUR] -- ARGS...' "$FUNCNAME" >&2 return 2 fi if [[ $1 != -* ]]; then # usage: _comp_compgen [options] NAME args if [[ $_has_ifs ]]; then printf 'bash_completion: %s: `-l'\'' and `-F sep'\'' are not supported for generators\n' "$FUNCNAME" >&2 return 2 fi local -a _generator if [[ $_icmd ]]; then _generator=("_comp_cmd_${_icmd//[^a-zA-Z0-9_]/_}__compgen_$1") elif [[ $_xcmd ]]; then _generator=(_comp_xfunc "$_xcmd" "compgen_$1") else _generator=("_comp_compgen_$1") fi if ! declare -F "${_generator[0]}" &>/dev/null; then printf 'bash_completion: %s: unrecognized generator `%s'\'' (function %s not found)\n' "$FUNCNAME" "$1" "${_generator[0]}" >&2 return 2 fi if [[ $_dir ]]; then local _original_pwd=$PWD local PWD=${PWD-} OLDPWD=${OLDPWD-} # Note: We also redirect stdout because `cd` may output the target # directory to stdout when CDPATH is set. command cd -- "$_dir" &>/dev/null || { _comp_compgen__error_fallback return } fi local _comp_compgen__append=$_append local _comp_compgen__var=$_var local _comp_compgen__cur=$_cur cur=$_cur # Note: we use $1 as a part of a function name, and we use $2... as # arguments to the function if any. # shellcheck disable=SC2145 "${_generator[@]}" "${@:2}" local _status=$? # Go back to the original directory. # Note: Failure of this line results in the change of the current # directory visible to the user. We intentionally do not redirect # stderr so that the error message appear in the terminal. # shellcheck disable=SC2164 [[ $_dir ]] && command cd -- "$_original_pwd" return "$_status" fi # usage: _comp_compgen [options] -- [compgen_options] if [[ $_icmd || $_xcmd ]]; then printf 'bash_completion: %s: generator name is unspecified for `%s'\''\n' "$FUNCNAME" "${_icmd:+-i $_icmd}${_xcmd:+x $_xcmd}" >&2 return 2 fi # Note: $* in the below checks would be affected by uncontrolled IFS in # bash >= 5.0, so we need to set IFS to the normal value. The behavior in # bash < 5.0, where unquoted $* in conditional command did not honor IFS, # was a bug. # Note: Also, ${_cur:+-- "$_cur"} and ${_append:+-a} would be affected by # uncontrolled IFS. local IFS=$' \t\n' # Note: extglob *\$?(\{)[0-9]* can be extremely slow when the string # "${*:2:_nopt}" becomes longer, so we test \$[0-9] and \$\{[0-9] # separately. if [[ $* == *\$[0-9]* || $* == *\$\{[0-9]* ]]; then printf 'bash_completion: %s: positional parameter $1, $2, ... do not work inside this function\n' "$FUNCNAME" >&2 return 2 fi local _result _result=$( if [[ $_dir ]]; then # Note: We also redirect stdout because `cd` may output the target # directory to stdout when CDPATH is set. command cd -- "$_dir" &>/dev/null || return fi IFS=$_ifs compgen "$@" ${_cur:+-- "$_cur"} ) || { _comp_compgen__error_fallback return } _comp_split -l ${_append:+-a} "$_var" "$_result" } # usage: _comp_compgen_set [words...] # Reset COMPREPLY with the specified WORDS. If no arguments are specified, the # array is cleared. # # When an array name is specified by `-v VAR` in a caller _comp_compgen, the # array is reset instead of COMPREPLY. When the `-a` flag is specified in a # caller _comp_compgen, the words are appended to the existing elements of the # array instead of replacing the existing elements. This function ignores # ${cur-} or the prefix specified by `-v CUR`. # @return 0 if at least one completion is generated, or 1 otherwise. # @since 2.12 _comp_compgen_set() { local _append=${_comp_compgen__append-} local _var=${_comp_compgen__var-COMPREPLY} eval -- "$_var${_append:++}=(\"\$@\")" (($#)) } # Simply split the text and generate completions. This function should be used # instead of `_comp_compgen -- -W "$(command)"`, which is vulnerable because # option -W evaluates the shell expansions included in the option argument. # Options: # -F sep Specify the separators. The default is $' \t\n' # -l The same as -F $'\n' # -X arg The same as the compgen option -X. # -S arg The same as the compgen option -S. # -P arg The same as the compgen option -P. # -o arg The same as the compgen option -o. # @param $1 String to split # @since 2.12 _comp_compgen_split() { local _ifs=$' \t\n' local -a _compgen_options=() local OPTIND=1 OPTARG="" OPTERR=0 _opt while getopts ':lF:X:S:P:o:' _opt "$@"; do case $_opt in l) _ifs=$'\n' ;; F) _ifs=$OPTARG ;; [XSPo]) _compgen_options+=("-$_opt" "$OPTARG") ;; *) printf 'bash_completion: usage: %s [-l|-F sep] [--] str\n' "$FUNCNAME" >&2 return 2 ;; esac done shift "$((OPTIND - 1))" if (($# != 1)); then printf 'bash_completion: %s: unexpected number of arguments.\n' "$FUNCNAME" >&2 printf 'usage: %s [-l|-F sep] [--] str' "$FUNCNAME" >&2 return 2 fi local _split_input=$1 IFS=$' \t\n' _comp_compgen -F "$_ifs" -- ${_compgen_options[@]+"${_compgen_options[@]}"} -W '$_split_input' } # Check if the argument looks like a path. # @param $1 thing to check # @return True (0) if it does, False (> 0) otherwise # @since 2.12 _comp_looks_like_path() { [[ ${1-} == @(*/|[.~])* ]] } # Reassemble command line words, excluding specified characters from the # list of word completion separators (COMP_WORDBREAKS). # @param $1 chars Characters out of $COMP_WORDBREAKS which should # NOT be considered word breaks. This is useful for things like scp where # we want to return host:path and not only path, so we would pass the # colon (:) as $1 here. # @param $2 words Name of variable to return words to # @param $3 cword Name of variable to return cword to # _comp__reassemble_words() { local exclude="" i j line ref # Exclude word separator characters? if [[ $1 ]]; then # Yes, exclude word separator characters; # Exclude only those characters, which were really included exclude="[${1//[^$COMP_WORDBREAKS]/}]" fi # Default to cword unchanged printf -v "$3" %s "$COMP_CWORD" # Are characters excluded which were former included? if [[ $exclude ]]; then # Yes, list of word completion separators has shrunk; line=$COMP_LINE # Re-assemble words to complete for ((i = 0, j = 0; i < ${#COMP_WORDS[@]}; i++, j++)); do # Is current word not word 0 (the command itself) and is word not # empty and is word made up of just word separator characters to # be excluded and is current word not preceded by whitespace in # original line? while [[ $i -gt 0 && ${COMP_WORDS[i]} == +($exclude) ]]; do # Is word separator not preceded by whitespace in original line # and are we not going to append to word 0 (the command # itself), then append to current word. [[ $line != [[:blank:]]* ]] && ((j >= 2)) && ((j--)) # Append word separator to current or new word ref="$2[$j]" printf -v "$ref" %s "${!ref-}${COMP_WORDS[i]}" # Indicate new cword ((i == COMP_CWORD)) && printf -v "$3" %s "$j" # Remove optional whitespace + word separator from line copy line=${line#*"${COMP_WORDS[i]}"} # Indicate next word if available, else end *both* while and # for loop if ((i < ${#COMP_WORDS[@]} - 1)); then ((i++)) else break 2 fi # Start new word if word separator in original line is # followed by whitespace. [[ $line == [[:blank:]]* ]] && ((j++)) done # Append word to current word ref="$2[$j]" printf -v "$ref" %s "${!ref-}${COMP_WORDS[i]}" # Remove optional whitespace + word from line copy line=${line#*"${COMP_WORDS[i]}"} # Indicate new cword ((i == COMP_CWORD)) && printf -v "$3" %s "$j" done ((i == COMP_CWORD)) && printf -v "$3" %s "$j" else # No, list of word completions separators hasn't changed; for i in "${!COMP_WORDS[@]}"; do printf -v "$2[i]" %s "${COMP_WORDS[i]}" done fi } # _comp__reassemble_words() # @param $1 exclude Characters out of $COMP_WORDBREAKS which should NOT be # considered word breaks. This is useful for things like scp where # we want to return host:path and not only path, so we would pass the # colon (:) as $1 in this case. # @param $2 words Name of variable to return words to # @param $3 cword Name of variable to return cword to # @param $4 cur Name of variable to return current word to complete to # @see _comp__reassemble_words() _comp__get_cword_at_cursor() { local cword words=() _comp__reassemble_words "$1" words cword local i cur="" index=$COMP_POINT lead=${COMP_LINE:0:COMP_POINT} # Cursor not at position 0 and not led by just space(s)? if [[ $index -gt 0 && ($lead && ${lead//[[:space:]]/}) ]]; then cur=$COMP_LINE for ((i = 0; i <= cword; ++i)); do # Current word fits in $cur, and $cur doesn't match cword? while [[ ${#cur} -ge ${#words[i]} && ${cur:0:${#words[i]}} != "${words[i]-}" ]]; do # Strip first character cur=${cur:1} # Decrease cursor position, staying >= 0 ((index > 0)) && ((index--)) done # Does found word match cword? if ((i < cword)); then # No, cword lies further; local old_size=${#cur} cur=${cur#"${words[i]}"} local new_size=${#cur} ((index -= old_size - new_size)) fi done # Clear $cur if just space(s) [[ $cur && ! ${cur//[[:space:]]/} ]] && cur= # Zero $index if negative ((index < 0)) && index=0 fi local IFS=$' \t\n' local "$2" "$3" "$4" && _comp_upvars -a${#words[@]} "$2" ${words[@]+"${words[@]}"} \ -v "$3" "$cword" -v "$4" "${cur:0:index}" } # Get the word to complete and optional previous words. # This is nicer than ${COMP_WORDS[COMP_CWORD]}, since it handles cases # where the user is completing in the middle of a word. # (For example, if the line is "ls foobar", # and the cursor is here --------> ^ # Also one is able to cross over possible wordbreak characters. # Usage: _comp_get_words [OPTIONS] [VARNAMES] # Available VARNAMES: # cur Return cur via $cur # prev Return prev via $prev # words Return words via $words # cword Return cword via $cword # # Available OPTIONS: # -n EXCLUDE Characters out of $COMP_WORDBREAKS which should NOT be # considered word breaks. This is useful for things like scp # where we want to return host:path and not only path, so we # would pass the colon (:) as -n option in this case. # -c VARNAME Return cur via $VARNAME # -p VARNAME Return prev via $VARNAME # -w VARNAME Return words via $VARNAME # -i VARNAME Return cword via $VARNAME # # Example usage: # # $ _comp_get_words -n : cur prev # # @since 2.12 _comp_get_words() { local exclude="" flag i OPTIND=1 local cur cword words=() local upargs=() upvars=() vcur="" vcword="" vprev="" vwords="" while getopts "c:i:n:p:w:" flag "$@"; do case $flag in [cipw]) if [[ $OPTARG != [a-zA-Z_]*([a-zA-Z_0-9])?(\[*\]) ]]; then echo "bash_completion: $FUNCNAME: -$flag: invalid variable name \`$OPTARG'" >&2 return 1 fi ;;& c) vcur=$OPTARG ;; i) vcword=$OPTARG ;; n) exclude=$OPTARG ;; p) vprev=$OPTARG ;; w) vwords=$OPTARG ;; *) echo "bash_completion: $FUNCNAME: usage error" >&2 return 1 ;; esac done while [[ $# -ge $OPTIND ]]; do case ${!OPTIND} in cur) vcur=cur ;; prev) vprev=prev ;; cword) vcword=cword ;; words) vwords=words ;; *) echo "bash_completion: $FUNCNAME: \`${!OPTIND}':" \ "unknown argument" >&2 return 1 ;; esac ((OPTIND += 1)) done _comp__get_cword_at_cursor "${exclude-}" words cword cur [[ $vcur ]] && { upvars+=("$vcur") upargs+=(-v "$vcur" "$cur") } [[ $vcword ]] && { upvars+=("$vcword") upargs+=(-v "$vcword" "$cword") } [[ $vprev && $cword -ge 1 ]] && { upvars+=("$vprev") upargs+=(-v "$vprev" "${words[cword - 1]}") } [[ $vwords ]] && { upvars+=("$vwords") upargs+=(-a"${#words[@]}" "$vwords" ${words+"${words[@]}"}) } ((${#upvars[@]})) && local "${upvars[@]}" && _comp_upvars "${upargs[@]}" } # Generate the specified items after left-trimming with the word-to-complete # containing a colon (:). If the word-to-complete does not contain a colon, # this generates the specified items without modifications. # @param $@ items to generate # @var[in] cur current word to complete # # @remarks In Bash, with a colon in COMP_WORDBREAKS, words containing colons # are always completed as entire words if the word to complete contains a # colon. This function fixes this behavior by removing the # colon-containing-prefix from the items. # # The preferred solution is to remove the colon (:) from COMP_WORDBREAKS in # your .bashrc: # # # Remove colon (:) from list of word completion separators # COMP_WORDBREAKS=${COMP_WORDBREAKS//:} # # See also: Bash FAQ - E13) Why does filename completion misbehave if a colon # appears in the filename? - https://tiswww.case.edu/php/chet/bash/FAQ # # @since 2.12 _comp_compgen_ltrim_colon() { (($#)) || return 0 local -a tmp tmp=("$@") if [[ $cur == *:* && $COMP_WORDBREAKS == *:* ]]; then # Remove colon-word prefix from items local colon_word=${cur%"${cur##*:}"} tmp=("${tmp[@]#"$colon_word"}") fi _comp_compgen -R -- -W '"${tmp[@]}"' } # If the word-to-complete contains a colon (:), left-trim COMPREPLY items with # word-to-complete. # # @param $1 current word to complete (cur) # @var[in,out] COMPREPLY # # @since 2.12 _comp_ltrim_colon_completions() { ((${#COMPREPLY[@]})) || return 0 _comp_compgen -c "$1" ltrim_colon "${COMPREPLY[@]}" } # _comp_ltrim_colon_completions() # This function quotes the argument in a way so that readline dequoting # results in the original argument. This is necessary for at least # `compgen` which requires its arguments quoted/escaped: # # $ ls "a'b/" # c # $ compgen -f "a'b/" # Wrong, doesn't return output # $ compgen -f "a\'b/" # Good # a\'b/c # # See also: # - https://lists.gnu.org/archive/html/bug-bash/2009-03/msg00155.html # - https://www.mail-archive.com/bash-completion-devel@lists.alioth.debian.org/msg01944.html # @param $1 Argument to quote # @var[out] ret Quoted result is stored in this variable # @since 2.12 # shellcheck disable=SC2178 # The assignment is not intended for the global "ret" _comp_quote_compgen() { if [[ $1 == \'* ]]; then # Leave out first character ret=${1:1} else printf -v ret %q "$1" # If result becomes quoted like this: $'string', re-evaluate in order # to drop the additional quoting. See also: # https://www.mail-archive.com/bash-completion-devel@lists.alioth.debian.org/msg01942.html if [[ $ret == \$\'*\' ]]; then local value=${ret:2:-1} # Strip beginning $' and ending '. value=${value//'%'/%%} # Escape % for printf format. # shellcheck disable=SC2059 printf -v ret "$value" # Decode escape sequences of \.... fi fi } # _comp_quote_compgen() # This function performs file and directory completion. It's better than # simply using 'compgen -f', because it honours spaces in filenames. # @param $1 If `-d', complete only on directories. Otherwise filter/pick only # completions with `.$1' and the uppercase version of it as file # extension. # @return 0 if at least one completion is generated, or 1 otherwise. # # @since 2.12 _comp_compgen_filedir() { _comp_compgen_tilde && return local -a toks local _arg=${1-} if [[ $_arg == -d ]]; then _comp_compgen -v toks -- -d else local ret _comp_quote_compgen "${cur-}" local _quoted=$ret _comp_unlocal ret # work around bash-4.2 where compgen -f "''" produces nothing. [[ $_quoted == "''" ]] && _quoted="" # Munge xspec to contain uppercase version too # https://lists.gnu.org/archive/html/bug-bash/2010-09/msg00036.html # news://news.gmane.io/4C940E1C.1010304@case.edu local _xspec=${_arg:+"!*.@($_arg|${_arg^^})"} _plusdirs=() # Use plusdirs to get dir completions if we have a xspec; if we don't, # there's no need, dirs come along with other completions. Don't use # plusdirs quite yet if fallback is in use though, in order to not ruin # the fallback condition with the "plus" dirs. local _opts=(-f -X "$_xspec") [[ $_xspec ]] && _plusdirs=(-o plusdirs) [[ ${BASH_COMPLETION_FILEDIR_FALLBACK-${COMP_FILEDIR_FALLBACK-}} || ! ${_plusdirs-} ]] || _opts+=("${_plusdirs[@]}") _comp_compgen -v toks -c "$_quoted" -- "${_opts[@]}" # Try without filter if it failed to produce anything and configured to [[ ${BASH_COMPLETION_FILEDIR_FALLBACK-${COMP_FILEDIR_FALLBACK-}} && $_arg && ${#toks[@]} -lt 1 ]] && _comp_compgen -av toks -c "$_quoted" -- \ -f ${_plusdirs+"${_plusdirs[@]}"} fi if ((${#toks[@]} != 0)); then # 2>/dev/null for direct invocation, e.g. in the _comp_compgen_filedir # unit test compopt -o filenames 2>/dev/null fi # Note: bash < 4.4 has a bug that all the elements are connected with # ${v-"${a[@]}"} when IFS does not contain whitespace. local IFS=$' \t\n' local -a _tmp=(${toks[@]+"${toks[@]}"}) _comp_unlocal toks _comp_compgen_set ${_tmp[@]+"${_tmp[@]}"} } # _comp_compgen_filedir() # This function splits $cur=--foo=bar into $prev=--foo, $cur=bar, making it # easier to support both "--foo bar" and "--foo=bar" style completions. # `=' should have been removed from COMP_WORDBREAKS when setting $cur for # this to be useful. # Returns 0 if current option was split, 1 otherwise. # _comp__split_longopt() { if [[ $cur == --?*=* ]]; then # Cut also backslash before '=' in case it ended up there # for some reason. prev=${cur%%?(\\)=*} cur=${cur#*=} return 0 fi return 1 } # Complete variables. # @return True (0) if variables were completed, # False (> 0) if not. # TODO:API: rename per conventions _variables() { if [[ $cur =~ ^(\$(\{[!#]?)?)([A-Za-z0-9_]*)$ ]]; then # Completing $var / ${var / ${!var / ${#var if [[ $cur == '${'* ]]; then local arrs vars _comp_compgen -v vars -c "${BASH_REMATCH[3]}" -- -A variable -P "${BASH_REMATCH[1]}" -S '}' _comp_compgen -v arrs -c "${BASH_REMATCH[3]}" -- -A arrayvar -P "${BASH_REMATCH[1]}" -S '[' if ((${#vars[@]} == 1 && ${#arrs[@]} != 0)); then # Complete ${arr with ${array[ if there is only one match, and that match is an array variable compopt -o nospace COMPREPLY+=("${arrs[@]}") else # Complete ${var with ${variable} COMPREPLY+=("${vars[@]}") fi else # Complete $var with $variable _comp_compgen -ac "${BASH_REMATCH[3]}" -- -A variable -P '$' fi return 0 elif [[ $cur =~ ^(\$\{[#!]?)([A-Za-z0-9_]*)\[([^]]*)$ ]]; then # Complete ${array[i with ${array[idx]} _comp_compgen -ac "${BASH_REMATCH[3]}" -- -W '"${!'"${BASH_REMATCH[2]}"'[@]}"' \ -P "${BASH_REMATCH[1]}${BASH_REMATCH[2]}[" -S ']}' # Complete ${arr[@ and ${arr[* if [[ ${BASH_REMATCH[3]} == [@*] ]]; then COMPREPLY+=("${BASH_REMATCH[1]}${BASH_REMATCH[2]}[${BASH_REMATCH[3]}]}") fi _comp_ltrim_colon_completions "$cur" # array indexes may have colons return 0 elif [[ $cur =~ ^\$\{[#!]?[A-Za-z0-9_]*\[.*\]$ ]]; then # Complete ${array[idx] with ${array[idx]} COMPREPLY+=("$cur}") _comp_ltrim_colon_completions "$cur" return 0 fi return 1 } # Complete a delimited value. # # Usage: [-k] DELIMITER COMPGEN_ARG... # -k: do not filter out already present tokens in value # @since 2.12 _comp_delimited() { local prefix="" delimiter=$1 deduplicate=set shift if [[ $delimiter == -k ]]; then deduplicate="" delimiter=$1 shift fi [[ $cur == *$delimiter* ]] && prefix=${cur%"$delimiter"*}$delimiter if [[ $deduplicate ]]; then # We could construct a -X pattern to feed to compgen, but that'd # conflict with possibly already set -X in $@, as well as have # glob char escaping issues to deal with. Do removals by hand instead. _comp_compgen -R -- "$@" local -a existing _comp_split -F "$delimiter" existing "$cur" # Do not remove the last from existing if it's not followed by the # delimiter so we get space appended. [[ ! $cur || $cur == *"$delimiter" ]] || unset -v "existing[${#existing[@]}-1]" if ((${#COMPREPLY[@]})); then local x i for x in ${existing+"${existing[@]}"}; do for i in "${!COMPREPLY[@]}"; do if [[ $x == "${COMPREPLY[i]}" ]]; then unset -v 'COMPREPLY[i]' continue 2 # assume no dupes in COMPREPLY fi done done ((${#COMPREPLY[@]})) && _comp_compgen -c "${cur##*"$delimiter"}" -- -W '"${COMPREPLY[@]}"' fi else _comp_compgen -c "${cur##*"$delimiter"}" -- "$@" fi # It would seem that in some specific cases we could avoid adding the # prefix to all completions, thereby making the list of suggestions # cleaner, and only adding it when there's exactly one completion. # The cases where this opportunity has been observed involve having # `show-all-if-ambiguous` on, but even that has cases where it fails # and the last separator including everything before it is lost. # https://github.com/scop/bash-completion/pull/913#issuecomment-1490140309 local i for i in "${!COMPREPLY[@]}"; do COMPREPLY[i]="$prefix${COMPREPLY[i]}" done [[ $delimiter != : ]] || _comp_ltrim_colon_completions "$cur" } # Complete assignment of various known environment variables. # # The word to be completed is expected to contain the entire assignment, # including the variable name and the "=". Some known variables are completed # with colon separated values; for those to work, colon should not have been # used to split words. See related parameters to _comp_initialize. # # @param $1 variable assignment to be completed # @return True (0) if variable value completion was attempted, # False (> 0) if not. # @since 2.12 _comp_variable_assignments() { local cur=${1-} i if [[ $cur =~ ^([A-Za-z_][A-Za-z0-9_]*)=(.*)$ ]]; then prev=${BASH_REMATCH[1]} cur=${BASH_REMATCH[2]} else return 1 fi case $prev in TZ) cur=/usr/share/zoneinfo/$cur _comp_compgen -a filedir if ((${#COMPREPLY[@]})); then for i in "${!COMPREPLY[@]}"; do if [[ ${COMPREPLY[i]} == *.tab ]]; then unset -v 'COMPREPLY[i]' continue elif [[ -d ${COMPREPLY[i]} ]]; then COMPREPLY[i]+=/ compopt -o nospace fi COMPREPLY[i]=${COMPREPLY[i]#/usr/share/zoneinfo/} done fi ;; TERM) _terms ;; LANG | LC_*) _comp_compgen_split -- "$(locale -a 2>/dev/null)" ;; LANGUAGE) _comp_delimited : -W '$(locale -a 2>/dev/null)' ;; *) _variables && return 0 _comp_compgen -a filedir ;; esac return 0 } # Initialize completion and deal with various general things: do file # and variable completion where appropriate, and adjust prev, words, # and cword as if no redirections exist so that completions do not # need to deal with them. Before calling this function, make sure # cur, prev, words, and cword are local, ditto split if you use -s. # # Options: # -n EXCLUDE Passed to _comp_get_words -n with redirection chars # -e XSPEC Passed to _comp_compgen_filedir as first arg for stderr # redirections # -o XSPEC Passed to _comp_compgen_filedir as first arg for other output # redirections # -i XSPEC Passed to _comp_compgen_filedir as first arg for stdin # redirections # -s Split long options with _comp__split_longopt, implies -n = # @param $1...$3 args Original arguments specified to the completion function. # The first argument $1 is command name. The second # argument $2 is the string before the cursor in the # current word. The third argument $3 is the previous # word. # @var[out] cur Reconstructed current word # @var[out] prev Reconstructed previous word # @var[out] words Reconstructed words # @var[out] cword Current word index in `words` # @var[out] comp_args Original arguments specified to the completion # function are saved in this array, if the arguments # $1...$3 is specified. # @var[out,opt] was_split When "-s" is specified, `"set"/""` is set depending # on whether the split happened. # @return True (0) if completion needs further processing, # False (> 0) no further processing is necessary. # # @since 2.12 _comp_initialize() { local exclude="" opt_split="" outx errx inx local flag OPTIND=1 OPTARG="" OPTERR=0 while getopts "n:e:o:i:s" flag "$@"; do case $flag in n) exclude+=$OPTARG ;; e) errx=$OPTARG ;; o) outx=$OPTARG ;; i) inx=$OPTARG ;; s) opt_split="set" was_split="" exclude+="=" ;; *) echo "bash_completion: $FUNCNAME: usage error" >&2 return 1 ;; esac done shift "$((OPTIND - 1))" (($#)) && comp_args=("$@") COMPREPLY=() local redir='@(?(+([0-9])|{[a-zA-Z_]*([a-zA-Z_0-9])})@(>?([>|&])|&])|<?(>))' _comp_get_words -n "$exclude<>&" cur prev words cword # Complete variable names. _variables && return 1 # Complete on files if current is a redirect possibly followed by a # filename, e.g. ">foo", or previous is a "bare" redirect, e.g. ">". # shellcheck disable=SC2053 if [[ $cur == $redir* || ${prev-} == $redir ]]; then local xspec case $cur in 2'>'*) xspec=${errx-} ;; *'>'*) xspec=${outx-} ;; *'<'*) xspec=${inx-} ;; *) case $prev in 2'>'*) xspec=${errx-} ;; *'>'*) xspec=${outx-} ;; *'<'*) xspec=${inx-} ;; esac ;; esac cur=${cur##"$redir"} _comp_compgen_filedir "$xspec" return 1 fi # Remove all redirections so completions don't have to deal with them. local i skip for ((i = 1; i < ${#words[@]}; )); do if [[ ${words[i]} == $redir* ]]; then # If "bare" redirect, remove also the next word (skip=2). # shellcheck disable=SC2053 [[ ${words[i]} == $redir ]] && skip=2 || skip=1 words=("${words[@]:0:i}" "${words[@]:i+skip}") ((i <= cword)) && ((cword -= skip)) else ((i++)) fi done ((cword <= 0)) && return 1 prev=${words[cword - 1]} [[ $opt_split ]] && _comp__split_longopt && was_split="set" return 0 } # Helper function for _comp_compgen_help and _comp_compgen_usage. # Obtain the help output based on the arguments. # @param $@ args Arguments specified to the caller. # @var[out] _lines # @return 2 if the usage is wrong, 1 if no output is obtained, or otherwise 0. _comp_compgen_help__get_help_lines() { local -a help_cmd case ${1-} in -) if (($# > 1)); then printf 'bash_completion: %s -: extra arguments for -\n' "${FUNCNAME[1]}" >&2 printf 'usage: %s -\n' "${FUNCNAME[1]}" >&2 printf 'usage: %s -c cmd args...\n' "${FUNCNAME[1]}" >&2 printf 'usage: %s [-- args...]\n' "${FUNCNAME[1]}" >&2 return 2 fi help_cmd=(exec cat) ;; -c) if (($# < 2)); then printf 'bash_completion: %s -c: no command is specified\n' "${FUNCNAME[1]}" >&2 printf 'usage: %s -\n' "${FUNCNAME[1]}" >&2 printf 'usage: %s -c cmd args...\n' "${FUNCNAME[1]}" >&2 printf 'usage: %s [-- args...]\n' "${FUNCNAME[1]}" >&2 return 2 fi help_cmd=("${@:2}") ;; --) shift 1 ;& *) local ret _comp_dequote "${comp_args[0]-}" || ret=${comp_args[0]-} help_cmd=("${ret:-false}" "$@") ;; esac local ret _comp_split -l ret "$(LC_ALL=C "${help_cmd[@]}" 2>&1)" && _lines=("${ret[@]}") } # Helper function for _comp_compgen_help and _comp_compgen_usage. # @var[in,out] _options Add options # @return True (0) if an option was found, False (> 0) otherwise _comp_compgen_help__parse() { local option option2 i # Take first found long option, or first one (short) if not found. option= local -a array if _comp_split -F $' \t\n,/|' array "$1"; then for i in "${array[@]}"; do case "$i" in ---*) break ;; --?*) option=$i break ;; -?*) [[ $option ]] || option=$i ;; *) break ;; esac done fi [[ $option ]] || return 1 # Expand --[no]foo to --foo and --nofoo etc if [[ $option =~ (\[((no|dont)-?)\]). ]]; then option2=${option/"${BASH_REMATCH[1]}"/} option2=${option2%%[<{().[]*} _options+=("${option2/=*/=}") option=${option/"${BASH_REMATCH[1]}"/"${BASH_REMATCH[2]}"} fi option=${option%%[<{().[]*} option=${option/=*/=} [[ $option ]] || return 1 _options+=("$option") } # Parse GNU style help output of the given command and generate and store # completions in an array. The help output is produced in the way depending on # the usage: # usage: _comp_compgen_help - # read from stdin # usage: _comp_compgen_help -c cmd args... # run "cmd args..." # usage: _comp_compgen_help [[--] args...] # run "${comp_args[0]} args..." # When no arguments are specified, `--help` is assumed. # # @var[in] comp_args[0] # @since 2.12 _comp_compgen_help() { (($#)) || set -- -- --help local -a _lines _comp_compgen_help__get_help_lines "$@" || return "$?" local -a _options=() local _line for _line in "${_lines[@]}"; do [[ $_line == *([[:blank:]])-* ]] || continue # transform "-f FOO, --foo=FOO" to "-f , --foo=FOO" etc while [[ $_line =~ ((^|[^-])-[A-Za-z0-9?][[:space:]]+)\[?[A-Z0-9]+([,_-]+[A-Z0-9]+)?(\.\.+)?\]? ]]; do _line=${_line/"${BASH_REMATCH[0]}"/"${BASH_REMATCH[1]}"} done _comp_compgen_help__parse "${_line// or /, }" done ((${#_options[@]})) || return 1 _comp_compgen -- -W '"${_options[@]}"' return 0 } # Parse BSD style usage output (options in brackets) of the given command. The # help output is produced in the way depending on the usage: # usage: _comp_compgen_usage - # read from stdin # usage: _comp_compgen_usage -c cmd args... # run "cmd args..." # usage: _comp_compgen_usage [[--] args...] # run "${comp_args[0]} args..." # When no arguments are specified, `--usage` is assumed. # # @var[in] comp_args[0] # @since 2.12 _comp_compgen_usage() { (($#)) || set -- -- --usage local -a _lines _comp_compgen_help__get_help_lines "$@" || return "$?" local -a _options=() local _line _match _option _i _char for _line in "${_lines[@]}"; do while [[ $_line =~ \[[[:space:]]*(-[^]]+)[[:space:]]*\] ]]; do _match=${BASH_REMATCH[0]} _option=${BASH_REMATCH[1]} case $_option in -?(\[)+([a-zA-Z0-9?])) # Treat as bundled short options for ((_i = 1; _i < ${#_option}; _i++)); do _char=${_option:_i:1} [[ $_char != '[' ]] && _options+=("-$_char") done ;; *) _comp_compgen_help__parse "$_option" ;; esac _line=${_line#*"$_match"} done done ((${#_options[@]})) || return 1 _comp_compgen -- -W '"${_options[@]}"' return 0 } # This function completes on signal names (minus the SIG prefix) # @param $1 prefix _comp_compgen_signals() { local -a sigs _comp_compgen -v sigs -c "SIG${cur#"${1-}"}" -- -P "${1-}" -A signal && _comp_compgen_set "${sigs[@]/#${1-}SIG/${1-}}" } # This function completes on known mac addresses # _comp_compgen_mac_addresses() { local re='\([A-Fa-f0-9]\{2\}:\)\{5\}[A-Fa-f0-9]\{2\}' local PATH="$PATH:/sbin:/usr/sbin" local -a addresses # Local interfaces # - ifconfig on Linux: HWaddr or ether # - ifconfig on FreeBSD: ether # - ip link: link/ether _comp_compgen -v addresses split -- "$( { LC_ALL=C ifconfig -a || ip -c=never link show || ip link show } 2>/dev/null | command sed -ne \ "s/.*[[:space:]]HWaddr[[:space:]]\{1,\}\($re\)[[:space:]].*/\1/p" -ne \ "s/.*[[:space:]]HWaddr[[:space:]]\{1,\}\($re\)[[:space:]]*$/\1/p" -ne \ "s|.*[[:space:]]\(link/\)\{0,1\}ether[[:space:]]\{1,\}\($re\)[[:space:]].*|\2|p" -ne \ "s|.*[[:space:]]\(link/\)\{0,1\}ether[[:space:]]\{1,\}\($re\)[[:space:]]*$|\2|p" )" # ARP cache _comp_compgen -av addresses split -- "$( { arp -an || ip -c=never neigh show || ip neigh show } 2>/dev/null | command sed -ne \ "s/.*[[:space:]]\($re\)[[:space:]].*/\1/p" -ne \ "s/.*[[:space:]]\($re\)[[:space:]]*$/\1/p" )" # /etc/ethers _comp_compgen -av addresses split -- "$(command sed -ne \ "s/^[[:space:]]*\($re\)[[:space:]].*/\1/p" /etc/ethers 2>/dev/null)" _comp_compgen_ltrim_colon "${addresses[@]}" } # This function completes on configured network interfaces # _comp_compgen_configured_interfaces() { local -a files if [[ -f /etc/debian_version ]]; then # Debian system _comp_expand_glob files '/etc/network/interfaces /etc/network/interfaces.d/*' ((${#files[@]})) || return 0 _comp_compgen_split -- "$(command sed -ne \ 's|^iface \([^ ]\{1,\}\).*$|\1|p' "${files[@]}" 2>/dev/null)" elif [[ -f /etc/SuSE-release ]]; then # SuSE system _comp_expand_glob files '/etc/sysconfig/network/ifcfg-*' ((${#files[@]})) || return 0 _comp_compgen_split -- "$(printf '%s\n' "${files[@]}" | command sed -ne 's|.*ifcfg-\([^*].*\)$|\1|p')" elif [[ -f /etc/pld-release ]]; then # PLD Linux _comp_compgen_split -- "$(command ls -B /etc/sysconfig/interfaces | command sed -ne 's|.*ifcfg-\([^*].*\)$|\1|p')" else # Assume Red Hat _comp_expand_glob files '/etc/sysconfig/network-scripts/ifcfg-*' ((${#files[@]})) || return 0 _comp_compgen_split -- "$(printf '%s\n' "${files[@]}" | command sed -ne 's|.*ifcfg-\([^*].*\)$|\1|p')" fi } # Local IP addresses. # If producing IPv6 completions, `_comp_initialize` with `-n :`. # # -4: IPv4 addresses only (default) # -6: IPv6 addresses only # -a: All addresses # _comp_compgen_ip_addresses() { local n case ${1-} in -a) n='6\{0,1\}' ;; -6) n='6' ;; *) n= ;; esac local PATH=$PATH:/sbin local addrs _comp_compgen -v addrs split -- "$({ LC_ALL=C ifconfig -a || ip -c=never addr show || ip addr show } 2>/dev/null | command sed -e 's/[[:space:]]addr:/ /' -ne \ "s|.*inet${n}[[:space:]]\{1,\}\([^[:space:]/]*\).*|\1|p")" || return if [[ ! $n ]]; then _comp_compgen -R -- -W '"${addrs[@]}"' else _comp_compgen_ltrim_colon "${addrs[@]}" fi } # This function completes on available kernels # # TODO:API: rename per conventions _kernel_versions() { _comp_compgen_split -- "$(command ls /lib/modules)" } # This function completes on all available network interfaces # -a: restrict to active interfaces only # -w: restrict to wireless interfaces only # _comp_compgen_available_interfaces() { local PATH=$PATH:/sbin local generated _comp_compgen -v generated split -- "$({ if [[ ${1-} == -w ]]; then iwconfig elif [[ ${1-} == -a ]]; then ifconfig || ip -c=never link show up || ip link show up else ifconfig -a || ip -c=never link show || ip link show fi } 2>/dev/null | awk \ '/^[^ \t]/ { if ($1 ~ /^[0-9]+:/) { print $2 } else { print $1 } }')" && _comp_compgen -R -- -W '"${generated[@]/%[[:punct:]]/}"' } # Echo number of CPUs, falling back to 1 on failure. # @var[out] ret # @return 0 if it successfully obtained the number of CPUs, or otherwise 1 # @since 2.12 _comp_get_ncpus() { local var=NPROCESSORS_ONLN [[ $OSTYPE == *@(linux|msys|cygwin)* ]] && var=_$var if ret=$(getconf $var 2>/dev/null) && ((ret >= 1)); then return 0 else ret=1 return 1 fi } # Perform tilde (~) completion # @return False (1) if completion needs further processing, # True (0) if tilde is followed by a valid username, completions are # put in COMPREPLY and no further processing is necessary. # @since 2.12 _comp_compgen_tilde() { if [[ ${cur-} == \~* && $cur != */* ]]; then # Try generate ~username completions if _comp_compgen -c "${cur#\~}" -- -P '~' -u; then # 2>/dev/null for direct invocation, e.g. in the # _comp_compgen_tilde unit test compopt -o filenames 2>/dev/null return 0 fi fi return 1 } # Expand variable starting with tilde (~) # We want to expand ~foo/... to /home/foo/... to avoid problems when # word-to-complete starting with a tilde is fed to commands and ending up # quoted instead of expanded. # Only the first portion of the variable from the tilde up to the first slash # (~../) is expanded. The remainder of the variable, containing for example # a dollar sign variable ($) or asterisk (*) is not expanded. # Example usage: # # $ v="~"; __expand_tilde_by_ref v; echo "$v" # # Example output: # # v output # -------- ---------------- # ~ /home/user # ~foo/bar /home/foo/bar # ~foo/$HOME /home/foo/$HOME # ~foo/a b /home/foo/a b # ~foo/* /home/foo/* # # @param $1 Name of variable (not the value of the variable) to expand # TODO:API: rename per conventions __expand_tilde_by_ref() { if [[ ${!1-} == \~* ]]; then eval "$1"="$(printf ~%q "${!1#\~}")" fi } # __expand_tilde_by_ref() # This function expands tildes in pathnames # # TODO:API: rename per conventions _expand() { # Expand ~username type directory specifications. We want to expand # ~foo/... to /home/foo/... to avoid problems when $cur starting with # a tilde is fed to commands and ending up quoted instead of expanded. case ${cur-} in ~*/*) __expand_tilde_by_ref cur ;; ~*) _comp_compgen -v COMPREPLY tilde && eval "COMPREPLY[0]=$(printf ~%q "${COMPREPLY[0]#\~}")" return ${#COMPREPLY[@]} ;; esac } # Process ID related functions. # for AIX and Solaris we use X/Open syntax, BSD for others. # TODO:API: rename per conventions if [[ $OSTYPE == *@(solaris|aix)* ]]; then # This function completes on process IDs. _pids() { _comp_compgen_split -- "$(command ps -efo pid | command sed 1d)" } _pgids() { _comp_compgen_split -- "$(command ps -efo pgid | command sed 1d)" } _pnames() { _comp_compgen_split -X '' -- "$(command ps -efo comm | command sed -e 1d -e 's:.*/::' -e 's/^-//' | sort -u)" } else _pids() { _comp_compgen_split -- "$(command ps ax -o pid=)" } _pgids() { _comp_compgen_split -- "$(command ps ax -o pgid=)" } # @param $1 if -s, don't try to avoid truncated command names _pnames() { local -a procs=() if [[ ${1-} == -s ]]; then _comp_split procs "$(command ps ax -o comm | command sed -e 1d)" else # Some versions of ps don't support "command", but do "comm", e.g. # some busybox ones. Fall back local -a psout _comp_split -l psout "$({ command ps ax -o command= || command ps ax -o comm= } 2>/dev/null)" local line i=-1 for line in "${psout[@]}"; do if ((i == -1)); then # First line, see if it has COMMAND column header. For # example some busybox ps versions do that, i.e. don't # respect command= if [[ $line =~ ^(.*[[:space:]])COMMAND([[:space:]]|$) ]]; then # It does; store its index. i=${#BASH_REMATCH[1]} else # Nope, fall through to "regular axo command=" parsing. break fi else # line=${line:i} # take command starting from found index line=${line%% *} # trim arguments [[ $line ]] && procs+=("$line") fi done if ((i == -1)); then # Regular command= parsing for line in "${psout[@]}"; do if [[ $line =~ ^[[(](.+)[])]$ ]]; then procs+=("${BASH_REMATCH[1]}") else line=${line%% *} # trim arguments line=${line##@(*/|-)} # trim leading path and - [[ $line ]] && procs+=("$line") fi done fi fi ((${#procs[@]})) && _comp_compgen -- -X "" -W '"${procs[@]}"' } fi # This function completes on user IDs # # TODO:API: rename per conventions _uids() { if type getent &>/dev/null; then _comp_compgen_split -- "$(getent passwd | cut -d: -f3)" elif type perl &>/dev/null; then _comp_compgen_split -- "$(perl -e 'while (($uid) = (getpwent)[2]) { print $uid . "\n" }')" else # make do with /etc/passwd _comp_compgen_split -- "$(cut -d: -f3 /etc/passwd)" fi } # This function completes on group IDs # # TODO:API: rename per conventions _gids() { if type getent &>/dev/null; then _comp_compgen_split -- "$(getent group | cut -d: -f3)" elif type perl &>/dev/null; then _comp_compgen_split -- "$(perl -e 'while (($gid) = (getgrent)[2]) { print $gid . "\n" }')" else # make do with /etc/group _comp_compgen_split -- "$(cut -d: -f3 /etc/group)" fi } # Glob for matching various backup files. # _comp_backup_glob='@(#*#|*@(~|.@(bak|orig|rej|swp|dpkg*|rpm@(orig|new|save))))' # Complete on xinetd services # # TODO:API: rename per conventions _xinetd_services() { local xinetddir=${_comp__test_xinetd_dir:-/etc/xinetd.d} if [[ -d $xinetddir ]]; then local -a svcs _comp_expand_glob svcs '$xinetddir/!($_comp_backup_glob)' if ((${#svcs[@]})); then _comp_compgen -- -W '"${svcs[@]#$xinetddir/}"' fi fi } # This function completes on services # # TODO:API: rename per conventions _services() { local sysvdirs _comp_sysvdirs _comp_expand_glob COMPREPLY '${sysvdirs[0]}/!($_comp_backup_glob|functions|README)' local generated=$({ systemctl list-units --full --all || systemctl list-unit-files } 2>/dev/null | awk '$1 ~ /\.service$/ { sub("\\.service$", "", $1); print $1 }') _comp_split -la COMPREPLY "$generated" if [[ -x /sbin/upstart-udev-bridge ]]; then _comp_split -la COMPREPLY "$(initctl list 2>/dev/null | cut -d' ' -f1)" fi ((${#COMPREPLY[@]})) && _comp_compgen -- -W '"${COMPREPLY[@]#${sysvdirs[0]}/}"' } # This completes on a list of all available service scripts for the # 'service' command and/or the SysV init.d directory, followed by # that script's available commands # This function is in the main bash_completion file rather than in a separate # one, because we set it up eagerly as completer for scripts in sysv init dirs # below. # # TODO:API: rename per conventions, rework to use vars rather than outputting _service() { local cur prev words cword comp_args _comp_initialize -- "$@" || return # don't complete past 2nd token ((cword > 2)) && return if [[ $cword -eq 1 && $prev == ?(*/)service ]]; then _services [[ -e /etc/mandrake-release ]] && _xinetd_services else local sysvdirs _comp_sysvdirs _comp_compgen_split -l -- "$(command sed -e 'y/|/ /' \ -ne 's/^.*\(U\|msg_u\)sage.*{\(.*\)}.*$/\2/p' \ "${sysvdirs[0]}/${prev##*/}" 2>/dev/null) start stop" fi } && complete -F _service service _comp__init_set_up_service_completions() { local sysvdirs svc svcdir _comp_sysvdirs for svcdir in "${sysvdirs[@]}"; do for svc in "$svcdir"/!($_comp_backup_glob); do [[ -x $svc ]] && complete -F _service "$svc" done done unset -f "$FUNCNAME" } _comp__init_set_up_service_completions # This function completes on modules # # TODO:API: rename per conventions (+ include "kernel" in the name) _modules() { local modpath modpath=/lib/modules/$1 _comp_compgen_split -- "$(command ls -RL "$modpath" 2>/dev/null | command sed -ne 's/^\(.*\)\.k\{0,1\}o\(\.[gx]z\)\{0,1\}$/\1/p' \ -e 's/^\(.*\)\.ko\.zst$/\1/p')" } # This function completes on installed modules # # TODO:API: rename per conventions (+ include "kernel" in the name) _installed_modules() { _comp_compgen -c "$1" split -- "$(PATH="$PATH:/sbin" lsmod | awk '{if (NR != 1) print $1}')" } # This function completes on user or user:group format; as for chown and cpio. # # The : must be added manually; it will only complete usernames initially. # The legacy user.group format is not supported. # # @param $1 If -u, only return users/groups the user has access to in # context of current completion. # TODO:API: rename per conventions _usergroup() { if [[ $cur == *\\\\* || $cur == *:*:* ]]; then # Give up early on if something seems horribly wrong. return elif [[ $cur == *\\:* ]]; then # Completing group after 'user\:gr'. # Reply with a list of groups prefixed with 'user:', readline will # escape to the colon. local prefix prefix=${cur%%*([^:])} prefix=${prefix//\\/} local mycur=${cur#*[:]} if [[ ${1-} == -u ]]; then _allowed_groups "$mycur" else _comp_compgen -c "$mycur" -- -g fi ((${#COMPREPLY[@]})) && COMPREPLY=("${COMPREPLY[@]/#/$prefix}") elif [[ $cur == *:* ]]; then # Completing group after 'user:gr'. # Reply with a list of unprefixed groups since readline with split on : # and only replace the 'gr' part local mycur=${cur#*:} if [[ ${1-} == -u ]]; then _allowed_groups "$mycur" else _comp_compgen -c "$mycur" -- -g fi else # Completing a partial 'usernam'. # # Don't suffix with a : because readline will escape it and add a # slash. It's better to complete into 'chown username ' than 'chown # username\:'. if [[ ${1-} == -u ]]; then _allowed_users "$cur" else _comp_compgen -- -u fi fi } # TODO:API: rename per conventions _allowed_users() { if _complete_as_root; then _comp_compgen -c "${1:-$cur}" -- -u else _comp_compgen -c "${1:-$cur}" split -- "$(id -un 2>/dev/null || whoami 2>/dev/null)" fi } # TODO:API: rename per conventions _allowed_groups() { if _complete_as_root; then _comp_compgen -c "$1" -- -g else _comp_compgen -c "$1" split -- "$(id -Gn 2>/dev/null || groups 2>/dev/null)" fi } # @since 2.12 _comp_selinux_users() { _comp_compgen -a split -- "$(semanage user -nl 2>/dev/null | awk '{ print $1 }')" } # This function completes on valid shells # # @param $1 chroot to search from # TODO:API: rename per conventions _shells() { local shell rest while read -r shell rest; do [[ $shell == /* && $shell == "$cur"* ]] && COMPREPLY+=("$shell") done 2>/dev/null <"${1-}"/etc/shells } # This function completes on valid filesystem types # # TODO:API: rename per conventions _fstypes() { local fss if [[ -e /proc/filesystems ]]; then # Linux fss="$(cut -d$'\t' -f2 /proc/filesystems) $(awk '! /\*/ { print $NF }' /etc/filesystems 2>/dev/null)" else # Generic fss="$(awk '/^[ \t]*[^#]/ { print $3 }' /etc/fstab 2>/dev/null) $(awk '/^[ \t]*[^#]/ { print $3 }' /etc/mnttab 2>/dev/null) $(awk '/^[ \t]*[^#]/ { print $4 }' /etc/vfstab 2>/dev/null) $(awk '{ print $1 }' /etc/dfs/fstypes 2>/dev/null) $(lsvfs 2>/dev/null | awk '$1 !~ /^(Filesystem|[^a-zA-Z])/ { print $1 }') $([[ -d /etc/fs ]] && command ls /etc/fs)" fi [[ $fss ]] && _comp_compgen -a -- -W "$fss" } # Get absolute path to a file, with rudimentary canonicalization. # No symlink resolution or existence checks are done; # see `_comp_realcommand` for those. # @param $1 The file # @var[out] ret The path # @since 2.12 _comp_abspath() { ret=$1 case $ret in /*) ;; ../*) ret=$PWD/${ret:3} ;; *) ret=$PWD/$ret ;; esac while [[ $ret == */./* ]]; do ret=${ret//\/.\//\/} done ret=${ret//+(\/)/\/} } # Get real command. # Command is the filename of command in PATH with possible symlinks resolved # (if resolve tooling available), empty string if command not found. # @param $1 Command # @var[out] ret Resulting string # @return True (0) if command found, False (> 0) if not. # @since 2.12 _comp_realcommand() { ret="" local file file=$(type -P "$1") || return $? if type -p realpath >/dev/null; then ret=$(realpath "$file") elif type -p greadlink >/dev/null; then ret=$(greadlink -f "$file") elif type -p readlink >/dev/null; then ret=$(readlink -f "$file") else _comp_abspath "$file" fi } # This function returns the first argument, excluding options # @param $1 chars Characters out of $COMP_WORDBREAKS which should # NOT be considered word breaks. See _comp__reassemble_words. # TODO:API: rename per conventions _get_first_arg() { local i arg= for ((i = 1; i < COMP_CWORD; i++)); do if [[ ${COMP_WORDS[i]} != -* ]]; then arg=${COMP_WORDS[i]} break fi done } # This function counts the number of args, excluding options # @param $1 chars Characters out of $COMP_WORDBREAKS which should # NOT be considered word breaks. See _comp__reassemble_words. # @param $2 glob Options whose following argument should not be counted # @param $3 glob Options that should be counted as args # TODO:API: rename per conventions _count_args() { local i cword words _comp__reassemble_words "${1-}" words cword args=1 for ((i = 1; i < cword; i++)); do # shellcheck disable=SC2053 if [[ ${words[i]} != -* && ${words[i - 1]} != ${2-} || ${words[i]} == ${3-} ]]; then ((args++)) fi done } # This function completes on PCI IDs # # TODO:API: rename per conventions _pci_ids() { _comp_compgen -a split -- "$(PATH="$PATH:/sbin" lspci -n | awk '{print $3}')" } # This function completes on USB IDs # # TODO:API: rename per conventions _usb_ids() { _comp_compgen -a split -- "$(PATH="$PATH:/sbin" lsusb | awk '{print $6}')" } # CD device names # TODO:API: rename per conventions _cd_devices() { _comp_compgen -ac "${cur:-/dev/}" -- -f -d -X "!*/?([amrs])cd*" } # DVD device names # TODO:API: rename per conventions _dvd_devices() { _comp_compgen -ac "${cur:-/dev/}" -- -f -d -X "!*/?(r)dvd*" } # TERM environment variable values # TODO:API: rename per conventions _terms() { _comp_compgen -a split -- "$({ command sed -ne 's/^\([^[:space:]#|]\{2,\}\)|.*/\1/p' /etc/termcap { toe -a || toe } | awk '{ print $1 }' _comp_expand_glob dirs '/{etc,lib,usr/lib,usr/share}/terminfo/?' ((${#dirs[@]})) && find "${dirs[@]}" -type f -maxdepth 1 | awk -F/ '{ print $NF }' } 2>/dev/null)" } # TODO:API: rename per conventions _bashcomp_try_faketty() { if type unbuffer &>/dev/null; then unbuffer -p "$@" elif script --version 2>&1 | command grep -qF util-linux; then # BSD and Solaris "script" do not seem to have required features script -qaefc "$*" /dev/null else "$@" # no can do, fallback fi } # a little help for FreeBSD ports users [[ $OSTYPE == *freebsd* ]] && complete -W 'index search fetch fetch-list extract patch configure build install reinstall deinstall clean clean-depends kernel buildworld' make # This function provides simple user@host completion # # TODO:API: rename per conventions _user_at_host() { local cur prev words cword comp_args _comp_initialize -n : -- "$@" || return if [[ $cur == *@* ]]; then _known_hosts_real "$cur" else _comp_compgen -- -u -S @ compopt -o nospace fi } shopt -u hostcomplete && complete -F _user_at_host talk ytalk finger # NOTE: Using this function as a helper function is deprecated. Use # `_known_hosts_real' instead. # TODO:API: rename per conventions _known_hosts() { local cur prev words cword comp_args _comp_initialize -n : -- "$@" || return # NOTE: Using `_known_hosts' as a helper function and passing options # to `_known_hosts' is deprecated: Use `_known_hosts_real' instead. local options="" [[ ${1-} == -a || ${2-} == -a ]] && options=-a [[ ${1-} == -c || ${2-} == -c ]] && options+=" -c" # shellcheck disable=SC2086 _known_hosts_real ${options-} -- "$cur" } # _known_hosts() # Helper function to locate ssh included files in configs # This function looks for the "Include" keyword in ssh config files and # includes them recursively, adding each result to the config variable. # TODO:API: rename per conventions _included_ssh_config_files() { (($# < 1)) && echo "bash_completion: $FUNCNAME: missing mandatory argument CONFIG" >&2 local configfile i files f configfile=$1 # From man ssh_config: # "Files without absolute paths are assumed to be in ~/.ssh if included # in a user configuration file or /etc/ssh if included from the system # configuration file." # This behavior is not affected by the the including file location - # if the system configuration file is included from the user's config, # relative includes are still resolved in the user's ssh config directory. local relative_include_base if [[ $configfile == /etc/ssh* ]]; then relative_include_base="/etc/ssh" else relative_include_base="$HOME/.ssh" fi local depth=1 local -a included local -a include_files included=("$configfile") # Max recursion depth per openssh's READCONF_MAX_DEPTH: # https://github.com/openssh/openssh-portable/blob/5ec5504f1d328d5bfa64280cd617c3efec4f78f3/readconf.c#L2240 local max_depth=16 while ((${#included[@]} > 0 && depth++ < max_depth)); do _comp_split include_files "$(command sed -ne 's/^[[:blank:]]*[Ii][Nn][Cc][Ll][Uu][Dd][Ee][[:blank:]]\(.*\)$/\1/p' "${included[@]}")" || return included=() for i in "${include_files[@]}"; do if [[ $i != [~/]* ]]; then i="${relative_include_base}/${i}" fi __expand_tilde_by_ref i # In case the expanded variable contains multiple paths _comp_expand_glob files '$i' if ((${#files[@]})); then for f in "${files[@]}"; do if [[ -r $f && ! -d $f ]]; then config+=("$f") included+=("$f") fi done fi done done } # _included_ssh_config_files() # Helper function for completing _known_hosts. # This function performs host completion based on ssh's config and known_hosts # files, as well as hostnames reported by avahi-browse if # BASH_COMPLETION_KNOWN_HOSTS_WITH_AVAHI is set to a non-empty value. # Also hosts from HOSTFILE (compgen -A hostname) are added, unless # BASH_COMPLETION_KNOWN_HOSTS_WITH_HOSTFILE is set to an empty value. # Usage: _known_hosts_real [OPTIONS] CWORD # Options: # -a Use aliases from ssh config files # -c Use `:' suffix # -F configfile Use `configfile' for configuration settings # -p PREFIX Use PREFIX # -4 Filter IPv6 addresses from results # -6 Filter IPv4 addresses from results # @return Completions, starting with CWORD, are added to COMPREPLY[] # TODO:API: rename per conventions _known_hosts_real() { local configfile="" flag prefix="" local cur suffix="" aliases="" i host ipv4="" ipv6="" local -a kh tmpkh=() khd=() config=() # TODO remove trailing %foo from entries local OPTIND=1 while getopts "ac46F:p:" flag "$@"; do case $flag in a) aliases=set ;; c) suffix=':' ;; F) if [[ ! $OPTARG ]]; then echo "bash_completion: $FUNCNAME: -F: an empty filename is specified" >&2 return 1 fi configfile=$OPTARG ;; p) prefix=$OPTARG ;; 4) ipv4=set ;; 6) ipv6=set ;; *) echo "bash_completion: $FUNCNAME: usage error" >&2 return 1 ;; esac done if (($# < OPTIND)); then echo "bash_completion: $FUNCNAME: missing mandatory argument CWORD" >&2 return 1 fi cur=${!OPTIND} ((OPTIND += 1)) if (($# >= OPTIND)); then echo "bash_completion: $FUNCNAME($*): unprocessed arguments:" \ "$(while (($# >= OPTIND)); do printf '%s ' ${!OPTIND} shift done)" >&2 return 1 fi [[ $cur == *@* ]] && prefix=$prefix${cur%@*}@ && cur=${cur#*@} kh=() # ssh config files if [[ $configfile ]]; then [[ -r $configfile && ! -d $configfile ]] && config+=("$configfile") else for i in /etc/ssh/ssh_config ~/.ssh/config ~/.ssh2/config; do [[ -r $i && ! -d $i ]] && config+=("$i") done fi local IFS=$' \t\n' reset=$(shopt -po noglob) set -o noglob # "Include" keyword in ssh config files if ((${#config[@]} > 0)); then for i in "${config[@]}"; do _included_ssh_config_files "$i" done fi # Known hosts files from configs if ((${#config[@]} > 0)); then # expand paths (if present) to global and user known hosts files # TODO(?): try to make known hosts files with more than one consecutive # spaces in their name work (watch out for ~ expansion # breakage! Alioth#311595) _comp_split -l tmpkh "$(awk 'sub("^[ \t]*([Gg][Ll][Oo][Bb][Aa][Ll]|[Uu][Ss][Ee][Rr])[Kk][Nn][Oo][Ww][Nn][Hh][Oo][Ss][Tt][Ss][Ff][Ii][Ll][Ee][ \t=]+", "") { print $0 }' "${config[@]}" | sort -u)" fi if ((${#tmpkh[@]} != 0)); then local j for i in "${tmpkh[@]}"; do # First deal with quoted entries... while [[ $i =~ ^([^\"]*)\"([^\"]*)\"(.*)$ ]]; do i=${BASH_REMATCH[1]}${BASH_REMATCH[3]} j=${BASH_REMATCH[2]} __expand_tilde_by_ref j # Eval/expand possible `~' or `~user' [[ -r $j ]] && kh+=("$j") done # ...and then the rest. for j in $i; do __expand_tilde_by_ref j # Eval/expand possible `~' or `~user' [[ -r $j ]] && kh+=("$j") done done fi if [[ ! $configfile ]]; then # Global and user known_hosts files for i in /etc/ssh/ssh_known_hosts /etc/ssh/ssh_known_hosts2 \ /etc/known_hosts /etc/known_hosts2 ~/.ssh/known_hosts \ ~/.ssh/known_hosts2; do [[ -r $i && ! -d $i ]] && kh+=("$i") done for i in /etc/ssh2/knownhosts ~/.ssh2/hostkeys; do [[ -d $i ]] && khd+=("$i"/*pub) done fi # If we have known_hosts files to use if ((${#kh[@]} + ${#khd[@]} > 0)); then if ((${#kh[@]} > 0)); then COMPREPLY+=() # make sure it exists # https://man.openbsd.org/sshd.8#SSH_KNOWN_HOSTS_FILE_FORMAT for i in "${kh[@]}"; do while read -ra tmpkh; do ((${#tmpkh[@]} == 0)) && continue set -- "${tmpkh[@]}" # Skip entries starting with | (hashed) and # (comment) [[ $1 == [\|\#]* ]] && continue # Ignore leading @foo (markers) [[ $1 == @* ]] && shift # Split entry on commas local -a hosts if _comp_split -F , hosts "$1"; then for host in "${hosts[@]}"; do # Skip hosts containing wildcards [[ $host == *[*?]* ]] && continue # Remove leading [ host=${host#[} # Remove trailing ] + optional :port host=${host%]?(:+([0-9]))} # Add host to candidates [[ $host ]] && COMPREPLY+=("$host") done fi done <"$i" done ((${#COMPREPLY[@]})) && _comp_compgen -- -W '"${COMPREPLY[@]}"' fi if ((${#khd[@]} > 0)); then # Needs to look for files called # .../.ssh2/key_22_.pub # dont fork any processes, because in a cluster environment, # there can be hundreds of hostkeys for i in "${khd[@]}"; do if [[ $i == *key_22_$cur*.pub && -r $i ]]; then host=${i/#*key_22_/} host=${host/%.pub/} [[ $host ]] && COMPREPLY+=("$host") fi done fi # apply suffix and prefix if ((${#COMPREPLY[@]})); then for i in ${!COMPREPLY[*]}; do COMPREPLY[i]=$prefix${COMPREPLY[i]}$suffix done fi fi # append any available aliases from ssh config files if [[ ${#config[@]} -gt 0 && $aliases ]]; then local -a hosts if _comp_split hosts "$(command sed -ne 's/^[[:blank:]]*[Hh][Oo][Ss][Tt][[:blank:]=]\{1,\}\(.*\)$/\1/p' "${config[@]}")"; then _comp_compgen -a -- -P "$prefix" \ -S "$suffix" -W '"${hosts[@]%%[*?%]*}"' -X '@(\!*|)' fi fi # Add hosts reported by avahi-browse, if desired and it's available. if [[ ${BASH_COMPLETION_KNOWN_HOSTS_WITH_AVAHI-${COMP_KNOWN_HOSTS_WITH_AVAHI-}} ]] && type avahi-browse &>/dev/null; then # Some old versions of avahi-browse reportedly didn't have -k # (even if mentioned in the manpage); those we do not support any more. local generated=$(avahi-browse -cprak 2>/dev/null | awk -F';' \ '/^=/ && $5 ~ /^_(ssh|workstation)\._tcp$/ { print $7 }' | sort -u) _comp_compgen -a -- -P "$prefix" -S "$suffix" -W '$generated' fi # Add hosts reported by ruptime. if type ruptime &>/dev/null; then local generated=$(ruptime 2>/dev/null | awk '!/^ruptime:/ { print $1 }') _comp_compgen -a -- -W '$generated' fi # Add results of normal hostname completion, unless # `BASH_COMPLETION_KNOWN_HOSTS_WITH_HOSTFILE' is set to an empty value. if [[ ${BASH_COMPLETION_KNOWN_HOSTS_WITH_HOSTFILE-${COMP_KNOWN_HOSTS_WITH_HOSTFILE-1}} ]]; then _comp_compgen -a -- -A hostname -P "$prefix" -S "$suffix" fi $reset if ((${#COMPREPLY[@]})); then if [[ $ipv4 ]]; then COMPREPLY=("${COMPREPLY[@]/*:*$suffix/}") fi if [[ $ipv6 ]]; then COMPREPLY=("${COMPREPLY[@]/+([0-9]).+([0-9]).+([0-9]).+([0-9])$suffix/}") fi if [[ $ipv4 || $ipv6 ]]; then for i in "${!COMPREPLY[@]}"; do [[ ${COMPREPLY[i]} ]] || unset -v 'COMPREPLY[i]' done fi fi _comp_ltrim_colon_completions "$prefix$cur" } # _known_hosts_real() complete -F _known_hosts traceroute traceroute6 \ fping fping6 telnet rsh rlogin ftp dig drill mtr ssh-installkeys showmount # Convert the word index in `words` to the index in `COMP_WORDS`. # @param $1 Index in the array WORDS. # @var[in,opt] words Words that contain reassmbled words. # @var[in,opt] cword Current word index in WORDS. # WORDS and CWORD, if any, are expected to be created by # _comp__reassemble_words. # _comp__find_original_word() { ret=$1 # If CWORD or WORDS are undefined, we return the first argument without any # processing. [[ -v cword && -v words ]] || return 0 local reassembled_offset=$1 i=0 j for ((j = 0; j < reassembled_offset; j++)); do local word=${words[j]} while [[ $word && i -lt ${#COMP_WORDS[@]} && $word == *"${COMP_WORDS[i]}"* ]]; do word=${word#*"${COMP_WORDS[i++]}"} done done ret=$i } # A meta-command completion function for commands like sudo(8), which need to # first complete on a command, then complete according to that command's own # completion definition. # # @since 2.12 _comp_command_offset() { # rewrite current completion context before invoking # actual command completion # obtain the word index in COMP_WORDS local ret _comp__find_original_word "$1" local word_offset=$ret # make changes to COMP_* local. Note that bash-4.3..5.0 have a # bug that `local -a arr=("${arr[@]}")` fails. We instead first # assign the values of `COMP_WORDS` to another array `comp_words`. local COMP_LINE=$COMP_LINE COMP_POINT=$COMP_POINT COMP_CWORD=$COMP_CWORD local -a comp_words=("${COMP_WORDS[@]}") local -a COMP_WORDS=("${comp_words[@]}") # find new first word position, then # rewrite COMP_LINE and adjust COMP_POINT local i tail for ((i = 0; i < word_offset; i++)); do tail=${COMP_LINE#*"${COMP_WORDS[i]}"} ((COMP_POINT -= ${#COMP_LINE} - ${#tail})) COMP_LINE=$tail done # shift COMP_WORDS elements and adjust COMP_CWORD COMP_WORDS=("${COMP_WORDS[@]:word_offset}") ((COMP_CWORD -= word_offset)) COMPREPLY=() local cur _comp_get_words cur if ((COMP_CWORD == 0)); then _comp_compgen_commands else _comp_dequote "${COMP_WORDS[0]}" || ret=${COMP_WORDS[0]} local cmd=$ret compcmd=$ret local cspec=$(complete -p "$cmd" 2>/dev/null) # If we have no completion for $cmd yet, see if we have for basename if [[ ! $cspec && $cmd == */* ]]; then cspec=$(complete -p "${cmd##*/}" 2>/dev/null) [[ $cspec ]] && compcmd=${cmd##*/} fi # If still nothing, just load it for the basename if [[ ! $cspec ]]; then compcmd=${cmd##*/} _completion_loader "$compcmd" cspec=$(complete -p "$compcmd" 2>/dev/null) fi local retry_count=0 while true; do # loop for the retry request by status 124 local args original_cur=${comp_args[1]-$cur} if ((${#COMP_WORDS[@]} >= 2)); then args=("$cmd" "$original_cur" "${COMP_WORDS[-2]}") else args=("$cmd" "$original_cur") fi if [[ ! $cspec ]]; then if ((${#COMPREPLY[@]} == 0)); then # XXX will probably never happen as long as completion loader loads # *something* for every command thrown at it ($cspec != empty) _minimal "${args[@]}" fi elif [[ $cspec == *' -F '* ]]; then # complete -F # get function name local func=${cspec#* -F } func=${func%% *} $func "${args[@]}" # restart completion (once) if function exited with 124 if (($? == 124 && retry_count++ == 0)); then # Note: When the completion function returns 124, the state # of COMPREPLY is discarded. COMPREPLY=() cspec=$(complete -p "$compcmd" 2>/dev/null) # Note: When completion spec is removed after 124, we do # not generate any completions including the default ones. # This is the behavior of the original Bash progcomp. [[ $cspec ]] || break continue fi # restore initial compopts local opt while [[ $cspec == *" -o "* ]]; do # FIXME: should we take "+o opt" into account? cspec=${cspec#*-o } opt=${cspec%% *} compopt -o "$opt" cspec=${cspec#"$opt"} done else cspec=${cspec#complete} cspec=${cspec%%@("$compcmd"|"'${compcmd//\'/\'\\\'\'}'")} eval "_comp_compgen -- $cspec" fi break done fi } # A _comp_command_offset wrapper function for use when the offset is unknown. # Only intended to be used as a completion function directly associated # with a command, not to be invoked from within other completion functions. # # @since 2.12 _comp_command() { # We unset the shell variable `words` locally to tell # `_comp_command_offset` that the index is intended to be that in # `COMP_WORDS` instead of `words`. local words unset -v words local offset i # find actual offset, as position of the first non-option offset=1 for ((i = 1; i <= COMP_CWORD; i++)); do if [[ ${COMP_WORDS[i]} != -* ]]; then offset=$i break fi done _comp_command_offset $offset } complete -F _comp_command aoss command "do" else eval exec ltrace nice nohup padsp \ "then" time tsocks vsound xargs # @since 2.12 _comp_root_command() { local PATH=$PATH:/sbin:/usr/sbin:/usr/local/sbin local root_command=$1 _comp_command } complete -F _comp_root_command fakeroot gksu gksudo kdesudo really # Return true if the completion should be treated as running as root # TODO:API: rename per conventions _complete_as_root() { [[ $EUID -eq 0 || ${root_command-} ]] } # Complete on available commands, subject to `no_empty_cmd_completion`. # @return True (0) if one or more completions are generated, or otherwise False # (1). Note that it returns 1 even when the completion generation is canceled # by `shopt -s no_empty_cmd_completion`. # # @since 2.12 _comp_compgen_commands() { [[ ! ${cur-} ]] && shopt -q no_empty_cmd_completion && return 1 # -o filenames for e.g. spaces in paths to and in command names _comp_compgen -- -c -o plusdirs && compopt -o filenames } # @since 2.12 _comp_longopt() { local cur prev words cword was_split comp_args _comp_initialize -s -- "$@" || return case "${prev,,}" in --help | --usage | --version) return ;; --!(no-*)dir*) _comp_compgen -a filedir -d return ;; --!(no-*)@(file|path)*) _comp_compgen -a filedir return ;; --+([-a-z0-9_])) local argtype=$(LC_ALL=C $1 --help 2>&1 | command sed -ne \ "s|.*$prev\[\{0,1\}=[<[]\{0,1\}\([-A-Za-z0-9_]\{1,\}\).*|\1|p") case ${argtype,,} in *dir*) _comp_compgen -a filedir -d return ;; *file* | *path*) _comp_compgen -a filedir return ;; esac ;; esac [[ $was_split ]] && return if [[ $cur == -* ]]; then _comp_compgen_split -- "$(LC_ALL=C $1 --help 2>&1 | while read -r line; do [[ $line =~ --[A-Za-z0-9]+([-_][A-Za-z0-9]+)*=? ]] && printf '%s\n' "${BASH_REMATCH[0]}" done)" [[ ${COMPREPLY-} == *= ]] && compopt -o nospace elif [[ $1 == *@(rmdir|chroot) ]]; then _comp_compgen -a filedir -d else [[ $1 == *mkdir ]] && compopt -o nospace _comp_compgen -a filedir fi } # makeinfo and texi2dvi are defined elsewhere. complete -F _comp_longopt \ a2ps awk base64 bash bc bison cat chroot colordiff cp \ csplit cut date df diff dir du enscript env expand fmt fold gperf \ grep grub head irb ld ldd less ln ls m4 mkdir mkfifo mknod \ mv netstat nl nm objcopy objdump od paste pr ptx readelf rm rmdir \ sed seq shar sort split strip sum tac tail tee \ texindex touch tr uname unexpand uniq units vdir wc who declare -Ag _xspecs # TODO:API: rename per conventions _filedir_xspec() { local cur prev words cword comp_args _comp_initialize -- "$@" || return _comp_compgen_tilde && return local ret _comp_quote_compgen "$cur" local quoted=$ret local xspec=${_xspecs[${1##*/}]} tmp local -a toks _comp_compgen -v toks -c "$quoted" -- -d # Munge xspec to contain uppercase version too # https://lists.gnu.org/archive/html/bug-bash/2010-09/msg00036.html # news://news.gmane.io/4C940E1C.1010304@case.edu eval xspec="${xspec}" local matchop=! if [[ $xspec == !* ]]; then xspec=${xspec#!} matchop=@ fi xspec="$matchop($xspec|${xspec^^})" _comp_compgen -av toks -c "$quoted" -- -f -X "@(|!($xspec))" # Try without filter if it failed to produce anything and configured to [[ ${BASH_COMPLETION_FILEDIR_FALLBACK-${COMP_FILEDIR_FALLBACK-}} && ${#toks[@]} -lt 1 ]] && _comp_compgen -av toks -c "$quoted" -- -f if ((${#toks[@]} != 0)); then compopt -o filenames COMPREPLY=("${toks[@]}") fi } # TODO:API: rename per conventions _install_xspec() { local xspec=$1 cmd shift for cmd in "$@"; do _xspecs[$cmd]=$xspec done } # bzcmp, bzdiff, bz*grep, bzless, bzmore intentionally not here, see Debian: #455510 _install_xspec '!*.?(t)bz?(2)' bunzip2 bzcat pbunzip2 pbzcat lbunzip2 lbzcat _install_xspec '!*.@(zip|[aegjkswx]ar|exe|pk3|wsz|zargo|xpi|s[tx][cdiw]|sx[gm]|o[dt][tspgfc]|od[bm]|oxt|?(o)xps|epub|cbz|apk|aab|ipa|do[ct][xm]|p[op]t[mx]|xl[st][xm]|pyz|whl|[Ff][Cc][Ss]td)' unzip zipinfo _install_xspec '*.Z' compress znew # zcmp, zdiff, z*grep, zless, zmore intentionally not here, see Debian: #455510 _install_xspec '!*.@(Z|[gGd]z|t[ag]z)' gunzip zcat _install_xspec '!*.@(Z|[gGdz]z|t[ag]z)' unpigz _install_xspec '!*.Z' uncompress # lzcmp, lzdiff intentionally not here, see Debian: #455510 _install_xspec '!*.@(tlz|lzma)' lzcat lzegrep lzfgrep lzgrep lzless lzmore unlzma _install_xspec '!*.@(?(t)xz|tlz|lzma)' unxz xzcat _install_xspec '!*.lrz' lrunzip _install_xspec '!*.@(gif|jp?(e)g|miff|tif?(f)|pn[gm]|p[bgp]m|bmp|xpm|ico|xwd|tga|pcx)' ee _install_xspec '!*.@(gif|jp?(e)g|tif?(f)|png|p[bgp]m|bmp|x[bp]m|rle|rgb|pcx|fits|pm|svg)' qiv _install_xspec '!*.@(gif|jp?(e)g?(2)|j2[ck]|jp[2f]|tif?(f)|png|p[bgp]m|bmp|x[bp]m|rle|rgb|pcx|fits|pm|?(e)ps)' xv _install_xspec '!*.@(@(?(e)ps|?(E)PS|pdf|PDF)?(.gz|.GZ|.bz2|.BZ2|.Z))' gv ggv kghostview _install_xspec '!*.@(dvi|DVI)?(.@(gz|Z|bz2))' xdvi kdvi _install_xspec '!*.dvi' dvips dviselect dvitype dvipdf advi dvipdfm dvipdfmx _install_xspec '!*.[pf]df' acroread gpdf xpdf _install_xspec '!*.@(?(e)ps|pdf)' kpdf _install_xspec '!*.@(okular|@(?(e|x)ps|?(E|X)PS|[pf]df|[PF]DF|dvi|DVI|cb[rz]|CB[RZ]|djv?(u)|DJV?(U)|dvi|DVI|gif|jp?(e)g|miff|tif?(f)|pn[gm]|p[bgp]m|bmp|xpm|ico|xwd|tga|pcx|GIF|JP?(E)G|MIFF|TIF?(F)|PN[GM]|P[BGP]M|BMP|XPM|ICO|XWD|TGA|PCX|epub|EPUB|odt|ODT|fb?(2)|FB?(2)|mobi|MOBI|g3|G3|chm|CHM|md|markdown)?(.?(gz|GZ|bz2|BZ2|xz|XZ)))' okular _install_xspec '!*.pdf' epdfview pdfunite _install_xspec '!*.@(cb[rz7t]|djv?(u)|?(e)ps|pdf)' zathura _install_xspec '!*.@(?(e)ps|pdf)' ps2pdf ps2pdf12 ps2pdf13 ps2pdf14 ps2pdfwr _install_xspec '!*.texi*' makeinfo texi2html _install_xspec '!*.@(?(la)tex|texi|dtx|ins|ltx|dbj)' tex latex slitex jadetex pdfjadetex pdftex pdflatex texi2dvi xetex xelatex luatex lualatex _install_xspec '!*.mp3' mpg123 mpg321 madplay _install_xspec '!*@(.@(mp?(e)g|MP?(E)G|wm[av]|WM[AV]|avi|AVI|asf|vob|VOB|bin|dat|divx|DIVX|vcd|ps|pes|fli|flv|FLV|fxm|FXM|viv|rm|ram|yuv|mov|MOV|qt|QT|web[am]|WEB[AM]|mp[234]|MP[234]|m?(p)4[av]|M?(P)4[AV]|mkv|MKV|og[agmv]|OG[AGMV]|t[ps]|T[PS]|m2t?(s)|M2T?(S)|mts|MTS|wav|WAV|flac|FLAC|asx|ASX|mng|MNG|srt|m[eo]d|M[EO]D|s[3t]m|S[3T]M|it|IT|xm|XM)|+([0-9]).@(vdr|VDR))?(.@(crdownload|part))' xine aaxine cacaxine fbxine _install_xspec '!*@(.@(mp?(e)g|MP?(E)G|wm[av]|WM[AV]|avi|AVI|asf|vob|VOB|bin|dat|divx|DIVX|vcd|ps|pes|fli|flv|FLV|fxm|FXM|viv|rm|ram|yuv|mov|MOV|qt|QT|web[am]|WEB[AM]|mp[234]|MP[234]|m?(p)4[av]|M?(P)4[AV]|mkv|MKV|og[agmv]|OG[AGMV]|opus|OPUS|t[ps]|T[PS]|m2t?(s)|M2T?(S)|mts|MTS|wav|WAV|flac|FLAC|asx|ASX|mng|MNG|srt|m[eo]d|M[EO]D|s[3t]m|S[3T]M|it|IT|xm|XM|iso|ISO)|+([0-9]).@(vdr|VDR))?(.@(crdownload|part))' kaffeine dragon totem _install_xspec '!*.@(avi|asf|wmv)' aviplay _install_xspec '!*.@(rm?(j)|ra?(m)|smi?(l))' realplay _install_xspec '!*.@(mpg|mpeg|avi|mov|qt)' xanim _install_xspec '!*.@(og[ag]|m3u|flac|spx)' ogg123 _install_xspec '!*.@(mp3|ogg|pls|m3u)' gqmpeg freeamp _install_xspec '!*.fig' xfig _install_xspec '!*.@(mid?(i)|cmf)' playmidi _install_xspec '!*.@(mid?(i)|rmi|rcp|[gr]36|g18|mod|xm|it|x3m|s[3t]m|kar)' timidity _install_xspec '!*.@(669|abc|am[fs]|d[bs]m|dmf|far|it|mdl|m[eo]d|mid?(i)|mt[2m]|oct|okt?(a)|p[st]m|s[3t]m|ult|umx|wav|xm)' modplugplay modplug123 _install_xspec '*.@([ao]|so|so.!(conf|*/*)|[rs]pm|gif|jp?(e)g|mp3|mp?(e)g|avi|asf|ogg|class)' vi vim gvim rvim view rview rgvim rgview gview emacs xemacs sxemacs kate kwrite _install_xspec '!*.@(zip|z|gz|tgz)' bzme # konqueror not here on purpose, it's more than a web/html browser _install_xspec '!*.@(?([xX]|[sS])[hH][tT][mM]?([lL]))' netscape mozilla lynx galeon dillo elinks amaya epiphany _install_xspec '!*.@(sxw|stw|sxg|sgl|doc?([mx])|dot?([mx])|rtf|txt|htm|html|?(f)odt|ott|odm|pdf)' oowriter lowriter _install_xspec '!*.@(sxi|sti|pps?(x)|ppt?([mx])|pot?([mx])|?(f)odp|otp)' ooimpress loimpress _install_xspec '!*.@(sxc|stc|xls?([bmx])|xlw|xlt?([mx])|[ct]sv|?(f)ods|ots)' oocalc localc _install_xspec '!*.@(sxd|std|sda|sdd|?(f)odg|otg)' oodraw lodraw _install_xspec '!*.@(sxm|smf|mml|odf)' oomath lomath _install_xspec '!*.odb' oobase lobase _install_xspec '!*.[rs]pm' rpm2cpio _install_xspec '!*.aux' bibtex _install_xspec '!*.po' poedit gtranslator kbabel lokalize _install_xspec '!*.@([Pp][Rr][Gg]|[Cc][Ll][Pp])' harbour gharbour hbpp _install_xspec '!*.[Hh][Rr][Bb]' hbrun _install_xspec '!*.ly' lilypond ly2dvi _install_xspec '!*.@(dif?(f)|?(d)patch)?(.@([gx]z|bz2|lzma))' cdiff _install_xspec '!@(*.@(ks|jks|jceks|p12|pfx|bks|ubr|gkr|cer|crt|cert|p7b|pkipath|pem|p10|csr|crl)|cacerts)' portecle _install_xspec '!*.@(mp[234c]|og[ag]|@(fl|a)ac|m4[abp]|spx|tta|w?(a)v|wma|aif?(f)|asf|ape)' kid3 kid3-qt unset -f _install_xspec # Minimal completion to use as fallback in _completion_loader. # TODO:API: rename per conventions _minimal() { local cur prev words cword comp_args _comp_initialize -- "$@" || return compopt -o bashdefault -o default } # Complete the empty string to allow completion of '>', '>>', and '<' on < 4.3 # https://lists.gnu.org/archive/html/bug-bash/2012-01/msg00045.html complete -F _minimal '' # TODO:API: rename per conventions __load_completion() { local cmd=$1 cmdname=${1##*/} dir compfile local -a paths [[ $cmdname ]] || return 1 local backslash= if [[ $cmd == \\* ]]; then cmd=${cmd:1} # If we already have a completion for the "real" command, use it $(complete -p "$cmd" 2>/dev/null || echo false) "\\$cmd" && return 0 backslash=\\ fi # Resolve absolute path to $cmd local ret pathcmd origcmd=$cmd if pathcmd=$(type -P "$cmd"); then _comp_abspath "$pathcmd" cmd=$ret fi local -a dirs=() # Lookup order: # 1) From BASH_COMPLETION_USER_DIR (e.g. ~/.local/share/bash-completion): # User installed completions. if [[ ${BASH_COMPLETION_USER_DIR-} ]]; then _comp_split -F : paths "$BASH_COMPLETION_USER_DIR" && dirs+=("${paths[@]/%//completions}") else dirs=("${XDG_DATA_HOME:-$HOME/.local/share}/bash-completion/completions") fi # 2) From the location of bash_completion: Completions relative to the main # script. This is primarily for run-in-place-from-git-clone setups, where # we want to prefer in-tree completions over ones possibly coming with a # system installed bash-completion. (Due to usual install layouts, this # often hits the correct completions in system installations, too.) if [[ $BASH_SOURCE == */* ]]; then dirs+=("${BASH_SOURCE%/*}/completions") else dirs+=(./completions) fi # 3) From bin directories extracted from the specified path to the command, # the real path to the command, and $PATH paths=() [[ $cmd == /* ]] && paths+=("${cmd%/*}") _comp_realcommand "$cmd" && paths+=("${ret%/*}") _comp_split -aF : paths "$PATH" for dir in "${paths[@]%/}"; do [[ $dir == ?*/@(bin|sbin) ]] && dirs+=("${dir%/*}/share/bash-completion/completions") done # 4) From XDG_DATA_DIRS or system dirs (e.g. /usr/share, /usr/local/share): # Completions in the system data dirs. _comp_split -F : paths "${XDG_DATA_DIRS:-/usr/local/share:/usr/share}" && dirs+=("${paths[@]/%//bash-completion/completions}") # Set up default $IFS in case loaded completions depend on it, # as well as for $compspec invocation below. local IFS=$' \t\n' # Look up and source shift local i prefix compspec for prefix in "" _; do # Regular from all dirs first, then fallbacks for i in ${!dirs[*]}; do dir=${dirs[i]} if [[ ! -d $dir ]]; then unset -v 'dirs[i]' continue fi for compfile in "$prefix$cmdname" "$prefix$cmdname.bash"; do compfile="$dir/$compfile" # Avoid trying to source dirs as long as we support bash < 4.3 # to avoid an fd leak; https://bugzilla.redhat.com/903540 if [[ -d $compfile ]]; then # Do not warn with . or .. (especially the former is common) [[ $compfile == */.?(.) ]] || echo "bash_completion: $compfile: is a directory" >&2 elif [[ -e $compfile ]] && . "$compfile" "$cmd" "$@"; then # At least $cmd is expected to have a completion set when # we return successfully; see if it already does if compspec=$(complete -p "$cmd" 2>/dev/null); then local -a extspecs=() # $cmd is the case in which we do backslash processing [[ $backslash ]] && extspecs+=("$backslash$cmd") # If invoked without path, that one should be set, too # ...but let's not overwrite an existing one, if any [[ $origcmd != */* ]] && ! complete -p "$origcmd" &>/dev/null && extspecs+=("$origcmd") ((${#extspecs[*]} != 0)) && $compspec "${extspecs[@]}" return 0 fi # If not, see if we got one for $cmdname if [[ $cmdname != "$cmd" ]] && compspec=$(complete -p "$cmdname" 2>/dev/null); then # Use that for $cmd too, if we have a full path to it [[ $cmd == /* ]] && $compspec "$cmd" return 0 fi # Nothing expected was set, continue lookup fi done done done # Look up simple "xspec" completions [[ -v _xspecs[$cmdname] ]] && complete -F _filedir_xspec "$cmdname" "$backslash$cmdname" && return 0 return 1 } # set up dynamic completion loading # TODO:API: rename per conventions _completion_loader() { # $1=_EmptycmD_ already for empty cmds in bash 4.3, set to it for earlier local cmd=${1:-_EmptycmD_} __load_completion "$cmd" && return 124 # Need to define *something*, otherwise there will be no completion at all. complete -F _minimal -- "$cmd" && return 124 } && complete -D -F _completion_loader # Function for loading and calling functions from dynamically loaded # completion files that may not have been sourced yet. # @param $1 completion file to load function from in case it is missing # @param $2 the xfunc name. When it does not start with `_', # `_comp_xfunc_${1//[^a-zA-Z0-9_]/_}_$2' is used for the actual name of the # shell function. # @param $3... if any, specifies the arguments that are passed to the xfunc. # @since 2.12 _comp_xfunc() { local xfunc_name=$2 [[ $xfunc_name == _* ]] || xfunc_name=_comp_xfunc_${1//[^a-zA-Z0-9_]/_}_$xfunc_name declare -F "$xfunc_name" &>/dev/null || __load_completion "$1" "$xfunc_name" "${@:3}" } # source compat completion directory definitions _comp__init_compat_dirs=() if [[ ${BASH_COMPLETION_COMPAT_DIR-} ]]; then _comp__init_compat_dirs+=("$BASH_COMPLETION_COMPAT_DIR") else _comp__init_compat_dirs+=(/etc/bash_completion.d) # Similarly as for the "completions" dir, look up from relative to # bash_completion, primarily for run-in-place-from-git-clone setups. # Notably we do it after the system location here, in order to # prefer in-tree variables and functions. if [[ $BASH_SOURCE == */* ]]; then _comp__init_compat_dir="${BASH_SOURCE%/*}/bash_completion.d" [[ ${_comp__init_compat_dirs[0]} == "$_comp__init_compat_dir" ]] || _comp__init_compat_dirs+=("$_comp__init_compat_dir") else _comp__init_compat_dirs+=(./bash_completion.d) fi fi for _comp__init_compat_dir in "${_comp__init_compat_dirs[@]}"; do [[ -d $_comp__init_compat_dir && -r $_comp__init_compat_dir && -x $_comp__init_compat_dir ]] || continue for _comp__init_file in "$_comp__init_compat_dir"/*; do [[ ${_comp__init_file##*/} != @($_comp_backup_glob|Makefile*|${BASH_COMPLETION_COMPAT_IGNORE-}) && -f $_comp__init_file && -r $_comp__init_file ]] && . "$_comp__init_file" done done unset -v _comp__init_compat_dirs _comp__init_compat_dir _comp__init_file # source user completion file # # Remark: We explicitly check that $user_completion is not '/dev/null' since # /dev/null may be a regular file in broken systems and can contain arbitrary # garbages of suppressed command outputs. _comp__init_user_file=${BASH_COMPLETION_USER_FILE:-~/.bash_completion} [[ $_comp__init_user_file != "${BASH_SOURCE[0]}" && $_comp__init_user_file != /dev/null && -r $_comp__init_user_file && -f $_comp__init_user_file ]] && . "$_comp__init_user_file" unset -v _comp__init_user_file unset -f have unset -v have set $_comp__init_original_set_v unset -v _comp__init_original_set_v # ex: filetype=sh