about summary refs log tree commit diff
path: root/Completion/Core/compinit
blob: b14e32a89ba1fcab046a26a6f803f3fffc0ee8cd (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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
# Initialisation for new style completion. This mainly contains some helper
# functions and aliases. Everything else is split into different files 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 an underscores (like `_setopt').
# The first line of these files will be read and has to say what should be
# done with its contents:
#
#   `#compdef <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 <names> are given.
#
#   `#compdef -p <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.
#
#   `#compdef -k <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.
#
#   `#compdef -K <widget-name> <style> <key-sequence> [ ... ]
#     This is similar to -k, except it takes any number of sets of
#     three arguments.  In each set, the widget <widget-name> will
#     be defined, which will behave as <style>, as with -k, and will
#     be bound to <key-sequence>, exactly one of which must be defined.
#     <widget-name> must be different for each:  this must begin with an
#     underscore, else one will be added, and should not clash with other
#     completion widgets (names based on the name of the function are the
#     clearest), but is otherwise arbitrary.  It can be tested in the
#     function by the parameter $WIDGET.
#
#   `#autoload'
#     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.
#
# Functions that are used to generate matches should return zero if they
# were able to add matches and non-zero otherwise.
#
# See the file `compdump' for how to speed up initialisation.

# If we got the `-d'-flag, we will automatically dump the new state (at
# the end).  This takes the dumpfile as an argument.  -d (with the
# default dumpfile) is now the default; to turn off dumping use -D.

emulate -L zsh

typeset _i_dumpfile _i_files _i_line _i_done _i_dir _i_autodump=1
typeset _i_tag _i_file _i_addfiles

while [[ $# -gt 0 && $1 = -[dDf] ]]; do
  if [[ "$1" = -d ]]; then
    _i_autodump=1
    shift
    if [[ $# -gt 0 && "$1" != -[df] ]]; then
      _i_dumpfile="$1"
      shift
    fi
  elif [[ "$1" = -D ]]; then
    _i_autodump=0
    shift
  elif [[ "$1" = -f ]]; then
    # Not used any more; use _compdir
    shift
    shift
  fi
done

# The associative array containing the definitions for the commands.
# Definitions for patterns will be stored in the associations `_patcomps'
# and `_postpatcomps'.

typeset -gA _comps _patcomps _postpatcomps

# The associative array use to report information about the last
# cmpletion to the outside.

typeset -gA _lastcomp

# Remember dumpfile.
if [[ -n $_i_dumpfile ]]; then
  # Explicitly supplied dumpfile.
  _comp_dumpfile="$_i_dumpfile"
else
  _comp_dumpfile="${ZDOTDIR:-$HOME}/.zcompdump"
fi

# This can hold names of functions that are to be called after all
# matches have been generated.

comppostfuncs=()

# Loading it now ensures that the `funcstack' parameter is always correct.

: $funcstack

# This function is used to register or delete completion functions. For
# registering completion functions, it is invoked with the name of the
# function as it's first argument (after the options). The other
# arguments depend on what type of completion function is defined. If
# none of the `-p' and `-k' options is given a function for a command is
# defined. The arguments after the function name are then interpreted as
# the names of the command for which the function generates matches.
# With the `-p' option a function for a name pattern is defined. This 
# function will be invoked when completing for a command whose name 
# matches the pattern given as argument after the function name (in this
# case only one argument is accepted).
# The option `-P' is like `-p', but the function will be called after
# trying to find a function defined for the command on the line if no
# such function could be found.
# With the `-k' option a function for a special completion keys is 
# defined and immediatly bound to those keys. Here, the extra arguments
# are the name of one of the builtin completion widgets and any number
# of key specifications as accepted by the `bindkey' builtin.
# In any case the `-a' option may be given which makes the function
# whose name is given as the first argument be autoloaded. When defining
# a function for command names the `-n' option may be given and keeps
# the definitions from overriding any previous definitions for the
# commands; with `-k', the `-n' option prevents compdef from rebinding
# a key sequence which is already bound.
# For deleting definitions, the `-d' option must be given. Without the
# `-p' option, this deletes definitions for functions for the commands
# whose names are given as arguments. If combined with the `-p' option
# it deletes the definitions for the patterns given as argument.
# The `-d' option may not be combined with the `-k' option, i.e.
# definitions for key function can not be removed.
#
# Examples:
#
#  compdef -a foo bar baz
#    make the completion for the commands `bar' and `baz' use the
#    function `foo' and make this function be autoloaded
#
#  compdef -p foo 'c*'
#    make completion for all command whose name begins with a `c'
#    generate matches by calling the function `foo' before generating
#    matches defined for the command itself
#
#  compdef -k foo list-choices '^X^M' '\C-xm'
#    make the function `foo' be invoked when typing `Control-X Control-M'
#    or `Control-X m'; the function should generate matches and will
#    behave like the `list-choices' builtin widget
#
#  compdef -d bar baz
#   delete the definitions for the command names `bar' and `baz'

compdef() {
  local opt autol type func delete new i

  # Get the options.

  if [[ $#* -eq 0 ]]; then
    echo "compdef needs parameters"
    return 1
  fi
  
  while getopts "anpPkKd" opt; do
    case "$opt" in
    a)    autol=yes;;
    n)    new=yes;;
    [pPkK]) if [[ -n "$type" ]]; then
            # Error if both `-p' and `-k' are given (or one of them
	    # twice).
            echo "$0: type already set to $type"
	    return 1
	  fi
	  if [[ "$opt" = p ]]; then
	    type=pattern
	  elif [[ "$opt" = P ]]; then
	    type=postpattern
	  elif [[ "$opt" = K ]]; then
	    type=widgetkey
	  else
	    type=key
	  fi
	  ;;
    d) delete=yes;;
    esac
  done
  shift OPTIND-1

  if [[ $#* -eq 0 ]]; then
    echo "compdef needs parameters"
    return 1
  fi
  
  if [[ -z "$delete" ]]; then
    # Adding definitions, first get the name of the function name
    # and probably do autoloading.

    func="$1"
    [[ -n "$autol" ]] && autoload -U "$func"
    shift

    case "$type" in
    pattern)
      if [[ $# -gt 1 ]]; then
        echo "$0: only one pattern allowed"
	return 1
      fi
      _patcomps[$1]="$func"
      ;;
    postpattern)
      if [[ $# -gt 1 ]]; then
        echo "$0: only one pattern allowed"
	return 1
      fi
      _postpatcomps[$1]="$func"
      ;;
    widgetkey)
      while [[ -n $1 ]]; do
	if [[ $# -lt 3 ]]; then
	  echo "$0: compdef -K requires <widget> <comp-widget> <key>"
	  return 1
	fi
	[[ $1 = _* ]] || 1="_$1"
	[[ $2 = .* ]] || 2=".$2"
	zle -C "$1" "$2" "$func"
	if [[ -n $new ]]; then
	  bindkey "$3" | read -A opt
	  [[ $opt[-1] = undefined-key ]] && bindkey "$3" "$1"
	else
	  bindkey "$3" "$1"
	fi
	shift 3
      done
      ;;	 
    key)
      if [[ $# -lt 2 ]]; then
        echo "$0: missing keys"
	return 1
      fi

      # Define the widget.
      if [[ $1 = .* ]]; then
	zle -C "$func" "$1" "$func"
      else
	zle -C "$func" ".$1" "$func"
      fi
      shift

      # And bind the keys...
      for i; do
        if [[ -n $new ]]; then
	   bindkey "$i" | read -A opt
	   [[ $opt[-1] = undefined-key ]] || continue
	fi
        bindkey "$i" "$func"
      done
      ;;
    *)
      # For commands store the function name in the `_comps'
      # associative array, command names as keys.
      if [[ -z "$new" ]]; then
	for i; do
	  _comps[$i]="$func"
	done
      else
        for i; do
          [[ "${+_comps[$i]}" -eq 0 ]] && _comps[$i]="$func"
        done
      fi
      ;;
    esac
  else
    # Handle the `-d' option, deleting.
    case "$type" in
    pattern)
      unset "_patcomps[$^@]"
      ;;
    postpattern)
      unset "_postpatcomps[$^@]"
      ;;
    key)
      # Oops, cannot do that yet.

      echo "$0: cannot restore key bindings"
      return 1
      ;;
    *)
      unset "_comps[$^@]"
    esac
  fi
}

# Do *not* use this...

compconf() {

  local style name val i tmp cmt

  if [[ -z "$_compconf_warn" ]]; then
    _compconf_warn=yep

    print "

Hello

\`compconf' will be removed in the near future. The \`styles' form of
your setup should be available in the file:

    \`${HOME}/.zsh-styles'

Note that the values for the style may not be fully correct.

Have fun

   Sven
" 1>&2
    command rm -f ${HOME}/.zsh-styles
  fi

  for i; do
    name="${i%%\=*}"
    val="${i#*\=}"

    tmp=''
    cmt=''

    case "$name" in
    urls_path)
      tmp="'*:urls' path ${(qq)val}"
      ;;
    urls_localhttp)
      tmp="'*:urls' local ${${(qqs.:.)val}}"
      ;;
    describe_options)
      tmp="'*:options' verbose 'yes'"
      ;;
    describe_values)
      tmp="'*:values' verbose 'yes'"
      ;;
    autodescribe_options)
      tmp="'*:options' auto-description ${(qq)val}"
      ;;
    description_format)
      tmp="'*:descriptions' format ${(qq)val}"
      ;;
    message_format)
      tmp="'*:messages' format ${(qq)val}"
      ;;
    warning_format)
      tmp="'*:warnings' format ${(qq)val}"
      ;;
    option_prefix)
      tmp="'*:options' prefix-needed yes"
      [[ "$val" = hide* ]] &&
          tmp="$tmp
zstyle '*:options' prefix-hidden yes"
      ;;    
    group_matches)
      tmp="'*' group-name ''"
      ;;
    colors_path)
      tmp="'*:colors' path ${(qq)val}"
      ;;
    path_expand)
      tmp="'*:paths' expand ${(qq)val}"
      ;;
    path_cursor)
      tmp="'*:paths' cursor ${(qq)val}"
      ;;
    (approximate|incremental|predict|list|oldlist|match)_*)
      tmp="':${name%%_*}' ${${name#*_}//_/-} ${(qq)val}"
      ;;
    correct_*)
      cmt="# This one is a bit ugly. You may want to use only \`*:correct'
# if you also have the \`correctword_*' or \`approximate_*' keys.
"
      tmp="':(correct(|-word)|approximate)' ${name#*_} ${(qq)val}"
      ;;
    correctword_*)
      tmp="':correct-word' ${name#correctword_} ${(qq)val}"
      ;;
    expand_*)
      cmt="# This one is a bit ugly. You may want to use only \`*:expand'
# if you also have the \`expandword_*' keys.
"
      tmp="':expand(|expand-word)' ${name#*_} ${(qq)val}"
      ;;
    expandword_*)
      tmp="':expand-word' ${name#expandword_} ${(qq)val}"
      ;;
    history_*)
      tmp="'*:history-words' ${name#history_} ${(qq)val}"
      ;;
    completer)
      tmp="'*' completer ${${(qqs.:.)val}}"
      ;;
    last_prompt)
      tmp="'*' last-prompt 'yes'"
      ;;
    esac
    [[ -n "$tmp" ]] && style="${style}${cmt}zstyle ${tmp}
"
  done

  eval "${style}"

  print "$style" >>! ${HOME}/.zsh-styles
}

# Very simple interface for setting styles:
#
#   compstyle pattern style values...

compstyle() {
  local long

  if [[ "$1" = -L ]]; then
    long=yes
    shift
  fi

  if (( ! $# )); then
    local pats styles vals pat style pre eq

    zstyle -g pats

    for pat in "${(@M)pats:#:completion*}"; do
      if [[ -n "$long" ]]; then
        pre="compstyle ${(qq)pat#:completion} "
      else
        print "${pat#:completion}"
	pre='    '
	eq=' ='
      fi
      zstyle -g styles "$pat"
      for style in "$styles[@]"; do
        zstyle -g vals "$pat" "$style"
        print "${pre}${style}${eq}" "${(@qq)vals}"
      done
    done

    return 0
  fi

  if [[ "$1" = -d ]]; then
    if [[ $# -gt 1 ]]; then
      zstyle -d ":completion$2" "${(@)argv[3,-1]}"
    else
      local pats

      zstyle -g pats

      for pat in "${(@M)pats:#:completion}"; do
        zstyle -d "$pat"
      done
    fi

    return 0
  fi

  [[ "$1" = -(|-) ]] && shift

  zstyle - ":completion$1" "${(@)argv[2,-1]}"

  return 0
}

# Default styles. This should be executed conditionally somehow.

zstyle ':completion:*'                      verbose       'yes'
zstyle ':completion:*'                      prefix-needed 'yes'
zstyle ':completion:*'                      prefix-hidden 'no'
zstyle ':completion:(correct|approximate):' max-errors    '2' numeric
zstyle ':completion:correct:'               prompt        'correct to:'
zstyle ':completion:*'                      completer     '_complete'
zstyle ':completion*:default'               list-colors   "${(s.:.)ZLS_COLORS:-${ZLS_COLOURS:-no=0:fi=0:di=0:ln=0:pi=0:so=0:bd=0:cd=0:ex=0}}"
(( $+SELECTMIN )) && zstyle ':completion*:default' menu "select=$SELECTMIN"
zstyle ':completion:*' tag-order 'arguments values' options \
                                 globbed-files directories all-files

# Now we automatically make the definition files autoloaded.

typeset -U _i_files
_i_files=( ${^~fpath:/.}/_(|*[^~])(N:t) )
if [[ $#_i_files -lt 20 || $_compdir = */Core || -d $_compdir/Core ]]; then
  # Too few files:  we need some more directories,
  # or we need to check that all directories (not just Core) are present.
  if [[ -n $_compdir ]]; then
    _i_addfiles=()
    if [[ $_compdir = */Core ]]; then
      # Add all the Completion subdirectories
      _i_addfiles=(${_compdir:h}/*(/))
    elif [[ -d $_compdir/Core ]]; then
      # Likewise
      _i_addfiles=(${_compdir}/*(/))
    fi
    for _i_line in {1..$#i_addfiles}; do
      _i_file=${_i_addfiles[$_i_line]}
      [[ -d $_i_file && -z ${fpath[(r)$_i_file]} ]] ||
        _i_addfiles[$_i_line]=
    done
    fpath=($fpath $_i_addfiles)
    _i_files=( ${^~fpath:/.}/_(|*[^~])(N:t) )
  fi
fi


# Rebind the standard widgets
for _i_line in complete-word delete-char-or-list expand-or-complete \
  expand-or-complete-prefix list-choices menu-complete \
  menu-expand-or-complete reverse-menu-complete; do
  zle -C $_i_line .$_i_line _main_complete
done
zle -la menu-select && zle -C menu-select .menu-select _main_complete

_i_done=''

# Make sure compdump is available, even if we aren't going to use it.
autoload -U compdump compinstall

# If we have a dump file, load it.

if [[ -f "$_comp_dumpfile" ]]; then
  read -rA _i_line < "$_comp_dumpfile"
  if [[ _i_autodump -eq 1 && $_i_line[2] -eq $#_i_files ]]; then
    builtin . "$_comp_dumpfile"
    _i_done=yes
  fi
fi
if [[ -z "$_i_done" ]]; then
  for _i_dir in $fpath; do
    [[ $_i_dir = . ]] && continue
    for _i_file in $_i_dir/_(|*[^~])(N); do
      read -rA _i_line < $_i_file
      _i_tag=$_i_line[1]
      shift _i_line
      case $_i_tag in
      (\#compdef)
	if [[ $_i_line[1] = -[pPkK](n|) ]]; then
	  compdef ${_i_line[1]}na "${_i_file:t}" "${(@)_i_line[2,-1]}"
	else
	  compdef -na "${_i_file:t}" "${_i_line[@]}"
	fi
	;;
      (\#autoload)
	autoload -U ${_i_file:t}
	;;
      esac
    done
  done

  # If autodumping was requested, do it now.

  if [[ $_i_autodump = 1 ]]; then
    compdump
  fi
fi

unfunction compinit
autoload -U compinit