diff options
| -rw-r--r-- | Completion/Core/_multi_parts | 254 |
1 files changed, 0 insertions, 254 deletions
diff --git a/Completion/Core/_multi_parts b/Completion/Core/_multi_parts deleted file mode 100644 index 6f6ef12f2..000000000 --- a/Completion/Core/_multi_parts +++ /dev/null @@ -1,254 +0,0 @@ -#autoload - -# This gets two arguments, a separator (which should be only one -# character) and an array. As usual, the array may be given by it's -# name or literal as in `(foo bar baz)' (words separated by spaces in -# parentheses). -# The parts of words from the array that are separated by the -# separator character are then completed independently. - -local sep pref npref i tmp2 group expl menu pre suf opre osuf cpre -local opts sopts matcher imm -typeset -U tmp1 matches - -# Get the options. - -zparseopts -D -a sopts \ - 'J+:=group' 'V+:=group' 'X+:=expl' 'P:=opts' 'F:=opts' \ - S: r: R: q 1 2 n f 'M+:=matcher' 'i=imm' - -sopts=( "$sopts[@]" "$opts[@]" ) -if (( $#matcher )); then - matcher="${matcher[2]}" -else - matcher= -fi - -# Get the arguments, first the separator, then the array. The array is -# stored in `tmp1'. Further on the array `matches' will always contain -# those words from the original array that still match everything we have -# tried to match while we walk through the string from the line. - -sep="$1" -if [[ "${2[1]}" = '(' ]]; then - tmp1=( ${=2[2,-2]} ) -else - tmp1=( "${(@P)2}" ) -fi - -# In `pre' and `suf' we will hold the prefix and the suffix from the -# line while we walk through them. The original string are used -# temporarily for matching. - -pre="$PREFIX" -suf="$SUFFIX" -opre="$PREFIX" -osuf="$SUFFIX" -orig="$PREFIX$SUFFIX" - -# Special handling for menucompletion? - -[[ $compstate[insert] = (*menu|[0-9]*) || -n "$_comp_correct" || - ( $#compstate[pattern_match] -ne 0 && - "$orig" != "${orig:q}" ) ]] && menu=yes - -# In `pref' we collect the unambiguous prefix path. - -pref='' - -# If the string from the line matches at least one of the strings, -# we use only the matching strings. - -compadd -O matches -M "r:|${sep}=* r:|=* $matcher" -a tmp1 - -(( $#matches )) || matches=( "$tmp1[@]" ) - -while true; do - - # Get the prefix and suffix for matching. - - if [[ "$pre" = *${sep}* ]]; then - PREFIX="${pre%%${sep}*}" - SUFFIX="" - else - PREFIX="${pre}" - SUFFIX="${suf%%${sep}*}" - fi - - # Check if the component for some of the possible matches is equal - # to the string from the line. If there are such strings, we directly - # use the stuff from the line. This avoids having `foo' complete to - # both `foo' and `foobar'. - - if [[ -n "$PREFIX$SUFFIX" || "$pre" = ${sep}* ]]; then - tmp1=( "${(@M)matches:#${PREFIX}${SUFFIX}${sep}*}" ) - else - tmp1=() - fi - - if (( $#tmp1 )); then - npref="${PREFIX}${SUFFIX}${sep}" - else - # No exact match, see how many strings match what's on the line. - - builtin compadd -O tmp1 - "${(@)${(@)matches%%${sep}*}:#}" - - [[ $#tmp1 -eq 0 && -n "$_comp_correct" ]] && - compadd -O tmp1 - "${(@)${(@)matches%%${sep}*}:#}" - - if [[ $#tmp1 -eq 1 ]]; then - - # Only one match. If there are still separators from the line - # we just accept this component. Otherwise we insert what we - # have collected, probably giving it a separator character - # as a suffix. - - if [[ "$pre$suf" = *${sep}* ]]; then - npref="${tmp1[1]}${sep}" - else - matches=( "${(@M)matches:#${tmp1[1]}*}" ) - - PREFIX="${cpre}${pre}" - SUFFIX="$suf" - - if [[ $#imm -ne 0 && $#matches -eq 1 ]] || - zstyle -t ":completion:${curcontext}:" expand suffix; then - compadd "$group[@]" "$expl[@]" "$sopts[@]" \ - -M "r:|${sep}=* r:|=* $matcher" - "$pref$matches[1]" - else - if (( $matches[(I)${tmp1[1]}${sep}*] )); then - compadd "$group[@]" "$expl[@]" -p "$pref" -r "$sep" -S "$sep" "$opts[@]" \ - -M "r:|${sep}=* r:|=* $matcher" - "$tmp1[1]" - else - compadd "$group[@]" "$expl[@]" -p "$pref" "$sopts[@]" \ - -M "r:|${sep}=* r:|=* $matcher" - "$tmp1[1]" - fi - fi - return - fi - elif (( $#tmp1 )); then - local ret=1 - - # More than one match. First we get all strings that match the - # rest from the line. - - PREFIX="$pre" - SUFFIX="$suf" - compadd -O matches -M "r:|${sep}=* r:|=* $matcher" -a matches - - if [[ "$pre" = *${sep}* ]]; then - PREFIX="${cpre}${pre%%${sep}*}" - SUFFIX="${sep}${pre#*${sep}}${suf}" - else - PREFIX="${cpre}${pre}" - SUFFIX="$suf" - fi - - matches=( "${(@M)matches:#(${(j:|:)~tmp1})*}" ) - - if ! zstyle -t ":completion:${curcontext}:" expand suffix || - [[ -n "$menu" || -z "$compstate[insert]" ]]; then - - # With menucompletion we add only the ambiguous component with - # the prefix collected and a spearator for the matches that - # have more components. - - tmp2="$pre$suf" - if [[ "$tmp2" = *${sep}* ]]; then - tmp2=(-s "${sep}${tmp2#*${sep}}") - else - tmp2=() - fi - - - compadd "$group[@]" "$expl[@]" -r "$sep" -S "$sep" "$opts[@]" \ - -p "$pref" "$tmp2[@]" -M "r:|${sep}=* r:|=* $matcher" - \ - "${(@)${(@)${(@M)matches:#*${sep}}%%${sep}*}:#}" && ret=0 - (( $matches[(I)${sep}*] )) && - compadd "$group[@]" "$expl[@]" -S '' "$opts[@]" \ - -p "$pref" \ - -M "r:|${sep}=* r:|=* $matcher" - "$sep" && ret=0 - compadd "$group[@]" "$expl[@]" -r "$sep" -S "$sep" "$opts[@]" \ - -p "$pref" "$tmp2[@]" -M "r:|${sep}=* r:|=* $matcher" - \ - "${(@)${(@)${(@M)matches:#*?${sep}?*}%%${sep}*}:#}" && ret=0 - compadd "$group[@]" "$expl[@]" -S '' "$opts[@]" -p "$pref" "$tmp2[@]" \ - -M "r:|${sep}=* r:|=* $matcher" - \ - "${(@)matches:#*${sep}*}" && ret=0 - else - # With normal completion we add all matches one-by-one with - # the unmatched part as a suffix. This will insert the longest - # unambiguous string for all matching strings. - - compadd "$group[@]" "$expl[@]" "$opts[@]" \ - -p "$pref" -s "${i#*${sep}}" \ - -M "r:|${sep}=* r:|=* $matcher" - \ - "${(@)${(@)${(@M)matches:#*${sep}*}%%${sep}*}:#}" && ret=0 - compadd "$group[@]" "$expl[@]" -S '' "$opts[@]" -p "$pref" \ - -M "r:|${sep}=* r:|=* $matcher" - \ - "${(@)matches:#*${sep}*}" && ret=0 - fi - return ret - else - # We are here if no string matched what's on the line. In this - # case we insert the expanded prefix we collected if it differs - # from the original string from the line. - - { ! zstyle -t ":completion:${curcontext}:" expand prefix || - [[ "$orig" = "$pref$pre$suf" ]] } && return 1 - - PREFIX="${cpre}${pre}" - SUFFIX="$suf" - - if [[ -n "$suf" ]]; then - compadd "$group[@]" "$expl[@]" -s "$suf" "$sopts[@]" \ - -M "r:|${sep}=* r:|=* $matcher" - "$pref$pre" - else - compadd "$group[@]" "$expl[@]" -S '' "$opts[@]" \ - -M "r:|${sep}=* r:|=* $matcher" - "$pref$pre" - fi - return - fi - fi - - # We just accepted and/or expanded a component from the line. We - # remove it from the matches (using only those that have a least - # the skipped string) and ad it the `pref'. - - matches=( "${(@)${(@)${(@M)matches:#${npref}*}#*${sep}}:#}" ) - pref="$pref$npref" - - # Now we set `pre' and `suf' to their new values. - - if [[ "$pre" = *${sep}* ]]; then - cpre="${cpre}${pre%%${sep}*}${sep}" - pre="${pre#*${sep}}" - elif [[ "$suf" = *${sep}* ]]; then - cpre="${cpre}${pre}${suf%%${sep}*}${sep}" - pre="${suf#*${sep}}" - suf="" - else - # The string from the line is fully handled. If we collected an - # unambiguous prefix and that differs from the original string, - # we insert it. - - PREFIX="${opre}${osuf}" - SUFFIX="" - - if [[ -n "$pref" && "$orig" != "$pref" ]]; then - if [[ "$pref" = *${sep}*${sep} ]]; then - compadd "$group[@]" "$expl[@]" "$opts[@]" \ - -p "${pref%${sep}*${sep}}${sep}" -S "$sep" \ - -M "r:|${sep}=* r:|=* $matcher" - "${${pref%${sep}}##*${sep}}" - - elif [[ "$pref" = *${sep}* ]]; then - compadd "$group[@]" "$expl[@]" -S '' "$opts[@]" \ - -p "${pref%${sep}*}${sep}" \ - -M "r:|${sep}=* r:|=* $matcher" - "${pref##*${sep}}" - else - compadd "$group[@]" "$expl[@]" -S '' "$opts[@]" \ - -M "r:|${sep}=* r:|=* $matcher" - "$pref" - fi - fi - return - fi -done |