diff options
Diffstat (limited to 'Functions/Completion')
67 files changed, 1072 insertions, 0 deletions
diff --git a/Functions/Completion/.distfiles b/Functions/Completion/.distfiles new file mode 100644 index 000000000..12621da29 --- /dev/null +++ b/Functions/Completion/.distfiles @@ -0,0 +1,11 @@ +DISTFILES_SRC=' + .distfiles + __aliases __arrays __autoload __bg_jobs __bindkey __builtin __cd __command + __command_names __compress __condition __configure __dd __default __dirs + __disable __dvi __echotc __enable __fc __files __find __functions __gunzip + __gzip __hash __hosts __jobs __kill __kill_helper __limits __main_complete + __main_key_complete __make __man __mh __most_recent_file __normal __path_files + __pdf __precommand __ps __rcs __rlogin __sched __set __setopt __source __strip + __stty __subscript __tar __tex __trap __uncompress __unhash __unsetopt __vars + __vars_eq __wait __which __x_options __xfig __zle __zmodload init +' diff --git a/Functions/Completion/__aliases b/Functions/Completion/__aliases new file mode 100644 index 000000000..cbf204e51 --- /dev/null +++ b/Functions/Completion/__aliases @@ -0,0 +1,2 @@ +#array unalias +__aliases=(-a) diff --git a/Functions/Completion/__arrays b/Functions/Completion/__arrays new file mode 100644 index 000000000..3f6ec8abe --- /dev/null +++ b/Functions/Completion/__arrays @@ -0,0 +1,2 @@ +#array shift +__arrays=(-A) diff --git a/Functions/Completion/__autoload b/Functions/Completion/__autoload new file mode 100644 index 000000000..9c3bb1f4f --- /dev/null +++ b/Functions/Completion/__autoload @@ -0,0 +1,2 @@ +#array autoload +__autoload=(-s '${^fpath}/*(N:t)') diff --git a/Functions/Completion/__bg_jobs b/Functions/Completion/__bg_jobs new file mode 100644 index 000000000..90e3b7ee0 --- /dev/null +++ b/Functions/Completion/__bg_jobs @@ -0,0 +1,2 @@ +#array bg +__bg_jobs=(-z -P '%') diff --git a/Functions/Completion/__bindkey b/Functions/Completion/__bindkey new file mode 100644 index 000000000..c9005347a --- /dev/null +++ b/Functions/Completion/__bindkey @@ -0,0 +1,7 @@ +#function bindkey + +if [[ -mword 1 -*[DAN]* || -mcurrent -1 -*M ]]; then + complist -s '$(bindkey -l)' +else + complist -b +fi diff --git a/Functions/Completion/__builtin b/Functions/Completion/__builtin new file mode 100644 index 000000000..5b4c777f5 --- /dev/null +++ b/Functions/Completion/__builtin @@ -0,0 +1,7 @@ +#function builtin + +if [[ -position 2 -1 ]]; then + compsub +else + complist -eB +fi diff --git a/Functions/Completion/__cd b/Functions/Completion/__cd new file mode 100644 index 000000000..ad5e36386 --- /dev/null +++ b/Functions/Completion/__cd @@ -0,0 +1,3 @@ +#function cd + +__files -W cdpath -g '*(-/)' diff --git a/Functions/Completion/__command b/Functions/Completion/__command new file mode 100644 index 000000000..deaabdb1f --- /dev/null +++ b/Functions/Completion/__command @@ -0,0 +1,7 @@ +#function command + +if [[ -position 2 -1 ]]; then + compsub +else + complist -em +fi diff --git a/Functions/Completion/__command_names b/Functions/Completion/__command_names new file mode 100644 index 000000000..7a28fa527 --- /dev/null +++ b/Functions/Completion/__command_names @@ -0,0 +1,2 @@ +#array --command-- +__command_names=(-c) diff --git a/Functions/Completion/__compress b/Functions/Completion/__compress new file mode 100644 index 000000000..d4e71f531 --- /dev/null +++ b/Functions/Completion/__compress @@ -0,0 +1,3 @@ +#function compress + +__files -g '*~*.Z' diff --git a/Functions/Completion/__condition b/Functions/Completion/__condition new file mode 100644 index 000000000..8ceb969b8 --- /dev/null +++ b/Functions/Completion/__condition @@ -0,0 +1,10 @@ +#function --condition-- + +if [[ -current -1 -o ]]; then + complist -o -M 'L:|[nN][oO]= M:_= M:{A-Z}={a-z}' +elif [[ -current -1 -nt || -current -1 -ot || -current -1 -ef ]]; then + files +else + files + complist -v +fi diff --git a/Functions/Completion/__configure b/Functions/Completion/__configure new file mode 100644 index 000000000..a4d00e0f2 --- /dev/null +++ b/Functions/Completion/__configure @@ -0,0 +1,11 @@ +#function configure +if [[ $PREFIX = *=* ]]; then + # Complete filenames after e.g. --prefix= + IPREFIX=${PREFIX%%=*}= + PREFIX=${PREFIX#*=} + complist -f +else + # Generate a list of options from configure --help + complist -s '$($COMMAND --help | + sed -n -e '\''s/^ *\(--[-a-z0-9]*\)[ =,].*$/\1/p'\'')' +fi diff --git a/Functions/Completion/__dd b/Functions/Completion/__dd new file mode 100644 index 000000000..c0e04de75 --- /dev/null +++ b/Functions/Completion/__dd @@ -0,0 +1,13 @@ +#function dd + +if [[ -iprefix conv= ]]; then + # If there's a comma present, ignore up to the last one. The + # test alone will have that effect. + [[ -string , ]] + complist -S, -q \ + -k '(ascii ebcdic ibm block unblock lcase ucase swab noerror sync)' +elif [[ -iprefix 'if=' || -iprefix 'of=' ]]; then + __files +else + complist -S '=' -k '(if of ibs obs bs cbs skip files seek count conv)' +fi diff --git a/Functions/Completion/__default b/Functions/Completion/__default new file mode 100644 index 000000000..cabe14a36 --- /dev/null +++ b/Functions/Completion/__default @@ -0,0 +1,13 @@ +#function --default-- + +# We first try the `compctl's. This is without first (-T) and default (-D) +# completion. If you want them add `-T' and/or `-D' to this command. +# If there is a `compctl' for the command we are working on, we return +# immediatly. If you want to use new style completion anyway, remove the +# `|| return'. Also, you may want to use new style completion if the +# `compctl' didn't produce any matches. In that case remove the `|| return' +# and at the line `[[ -nmatches 0 ]] || return' after `compcall'. + +compcall || return + +__files diff --git a/Functions/Completion/__dirs b/Functions/Completion/__dirs new file mode 100644 index 000000000..a838168bc --- /dev/null +++ b/Functions/Completion/__dirs @@ -0,0 +1,3 @@ +#function rmdir df du dircmp + +__files -/ '*(-/)' diff --git a/Functions/Completion/__disable b/Functions/Completion/__disable new file mode 100644 index 000000000..c56ffb7f7 --- /dev/null +++ b/Functions/Completion/__disable @@ -0,0 +1,6 @@ +#function disable + +[[ -mcurrent -1 -*a* ]] && complist -ea +[[ -mcurrent -1 -*f* ]] && complist -eF +[[ -mcurrent -1 -*r* ]] && complist -ew +[[ ! -mcurrent -1 -* ]] && complist -eB diff --git a/Functions/Completion/__dvi b/Functions/Completion/__dvi new file mode 100644 index 000000000..873d5812a --- /dev/null +++ b/Functions/Completion/__dvi @@ -0,0 +1,3 @@ +#function xdvi dvips dvibook dviconcat dvicopy dvidvi dviselect dvitodvi dvitype + +__files -g '*.(dvi|DVI)' diff --git a/Functions/Completion/__echotc b/Functions/Completion/__echotc new file mode 100644 index 000000000..d9b7029c1 --- /dev/null +++ b/Functions/Completion/__echotc @@ -0,0 +1,2 @@ +#array echotc +__echotc=(-k '(al dc dl do le up al bl cd ce cl cr dc dl do ho is le ma nd nl se so up)') diff --git a/Functions/Completion/__enable b/Functions/Completion/__enable new file mode 100644 index 000000000..b315611df --- /dev/null +++ b/Functions/Completion/__enable @@ -0,0 +1,6 @@ +#function enable + +[[ -mcurrent -1 -*a* ]] && complist -da +[[ -mcurrent -1 -*f* ]] && complist -dF +[[ -mcurrent -1 -*r* ]] && complist -dw +[[ ! -mcurrent -1 -* ]] && complist -dB diff --git a/Functions/Completion/__fc b/Functions/Completion/__fc new file mode 100644 index 000000000..9185312b0 --- /dev/null +++ b/Functions/Completion/__fc @@ -0,0 +1,7 @@ +#function fc + +if [[ -mcurrent -1 -*e ]]; then + complist -c +elif [[ -mcurrent -1 -[ARWI]## ]]; then + __files +fi diff --git a/Functions/Completion/__files b/Functions/Completion/__files new file mode 100644 index 000000000..dfade8c7f --- /dev/null +++ b/Functions/Completion/__files @@ -0,0 +1,10 @@ +#helper + +# Utility function for completing files of a given type or any file. +# In many cases you will want to call this one instead of __path_files(). + +local nm=$NMATCHES + +__path_files "$@" + +[[ $# -ne 0 && -nmatches nm ]] && __path_files diff --git a/Functions/Completion/__find b/Functions/Completion/__find new file mode 100644 index 000000000..b16bb09c7 --- /dev/null +++ b/Functions/Completion/__find @@ -0,0 +1,24 @@ +#function find + +compsave + +if [[ -mbetween -(ok|exec) \\\; ]]; then + compsub +elif [[ -iprefix - ]]; then + complist -s 'daystart {max,min,}depth follow noleaf version xdev \ +{a,c,}newer {a,c,m}{min,time} empty false {fs,x,}type gid inum links \ +{i,}{l,}name {no,}{user,group} path perm regex size true uid used \ +exec {f,}print{f,0,} ok prune ls' + compreset +elif [[ -position 1 ]]; then + complist -g '. ..' + __files -g '(-/)' +elif [[ -mcurrent -1 -((a|c|)newer|fprint(|0|f)) ]]; then + __files +elif [[ -current -1 -fstype ]]; then + complist -k '(ufs 4.2 4.3 nfs tmp mfs S51K S52K)' +elif [[ -current -1 -group ]]; then + complist -k groups +elif [[ -current -1 -user ]]; then + complist -u +fi diff --git a/Functions/Completion/__functions b/Functions/Completion/__functions new file mode 100644 index 000000000..4fd24e379 --- /dev/null +++ b/Functions/Completion/__functions @@ -0,0 +1,2 @@ +#array unfunction +__functions=(-F) diff --git a/Functions/Completion/__gunzip b/Functions/Completion/__gunzip new file mode 100644 index 000000000..f14803c62 --- /dev/null +++ b/Functions/Completion/__gunzip @@ -0,0 +1,3 @@ +#function gunzip zcat + +__files -g '*.[gG][z]' diff --git a/Functions/Completion/__gzip b/Functions/Completion/__gzip new file mode 100644 index 000000000..ce4e0787a --- /dev/null +++ b/Functions/Completion/__gzip @@ -0,0 +1,3 @@ +#function gzip + +__files -g '*~*.[gG][zZ]' diff --git a/Functions/Completion/__hash b/Functions/Completion/__hash new file mode 100644 index 000000000..bd43eb967 --- /dev/null +++ b/Functions/Completion/__hash @@ -0,0 +1,13 @@ +#function hash + +if [[ -mword 1 -*d* ]]; then + if [[ -string 1 '=' ]]; then + pfiles -g '*(-/)' + else + complist -n -q -S '=' + fi +elif [[ -string 1 '=' ]]; then + files -g '*(*)' '*(-/)' +else + complist -m -q -S '=' +fi diff --git a/Functions/Completion/__hosts b/Functions/Completion/__hosts new file mode 100644 index 000000000..a91251581 --- /dev/null +++ b/Functions/Completion/__hosts @@ -0,0 +1,2 @@ +#array ftp ncftp ping rwho rup xping traceroute nslookup +__hosts=(-k hosts) diff --git a/Functions/Completion/__jobs b/Functions/Completion/__jobs new file mode 100644 index 000000000..d3e0d7776 --- /dev/null +++ b/Functions/Completion/__jobs @@ -0,0 +1,2 @@ +#array fg jobs +__jobs=(-j -P '%') diff --git a/Functions/Completion/__kill b/Functions/Completion/__kill new file mode 100644 index 000000000..09ba248dc --- /dev/null +++ b/Functions/Completion/__kill @@ -0,0 +1,8 @@ +#function kill + +if [[ -iprefix '-' ]]; then + complist -k "($signals[1,-3])" +else + complist -P '%' -j + complist -y __kill_helper -s '`ps 2>/dev/null | tail +2 | cut -c1-5`' +fi diff --git a/Functions/Completion/__kill_helper b/Functions/Completion/__kill_helper new file mode 100644 index 000000000..e1d286938 --- /dev/null +++ b/Functions/Completion/__kill_helper @@ -0,0 +1,3 @@ +#helper + +reply=( "$(ps 2>/dev/null)" ) diff --git a/Functions/Completion/__limits b/Functions/Completion/__limits new file mode 100644 index 000000000..e3f97155d --- /dev/null +++ b/Functions/Completion/__limits @@ -0,0 +1,2 @@ +#array limit unlimit +__limits=(-k "(${(j: :)${(f)$(limit)}%% *})") diff --git a/Functions/Completion/__main_complete b/Functions/Completion/__main_complete new file mode 100644 index 000000000..48f2338de --- /dev/null +++ b/Functions/Completion/__main_complete @@ -0,0 +1,48 @@ +#helper + +# The main loop of the completion code. This is what is called when +# completion is attempted from the command line. +# The completion code gives us the special variables and the arguments +# from the command line are given as positional parameters. + +local comp name + +setopt localoptions nullglob rcexpandparam globdots +unsetopt markdirs globsubst shwordsplit nounset + +# An entry for `--first--' is the replacement for `compctl -T' +# The `|| return 1' is used throughout: if a function producing matches +# returns non-zero this is interpreted as `do not try to produce more matches' +# (this is the replacement for `compctl -t'). + +comp="$comps[--first--]" +[[ -z "$comp" ]] || callcomplete comps --first-- "$@" || return 1 + +# For arguments we use the `__normal' function called via the convenience +# alias `compsub'. + +if [[ $CONTEXT == argument || $CONTEXT == command ]]; then + compsub +else + # Let's see if we have a special completion definition for the other + # possible contexts. + + comp='' + + case $CONTEXT in + redirect) name=--redirect--;; + math) name=--math--;; + subscript) name=--subscript--;; + value) name=--value--;; + condition) name=--condition--;; + esac + + # If not, we use default completion, if any. + + comp="$comps[$name]" + if [[ -z "$comp" ]]; then + name=--default-- + comp="$comps[--default--]" + fi + [[ -z "$comp" ]] || callcomplete comps "$name" "$@" || return 1 +fi diff --git a/Functions/Completion/__main_key_complete b/Functions/Completion/__main_key_complete new file mode 100644 index 000000000..35fa1a0a3 --- /dev/null +++ b/Functions/Completion/__main_key_complete @@ -0,0 +1,6 @@ +#helper + +# The widget name looks like `__complete_key_<num>' where <num> can be +# used as an index into the `keycomps' array to get at the definition. + +callcomplete keycomps "$WIDGET" "$@" diff --git a/Functions/Completion/__make b/Functions/Completion/__make new file mode 100644 index 000000000..4a2c5a7c8 --- /dev/null +++ b/Functions/Completion/__make @@ -0,0 +1,3 @@ +#function make gmake pmake + +complist -s "\$(awk '/^[a-zA-Z0-9][^/ ]+:/ {print \$1}' FS=: [mM]akefile)" diff --git a/Functions/Completion/__man b/Functions/Completion/__man new file mode 100644 index 000000000..a0f00f58b --- /dev/null +++ b/Functions/Completion/__man @@ -0,0 +1,11 @@ +#function man +setopt localoptions rcexpandparam + +local rep +if [[ $2 = (<->*|ln) ]]; then + rep=( $manpath/(man|cat)$2/$PREFIX*$SUFFIX.<->*(N:t:r) ) +else + rep=( $manpath/(man|cat)*/$PREFIX*$SUFFIX.<->*(N:t:r) ) +fi + +(( $#rep )) && compadd -m $rep diff --git a/Functions/Completion/__mh b/Functions/Completion/__mh new file mode 100644 index 000000000..2e4738e17 --- /dev/null +++ b/Functions/Completion/__mh @@ -0,0 +1,70 @@ +#function folder comp inc mark refile repl scan show next prev rmm pick whom mhn mhpath mhpatch + +# Completion for all possible MH commands. +# Alter the following two to your own mh directory and the directory +# where standard mh library files live. (It works anyway, but this +# will save a little time.) +local mymhdir=~/Mail +local mhlib=/usr/lib/mh + +# To be on the safe side, check this exists and if not, get it anyway. +[[ -d $mymhdir ]] || mymhdir=$(mhpath +) + +if [[ -iprefix - ]]; then + # get list of options, which MH commands can generate themselves + # awk is just too icky to use for this, sorry. send me one if + # you come up with it. + compadd -m $($COMMAND -help | perl -ne 'if (/^\s*-\(?(\S+)/) { + $n = $1; + $n =~ s/\)//g; + print $n =~ s/^\[([a-z]+)\]// ? "$n\n$1$n\n" : "$n\n"; + }') + return +elif [[ -iprefix '+' || -iprefix '@' || -current -1 -draftfolder ]]; then + # Complete folder names. + local mhpath + if [[ $IPREFIX != '@' ]]; then + [[ $IPREFIX = '+' ]] || IPREFIX=+ + mhpath=$mymhdir + else + mhpath=$(mhpath) + fi + + # painless, or what? + complist -W mhpath -/ +elif [[ -mcurrent -1 -(editor|(whatnow|rmm|show|more)proc) ]]; then + complist -c +elif [[ -current -1 -file ]]; then + complist -f +elif [[ -mcurrent -1 -(form|audit|filter) ]]; then + # Need some MH template file, which may be in our own MH directory + # or with the standard library. + local mhfpath + # This is the only place we need mhlib, so leave the test till here. + [[ -d $mhlib ]] || { mhlib=$(mhparam mhlproc); mhlib=$mhlib:h; } + mhfpath=($mymhdir $mhlib) + + complist -W mhfpath -g '*(.)' +elif [[ -mcurrent -1 -(no|)cc ]]; then + compadd -m all to cc me +elif [[ -mcurrent -1 -[rw]cache ]]; then + compadd -m public private never ask +else + # Generate sequences. + local foldnam folddir f + for f in $argv; do + [[ $f = [@+]* ]] && foldnam=$f + done + if [[ $foldnam = '+'* ]]; then + folddir=$mymhdir/${foldnam#+} + elif [[ $foldnam = '@'* ]]; then + folddir=$(mhpath)/${foldnam#@} + else + folddir=$(mhpath) + # leaving foldnam empty works here + fi + + complist -s '$(mark $foldnam | awk -F: '\''{ print $1 }'\'')' + compadd -m reply next cur prev first last all unseen + complist -W folddir -g '<->' +fi diff --git a/Functions/Completion/__most_recent_file b/Functions/Completion/__most_recent_file new file mode 100644 index 000000000..cf1f83282 --- /dev/null +++ b/Functions/Completion/__most_recent_file @@ -0,0 +1,2 @@ +#key-array expand-or-complete \C-xm +__most_recent_file=(-g '*(om[1])') diff --git a/Functions/Completion/__normal b/Functions/Completion/__normal new file mode 100644 index 000000000..7750563d1 --- /dev/null +++ b/Functions/Completion/__normal @@ -0,0 +1,54 @@ +#helper + +local comp cmd1 cmd2 pat val name + +# Completing in command position? If not we set up `cmd1' and `cmd2' as +# two strings we have search in the completion definition arrays (e.g. +# a path and the last path name component). + +if [[ $CONTEXT == command ]]; then + comp="$comps[--command--]" + [[ -z "$comp" ]] || callcomplete comps --command-- "$@" || return 1 + return 0 +elif [[ "$COMMAND[1]" == '=' ]]; then + eval cmd1\=$COMMAND + cmd2="$COMMAND[2,-1]" +elif [[ "$COMMAND" == */* ]]; then + cmd1="$COMMAND" + cmd2="${COMMAND:t}" +else + cmd1="$COMMAND" + eval cmd2=$(whence -p $COMMAND) +fi + +# See if there are any matching pattern completions. + +if (( $#patcomps )); then + for i in "$patcomps[@]"; do + pat="${i% *}" + val="${i#* }" + if [[ "$cmd1" == $~pat || "$cmd2" == $~pat ]]; then + callcomplete patcomps "$pat" "$@" || return 1 + fi + done +fi + +# Now look up the two names in the normal completion array. + +name="$cmd1" +comp="$comps[$cmd1]" + +if [[ -z "$comp" ]]; then + name="$cmd2" + comp="$comps[$cmd2]" +fi + +# And generate the matches, probably using default completion. + +if [[ -z "$comp" ]]; then + name=--default-- + comp="$comps[--default--]" +fi +[[ -z "$comp" ]] || callcomplete comps "$name" "$@" || return 1 + +return 0 diff --git a/Functions/Completion/__path_files b/Functions/Completion/__path_files new file mode 100644 index 000000000..f9e7c631a --- /dev/null +++ b/Functions/Completion/__path_files @@ -0,0 +1,272 @@ +#helper + +# Utility function for in-path completion. +# First argument should be an complist-option (e.g. -f, -/, -g). The other +# arguments should be glob patterns, one per argument. +# +# E.g.: __path_files -g '*.tex' '*.texi' +# +# This is intended as a replacement for `complist -f', `complist -/', and +# `complist -g ...' (but don't use it with other options). +# +# You may also give the `-W <spec>' option as with `compctl' and `complist', +# but only as the first argument. +# +# This function also accepts an optional `-F <string>' option as its first +# argument or just after the `-W <spec>'. This can be used to define file +# name extension (a la `fignore'). Files with such an extension will not +# be considered possible completions. +# +# This function behaves as if you have a matcher definition like: +# compctl -M 'r:|[-.,_/]=* r:|=* m:{a-z}={A-Z} m:-=_ m:.=,' \ +# 'm:{a-z}={A-Z} l:|=* r:|=*' +# so you may want to modify this. + +local nm prepaths str linepath realpath donepath patstr prepath testpath rest +local tmp1 collect tmp2 suffixes i ignore + +setopt localoptions nullglob rcexpandparam globdots extendedglob +unsetopt markdirs globsubst shwordsplit nounset + +# Get the optional `-W' option and its argument. +if [[ "$1" = -W ]]; then + tmp1="$2" + if [[ "$tmp1[1]" = '(' ]]; then + prepaths=( $tmp1[2,-2]/ ) + else + prepaths=( ${(P)${tmp1}} ) + [[ $#prepaths -eq 0 ]] && prepaths=( $tmp1/ ) + fi + [[ $#prepaths -eq 0 ]] && prepaths=( '' ) + shift 2 +else + prepaths=( '' ) +fi + +# Get the optional `-F' option and its argument. +if [[ "$1" = -F ]]; then + ignore=(-F "$2") + shift 2 +else + ignore='' +fi + +# str holds the whole string from the command line with a `*' between +# the prefix and the suffix. + +str="${PREFIX:q}*${SUFFIX:q}" + +# We will first try normal completion called with `complist', but only if we +# weren't given a `-F' option. + +if [[ -z "$ignore" ]]; then + # First build an array containing the `-W' option, if there is any and we + # want to use it. We don't want to use it if the string from the command line + # is a absolute path or relative to the current directory. + + if [[ -z "$tmp1[1]" || "$str[1]" = [~/] || "$str" = (.|..)/* ]]; then + tmp1=() + else + tmp1=(-W "( $ppres )") + fi + + # Now call complist. + + nm=$NMATCHES + if [[ $# -eq 0 ]]; then + complist "$tmp1[@]" -f + elif [[ "$1" = -g ]]; then + complist "$tmp1[@]" -g "$argv[2,-1]" + shift + else + complist "$tmp1[@]" $1 + shift + fi + + # If this generated any matches, we don't wnat to do in-path completion. + + [[ -nmatches nm ]] || return + + # No `-F' option, so we want to use `fignore'. + + ignore=(-F fignore) +fi + +# If we weren't given any file patterns as arguments, we trick ourselves +# into believing that we were given the pattern `*'. This is just to simplify +# the following code. + +[[ -z "$1" ]] && 1='*' + +# Now let's have a closer look at the string to complete. + +if [[ "$str[1]" = \~ ]]; 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="${str%%/*}/" + eval realpath\=path + str="${str#*/}" + donepath='' + prepaths=( '' ) +else + # If the string does not start with a `~' we don't remove a prefix from the + # string. + + liniepath='' + realpath='' + + if [[ "$str[1]" = / ]]; then + # If it is a absolut 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'. + + str="$str[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'. + + [[ "$str" = (.|..)/* ]] && prepaths=( '' ) + donepath='' + fi +fi + +# First we skip over all pathname components in `str' which really exist in +# the file-system, so that `/usr/lib/l<TAB>' doesn't offer you `lib' and +# `lib5'. Pathname components skipped this way are taken from `str' and added +# to `donepath'. + +while [[ "$str" = */* ]] do + [[ -e "$realpath$donepath${str%%/*}" ]] || break + donepath="$donepath${str%%/*}/" + str="${str#*/}" +done + +# Now build the glob pattern. As noted above, this function behaves as if +# a global matcher with two matching specifications are given. + +if [[ -matcher 1 ]]; then + patstr="$str:gs/,/*,/:gs/_/*_/:gs./.*/.:gs/-/*[-_]/:gs/./*[.,]/:gs-*[.,]*[.,]*/-../-:gs.**.*." +else + patstr="${str%/*}/*${str##*/}*" + patstr="$patstr:gs./.*/.:gs.**.*." +fi + +# Finally, generate the matches. First we loop over all the paths from `-W'. +# Note that in this loop `str' is used as a modifyable version of `patstr' +# and `testpath' is a modifyable version of `donepath'. + +for prepath in "$prepaths[@]"; do + str="$patstr" + testpath="$donepath" + + # The second loop tests the components of the path in `str' to get the + # possible matches. + + while [[ "$str" = */* ]] do + # `rest' is the pathname after the first slash that is left. In `tmp1' + # we get the globbing matches for the pathname component currently + # handled. + + rest="${str#*/}" + tmp1="${prepath}${realpath}${testpath}(#l)${str%%/*}(-/)" + tmp1=( $~tmp1 ) + + if [[ $#tmp1 -eq 0 ]]; then + # If this didn't produce any matches, we don't need to test this path + # any further, so continue with the next `-W' path, if any. + + continue 2 + elif [[ $#tmp1 -gt 1 ]]; then + # If it produced more than one match, we want to remove those which + # don't have possible following pathname components matching the + # rest of the string we are completing. (The case with only one + # match is handled below.) + # In `collect' we will collect those of the produced pathnames that + # have a matching possible path-suffix. In `suffixes' we build an + # array containing strings build from the rest of the string to + # complete and the glob patterns we were given as arguments. + + collect=() + suffixes=( $rest$@ ) + suffixes=( "${(@)suffixes:gs.**.*.}" ) + + # In the loop the prefixes from the `tmp1' array produced above and + # the suffixes we just built are used to produce possible matches + # via globbing. + + for i in $tmp1; do + tmp2=( $~i/(#l)$~suffixes ) + [[ $#tmp2 -ne 0 ]] && collect=( $collect $i ) + done + + # If this test showed that none of the matches from the glob in `tmp1' + # has a possible sub-path matching what's on the line, we give up and + # continue with the next `-W' path. + + if [[ $#collect -eq 0 ]]; then + continue 2 + elif [[ $#collect -ne 1 ]]; then + # If we have more than one possible match, this means that the + # pathname component currently handled is ambiguous, so we give + # it to the completion code. + # First we build the full path prefix in `tmp1'. + + tmp1="$prepath$realpath$testpath" + + # Now produce all matching pathnames in `collect'. + + collect=( $~collect/(#l)$~suffixes ) + + # And then remove the common path prefix from all these matches. + + collect=( ${collect#$tmp1} ) + + # Finally, we add all these matches with the common (unexpanded) + # pathprefix (the `-p' option), the path-prefix (the `-W' option) + # to allow the completion code to test file type, and the path- + # suffix (the `-s' option). We also tell the completion code that + # these are file names and that `fignore' should be used as usual + # (the `-f' and `-F' options). + + for i in $collect; do + compadd -p "$linepath$testpath" -W "$tmp1" -s "/${i#*/}" -f "$ignore[@]" -- "${i%%/*}" + done + + # We have just finished handling all the matches from above, so we + # can continue with the next `-W' path. + + continue 2 + fi + # We reach this point if only one of the path prefixes in `tmp1' + # has a existing path-suffix matching the string from the line. + # In this case we accept this match and continue with the next + # path-name component. + + tmp1=( "$collect[1]" ) + fi + # This is also reached if the first globbing produced only one match + # in this case we just continue with the next pathname component, too. + + tmp1="$tmp1[1]" + testpath="$testpath${tmp1##*/}/" + str="$rest" + done + + # We are here if all pathname components except the last one (which is still + # not tested) are unambiguous. So we add matches with the full path prefix, + # no path suffix, the `-W' we are currently handling, all the matches we + # can produce in this directory, if any. + + tmp1="$prepath$realpath$testpath" + suffixes=( $str$@ ) + suffixes=( "${(@)suffixes:gs.**.*.}" ) + tmp2=( $~tmp1(#l)$~suffixes ) + compadd -p "$linepath$testpath" -W "$prepath$realpath$testpath" -f "$ignore[@]" -- ${tmp2#$tmp1} +done diff --git a/Functions/Completion/__pdf b/Functions/Completion/__pdf new file mode 100644 index 000000000..97f656f40 --- /dev/null +++ b/Functions/Completion/__pdf @@ -0,0 +1,3 @@ +function acroread + +__files -g '*.(pdf|PDF)' diff --git a/Functions/Completion/__precommand b/Functions/Completion/__precommand new file mode 100644 index 000000000..a07cae96a --- /dev/null +++ b/Functions/Completion/__precommand @@ -0,0 +1,15 @@ +#function - nohup nice eval time rusage noglob nocorrect exec + +# We just change the special completion parameters, to make the first +# argument be treated as the command name and removing it from the +# positional parameters. + +COMMAND="$1" +shift +(( CURRENT-- )) +if [[ CURRENT -eq 0 ]]; then + CONTEXT=command +else + CONTEXT=argument +fi +compsub diff --git a/Functions/Completion/__ps b/Functions/Completion/__ps new file mode 100644 index 000000000..fa7395113 --- /dev/null +++ b/Functions/Completion/__ps @@ -0,0 +1,3 @@ +#function gs ghostview gview psnup psselect pswrap pstops pstruct lpr + +__files -g '*([pP][sS]|eps)' diff --git a/Functions/Completion/__rcs b/Functions/Completion/__rcs new file mode 100644 index 000000000..8d55cc470 --- /dev/null +++ b/Functions/Completion/__rcs @@ -0,0 +1,9 @@ +#function co ci rcs + +[[ $COMMAND = ci || $COMMAND = rcs ]] && __files + +if [[ $NMATCHES -eq 0 && -d RCS && $COMMAND != ci ]]; then + local rep + rep=(RCS/$PREFIX*$SUFFIX,v(:t:s/\,v//)) + (( $#rep )) && compadd -m $rep +fi diff --git a/Functions/Completion/__rlogin b/Functions/Completion/__rlogin new file mode 100644 index 000000000..69fdebe13 --- /dev/null +++ b/Functions/Completion/__rlogin @@ -0,0 +1,9 @@ +#function rlogin rsh ssh + +if [[ -position 1 ]]; then + complist -k hosts +elif [[ -position 2 ]]; then + complist -k '(-l)' +else + complist -u +fi diff --git a/Functions/Completion/__sched b/Functions/Completion/__sched new file mode 100644 index 000000000..dcd7385e1 --- /dev/null +++ b/Functions/Completion/__sched @@ -0,0 +1,3 @@ +#function sched + +[[ -position 2 -1 ]] && compsub diff --git a/Functions/Completion/__set b/Functions/Completion/__set new file mode 100644 index 000000000..e9db6c43a --- /dev/null +++ b/Functions/Completion/__set @@ -0,0 +1,7 @@ +#function set + +if [[ -mcurrent -1 [-+]o ]]; then + complist -o +elif [[ -current -1 -A ]]; then + complist -A +fi diff --git a/Functions/Completion/__setopt b/Functions/Completion/__setopt new file mode 100644 index 000000000..8a97befc7 --- /dev/null +++ b/Functions/Completion/__setopt @@ -0,0 +1,7 @@ +#function setopt + +local nm=$NMATCHES + +complist -M 'L:|[nN][oO]= M:_= M:{A-Z}={a-z}' \ + -s '$({ unsetopt kshoptionprint; unsetopt } 2>/dev/null)' +[[ -nmatches nm ]] && complist -M 'L:|[nN][oO]= M:_= M:{A-Z}={a-z}' -o diff --git a/Functions/Completion/__source b/Functions/Completion/__source new file mode 100644 index 000000000..3478c9f38 --- /dev/null +++ b/Functions/Completion/__source @@ -0,0 +1,7 @@ +#function source + +if [[ -position 2 -1 ]]; then + compsub +else + __files +fi diff --git a/Functions/Completion/__strip b/Functions/Completion/__strip new file mode 100644 index 000000000..9abd38b63 --- /dev/null +++ b/Functions/Completion/__strip @@ -0,0 +1,2 @@ +#function strip +__files -g '*(*)' diff --git a/Functions/Completion/__stty b/Functions/Completion/__stty new file mode 100644 index 000000000..ebf0de68f --- /dev/null +++ b/Functions/Completion/__stty @@ -0,0 +1,16 @@ +#function stty + +if [[ -mcurrent -1 \ + (*erase|discard|status|dsusp|intr|kill|lnext|quit|reprint|start|s*p) ]] +then + compadd -m -Q '^-' '^h' '^?' '^c' '^u' +else + [[ -string '-' || -string '+' ]] + compadd -m rows columns intr quit erase kill eof eol \ + eol2 start stop susp dsusp reprint discard werase lnext \ + parenb parodd cs8 cstopb hupcl cread clocal parext \ + ignbrk brkint ignpar parmrk inpck istrip inlcr igncr icrnl iuclc \ + ixon ixany ixoff imaxbel isig icanon xcase echo echoe echok \ + echonl noflsh tostop echoctl echoprt echoke flusho pending iexten \ + opost olcuc onlcr ocrnl onocr onlret ofill ofdel +fi diff --git a/Functions/Completion/__subscript b/Functions/Completion/__subscript new file mode 100644 index 000000000..a10b1202b --- /dev/null +++ b/Functions/Completion/__subscript @@ -0,0 +1,4 @@ +#function --subscript-- + +compalso --math-- "$@" +[[ ${(Pt)${COMMAND}} = assoc* ]] && complist -k "( ${(kP)${COMMAND}} )" diff --git a/Functions/Completion/__tar b/Functions/Completion/__tar new file mode 100644 index 000000000..4f8b51a00 --- /dev/null +++ b/Functions/Completion/__tar @@ -0,0 +1,14 @@ +#function tar + +local nm=$NMATCHES tf="$2" +compsave + +if [[ ( -mword 1 *t*f* || -mword 1 *x*f* ) && -position 3 100000 ]]; then + complist -k "( $(tar tf $tf) )" + compreset +elif [[ -mword 1 *c*f* && -position 3 100000 ]]; then + __files + compreset +elif [[ -mcurrent -1 *f* && -position 2 ]]; then + __files -g '*.(tar|TAR)' +fi diff --git a/Functions/Completion/__tex b/Functions/Completion/__tex new file mode 100644 index 000000000..7331bb794 --- /dev/null +++ b/Functions/Completion/__tex @@ -0,0 +1,3 @@ +#function tex latex slitex + +__files -g '*.(tex|TEX|texinfo|texi)' diff --git a/Functions/Completion/__trap b/Functions/Completion/__trap new file mode 100644 index 000000000..0171bdc2b --- /dev/null +++ b/Functions/Completion/__trap @@ -0,0 +1,7 @@ +#function trap + +if [[ -position 1 ]]; then + complist -c +else + complist -k signals +fi diff --git a/Functions/Completion/__uncompress b/Functions/Completion/__uncompress new file mode 100644 index 000000000..91343521e --- /dev/null +++ b/Functions/Completion/__uncompress @@ -0,0 +1,3 @@ +#function uncompress zmore + +__files -g '*.Z' diff --git a/Functions/Completion/__unhash b/Functions/Completion/__unhash new file mode 100644 index 000000000..73196ca1b --- /dev/null +++ b/Functions/Completion/__unhash @@ -0,0 +1,6 @@ +#function unhash + +[[ -mword 1 -*d* ]] && complist -n +[[ -mword 1 -*a* ]] && complist -a +[[ -mword 1 -*f* ]] && complist -F +[[ ! -mword 1 -* ]] && complist -m diff --git a/Functions/Completion/__unsetopt b/Functions/Completion/__unsetopt new file mode 100644 index 000000000..c9a074d9b --- /dev/null +++ b/Functions/Completion/__unsetopt @@ -0,0 +1,7 @@ +#function unsetopt + +local nm=$NMATCHES + +complist -M 'L:|[nN][oO]= M:_= M:{A-Z}={a-z}' \ + -s '$({ unsetopt kshoptionprint; setopt } 2>/dev/null)' +[[ -nmatches nm ]] && complist -M 'L:|[nN][oO]= M:_= M:{A-Z}={a-z}' -o diff --git a/Functions/Completion/__vars b/Functions/Completion/__vars new file mode 100644 index 000000000..649e347fa --- /dev/null +++ b/Functions/Completion/__vars @@ -0,0 +1,2 @@ +#array --math-- getopts read unset vared +__vars=(-v) diff --git a/Functions/Completion/__vars_eq b/Functions/Completion/__vars_eq new file mode 100644 index 000000000..e0b5d9ae5 --- /dev/null +++ b/Functions/Completion/__vars_eq @@ -0,0 +1,2 @@ +#array declare export integer local readonly typeset +__varseq=(-v -q -S '=') diff --git a/Functions/Completion/__wait b/Functions/Completion/__wait new file mode 100644 index 000000000..1c04108f6 --- /dev/null +++ b/Functions/Completion/__wait @@ -0,0 +1,4 @@ +#function wait + +complist -P '%' -j +complist -y __kill_helper -s '`ps 2>/dev/null | tail +2 | cut -c1-5`' diff --git a/Functions/Completion/__which b/Functions/Completion/__which new file mode 100644 index 000000000..32b95b9c5 --- /dev/null +++ b/Functions/Completion/__which @@ -0,0 +1,2 @@ +#array which whence where type +__which=(-caF) diff --git a/Functions/Completion/__x_options b/Functions/Completion/__x_options new file mode 100644 index 000000000..d5f85ea36 --- /dev/null +++ b/Functions/Completion/__x_options @@ -0,0 +1,5 @@ +#pattern-function '*/X11/*' + +# A simple pattern completion, just as an example. + +complist -J options -k '(-display -name -xrm)' diff --git a/Functions/Completion/__xfig b/Functions/Completion/__xfig new file mode 100644 index 000000000..7f17c2e42 --- /dev/null +++ b/Functions/Completion/__xfig @@ -0,0 +1,3 @@ +#function xfig + +__files -g '*.fig' diff --git a/Functions/Completion/__zle b/Functions/Completion/__zle new file mode 100644 index 000000000..f677374c8 --- /dev/null +++ b/Functions/Completion/__zle @@ -0,0 +1,7 @@ +#function zle + +if [[ -word 1 -N && -position 3 ]]; then + complist -F +else + complist -b +fi diff --git a/Functions/Completion/__zmodload b/Functions/Completion/__zmodload new file mode 100644 index 000000000..78c7393a3 --- /dev/null +++ b/Functions/Completion/__zmodload @@ -0,0 +1,9 @@ +#function zmodload + +if [[ -mword 1 -*(a*u|u*a)* || -mword 1 -*a* && -position 3 -1 ]]; then + complist -B +elif [[ -mword 1 -*u* ]]; then + complist -s '$(zmodload)' +else + complist -s '${^module_path}/*(N:t:r)' +fi diff --git a/Functions/Completion/init b/Functions/Completion/init new file mode 100644 index 000000000..a40c5f61b --- /dev/null +++ b/Functions/Completion/init @@ -0,0 +1,253 @@ +# Initialisation for new style completion. This mainly contains some helper +# function and aliases. Everything else is split into different files in this +# directory that will automatically be made autoloaded (see the end of this +# file). +# The names of the files that will be considered for autoloading have to +# start with two underscores (like `__setopt). +# The first line of these files will be read and has to say what should be +# done with its contents: +# +# `#function <names ...>' +# if the first line looks like this, the file is +# autoloaded as a function and that function will +# be called to generate the matches when completing +# for one of the commands whose <name> is given +# +# `#array <names ...>' +# with a first line like this, the filename is taken as +# the name of an array; when trying to generate matches +# for the command <name>, the file will be sourced and +# should define this array, the builtin `complist' will +# then be called with the elements of this array as its +# arguments; this is intended for simple definitions +# for which you don't need a shell function +# +# `#pattern-function <pattern>' +# this defines a function that should be called to generate +# matches for commands whose name matches <pattern>; note +# that only one pattern may be given +# +# `#pattern-array <pattern>' +# like `#pattern-function' but defining an array +# +# `#key-function <style> [ <key-sequence> ... ] +# this is used to bind special completions to all the given +# <key-sequence>(s). The <style> is the name of one of the built-in +# completion widgets (complete-word, delete-char-or-list, +# expand-or-complete, expand-or-complete-prefix, list-choices, +# menu-complete, menu-expand-or-complete, or reverse-menu-complete). +# This creates a widget behaving like <style> so that the +# completions are chosen as given in the the rest of the file, +# rather than by the context. The widget has the same name as +# the autoload file and can be bound using bindkey in the normal way. +# +# `#key-array <style> [ <key-sequence> ... ] +# like `#key-function', but defining an array instead +# +# `#helper' +# this is for helper functions that are not used to +# generate matches, but should automatically be loaded +# when they are called +# +# Note that no white space is allowed between the `#' and the rest of +# the string. + + +# An associative array for completions definitions. The keys of the entries +# are the names of the command, the values are names of functions or variables +# that are to be used to generate the matches. +# Pattern completions will be stored in an normal array named `patcomps'. +# Completion definitions bound directly to keys are stored in an assoc array +# named `keycomps'. + +typeset -A comps +typeset -A keycomps + + +# This may be used to define completion handlers. The first argument is the +# name of the function or variable containing the definition, the other +# arguments are the command names for which this definition should be used. +# With only one argument the function/variable-name __$1 is used. +# If given the `-a' option, the function is defined as being autoloaded. + +defcomp() { + local name autol='' + + if [[ "$1" = -a ]]; then + shift + autol=yes + fi + if [[ $# -eq 1 ]]; then + comps[$1]="__$1" + [[ -z "$autol" ]] || autoload "__$1" + else + name="$1" + shift + for i; do + comps[$i]="$name" + done + [[ -z "$autol" ]] || autoload "$name" + fi +} + + +# Almost like `defcomp', but this always gets two arguments: the name of a +# variable or function describing what should be completed and the pattern +# that will be compared to the command names for which completion is attempted. + +defpatcomp() { + if [[ "$1" = -a ]]; then + shift + autoload "$1" + fi + if (( $+patcomps )) then + patcomps=("$patcomps[@]" "$2 $1" ) + else + patcomps=( "$2 $1" ) + fi +} + + +# This is used to define completion handlers directly bound to keys. The +# first argument is as for `defcomp', giving the handler. The second +# argument is the name of one of the built-in completion widgets. Any +# remaining arguments are used as key sequences to bind the widget. +# Typing that key sequence will complete the word the cursor is on +# according to the completion definition given and will behave as if the +# built-in completion widget was used. + +defkeycomp() { + local name + + if [[ "$1" = -a ]]; then + shift + autoload "$1" + name="$1" + elif [[ "${1[1]}" = ' ' ]]; then + name="${1:t}" + else + name="$1" + fi + keycomps[$name]="$1" + shift + zle -C "$name" "$1" __main_key_complete + shift + while (( $# )); do + bindkey "$1" "$name" + shift + done +} + +# These can be used to easily save and restore the state of the special +# variables used by the completion code. + +alias compsave='local _oprefix _oiprefix _oargv _ocurrent; \ + _oprefix="$PREFIX"; \ + _oiprefix="$IPREFIX"; \ + _oargv=( "$@" ); \ + _ocurrent="$CURRENT"' +alias compreset='PREFIX="$_oprefix"; \ + IPREFIX="$_oiprefix"; \ + argv=( "$_oargv[@]" ); \ + CURRENT="$_ocur"' + + +# This is an easy way to get completion for sub-commands. + +alias compsub='__normal "$@" || return 1' + + +# This searches $1 in the array for normal completions and calls the result. + +compalso() { + local tmp + + tmp="$comps[$1]" + [[ -z "$tmp" ]] || callcomplete comps "$1" "$@" +} + + +# This generates matches. The first argument is the name of one of the +# arrays containing completion definitions. The second argument is the index +# into this array. The other arguments are the positional parameters to give +# to the completion function (containing the arguments from the command line). + +callcomplete() { + local file def + + # Get the definition from the array. + + eval "def=\$${1}[${2}]" + + # If the definition starts with a space then this means that we should + # source a file to get the definition for an array. + + if [[ "$def[1]" = ' ' ]]; then + # The definition starts with a space, so source the file and change + # the definition. + + file="$def[2,-1]" + builtin . "$file" + def="${file:t}" + eval "${1}[${2}]=$def" + fi + + # Get rid of the array-name and -index. + + shift 2 + if [[ ${(P)+def} -eq 1 ]]; then + # It is a parameter name, call complist directly. + + complist "${(@P)def}" + else + # Otherwise it's a function name, call this function. + + "$def" "$@" + fi +} + + +# Now we make the files automatically autoloaded. + +local dir file line func + +for dir in $fpath; do + [[ $dir = . ]] && continue + for file in $dir/__*~*~(N); do + read -rA line < $file + func=$line[1] + shift line + if [[ $func = '#function' ]]; then + defcomp -a ${file:t} "${line[@]}" + elif [[ $func = '#array' ]]; then + defcomp " $file" "${line[@]}" + elif [[ $func = '#pattern-function' ]]; then + defpatcomp -a ${file:t} "${line[@]}" + elif [[ $func = '#pattern-array' ]]; then + defcomp " $file" "${line[@]}" + elif [[ $func = '#key-function' ]]; then + defkeycomp -a "${file:t}" "${line[@]}" + elif [[ $func = '#key-array' ]]; then + defkeycomp " $file" "${line[@]}" + elif [[ $func = '#helper' ]]; then + autoload ${file:t} + fi + done +done + + +# Finally we make all this be called by changing the key bindings. + +bindkey | while read -A line; do + if [[ "$line[2]" = complete-word || + "$line[2]" = delete-char-or-list || + "$line[2]" = expand-or-complete || + "$line[2]" = expand-or-complete-prefix || + "$line[2]" = list-choices || + "$line[2]" = menu-complete || + "$line[2]" = menu-expand-or-complete || + "$line[2]" = reverse-menu-complete ]]; then + zle -C __complete_$line[2] $line[2] __main_complete + bindkey "${line[1][2,-2]}" __complete_$line[2] + fi + done |