diff options
Diffstat (limited to 'Completion')
| -rw-r--r-- | Completion/Core/_path_files | 650 |
1 files changed, 0 insertions, 650 deletions
diff --git a/Completion/Core/_path_files b/Completion/Core/_path_files deleted file mode 100644 index 541a883e8..000000000 --- a/Completion/Core/_path_files +++ /dev/null @@ -1,650 +0,0 @@ -#autoload - -# Utility function for in-path completion. This allows `/u/l/b<TAB>' -# to complete to `/usr/local/bin'. - -local linepath realpath donepath prepath testpath exppath skips skipped -local tmp1 tmp2 tmp3 tmp4 i orig eorig pre suf tpre tsuf opre osuf cpre -local pats haspats ignore pfxsfx sopt gopt opt sdirs ignpar cfopt listsfx -local nm=$compstate[nmatches] menu matcher mopts sort match mid accex fake - -typeset -U prepaths exppaths - -exppaths=() - -# Get the options. - -zparseopts -a mopts \ - 'P:=pfxsfx' 'S:=pfxsfx' 'q=pfxsfx' 'r:=pfxsfx' 'R:=pfxsfx' \ - 'W:=prepaths' 'F:=ignore' 'M+:=matcher' \ - J+: V+: X+: 1: 2: n: 'f=tmp1' '/=tmp1' 'g+:-=tmp1' - -sopt="-${(@j::M)${(@)tmp1#-}#?}" -(( $tmp1[(I)-[/g]*] )) && haspats=yes -(( $tmp1[(I)-g*] )) && gopt=yes -if (( $tmp1[(I)-/] )); then - pats=( '*(-/)' ${=${(M)tmp1:#-g*}#-g} ) -else - pats=( "${(@)=${(@M)tmp1:#-g*}#-g}" ) -fi -pats=( "${(@)pats:# #}" ) - -if (( $#prepaths )); then - tmp1="${prepaths[2]}" - if [[ "$tmp1[1]" = '(' ]]; then - prepaths=( ${^=tmp1[2,-2]%/}/ ) - elif [[ "$tmp1[1]" = '/' ]]; then - prepaths=( "${tmp1%/}/" ) - else - prepaths=( ${(P)^tmp1%/}/ ) - (( ! $#prepaths )) && prepaths=( ${tmp1%/}/ ) - fi - (( ! $#prepaths )) && prepaths=( '' ) -else - prepaths=( '' ) -fi - -if (( $#ignore )); then - if [[ "${ignore[2]}" = \(* ]]; then - ignore=( ${=ignore[2][2,-2]} ) - else - ignore=( ${(P)ignore[2]} ) - fi -fi - -# If we were given no file selection option, we behave as if we were given -# a `-f'. - -if [[ "$sopt" = -(f|) ]]; then - if [[ -z "$gopt" ]]; then - sopt='-f' - pats=('*') - else - unset sopt - fi -fi - -if (( ! $mopts[(I)-[JVX]] )); then - local expl - - if [[ -z "$gopt" && "$sopt" = -/ ]]; then - _description directories expl directory - else - _description files expl file - fi - tmp1=$expl[(I)-M*] - if (( tmp1 )); then - if (( $#matcher )); then - matcher[2]="$matcher[2] $expl[1+tmp1]" - else - matcher=(-M "$expl[1+tmp1]") - fi - fi - mopts=( "$mopts[@]" "$expl[@]" ) -fi - -# If given no `-F' option, we may want to use $fignore, turned into patterns. - -[[ -z "$_comp_no_ignore" && $#ignore -eq 0 && - ( -z $gopt || "$pats" = \ #\*\ # ) && -n $FIGNORE ]] && - ignore=( "?*${^fignore[@]}" ) - -if (( $#ignore )); then - _comp_ignore=( "$_comp_ignore[@]" "$ignore[@]" ) - (( $mopts[(I)-F] )) || mopts=( "$mopts[@]" -F _comp_ignore ) -fi - -(( $#matcher )) && mopts=( "$mopts[@]" "$matcher[@]" ) - -if zstyle -s ":completion:${curcontext}:" file-sort tmp1; then - case "$tmp1" in - *size*) sort=oL;; - *links*) sort=ol;; - *(time|date|modi)*) sort=om;; - *access*) sort=oa;; - *(inode|change)*) sort=oc;; - *) sort=on;; - esac - [[ "$tmp1" = *rev* ]] && sort[1]=O - - if [[ "$sort" = on ]]; then - sort= - else - mopts=( "${(@)mopts/#-J/-V}" ) - - tmp2=() - for tmp1 in "$pats[@]"; do - if [[ "$tmp1" = (#b)(*[^\$])(\(\([^\|~]##\)\)) ]]; then - tmp2=( "$tmp2[@]" "${match[1]}((${sort}${match[2][3,-1]}" ) - elif [[ "$tmp1" = (#b)(*[^\$])(\([^\|~]##\)) ]]; then - tmp2=( "$tmp2[@]" "${match[1]}(${sort}${match[2][2,-1]}" ) - else - tmp2=( "$tmp2[@]" "${tmp1}(${sort})" ) - fi - done - pats=( "$tmp2[@]" ) - fi -fi - -# Check if we have to skip over sequences of slashes. The value of $skips -# is used below to match the pathname components we always have to accept -# immediatly. - -if zstyle -t ":completion:${curcontext}:paths" squeeze-slashes; then - skips='((.|..|)/)##' -else - skips='((.|..)/)##' -fi - -zstyle -s ":completion:${curcontext}:paths" special-dirs sdirs -zstyle -t ":completion:${curcontext}:paths" list-suffixes && - listsfx=yes - -[[ "$pats" = ((|*[[:blank:]])\*(|[[:blank:]]*)|*\([^[:blank:]]#/[^[:blank:]]#\)*) ]] && - sopt=$sopt/ - -zstyle -a ":completion:${curcontext}:paths" accept-exact accex -zstyle -a ":completion:${curcontext}:" fake-files fake - -zstyle -s ":completion:${curcontext}:" ignore-parents ignpar - -if [[ -n "$compstate[pattern_match]" && - ( ( -z "$SUFFIX" && "$PREFIX" = (|*[^\$])\([^\|\~]##\) ) || - "$SUFFIX" = (|*[^\$])\([^\|\~]##\) ) ]]; then - # Copy all glob qualifiers from the line to - # the patterns used when generating matches - if [[ "$SUFFIX" = *\([^\|\~]##\) ]]; then - tmp3="${${(M)SUFFIX%\([^\|\~]##\)}[2,-2]}" - SUFFIX="${SUFFIX%\($tmp3\)}" - else - tmp3="${${(M)PREFIX%\([^\|\~]##\)}[2,-2]}" - PREFIX="${PREFIX%\($tmp3\)}" - fi - tmp2=() - for tmp1 in "$pats[@]"; do - if [[ "$tmp1" = (#b)(*[^\$])(\(\([^\|~]##\)\)) ]]; then - tmp2=( "$tmp2[@]" "${match[1]}((${tmp3}${match[2][3,-1]}" ) - elif [[ "$tmp1" = (#b)(*[^\$])(\([^\|~]##\)) ]]; then - tmp2=( "$tmp2[@]" "${match[1]}(${tmp3}${match[2][2,-1]}" ) - else - tmp2=( "$tmp2[@]" "${tmp1}(${tmp3})" ) - fi - done - pats=( "$tmp2[@]" ) -fi - -# We get the prefix and the suffix from the line and save the whole -# original string. Then we see if we will do menucompletion. - -pre="$PREFIX" -suf="$SUFFIX" -opre="$PREFIX" -osuf="$SUFFIX" -orig="${PREFIX}${SUFFIX}" -eorig="$orig" - -[[ $compstate[insert] = (*menu|[0-9]*) || -n "$_comp_correct" || - ( -n "$compstate[pattern_match]" && - "${orig#\~}" != (|*[^\\])[][*?#~^\|\<\>]* ) ]] && menu=yes -[[ -n "$_comp_correct" ]] && cfopt=- - -# Now let's have a closer look at the string to complete. - -if [[ "$pre[1]" = \~ && -z "$compstate[quote]" ]]; then - # It begins with `~', so remember anything before the first slash to be able - # to report it to the completion code. Also get an expanded version of it - # (in `realpath'), so that we can generate the matches. Then remove that - # prefix from the string to complete, set `donepath' to build the correct - # paths and make sure that the loop below is run only once with an empty - # prefix path by setting `prepaths'. - - linepath="${pre[2,-1]%%/*}" - if [[ -z "$linepath" ]]; then - realpath="${HOME%/}/" - elif (( $+userdirs[$linepath] )); then - realpath="${userdirs[$linepath]%/}/" - elif (( $+nameddirs[$linepath] )); then - realpath="${nameddirs[$linepath]%/}/" - elif [[ "$linepath" = ([-+]|)[0-9]## ]]; then - if [[ "$linepath" != [-+]* ]]; then - if [[ -o pushdminus ]]; then - tmp1="-$linepath" - else - tmp1="+$linepath" - fi - else - tmp1="$linepath" - fi - if [[ "$linepath" = -* ]]; then - tmp1=$(( $#dirstack $tmp1 )) - else - tmp1=$tmp1[2,-1] - fi - [[ -o pushdminus ]] && tmp1=$(( $#dirstack - $tmp1 )) - if (( ! tmp1 )); then - realpath=$PWD/ - elif [[ tmp1 -le $#dirstack ]]; then - realpath=$dirstack[tmp1]/ - else - _message 'not enough directory stack entries' - return 1 - fi - elif [[ "$linepath" = [-+] ]]; then - realpath=${~:-\~$linepath}/ - else - _message "unknown user \`$linepath'" - return 1 - fi - linepath="~${linepath}/" - [[ "$realpath" = "$linepath" ]] && return 1 - pre="${pre#*/}" - orig="${orig#*/}" - donepath= - prepaths=( '' ) -elif [[ "$pre" = *\$*/* && "$compstate[quote]" != \" ]]; then - - # If there is a parameter expansion in the word from the line, we try - # to complete the beast by expanding the prefix and completing anything - # after the first slash after the parameter expansion. - # This fails for things like `f/$foo/b/<TAB>' where the first `f' is - # meant as a partial path. - - linepath="${(M)pre##*\$[^/]##/}" - eval 'realpath=${(e)~linepath}' 2>/dev/null - [[ -z "$realpath" || "$realpath" = "$linepath" ]] && return 1 - pre="${pre#${linepath}}" - i="${#linepath//[^\\/]}" - orig="${orig[1,(in:i:)/][1,-2]}" - donepath= - prepaths=( '' ) -else - # If the string does not start with a `~' we don't remove a prefix from the - # string. - - linepath= - realpath= - - if [[ "$pre[1]" = / ]]; then - # If it is a absolute path name, we remove the first slash and put it in - # `donepath' meaning that we treat it as the path that was already handled. - # Also, we don't use the paths from `-W'. - - pre="$pre[2,-1]" - orig="$orig[2,-1]" - donepath='/' - prepaths=( '' ) - else - # The common case, we just use the string as it is, unless it begins with - # `./' or `../' in which case we don't use the paths from `-W'. - - [[ "$pre" = (.|..)/* ]] && prepaths=( '' ) - donepath= - fi -fi - -# Now we generate the matches. First we loop over all prefix paths given -# with the `-W' option. - -for prepath in "$prepaths[@]"; do - - # Get local copies of the prefix, suffix, and the prefix path to use - # in the following loop, which walks through the pathname components - # in the string from the line. - - skipped= - cpre= - tpre="$pre" - tsuf="$suf" - testpath="$donepath" - - tmp2="${(M)tpre##${~skips}}" - tpre="${tpre#$tmp2}" - - tmp1=( "$prepath$realpath$donepath$tmp2" ) - - while true; do - - # Get the prefix and suffix for matching. - - if [[ "$tpre" = */* ]]; then - PREFIX="${tpre%%/*}" - SUFFIX= - else - PREFIX="${tpre}" - SUFFIX="${tsuf%%/*}" - fi - - # Force auto-mounting. There might be a better way... - - : ${^tmp1}/${PREFIX}${SUFFIX}/.(/) - - # Get the matching files by globbing. - - if [[ "$tpre$tsuf" = */* ]]; then - compfiles -P$cfopt tmp1 accex "$skipped" "$_matcher" "$sdirs" fake - elif [[ "$sopt" = *[/f]* ]]; then - compfiles -p$cfopt tmp1 accex "$skipped" "$_matcher" "$sdirs" fake "$pats[@]" - else - compfiles -p$cfopt tmp1 accex "$skipped" "$_matcher" '' fake "$pats[@]" - fi - tmp1=( $~tmp1 ) - - if [[ -n "$PREFIX$SUFFIX" ]]; then - # See which of them match what's on the line. - - if [[ "$tmp1[1]" = */* ]]; then - if [[ -n "$_comp_correct" ]]; then - tmp2=( "$tmp1[@]" ) - builtin compadd -D tmp1 -F _comp_ignore "$matcher[@]" - "${(@)tmp1:t}" - - if [[ $#tmp1 -eq 0 ]]; then - tmp1=( "$tmp2[@]" ) - compadd -D tmp1 -F _comp_ignore "$matcher[@]" - "${(@)tmp2:t}" - fi - else - tmp2=( "$tmp1[@]" ) - compadd -D tmp1 -F _comp_ignore "$matcher[@]" - "${(@)tmp1:t}" - fi - else - tmp2=( '' ) - compadd -D tmp1 -F _comp_ignore "$matcher[@]" -a tmp1 - fi - - # If no file matches, save the expanded path and continue with - # the outer loop. - - if (( ! $#tmp1 )); then - if [[ "$tmp2[1]" = */* ]]; then - tmp2=( "${(@)tmp2#${prepath}${realpath}}" ) - if [[ "$tmp2[1]" = */* ]]; then - tmp2=( "${(@)tmp2:h}" ) - compquote tmp2 - if [[ "$tmp2" = */ ]]; then - exppaths=( "$exppaths[@]" ${^tmp2}${tpre}${tsuf} ) - else - exppaths=( "$exppaths[@]" ${^tmp2}/${tpre}${tsuf} ) - fi - elif [[ ${tpre}${tsuf} = */* ]]; then - exppaths=( "$exppaths[@]" ${tpre}${tsuf} ) - - ### this once was in an `else' (not `elif') - fi - fi - continue 2 - fi - elif (( ! $#tmp1 )); then - # A little extra hack: if we were completing `foo/<TAB>' and `foo' - # contains no files, this will normally produce no matches and other - # completers might think that's it's their time now. But if the next - # completer is _correct or something like that, this will result in - # an attempt to correct a valid directory name. So we just add the - # original string in such a case so that the command line doesn't - # change but other completers still think there are matches. - # We do this only if we weren't given a `-g' or `-/' option because - # otherwise this would keep `_files' from completing all filenames - # if none of the patterns match. - - if [[ -z "$tpre$tsuf" && -n "$pre$suf" ]]; then - pfxsfx=(-S '' "$pfxsfx[@]") - ### Don't remember what the break was good for. We explicitly - ### execute this only when there are no matches in the directory, - ### so why continue? - ### - ### tmp1=( "$tmp2[@]" ) - ### break - elif [[ -n "$haspats" && -z "$tpre$tsuf$suf" && "$pre" = */ ]]; then - PREFIX="${opre}" - SUFFIX="${osuf}" - compadd -nQS '' - "$linepath$donepath$orig" - tmp4=- - fi - continue 2 - fi - - if [[ -n "$ignpar" && -z "$_comp_no_ignore" && - "$tpre$tsuf" != */* && $#tmp1 -ne 0 && - ( "$ignpar" != *dir* || "$pats" = '*(-/)' ) && - ( "$ignpar" != *..* || "$tmp1[1]" = *../* ) ]]; then - - compfiles -i tmp1 _comp_ignore "$ignpar" "$prepath$realpath$donepath" - - (( $#_comp_ignore && $mopts[(I)-F] )) || - mopts=( "$mopts[@]" -F _comp_ignore ) - fi - - # Step over to the next component, if any. - - if [[ "$tpre" = */* ]]; then - tpre="${tpre#*/}" - elif [[ "$tsuf" = */* ]]; then - tpre="${tsuf#*/}" - tsuf= - else - break - fi - - # There are more components, so skip over the next components and make a - # slash be added. - - tmp1=( ${tmp1//(#b)([][()|*?^#~<>\\=])/\\${match[1]}} ) - tmp2="${(M)tpre##((.|..|)/)##}" - if [[ -n "$tmp2" ]]; then - skipped="/$tmp2" - tpre="${tpre#$tmp2}" - else - skipped=/ - fi - done - - # The next loop searches the first ambiguous component. - - tmp3="$pre$suf" - tpre="$pre" - tsuf="$suf" - [[ -n "${prepath}${realpath}${testpath}" ]] && - tmp1=( "${(@)tmp1#${prepath}${realpath}${testpath}}" ) - - while true; do - - # First we check if some of the files match the original string - # for this component. If there are some we remove all other - # names. This avoids having `foo' complete to `foo' and `foobar'. - # The return value is non-zero if the component is ambiguous. - - compfiles -r tmp1 "$tmp3" - tmp4=$? - - if [[ "$tpre" = */* ]]; then - tmp2="${cpre}${tpre%%/*}" - PREFIX="${donepath}${linepath}${tmp2}" - SUFFIX="/${tpre#*/}${tsuf#*/}" - else - tmp2="${cpre}${tpre}" - PREFIX="${donepath}${linepath}${tmp2}" - SUFFIX="${tsuf}" - fi - - # This once tested `|| [[ -n "$compstate[pattern_match]" && - # "$tmp2" = (|*[^\\])[][*?#~^\|\<\>]* ]]' but it should now be smart - # enough to handle multiple components with patterns. - - if (( tmp4 )); then - # It is. For menucompletion we now add the possible completions - # for this component with the unambigous prefix we have built - # and the rest of the string from the line as the suffix. - # For normal completion we add the rests of the filenames - # collected as the suffixes to make the completion code expand - # it as far as possible. - - tmp2="$testpath" - if [[ -n "$linepath" ]]; then - compquote -p tmp2 tmp1 - elif [[ -n "$tmp2" ]]; then - compquote -p tmp1 - compquote tmp2 - else - compquote tmp1 tmp2 - fi - - if [[ -z "$_comp_correct" && - "$compstate[pattern_match]" = \* && -n "$listsfx" && - "$tmp2" = (|*[^\\])[][*?#~^\|\<\>]* ]]; then - PREFIX="$opre" - SUFFIX="$osuf" - fi - - if [[ -n $menu || -z "$compstate[insert]" ]] || - ! zstyle -t ":completion:${curcontext}:paths" expand suffix || - [[ -z "$listsfx" && - ( -n "$_comp_correct" || - -z "$compstate[pattern_match]" || "$SUFFIX" != */* || - "${SUFFIX#*/}" = (|*[^\\])[][*?#~^\|\<\>]* ) ]]; then - (( tmp4 )) && zstyle -t ":completion:${curcontext}:paths" ambiguous && - compstate[to_end]= - if [[ "$tmp3" = */* ]]; then - if [[ -z "$listsfx" || "$tmp3" != */?* ]]; then - compadd -Qf "$mopts[@]" -p "$linepath$tmp2" -s "/${tmp3#*/}" \ - -W "$prepath$realpath$testpath" \ - "$pfxsfx[@]" -M "r:|/=* r:|=*" \ - - "${(@)tmp1%%/*}" - else - compadd -Qf "$mopts[@]" -p "$linepath$tmp2" \ - -W "$prepath$realpath$testpath" \ - "$pfxsfx[@]" -M "r:|/=* r:|=*" \ - - "${(@)^tmp1%%/*}/${tmp3#*/}" - fi - else - compadd -Qf "$mopts[@]" -p "$linepath$tmp2" \ - -W "$prepath$realpath$testpath" \ - "$pfxsfx[@]" -M "r:|/=* r:|=*" \ - -a tmp1 - fi - else - if [[ "$tmp3" = */* ]]; then - tmp4=( -Qf "$mopts[@]" -p "$linepath$tmp2" - -W "$prepath$realpath$testpath" - "$pfxsfx[@]" -M "r:|/=* r:|=*" ) - if [[ -z "$listsfx" ]]; then - for i in "$tmp1[@]"; do - compadd "$tmp4[@]" -s "/${i#*/}" - "${i%%/*}" - done - else - [[ -n "$compstate[pattern_match]" ]] && SUFFIX="${SUFFIX:s./.*/}*" - - for i in "$tmp1[@]"; do - compadd "$tmp4[@]" - "$i" - done - fi - else - compadd -Qf "$mopts[@]" -p "$linepath$tmp2" \ - -W "$prepath$realpath$testpath" \ - "$pfxsfx[@]" -M "r:|/=* r:|=*" \ - -a tmp1 - fi - fi - tmp4=- - break - fi - - # If we have checked all components, we stop now and add the - # strings collected after the loop. - - if [[ "$tmp3" != */* ]]; then - tmp4= - break - fi - - # Otherwise we add the unambiguous component to `testpath' and - # take it from the filenames. - - testpath="${testpath}${tmp1[1]%%/*}/" - - tmp3="${tmp3#*/}" - - if [[ "$tpre" = */* ]]; then - if [[ -z "$_comp_correct" && -n "$compstate[pattern_match]" && - "$tmp2" = (|*[^\\])[][*?#~^\|\<\>]* ]]; then - cpre="${cpre}${tmp1[1]%%/*}/" - else - cpre="${cpre}${tpre%%/*}/" - fi - tpre="${tpre#*/}" - elif [[ "$tsuf" = */* ]]; then - [[ "$tsuf" != /* ]] && mid="$testpath" - if [[ -z "$_comp_correct" && -n "$compstate[pattern_match]" && - "$tmp2" = (|*[^\\])[][*?#~^\|\<\>]* ]]; then - cpre="${cpre}${tmp1[1]%%/*}/" - else - cpre="${cpre}${tpre}/" - fi - tpre="${tsuf#*/}" - tsuf= - else - tpre= - tsuf= - fi - - tmp1=( "${(@)tmp1#*/}" ) - done - - if [[ -z "$tmp4" ]]; then - if [[ "$mid" = */ ]]; then - PREFIX="${opre}" - SUFFIX="${osuf}" - - tmp4="${testpath#${mid}}" - tmp3="${mid%/*/}" - tmp2="${${mid%/}##*/}" - if [[ -n "$linepath" ]]; then - compquote -p tmp3 - else - compquote tmp3 - fi - compquote tmp4 tmp2 tmp1 - for i in "$tmp1[@]"; do - compadd -Qf "$mopts[@]" -p "$linepath$tmp3/" -s "/$tmp4$i" \ - -W "$prepath$realpath${mid%/*/}/" \ - "$pfxsfx[@]" -M "r:|/=* r:|=*" - "$tmp2" - done - else - if [[ "$osuf" = */* ]]; then - PREFIX="${opre}${osuf}" - SUFFIX= - else - PREFIX="${opre}" - SUFFIX="${osuf}" - fi - tmp4="$testpath" - if [[ -n "$linepath" ]]; then - compquote -p tmp4 tmp1 - elif [[ -n "$tmp4" ]]; then - compquote -p tmp1 - compquote tmp4 - else - compquote tmp4 tmp1 - fi - if [[ -z "$_comp_correct" && -n "$compstate[pattern_match]" && - "${PREFIX#\~}$SUFFIX" = (|*[^\\])[][*?#~^\|\<\>]* ]]; then - compadd -Qf -W "$prepath$realpath" "$pfxsfx[@]" "$mopts[@]" \ - -M "r:|/=* r:|=*" - "$linepath$tmp4${(@)^tmp1}" - else - compadd -Qf -p "$linepath$tmp4" -W "$prepath$realpath$testpath" \ - "$pfxsfx[@]" "$mopts[@]" -M "r:|/=* r:|=*" -a tmp1 - fi - fi - fi -done - -# If we are configured to expand paths as far as possible and we collected -# expanded paths that are different from the string on the line, we add -# them as possible matches. - -if zstyle -t ":completion:${curcontext}:paths" expand prefix && - [[ nm -eq compstate[nmatches] && $#exppaths -ne 0 && - "$exppaths" != "$eorig" ]]; then - PREFIX="${opre}" - SUFFIX="${osuf}" - compadd -Q "$mopts[@]" -S '' -M "r:|/=* r:|=*" -p "$linepath" -a exppaths -fi - -[[ nm -ne compstate[nmatches] ]] |