| Current Path : /proc/thread-self/root/usr/share/bash-completion/completions/ |
Linux ift1.ift-informatik.de 5.4.0-216-generic #236-Ubuntu SMP Fri Apr 11 19:53:21 UTC 2025 x86_64 |
| Current File : //proc/thread-self/root/usr/share/bash-completion/completions/winetricks |
# winetricks(1) completion -*- shell-script -*-
#
# Copyright:
# Copyright (C) 2018 Rob Walker <bob.mt.wya!gmail.com>
#
# License:
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this program. If not, see
# <https://www.gnu.org/licenses/>.
##### Define Global constants / variables #####
WINETRICKS_PATH="$(command -v winetricks)"
# https://pkgstore.datahub.io/core/country-list/data_csv/data/d7c9d7cfb42cb69f4422dec222dbbaa8/data_csv.csv
COUNTRY_CODES="AF AX AL DZ AS AD AO AI AQ AG AR AM AW AU AT AZ BS BH BD BB BY BE BZ BJ BM BT BA BW BV BR IO BN BG BF BI \
KH CM CA CV KY CF TD CL CN CX CC CO KM CG CK CR CI HR CU CW CY CZ DK DJ DM DO EC EG SV GQ ER EE ET FK FO FJ FI FR \
GF PF TF GA GM GE DE GH GI GR GL GD GP GU GT GG GN GW GY HT HM VA HN HK HU IS IN ID IQ IE IM IL IT JM JP JE JO KZ KE KI KW KG \
LA LV LB LS LR LY LI LT LU MO MG MW MY MV ML MT MH MQ MR MU YT MX MC MN ME MS MA MZ MM NA NR NP NL NC NZ NI NE NG NU NF MP NO \
OM PK PW PA PG PY PE PH PN PL PT PR QA RE RO RU RW BL KN LC MF PM VC WS SM ST SA SN RS SC SL SG SX SK SI SB SO ZA GS SS ES LK \
SD SR SJ SZ SE CH SY TJ TH TL TG TK TO TT TN TR TM TC TV UG UA AE GB US UM UY UZ VU VN WF EH YE ZM ZW"
INVERTIBLE_OPTS="isolate opt"
TERMINATING_OPTS="help update version"
TERMINATING_LIST_COMMAND="list"
VERB_WINVER="winver="
COMMAND_WINEPREFIX="prefix="
##### Define Global regular expression constants #####
BLANK_LINE_REGEX="^[[:blank:]]*$"
VERB_REGEX="[[:alnum:]][-_[:alnum:]]*(|=[[:alnum:]][[:alnum:]]*)"
METADATA_REGEX="^w_metadata[[:blank:]][[:blank:]]*[^\\\\]*[\\\\]\$"
SHORT_OPTION_REGEX="[-]([[:alpha:]]|[[:alpha:]][[:alpha:]])"
LONG_OPTION_REGEX="[-][-][[:lower:]][-_=*[:lower:]]*"
FUNCTION_HANDLE_OPTIONS_REGEX="^winetricks_handle_option[(][)]$"
FUNCTION_EXECUTE_COMMAND_REGEX="^execute_command[(][)]$"
COMMAND_LINE_REGEX="^[[:blank:]][[:blank:]]*${VERB_REGEX}(|[=][*])[)]"
REGULAR_VERB_LINE_REGEX="[[:blank:]](w_call|w_do_call)[[:blank:]]"
DEPRECIATED_LINE_REGEX="[[:blank:]]w_warn[[:blank:]]"
##### Find and wrap a functioning awk variant #####
AWK="$(command -v awk 2>/dev/null || command -v mawk 2>/dev/null)"
if [[ -z "${AWK}" ]] || "${AWK}" -W version 2>/dev/null | grep -q -E '^mawk 1\.3\.3'; then
AWK="$(command -v gawk 2>/dev/null || command -v nawk 2>/dev/null)"
[[ -z "${AWK}" ]] && AWK="$(command -v busybox)" && AWK="${AWK}${AWK:+ awk}"
fi
##### Define shared awk functions #####
# _parse_and_dump_verbs()
#
# 1< array_verbs
# > stdout
#
# awk function to parse an array of verbs or commands.
# Assignment commands/ verbs are grouped in an array and parsed separately
# from regular verbs, i.e. verbs of the form:
#
# videomem=512|1024|2048|default
#
# Dump output in the form:
#
# >
# "verb(1) [... verb(M)] verb(M+1)=...|... [... verb(N)=...|...]"
#
awk_function_parse_and_dump_verbs=\
'function _parse_and_dump_verbs(array_verbs,
i, j, test_verb_prefix, verb_prefix, verb_suffix)
{
for (i=1 ; i<=array_verbs[0] ; ++i) {
# Dump non-assignment verbs first...
# Deleting these array entries as we go.
if (array_verbs[i] !~ "=") {
printf("%s ", array_verbs[i])
delete array_verbs[i]
continue
}
# Process assignment verbs, by appending the suffix value to
# an existing array entry (with the same prefix), and deleting
# the current array entry...
# Or if no existing, matching array entry exists, then simply leave
# the existing array entry in place and take no further action.
verb_prefix=verb_suffix=array_verbs[i]
sub("=.*$", "", verb_prefix)
sub("^.*=", "", verb_suffix)
for (j=1; j<i ; ++j) {
if (! (j in array_verbs))
continue
test_verb_prefix=array_verbs[j]
sub("=.*$", "", test_verb_prefix)
if (verb_prefix == test_verb_prefix) {
array_verbs[j]=(array_verbs[j] "|" verb_suffix)
delete array_verbs[i]
break
}
}
}
# Secondly dump all assignment verbs...
for (i=1 ; i<=array_verbs[0] ; ++i) {
if (i in array_verbs)
printf("%s ", array_verbs[i])
}
printf("\n")
}'
##### Define awk-based BASH functions to scrape winetricks script #####
# _scrape_options()
# (< WINETRICKS_PATH)
# > stdout
#
# Dumps winetricks options, which can then be stored for later processing.
# Parse the raw winetricks script, to increase processing and avoid any
# calls to wine.
#
_scrape_options()
{
# shellcheck disable=SC2016
${AWK} -vblank_line_regex="${BLANK_LINE_REGEX}" \
-vfunction_handle_options_regex="${FUNCTION_HANDLE_OPTIONS_REGEX}" \
-vshort_long_option_regex="^[[:blank:]][[:blank:]]*${SHORT_OPTION_REGEX}[|]${LONG_OPTION_REGEX}[)]" \
-vlong_option_regex="^[[:blank:]][[:blank:]]*${LONG_OPTION_REGEX}[)]" \
'{
in_function=in_function || ($0 ~ function_handle_options_regex)
is_blank=($0 ~ blank_line_regex)
is_comment=($0 ~ "^[[:blank:]]*#")
if (!in_function || is_blank || is_comment)
next
if (($0 ~ long_option_regex) || ($0 ~ short_long_option_regex)) {
gsub("(^[[:blank:]]*|[)][^)]*$)" , "")
printf("%s\n", $0)
}
in_function=($0 !~ "^[}]$")
if (!in_function)
exit 0
}' "${WINETRICKS_PATH}" 2>/dev/null
}
# _scrape_commands()
# (< VERB_REGEX, WINETRICKS_RAW_COMMANDS)
# > stdout
#
# Parse list of commands (excluding options) directly from the
# winetricks script. Dump all regular commands, followed by
# a list of assignment commands (i.e. prefix=*)
#
# >
# "command(1) [... command(M)] command(M+1)=...|... [... command(N)=...|...]"
#
_scrape_commands()
{
# shellcheck disable=SC2016
${AWK} -vfunction_execute_command_regex="${FUNCTION_EXECUTE_COMMAND_REGEX}" \
-vcommand_line_regex="${COMMAND_LINE_REGEX}" \
-vregular_verb_line_regex="${REGULAR_VERB_LINE_REGEX}" \
-vdepreciated_line_regex="${DEPRECIATED_LINE_REGEX}" \
"${awk_function_parse_and_dump_verbs}"'
{
in_function=in_function || ($0 ~ function_execute_command_regex)
if (!in_function)
next
in_function=($0 !~ "^[}]$")
if (!in_function)
exit 0
is_command=($0 ~ command_line_regex)
is_warning=($0 ~ depreciated_line_regex)
is_normal_verb=($0 ~ regular_verb_line_regex)
if (!is_command || is_warning || is_normal_verb)
next
gsub("(^[[:blank:]][[:blank:]]*|[)].*)", "")
if ($0 == "*=*")
next
array_commands[++array_commands[0]]=$0
}
END{
_parse_and_dump_verbs(array_commands)
}' "${WINETRICKS_PATH}" 2>/dev/null
}
# _scrape_all_categories_and_verbs()
# (< METADATA_REGEX, WINETRICKS_RAW_METADATA)
# > stdout
#
# Parse winetricks list-all to get sets of all categories and
# the verbs contained within that category.
# NB the BASH completion script copes with jumbled up category
# blocks in the main winetricks script (i.e. blocks of one category
# that are interspersed with other categories).
#
# >
# "category(1)
# verb(1) [... verb(N)]
# category(2)
# verb(1) [... verb(N)]
# ..."
#
_scrape_all_categories_and_verbs()
{
# shellcheck disable=SC2016
${AWK} -vmetadata_regex="${METADATA_REGEX//\\/\\\\}" \
"${awk_function_parse_and_dump_verbs}"'
{
if (($0 !~ metadata_regex) || (NF < 3))
next
new_verb=$2
new_category=$3
if (category != new_category) {
if (array_verbs[0]) {
printf("%s\n", category)
_parse_and_dump_verbs(array_verbs)
}
category=new_category
delete array_verbs
}
array_verbs[++array_verbs[0]]=new_verb
}
END{
if (array_verbs[0]) {
printf("%s\n", category)
_parse_and_dump_verbs(array_verbs)
}
}' "${WINETRICKS_PATH}" 2>/dev/null
}
##### Define general BASH helper functions #####
# _list_remove_items()
# 1-N< search-term1 [... search-termN]
# < stdin (list)
# > stdout (list)
#
# Takes a list of items and parses items to stdout.
# Removing any items matching the supplied 'search-term'(s).
#
_list_remove_items()
{
(($#>=1)) || return 1
local found i item search_term
while read -r -d ' ' item || [[ -n "${item}" ]]; do
[[ -z "${item}" ]] && continue
found=0
for ((i=1 ; i<=$# ; ++i)); do
# shellcheck disable=SC2124
search_term="${@:i:1}"
[[ -z "${search_term}" ]] && continue
if [[ "${item}" = "${search_term}" ]]; then
found=1
break
fi
done
if ((!found)); then
printf "%s " "${item}"
fi
done
}
# _list_remove_regex_item()
# 1< regular-expression
# < stdin (list)
# > stdout (list)
#
# Takes a list of items and parses items to stdout.
# Removing any items matching 'regular-expression'.
#
_list_remove_regex_item()
{
(($#==1)) || return 1
local regex_search_term="${1}" item
while read -r -d ' ' item || [[ -n "${item}" ]]; do
if [[ ! ( -z "${item}" || "${item}" =~ ${regex_search_term} ) ]]; then
printf "%s " "${item}"
fi
done
}
# _list_match_item()
# 1 < search-text
# [2-N]< items to match against (list)
# > match?
#
# Match list of items on stdin with 'search-text',
#
# Return 0=match / 1=no match
#
_list_match_item()
{
(($#>=1)) || return 1
[[ -z "${1}" ]] && return 1
local search_text="${1}"
shift 1
while [[ ! -z "${1}" ]]; do
[[ "${search_text}" = "${1}" ]] && return 0
shift 1
done
return 1
}
# _get_duplicate_options()
# 1-N< Winetricks options (multi-line list)
# (< INVERTIBLE_OPTS)
# > stdout
#
# For each long option determine if it has a matching short option or if
# the long option is invertible (i.e. "--no-xxxx" vs "--xxxx").
#
# >
# "[short-option(1)|inverted-long-option(1)] long-option(1)
# ...
# [short-option(N)|inverted-long-option(N)] long-option(N)"
#
_get_duplicate_options()
{
(($#>=1)) || return 1
local first_item item option options invertible_option \
invertible_options=" ${INVERTIBLE_OPTS} " \
removed_options=""
while IFS='' read -r options || [[ -n "${options}" ]]; do
options=" ${options//|/ } "
for option in ${removed_options}; do
options="${options// ${option} / }"
done
[[ "${options}" =~ ${BLANK_LINE_REGEX} ]] && continue
unset -v negated_duplicate
# shellcheck disable=SC2016
first_item="$( echo "${options}" | ${AWK} '{print $1}' 2>/dev/null )"
for invertible_option in ${invertible_options}; do
case "${invertible_option}" in
isolate)
negated_duplicate="${first_item/#--no-${invertible_option}/--${invertible_option}}"
[[ "${negated_duplicate}" = "${first_item}" ]] || break
negated_duplicate="${first_item/#--${invertible_option}/--no-${invertible_option}}"
[[ "${negated_duplicate}" = "${first_item}" ]] || break
;;
opt)
negated_duplicate="${first_item/%${invertible_option}out/${invertible_option}in}"
[[ "${negated_duplicate}" = "${first_item}" ]] || break
negated_duplicate="${first_item/%${invertible_option}in/${invertible_option}out}"
[[ "${negated_duplicate}" = "${first_item}" ]] || break
;;
esac
done
if [[ ! -z "${negated_duplicate}" && ( ! "${negated_duplicate}" = "${first_item}" ) ]]; then
options="${options} ${negated_duplicate}"
removed_options="${removed_options} ${first_item} ${negated_duplicate}"
invertible_options="${invertible_options// ${invertible_option} / }"
fi
[[ "${options}" =~ ${BLANK_LINE_REGEX} ]] && continue
printf " %s \\n" "${options}"
done <<<"${@}"
}
# _process_options()
# (< COUNTRY_CODES)
# 1< Winetricks options (multi-line list)
# > stdout
#
# Process winetricks options. Format these into a list of short options
# followed by a list of long options. Expands country codes assignment
# variable arguments.
#
# >
# "short-option(1) [... short-option(N)] long-option(1) [... long-option(N)]"
#
_process_options()
{
(($#==1)) || return 1
[[ -z "${1}" ]] && return 1
local line long_options option short_options
while IFS='' read -r line || [[ -n "${line}" ]]; do
while read -r -d '|' option || [[ -n "${option}" ]]; do
case "${option}" in
--*)
if [[ ! "${option}" = "${option/country/}" ]]; then
option="${option%=*}=${COUNTRY_CODES// /|}"
fi
long_options="${long_options} ${option}"
;;
-*)
short_options="${short_options} ${option}"
;;
esac
done <<<"${line}"
done <<<"${1}"
printf "%s\\n" "${short_options}${long_options}"
}
# _get_categories()
# ( < CATEGORIES_VERBS_LIST )
# > stdout
#
# Get a list of categories.
#
# >
# "category(1) [... category(N)]"
#
_get_categories()
{
local categories="" is_category=1 line
while IFS='' read -r line || [[ -n "${line}" ]]; do
if ((is_category)) && [[ ! "${categories}" =~ ${line} ]]; then
categories="${categories} ${line}"
fi
is_category=$((!is_category))
done <<<"${CATEGORIES_VERBS_LIST}"
[[ -z "${categories}" ]] || printf "%s " "${categories}"
}
# _get_category_verbs()
# ( < CATEGORIES_VERBS_LIST )
# [1< category]
# > stdout
#
# For the specified category, print a line of all verbs in that category.
# If no category is specified then print a line of all verbs, for all categories.
#
# >
# "verb(1) [... verb(N)]"
#
_get_category_verbs()
{
local category="${1:-}" is_category=1 line matched
while IFS='' read -r line || [[ -n "${line}" ]]; do
if ((is_category)); then
matched=0
if [[ -z "${category}" || ( "${category}" = "${line}" ) ]]; then
matched=1
fi
elif ((matched)); then
printf " %s " "${line}"
fi
is_category=$((!is_category))
done <<<"${CATEGORIES_VERBS_LIST}"
}
# _assignment_strip_values()
# 1< new line: 1= TRUE , 0=FALSE (for all items)
# < stdin
# > stdout
#
# Takes a list of verbs or options and processes assignments,
# which use the "=" assignment operator.
# Remove the post-assignment regex values.
#
# <
# "... videomem=default|512|1024|2048 ..."
# >
# "... videomem= ..."
#
_assignment_strip_values()
{
(($#==1)) || return 1
# shellcheck disable=SC2016
${AWK} -vnew_line="${1}" \
'{
gsub("=[^[:blank:]]*","=")
for (i=1 ; i<=NF ; ++i)
printf("%s%s", $i, new_line ? "\n" : " ")
}' 2>/dev/null
}
# _assignment_get_values()
# 1< target
# < stdin
# > stdout
#
# Takes a list of verbs or options and processes a single specified target assignment.
# Remove the prefix target name.
# Convert the postfix regex values to a simple WS separated list.
#
# 1< target="videomem"
# <
# "... videomem=default|512|1024|2048 ..."
# >
# "default 512 1024 2048"
#
_assignment_get_values()
{
(($#==1)) || return 1
# shellcheck disable=SC2016
${AWK} -vtarget_prefix="${1}" \
'{
for (i=1 ; i<=NF ; ++i) {
verb_prefix=verb_suffix=verb=$i
if (verb !~ "=")
continue
sub("=.*$", "", verb_prefix)
sub("^.*=", "", verb_suffix)
if (verb_prefix != target_prefix)
continue
gsub("[|]", " ", verb_suffix)
printf("%s\n", verb_suffix)
}
}'
}
# _get_alternate_opt()
# (< DUP_OPTS_LIST)
# 1< search-option
# > stdout (alternate-option)
#
# Given the specified 'search-option' find the alternate
# (or inverse) operation, if one exists.
# Print this to stdout.
#
# < option="--no-isolate"
# >
# "--isolate"
#
_get_alternate_opt()
{
(($#==1)) || return 1
local search_opt="${1}" alt_opt dummy line opt
while IFS='' read -r line || [[ -n "${line}" ]]; do
# shellcheck disable=SC2034
read -r opt alt_opt dummy<<<"${line}" || continue
[[ -z "${opt}" || -z "${alt_opt}" ]] && continue
if [[ "${opt}" = "${search_opt}" ]]; then
printf "%s\\n" "${alt_opt}"
elif [[ "${alt_opt}" = "${search_opt}" ]]; then
printf "%s\\n" "${opt}"
fi
done <<<"${DUP_OPTS_LIST}"
}
# _get_opt_regex_matches()
# (< OPTS, DUP_OPTS_LIST)
# 1-N < regex [... regex]
# > stdout
#
# Takes a list of regular expressions.
# Match all available options, including duplicate / inverse options,
# against each regular expression.
# Dump all matching options to stdout.
#
# < "help" "update"
# >
# " -h --help --self-update --update-rollback "
#
_get_opt_regex_matches()
{
(($#>=1)) || return 1
local i line opts_list search_regex
# shellcheck disable=SC2207
opts_list="$( echo "${OPTS}" | _assignment_strip_values 1 )"
opts_list="${opts_list}
${DUP_OPTS_LIST}"
while IFS='' read -r line || [[ -n "${line}" ]]; do
for ((i=1 ; i<=$# ; ++i)); do
# shellcheck disable=SC2124
search_regex="${@:i:1}"
if [[ "${line}" =~ ${search_regex} ]]; then
printf "%s " "${line}"
fi
done
done <<<"${opts_list}"
printf " \\n"
}
# _cull_duplicate_options()
# 1 < option to remove
# 2-N < option list to process
# > stdout
#
# Takes an option to remove, from an list of options.
# Note: also removes duplicate or inverse option(s) (if any exist).
#
_cull_duplicate_options()
{
(($#>=1)) || return 1
local opt="${1}" alt_other_alt_opt alt_opt other_alt_opt
shift 1
# Ignore non-option verbs, not starting with '-'
if [[ "${opt#-}" == "${opt}" ]]; then
echo "${@}"
return
fi
alt_opt="$( _get_alternate_opt "${opt}" )"
# Try to remove additional duplicate operations of the form:
# --really-verbose = --verbose / -vv = -v
# shellcheck disable=SC1001
if [[ "${opt}" =~ ^\-[[:alpha:]][[:alpha:]]$ ]]; then
other_alt_opt="${opt%?}"
else
other_alt_opt="${opt/really-/}"
fi
alt_other_alt_opt="$( _get_alternate_opt "${other_alt_opt}" )"
echo "${@}" | _list_remove_items "${opt}" "${alt_opt}" "${other_alt_opt}" "${alt_other_alt_opt}"
}
##### Define main BASH completion function #####
_winetricks()
{
local cur i opt test_cur test_prev reply temp_opts temp_verbs terminating_opts
cur="${COMP_WORDS[COMP_CWORD]}"
prev="${COMP_WORDS[COMP_CWORD-1]}"
COMPREPLY=( )
# shellcheck disable=SC2086
if _list_match_item "${prev}" ${CATEGORIES_LIST}; then
# shellcheck disable=SC2207
COMPREPLY=( $(compgen -W "${TERMINATING_LIST_COMMAND}" -- "${cur}") )
return 0
fi
# Handle the special case when a Wineprefix path needs to be specified.
for ((i=(COMP_CWORD-1) ; i>=(COMP_CWORD-2) ; --i)); do
((i < 0)) && continue
if [[ "${COMP_WORDS[i]}=" = "${COMMAND_WINEPREFIX}" ]]; then
_filedir -d
return 0
fi
done
# Disable tab expansion when a terminating option or command has been typed...
# shellcheck disable=SC2086
terminating_opts="$(_get_opt_regex_matches ${TERMINATING_OPTS})"
# shellcheck disable=SC2086
if _list_match_item "${prev}" ${terminating_opts} ${COMMANDS} ${TERMINATING_LIST_COMMAND}; then
# shellcheck disable=SC2207
COMPREPLY=( $(compgen -W "" -- "") )
return 0
fi
# When an option or verb is specified then disable from being repeated via tab expansion.
# For options also handle any duplicate and inverse/negated variants.
# NB we don't touch the global OPTS / ALL_VERBS variables. If the user starts a new line
# or deletes a term, then we must be able to revert back to the default verbs / options.
temp_opts="${OPTS}"
temp_verbs="${ALL_VERBS}"
for ((i=1 ; i<=(COMP_CWORD-1) ; ++i)); do
# shellcheck disable=SC2086
temp_opts="$( _cull_duplicate_options "${COMP_WORDS[i]}" ${temp_opts} )"
temp_verbs="${temp_verbs// ${COMP_WORDS[i]} / }"
done
# Parse assignment verbs and options, of the form 'videomem='
for ((i=(COMP_CWORD-1) ; i<=COMP_CWORD ; ++i)); do
((i<1)) && continue
test_cur="${COMP_WORDS[i]}"
test_prev="${COMP_WORDS[i-1]}"
if [[ ( "${test_cur}" != "=" ) || ( "${test_prev}=" == "${VERB_WINVER}" ) ]]; then
continue
fi
case "${test_prev}" in
-*)
reply="${temp_opts}"
;;
*)
reply="${COMMANDS} ${temp_verbs}"
;;
esac
# If the reply contains any assignment operations matching the previous term
# then strip the first part of the verb (e.g. 'videomem=') from the reply term.
# Replace this with all the possible assignment values, e.g.: '1024 2048 512 default'.
reply="$( echo "${reply}" | _assignment_get_values "${test_prev}" )"
# shellcheck disable=SC2207
COMPREPLY=( $(compgen -W "${reply}" -- "${cur%=}") )
# Suppress starting a new argument when have an assignment option or command...
if [[ "${COMPREPLY[0]%=}=" = "${COMPREPLY[0]}" ]]; then
compopt -o nospace
fi
return 0
done
# Parse general (non-assignment) verbs and options.
# Only display all available short options when the end user tab completes a hyphen character.
# Only display all available long options when the end user tab completes a pair of hyphen characters.
# Reduces end-user overload!
case "${cur}" in
--*)
reply="$( echo "${temp_opts}" | _assignment_strip_values 0 )"
;;
-*)
reply="$( echo "${temp_opts}" | _list_remove_regex_item "${LONG_OPTION_REGEX}" )"
;;
*)
reply="$( echo "${COMMANDS}" "${temp_verbs}" | _assignment_strip_values 0 )"
;;
esac
# shellcheck disable=SC2207
COMPREPLY=( $(compgen -W "${reply}" -- "${cur}") )
if [[ "${COMPREPLY[0]}" = "${VERB_WINVER}" ]]; then
return 0
fi
# Suppress starting a new argument when have an assignment option or command...
if [[ "${COMPREPLY[0]%=}=" = "${COMPREPLY[0]}" ]]; then
compopt -o nospace
fi
return 0
}
# We've found no winetricks script in the end-user's PATH, so give up now ...
[[ -z "${WINETRICKS_PATH}" || ! -f "${WINETRICKS_PATH}" ]] && return 1
# We've tried real hard, but the end-user doesn't appear to have a working awk implementation...
[[ -z "${AWK}" ]] && return 1
# Setup various Global variables (when this script is initially source'd)...
CATEGORIES_VERBS_LIST="$(_scrape_all_categories_and_verbs)"
RAW_OPTIONS="$(_scrape_options)"
COMMANDS="$(_scrape_commands)"
CATEGORIES_LIST="$(_get_categories)"
COMMANDS="${COMMANDS} ${CATEGORIES_LIST}"
OPTS="$(_process_options "${RAW_OPTIONS}")"
DUP_OPTS_LIST="$(_get_duplicate_options "${RAW_OPTIONS}")"
# Convert a multi-line list of all categories and verbs into a single line of verbs...
ALL_VERBS="$(_get_category_verbs "")"
complete -F _winetricks winetricks