1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
#compdef autoload declare export functions integer float local readonly typeset
local expl state state_descr line func i use curcontext="$curcontext" ret=1
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//[fgkz]/}" ;;
export) use="${use//[fgkxz]/}" ;;
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' && ret=0
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 }%% *} && ret=0
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' && ret=0
elif (( $+opt_args[-w] )); then
_wanted files expl 'zwc file' _files -g '*.zwc(-.)' && ret=0
elif [[ $service = autoload || -n $opt_args[(i)-[uU]] ]]; then
if [[ ${"${(e)PREFIX}"[1]} = [/~] ]] && _files; then
# Autoload by absolute path
ret=0
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 && ret=0
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 && ret=0
else
_functions && ret=0
fi
elif [[ "$PREFIX" = *\=* ]]; then
compstate[parameter]="${PREFIX%%\=*}"
compset -P 1 '*='
_value && ret=0
elif (( $+opt_args[-a] || $+opt_args[-A] )); then
_parameters -q && ret=0
elif (( $+opt_args[-T] )); then
_arguments \
':scalar parameter:_parameters -g "*scalar*" -q -S "="' \
':array parameter:_parameters -g "*array*"' \
':separator character' && ret=0
else
_parameters -q -S '=' && ret=0
fi
fi
return ret
|
