aboutsummaryrefslogtreecommitdiff
path: root/Completion/Zsh/Command/_typeset
blob: 3f7de970634b2970eed7075cc2b5538c05300484 (plain) (blame)
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/[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' && 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 [[ $PREFIX[1] = [/~] ]]; then
	# Autoload by absolute path
	_files && 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