#compdef autoload declare export functions integer float local readonly typeset local expl state line func i use curcontext="$curcontext" local fopts="-f -k -z +k +z" local popts="-A -E -F -L -R -T -Z -a -g -h -H -i -l -r -x" local -A allargs opt_args local -a args allargs=( A "($fopts -E -F -L -R -T -U -Z -a -i -m)-A[specify that arguments refer to associative arrays]" E "($fopts -A -F -L -R -T -U -Z -a -i -m)-E[floating point, use engineering notation on output]" F "($fopts -A -E -L -R -T -U -Z -a -i -m)-F[floating point, use fixed point decimal on output]" L "($fopts -A -E -F -i)-L+[left justify and remove leading blanks from value]:width" R "($fopts -A -E -F -i)-R+[right justify and fill with leading blanks]:width" T "($fopts -A -E -F -a -g -h -i -l -m -t)-T[tie scalar to array or trace function]" Tf "($popts -t)-T[trace execution of this function only]" Tp "($fopts -A -E -F -a -g -h -i -l -m -t)-T[tie scalar to array]" U '(-A -E -F -i)-U[keep array values unique and suppress alias expansion for functions]' Uf '-U[suppress alias expansion for functions]' Up '(-E -F -i)-+U[keep array values unique]' X '+X[immediately autoload function]' Z "($fopts -A -E -F -i)-Z+[right justify and fill with leading zeros]:width" a "($fopts -A -E -F -T -i)-a[specify that arguments refer to arrays]" df "-d[default absolute path autoload to fpath]" f "($popts)-f[specify that arguments refer to functions]" g "($fopts -T)-+g[do not restrict parameter to local scope]" h "($fopts -T)-+h[hide specialness of parameter]" H "($fopts -T)-+H[hide value of parameter in listings]" i "($fopts -A -E -F -T)-+i[represent internally as an integer]" k "($popts -w -z)-+k[mark function for ksh-style autoloading]" l "($popts -T)-l[convert the value to lowercase]" m '(-A -E -F -T -i)-m[treat arguments as patterns]' p '-p+[output parameters in form of calls to typeset]::option:((1\:multi-line\ output\ of\ arrays))' r '(-f)-+r[mark parameters as readonly]' rf '-r[remember autoload path]' Rf '-R[remember autoload path, error if not found]' t '(-T)-+t[tag parameters and turn on execution tracing for functions]' tf '(-T)-+t[turn on execution tracing for functions]' tp '(-T)-+t[tag parameters]' u '-u[convert the value to uppercase or mark function for autoloading]' uf '-u[mark function for autoloadling]' up '-u[convert the value to uppercase]' w '(-k -z)-w[specify that arguments refer to files compiled with zcompile]' W '-+W[turn on WARN_NESTED_VAR for function]' x "($fopts)-+x[export parameter]" z "($popts -k -w)-+z[mark function for zsh-style autoloading]" ) use="AEFHLRTUZafghiklmprtuxz" case ${service} in autoload) use="URTXdkrtwz" func=f ;; float) use="EFHghlprtux";; functions) use="UkmTtuzW" func=f args=( '(-k -t -T -u -U -W -x -z -M +M +k +t +W +z)-+M[define mathematical function]' '(-k -m -t -T -u -U -W -x -z +M +k +t +W +z)-s[define mathematical function that takes a string argument]' '(-M)-x+[specify spaces to use for indentation]:spaces' '(-* +*)-c[copy shell function to another name]:old name:_functions:new name:_functions' ) ;; integer) use="Hghilprtux" allargs[i]='-i+[specify arithmetic base for output]:: :_guard "[0-9]#" base' \ ;; readonly) use="${use/r/}" ;; local) use="${use/[fkz]/}" ;& export) use="${${use//[gkz]/}/x/}" ;; esac [[ -z "${words[(r)-*[aA]*]}" ]] || func=p [[ -z "${words[(r)-*f*]}" ]] || func=f # This function uses whacky features of _arguments which means we # need to look for options to the command beforehand. local onopts offopts onopts=${(j..)${${words[1,CURRENT-1]:#^-*}##-}} offopts=${(j..)${${words[1,CURRENT-1]:#^+*}##+}} for ((i=1;i<=$#use;++i)); do args+=( ${allargs[${use[$i]}${${(s::)use[$i]}[(r)[dUurRtT]]:+$func}]} ) done _arguments -C -s -A "-*" -S "${args[@]}" '*::vars:= ->vars_eq' if [[ "$state" = vars_eq ]]; then if [[ $func = f ]]; then if (( $+opt_args[+M] || ( $+opt_args[-M] && $+opt_args[-m] ) )); then _wanted functions expl 'math function' compadd -F line - \ ${${${(f)"$(functions -M)"}##*-M }%% *} elif (( $+opt_args[-M] )); then _arguments ':new math function:_functions' \ ":minimum arguments${(k)opt_args[-s]:+:(1)}" \ ":maximum arguments${(k)opt_args[-s]:+:(1)}" \ ':shell function:_functions' elif (( $+opt_args[-w] )); then _wanted files expl 'zwc file' _files -g '*.zwc(-.)' elif [[ $service = autoload || -n $opt_args[(i)-[uU]] ]]; then if [[ $PREFIX[1] = [/~] ]]; then # Autoload by absolute path _files else args=(${^fpath}/*(-.:t)) # Filter out functions already loaded or marked for autoload. local -a funckeys funckeys=(${(k)functions}) args=(${args:|funckeys}) _wanted functions expl 'shell function' compadd -a args fi elif [[ -n $onopts$offopts ]]; then if [[ -n $offopts ]]; then args=(${(f)"$(functions +${offopts//[^UXkmtTuz]/})"}) else args=(${(k)functions}) fi if [[ -n $onopts ]]; then local -a funckeys funckeys=(${(f)"$(functions +${onopts//[^UXkmtTuz]/})"}) args=(${args:|funckeys}) fi if zstyle -t ":completion:${curcontext}:functions" prefix-needed && [[ $PREFIX != [_.]* ]]; then args=(${args:#_*}) fi _wanted functions expl 'shell function' compadd -a args else _functions fi elif [[ "$PREFIX" = *\=* ]]; then compstate[parameter]="${PREFIX%%\=*}" compset -P 1 '*=' _value elif (( $+opt_args[-a] || $+opt_args[-A] )); then _parameters -q elif (( $+opt_args[-T] )); then _arguments \ ':scalar parameter:_parameters -g "*scalar*" -q -S "="' \ ':array parameter:_parameters -g "*array*"' \ ':separator character' else _parameters -q -S '=' fi fi