diff options
Diffstat (limited to 'Completion/Base/_long_options')
| -rw-r--r-- | Completion/Base/_long_options | 309 |
1 files changed, 0 insertions, 309 deletions
diff --git a/Completion/Base/_long_options b/Completion/Base/_long_options deleted file mode 100644 index a5d92632c..000000000 --- a/Completion/Base/_long_options +++ /dev/null @@ -1,309 +0,0 @@ -#autoload - -# This function tries to automatically complete long option names. For -# this it invokes the command from the line with the `--help' option -# and then parses the output to find possible option names. For -# options that get an argument after a `=', the function also tries to -# automatically find out what should be complete as the argument. -# The possible completions for option-arguments can be described with -# the arguments to this function. This is done by giving pairs of -# patterns and actions as consecutive arguments. The actions specify -# what should be done to complete arguemts of those options that match -# the pattern. The action may be a list of words in brackets or in -# parentheses, separated by spaces. A list in brackets denotes -# possible values for an optional argument, a list in parentheses -# gives words to complete for mandatory arguments. If the action does -# not start with a bracket or parentheses, it should be the name of a -# command (probably with arguments) that should be invoked to complete -# after the equal sign. E.g.: -# -# _long_options '*\*' '(yes no)' \ -# '*=FILE*' '_files' \ -# '*=DIR*' '_files -/' -# -# This makes `yes' and `no' be completed as the argument of options -# whose description ends in a star, file names for options that -# contain the substring `=FILE' in the description, and paths for -# options whose description contains `=DIR'. Note the last two -# patterns are not needed since this function always completes files -# for option descriptions containing `=FILE' and paths for option -# descriptions that contain `=DIR' or `=PATH'. These builtin patterns -# can be overridden by patterns given as arguments, though. -# -# This function also accepts the `-X', `-J', and `-V' options which -# are given to `compadd'. Finally, it accepts the option `-t'. If this -# is given, completion is only done on words starting with two hyphens. - -local opt expl group test i name action ret=1 tmp suffix - -setopt extendedglob - -# Get the options. - -group=() -expl=() -if [[ $1 = -*~--* ]]; then - while getopts "J:V:X:t" opt; do - case "$opt" in - [JV]) group=("-$opt" "$OPTARG");; - X) expl=(-X "$OPTARG");; - t) test=yes;; - esac - done - shift OPTIND-1 -fi - -# Test if we are completing after `--' if we were asked to do so. - -[[ -n "$test" && "$PREFIX" != --* ]] && return 1 - -# We cache the information about options and the command name, see if -# we can use the cache. - -if [[ "$words[1]" = (.|..)/* ]]; then - tmp="$PWD/$words[1]" -else - tmp="$words[1]" -fi - -if [[ "$tmp" != $_lo_cache_cmd ]]; then - - # No, store the new command name and clear the old parameters. - - _lo_cache_cmd="$tmp" - (( $+_lo_cache_actions )) && unset "$_lo_cache_names[@]" _lo_cache_actions _lo_cache_names - - local opts pattern anum=1 tmpo str - - # Now get the long option names by calling the command with `--help'. - # The parameter expansion trickery first gets the lines as separate - # array elements. Then we select all lines whose first non-blank - # character is a hyphen. Since some commands document more than one - # option per line, separated by commas, we convert commas int - # newlines and then split the result again at newlines after joining - # the old array elements with newlines between them. Then we select - # those elements that start with two hyphens, remove anything up to - # those hyphens and anything from the space or comma after the - # option up to the end. Finally all elements with option strings - # that contain uppercase letters are removed. - - opts=("--${(@)^${(@)${(@)${(@M)${(@ps:\n:j:\n:)${(@)${(@M)${(@f)$("$words[1]" --help)}:#[ ]#-*}//,/ -}}:#[ ]#--*}#*--}%%[, ]*}:#(*-[A-Z]*|)}") - - # The interpretation of the options is completely table driven. We - # use the positional parameters we were given and a few standard - # ones. Then we loop through this table. - - set -- "$@" '*=FILE*' '_files' '*=(DIR|PATH)*' '_files -/' '*' '' - - while [[ $# -gt 1 ]]; do - - # First, we get the pattern and the action to use and take them - # from the positional parameters. - - pattern="$1" - action="$2" - shift 2 - - # We get all options matching the pattern and take them from the - # list we have built. If no option matches the pattern, we - # continue with the next. - - tmp=("${(@M)opts:##$~pattern}") - opts=("${(@)opts:##$~pattern}") - - (( $#tmp )) || continue - - # Now we collect the options for the pattern in an array. We also - # check if the options take an argument after a `=', and if this - # argument is optional. The name of the array built contains - # `_arg_' for mandatory arguments, `_optarg_' for optional - # arguments, and `_simple_' for options that don't get an - # argument. In `_lo_cache_names' we save the names of these - # arrays and in `_lo_cache_actions' the associated actions. - - # If the action is a list of words in brackets, this denotes - # options that get an optional argument. If the action is a list - # of words in parentheses, the option has to get an argument. - # In both cases we just build the array name to use. - - if [[ "$action[1]" = '[' ]]; then - name="_lo_cache_optarg_$anum" - elif [[ "$action[1]" = '(' ]]; then - name="_lo_cache_arg_$anum" - else - - # If there are option strings with a `[=', we take make these - # get an optional argument... - - tmpo=("${(@M)tmp:#*\[\=*}") - if (( $#tmpo )); then - - # ...by removing them from the option list and storing them in - # an array. - - tmp=("${(@)tmp:#*\[\=*}") - tmpo=("${(@)${(@)tmpo%%\=*}//[^a-z0-9-]}") - _lo_cache_names[anum]="_lo_cache_optarg_$anum" - _lo_cache_actions[anum]="$action" - eval "_lo_cache_optarg_${anum}=(\"\$tmpo[@]\")" - (( anum++ )) - fi - - # Now we do the same for option strings containing `=', these - # are options getting an argument. - - tmpo=("${(@M)tmp:#*\=*}") - if (( $#tmpo )); then - tmp=("${(@)tmp:#*\=*}") - tmpo=("${(@)${(@)tmpo%%\=*}//[^a-z0-9-]}") - _lo_cache_names[anum]="_lo_cache_arg_$anum" - _lo_cache_actions[anum]="$action" - eval "_lo_cache_arg_${anum}=(\"\$tmpo[@]\")" - (( anum++ )) - fi - - # The name for the options without arguments, if any. - - name="_lo_cache_simple_$anum" - fi - # Now filter out any option strings we don't like and stuff them - # in an array, if there are still some. - - tmp=("${(@)${(@)tmp%%\=*}//[^a-z0-9-]}") - if (( $#tmp )); then - _lo_cache_names[anum]="$name" - _lo_cache_actions[anum]="$action" - eval "${name}=(\"\$tmp[@]\")" - (( anum++ )) - fi - done -fi - -# We get the string from the line and and see if it already contains a -# equal sign. - -str="$PREFIX$SUFFIX" - -if [[ "$str" = *\=* ]]; then - - # It contains a `=', now we ignore anything up to it, but first save - # the old contents of the special parameters we change. - - local oipre opre osuf pre parto parta pat patflags anum=1 - - oipre="$IPREFIX" - opre="$PREFIX" - osuf="$SUFFIX" - - pre="${str%%\=*}" - IPREFIX="${IPREFIX}${pre}=" - PREFIX="${str#*\=}" - SUFFIX="" - - # We will check if the arrays contain an option matching what's on - # the line. To do this good, we build a pattern. - - [[ -n "$_comp_correct" && $#pre -le _comp_correct ]] && return 1 - - pat="${pre}*" - patflags='' - _match_pattern _long_options pat patflags - [[ -n "$_comp_correct" ]] && patflags="$patflags(#a$_comp_correct)" - - # Then we walk through the array names. For each array we test if it - # contains the option string. If so, we `invoke' the action stored - # with the name. If the action is a list of words, we just add them, - # otherwise we invoke the command or function named. - - for name in "$_lo_cache_names[@]"; do - action="$_lo_cache_actions[anum]" - if (( ${(@)${(@P)name}[(I)$pre]} )); then - if [[ "$action[1]" = (\[|\() ]]; then - compadd - ${=action[2,-2]} - elif (( $#action )); then - $=action - fi - - # We found the option string, return. - - return - fi - - # The array did not contain the full option string, see if it - # contains a string matching the string from the line. - # If there is one, we store the option string in `parto' and the - # element from `_lo_actions' in `parta'. If we find more than one - # such option or if we already had one, we set `parto' to `-'. - - tmp=("${(@M)${(@P)name}:#${~pat}}") - if [[ $#tmp -eq 1 ]]; then - if [[ -z "$parto" ]]; then - parto="$tmp[1]" - parta="$action" - else - parto=- - fi - elif (( $#tmp )); then - parto=- - fi - (( anum++ )) - done - - # If we found only one matching option, we accept it and immediatly - # try to complete the string after the `='. - - if [[ -n "$parto" && "$parto" != - ]]; then - IPREFIX="${parto}=" - - if (( $#parta )); then - if [[ "$parta[1]" = (\[|\() ]]; then - compadd - ${=parta[2,-2]} - else - $=parta - fi - else - compadd -S '' - "$PREFIX" - fi - return - fi - - # The option string was not found, restore the special parameters. - - IPREFIX="$oipre" - PREFIX="$opre" - SUFFIX="$osuf" -fi - -# The string on the line did not contain a `=', or we couldn't -# complete the option string since there were more than one matching -# what's on the line. So we just ad the option string as possible -# matches, giving the string from the `=' on as a suffix. - -if [[ "$str" = *\=* ]]; then - str="=${str#*\=}" - PREFIX="${PREFIX%%\=*}" - suffix=() -else - str="" - suffix=('-S=') -fi - -anum=1 -for name in "$_lo_cache_names[@]"; do - action="$_lo_cache_actions[anum]" - - if [[ "$name" = *_optarg_* ]]; then - compadd -M 'r:|-=* r:|=*' -Qq "$suffix[@]" -s "$str" - \ - "${(@P)name}" && ret=0 - elif [[ "$name" = *_arg_* ]]; then - compadd -M 'r:|-=* r:|=*' -Q "$suffix[@]" -s "$str" - \ - "${(@P)name}" && ret=0 - elif [[ -z "$str" ]]; then - compadd -M 'r:|-=* r:|=*' -Q - \ - "${(@P)name}" && ret=0 - fi - (( anum++ )) -done - -return ret |