]> git.ipfire.org Git - thirdparty/bash.git/blob - examples/complete/bash_completion
projects / thirdparty / bash.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
commit bash-20080821 snapshot
[thirdparty/bash.git] / examples / complete / bash_completion
1 # bash_completion - programmable completion functions for bash 3.x
2 # (backwards compatible with bash 2.05b)
3 #
4 # $Id: bash_completion,v 1.872 2006/03/01 16:20:18 ianmacd Exp $
5 #
6 # Copyright (C) Ian Macdonald <ian@caliban.org>
7 #
8 # This program is free software; you can redistribute it and/or modify
9 # it under the terms of the GNU General Public License as published by
10 # the Free Software Foundation; either version 2, or (at your option)
11 # any later version.
12 #
13 # This program is distributed in the hope that it will be useful,
14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 # GNU General Public License for more details.
17 #
18 # You should have received a copy of the GNU General Public License
19 # along with this program; if not, write to the Free Software Foundation,
20 # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 #
22 # The latest version of this software can be obtained here:
23 #
24 # http://www.caliban.org/bash/index.shtml#completion
25 #
26 # RELEASE: 20060301
27
28 if [[ $- == *v* ]]; then
29 BASH_COMPLETION_ORIGINAL_V_VALUE="-v"
30 else
31 BASH_COMPLETION_ORIGINAL_V_VALUE="+v"
32 fi
33
34 if [[ -n $BASH_COMPLETION_DEBUG ]]; then
35 set -v
36 else
37 set +v
38 fi
39
40 # Alter the following to reflect the location of this file.
41 #
42 [ -n "$BASH_COMPLETION" ] || BASH_COMPLETION=/etc/bash_completion
43 [ -n "$BASH_COMPLETION_DIR" ] || BASH_COMPLETION_DIR=/etc/bash_completion.d
44 readonly BASH_COMPLETION BASH_COMPLETION_DIR
45
46 # Set a couple of useful vars
47 #
48 UNAME=$( uname -s )
49 # strip OS type and version under Cygwin (e.g. CYGWIN_NT-5.1 => Cygwin)
50 UNAME=${UNAME/CYGWIN_*/Cygwin}
51 RELEASE=$( uname -r )
52
53 # features supported by bash 2.05 and higher
54 if [ ${BASH_VERSINFO[0]} -eq 2 ] && [[ ${BASH_VERSINFO[1]} > 04 ]] ||
55 [ ${BASH_VERSINFO[0]} -gt 2 ]; then
56 declare -r bash205=$BASH_VERSION 2>/dev/null || :
57 default="-o default"
58 dirnames="-o dirnames"
59 filenames="-o filenames"
60 fi
61 # features supported by bash 2.05b and higher
62 if [ ${BASH_VERSINFO[0]} -eq 2 ] && [[ ${BASH_VERSINFO[1]} = "05b" ]] ||
63 [ ${BASH_VERSINFO[0]} -gt 2 ]; then
64 declare -r bash205b=$BASH_VERSION 2>/dev/null || :
65 nospace="-o nospace"
66 fi
67 # features supported by bash 3.0 and higher
68 if [ ${BASH_VERSINFO[0]} -gt 2 ]; then
69 declare -r bash3=$BASH_VERSION 2>/dev/null || :
70 bashdefault="-o bashdefault"
71 plusdirs="-o plusdirs"
72 fi
73
74 # Turn on extended globbing and programmable completion
75 shopt -s extglob progcomp
76
77 # A lot of the following one-liners were taken directly from the
78 # completion examples provided with the bash 2.04 source distribution
79
80 # Make directory commands see only directories
81 complete -d pushd
82
83 # The following section lists completions that are redefined later
84 # Do NOT break these over multiple lines.
85 #
86 # START exclude -- do NOT remove this line
87 complete -f -X '!*.?(t)bz?(2)' bunzip2 bzcat bzcmp bzdiff bzegrep bzfgrep bzgrep
88 complete -f -X '!*.@(zip|ZIP|jar|JAR|exe|EXE|pk3|war|wsz|ear|zargo|xpi|sxw|ott)' unzip zipinfo
89 complete -f -X '*.Z' compress znew
90 complete -f -X '!*.@(Z|gz|tgz|Gz|dz)' gunzip zcmp zdiff zcat zegrep zfgrep zgrep zless zmore
91 complete -f -X '!*.Z' uncompress
92 complete -f -X '!*.@(gif|jp?(e)g|miff|tif?(f)|pn[gm]|p[bgp]m|bmp|xpm|ico|xwd|tga|pcx|GIF|JP?(E)G|MIFF|TIF?(F)|PN[GM]|P[BGP]M|BMP|XPM|ICO|XWD|TGA|PCX)' ee display
93 complete -f -X '!*.@(gif|jp?(e)g|tif?(f)|png|p[bgp]m|bmp|x[bp]m|rle|rgb|pcx|fits|pm|GIF|JPG|JP?(E)G|TIF?(F)|PNG|P[BGP]M|BMP|X[BP]M|RLE|RGB|PCX|FITS|PM)' xv qiv
94 complete -f -X '!*.@(@(?(e)ps|?(E)PS|pdf|PDF)?(.gz|.GZ|.bz2|.BZ2|.Z))' gv ggv kghostview
95 complete -f -X '!*.@(dvi|DVI)?(.@(gz|Z|bz2))' xdvi
96 complete -f -X '!*.@(dvi|DVI)?(.@(gz|bz2))' kdvi
97 complete -f -X '!*.@(dvi|DVI)' dvips dviselect dvitype dvipdf advi dvipdfm dvipdfmx
98 complete -f -X '!*.@(pdf|PDF)' acroread gpdf xpdf
99 complete -f -X '!*.@(?(e)ps|?(E)PS|pdf|PDF)' kpdf
100 complete -f -X '!*.@(@(?(e)ps|?(E)PS|pdf|PDF)?(.gz|.GZ)|cb(r|z)|CB(R|Z)|djv?(u)|DJV?(U)||dvi|DVI|gif|jp?(e)g|miff|tif?(f)|pn[gm]|p[bgp]m|bmp|xpm|ico|xwd|tga|pcx|GIF|JP?(E)G|MIFF|TIF?(F)|PN[GM]|P[BGP]M|BMP|XPM|ICO|XWD|TGA|PCX)' evince
101 complete -f -X '!*.@(?(e)ps|?(E)PS)' ps2pdf
102 complete -f -X '!*.texi*' makeinfo texi2html
103 complete -f -X '!*.@(?(la)tex|?(LA)TEX|texi|TEXI|dtx|DTX|ins|INS)' tex latex slitex jadetex pdfjadetex pdftex pdflatex texi2dvi
104 complete -f -X '!*.@(mp3|MP3)' mpg123 mpg321 madplay
105 complete -f -X '!*.@(mp?(e)g|MP?(E)G|wma|avi|AVI|asf|vob|VOB|bin|dat|divx|DIVX|vcd|ps|pes|fli|flv|FLV|viv|rm|ram|yuv|mov|MOV|qt|QT|wmv|mp3|MP3|m4v|M4V|ogg|OGG|ogm|OGM|mp4|MP4|wav|WAV|asx|ASX|mng|MNG|srt)' xine aaxine fbxine kaffeine
106 complete -f -X '!*.@(avi|asf|wmv)' aviplay
107 complete -f -X '!*.@(rm?(j)|ra?(m)|smi?(l))' realplay
108 complete -f -X '!*.@(mpg|mpeg|avi|mov|qt)' xanim
109 complete -f -X '!*.@(ogg|OGG|m3u|flac|spx)' ogg123
110 complete -f -X '!*.@(mp3|MP3|ogg|OGG|pls|m3u)' gqmpeg freeamp
111 complete -f -X '!*.fig' xfig
112 complete -f -X '!*.@(mid?(i)|MID?(I))' playmidi
113 complete -f -X '!*.@(mid?(i)|MID?(I)|rmi|RMI|rcp|RCP|[gr]36|[GR]36|g18|G18|mod|MOD|xm|XM|it|IT|x3m|X3M)' timidity
114 complete -f -X '*.@(o|so|so.!(conf)|a|rpm|gif|GIF|jp?(e)g|JP?(E)G|mp3|MP3|mp?(e)g|MPG|avi|AVI|asf|ASF|ogg|OGG|class|CLASS)' vi vim gvim rvim view rview rgvim rgview gview
115 complete -f -X '*.@(o|so|so.!(conf)|a|rpm|gif|GIF|jp?(e)g|JP?(E)G|mp3|MP3|mp?(e)g|MPG|avi|AVI|asf|ASF|ogg|OGG|class|CLASS)' emacs
116 complete -f -X '!*.@(exe|EXE|com|COM|scr|SCR|exe.so)' wine
117 complete -f -X '!*.@(zip|ZIP|z|Z|gz|GZ|tgz|TGZ)' bzme
118 complete -f -X '!*.@(?([xX]|[sS])[hH][tT][mM]?([lL]))' netscape mozilla lynx opera galeon curl dillo elinks amaya
119 complete -f -X '!*.@(sxw|stw|sxg|sgl|doc|dot|rtf|txt|htm|html|odt|ott|odm)' oowriter
120 complete -f -X '!*.@(sxi|sti|pps|ppt|pot|odp|otp)' ooimpress
121 complete -f -X '!*.@(sxc|stc|xls|xlw|xlt|csv|ods|ots)' oocalc
122 complete -f -X '!*.@(sxd|std|sda|sdd|odg|otg)' oodraw
123 complete -f -X '!*.@(sxm|smf|mml|odf)' oomath
124 complete -f -X '!*.odb' oobase
125 complete -f -X '!*.rpm' rpm2cpio
126 # FINISH exclude -- do not remove this line
127
128 # start of section containing compspecs that can be handled within bash
129
130 # user commands see only users
131 complete -u su usermod userdel passwd chage write chfn groups slay w sux
132
133 # group commands see only groups
134 [ -n "$bash205" ] && complete -g groupmod groupdel newgrp 2>/dev/null
135
136 # bg completes with stopped jobs
137 complete -A stopped -P '%' bg
138
139 # other job commands
140 complete -j -P '%' fg jobs disown
141
142 # readonly and unset complete with shell variables
143 complete -v readonly unset
144
145 # set completes with set options
146 complete -A setopt set
147
148 # shopt completes with shopt options
149 complete -A shopt shopt
150
151 # helptopics
152 complete -A helptopic help
153
154 # unalias completes with aliases
155 complete -a unalias
156
157 # bind completes with readline bindings (make this more intelligent)
158 complete -A binding bind
159
160 # type and which complete on commands
161 complete -c command type which
162
163 # builtin completes on builtins
164 complete -b builtin
165
166 # start of section containing completion functions called by other functions
167
168 # This function checks whether we have a given program on the system.
169 # No need for bulky functions in memory if we don't.
170 #
171 have()
172 {
173 unset -v have
174 PATH=$PATH:/sbin:/usr/sbin:/usr/local/sbin type $1 &>/dev/null &&
175 have="yes"
176 }
177
178 # use GNU sed if we have it, since its extensions are still used in our code
179 #
180 [ $UNAME != Linux ] && have gsed && alias sed=gsed
181
182 # This function checks whether a given readline variable
183 # is `on'.
184 #
185 _rl_enabled()
186 {
187 [[ "$( bind -v )" = *$1+([[:space:]])on* ]]
188 }
189
190 # This function shell-quotes the argument
191 quote()
192 {
193 echo \'${1//\'/\'\\\'\'}\' #'# Help vim syntax highlighting
194 }
195
196 # This function quotes the argument in a way so that readline dequoting
197 # results in the original argument
198 quote_readline()
199 {
200 local t="${1//\\/\\\\}"
201 echo \'${t//\'/\'\\\'\'}\' #'# Help vim syntax highlighting
202 }
203
204 # This function shell-dequotes the argument
205 dequote()
206 {
207 eval echo "$1"
208 }
209
210
211 # Get the word to complete
212 # This is nicer than ${COMP_WORDS[$COMP_CWORD]}, since it handles cases
213 # where the user is completing in the middle of a word.
214 # (For example, if the line is "ls foobar",
215 # and the cursor is here --------> ^
216 # it will complete just "foo", not "foobar", which is what the user wants.)
217 _get_cword()
218 {
219 if [[ "${#COMP_WORDS[COMP_CWORD]}" -eq 0 ]] || [[ "$COMP_POINT" == "${#COMP_LINE}" ]]; then
220 echo "${COMP_WORDS[COMP_CWORD]}"
221 else
222 local i
223 local cur="$COMP_LINE"
224 local index="$COMP_POINT"
225 for (( i = 0; i <= COMP_CWORD; ++i )); do
226 while [[ "${#cur}" -ge ${#COMP_WORDS[i]} ]] && [[ "${cur:0:${#COMP_WORDS[i]}}" != "${COMP_WORDS[i]}" ]]; do
227 cur="${cur:1}"
228 index="$(( index - 1 ))"
229 done
230 if [[ "$i" -lt "$COMP_CWORD" ]]; then
231 local old_size="${#cur}"
232 cur="${cur#${COMP_WORDS[i]}}"
233 local new_size="${#cur}"
234 index="$(( index - old_size + new_size ))"
235 fi
236 done
237
238 if [[ "${COMP_WORDS[COMP_CWORD]:0:${#cur}}" != "$cur" ]]; then
239 # We messed up! At least return the whole word so things keep working
240 echo "${COMP_WORDS[COMP_CWORD]}"
241 else
242 echo "${cur:0:$index}"
243 fi
244 fi
245 }
246
247
248 # This function performs file and directory completion. It's better than
249 # simply using 'compgen -f', because it honours spaces in filenames.
250 # If passed -d, it completes only on directories. If passed anything else,
251 # it's assumed to be a file glob to complete on.
252 #
253 _filedir()
254 {
255 local IFS=$'\t\n' xspec
256
257 _expand || return 0
258
259 local toks=( ) tmp
260 while read -r tmp; do
261 [[ -n $tmp ]] && toks[${#toks[@]}]=$tmp
262 done < <( compgen -d -- "$(quote_readline "$cur")" )
263
264 if [[ "$1" != -d ]]; then
265 xspec=${1:+"!*.$1"}
266 while read -r tmp; do
267 [[ -n $tmp ]] && toks[${#toks[@]}]=$tmp
268 done < <( compgen -f -X "$xspec" -- "$(quote_readline "$cur")" )
269 fi
270
271 COMPREPLY=( "${COMPREPLY[@]}" "${toks[@]}" )
272 }
273
274 # This function completes on signal names
275 #
276 _signals()
277 {
278 local i
279
280 # standard signal completion is rather braindead, so we need
281 # to hack around to get what we want here, which is to
282 # complete on a dash, followed by the signal name minus
283 # the SIG prefix
284 COMPREPLY=( $( compgen -A signal SIG${cur#-} ))
285 for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
286 COMPREPLY[i]=-${COMPREPLY[i]#SIG}
287 done
288 }
289
290 # This function completes on configured network interfaces
291 #
292 _configured_interfaces()
293 {
294 if [ -f /etc/debian_version ]; then
295 # Debian system
296 COMPREPLY=( $( sed -ne 's|^iface \([^ ]\+\).*$|\1|p' \
297 /etc/network/interfaces ) )
298 elif [ -f /etc/SuSE-release ]; then
299 # SuSE system
300 COMPREPLY=( $( command ls \
301 /etc/sysconfig/network/ifcfg-* | \
302 sed -ne 's|.*ifcfg-\('$cur'.*\)|\1|p' ) )
303 elif [ -f /etc/pld-release ]; then
304 # PLD Linux
305 COMPREPLY=( $( command ls -B \
306 /etc/sysconfig/interfaces | \
307 sed -ne 's|.*ifcfg-\('$cur'.*\)|\1|p' ) )
308 else
309 # Assume Red Hat
310 COMPREPLY=( $( command ls \
311 /etc/sysconfig/network-scripts/ifcfg-* | \
312 sed -ne 's|.*ifcfg-\('$cur'.*\)|\1|p' ) )
313 fi
314 }
315
316 # This function completes on all available network interfaces
317 # -a: restrict to active interfaces only
318 # -w: restrict to wireless interfaces only
319 #
320 _available_interfaces()
321 {
322 local cmd
323
324 if [ "${1:-}" = -w ]; then
325 cmd="iwconfig"
326 elif [ "${1:-}" = -a ]; then
327 cmd="ifconfig"
328 else
329 cmd="ifconfig -a"
330 fi
331
332 COMPREPLY=( $( eval $cmd 2>/dev/null | \
333 sed -ne 's|^\('$cur'[^[:space:][:punct:]]\{1,\}\).*$|\1|p') )
334 }
335
336 # This function expands tildes in pathnames
337 #
338 _expand()
339 {
340 # FIXME: Why was this here?
341 # [ "$cur" != "${cur%\\}" ] && cur="$cur\\"
342
343 # expand ~username type directory specifications
344 if [[ "$cur" == \~*/* ]]; then
345 eval cur=$cur
346 elif [[ "$cur" == \~* ]]; then
347 cur=${cur#\~}
348 COMPREPLY=( $( compgen -P '~' -u $cur ) )
349 return ${#COMPREPLY[@]}
350 fi
351 }
352
353 # This function completes on process IDs.
354 # AIX and Solaris ps prefers X/Open syntax.
355 [ $UNAME = SunOS -o $UNAME = AIX ] &&
356 _pids()
357 {
358 COMPREPLY=( $( compgen -W '$( command ps -efo pid | sed 1d )' -- $cur ))
359 } ||
360 _pids()
361 {
362 COMPREPLY=( $( compgen -W '$( command ps axo pid | sed 1d )' -- $cur ) )
363 }
364
365 # This function completes on process group IDs.
366 # AIX and SunOS prefer X/Open, all else should be BSD.
367 [ $UNAME = SunOS -o $UNAME = AIX ] &&
368 _pgids()
369 {
370 COMPREPLY=( $( compgen -W '$( command ps -efo pgid | sed 1d )' -- $cur ))
371 } ||
372 _pgids()
373 {
374 COMPREPLY=( $( compgen -W '$( command ps axo pgid | sed 1d )' -- $cur ))
375 }
376
377 # This function completes on user IDs
378 #
379 _uids()
380 {
381 if type getent &>/dev/null; then
382 COMPREPLY=( $( getent passwd | \
383 awk -F: '{if ($3 ~ /^'$cur'/) print $3}' ) )
384 elif type perl &>/dev/null; then
385 COMPREPLY=( $( compgen -W '$( perl -e '"'"'while (($uid) = (getpwent)[2]) { print $uid . "\n" }'"'"' )' -- $cur ) )
386 else
387 # make do with /etc/passwd
388 COMPREPLY=( $( awk 'BEGIN {FS=":"} {if ($3 ~ /^'$cur'/) print $3}'\
389 /etc/passwd ) )
390 fi
391 }
392
393 # This function completes on group IDs
394 #
395 _gids()
396 {
397 if type getent &>/dev/null; then
398 COMPREPLY=( $( getent group | \
399 awk -F: '{if ($3 ~ /^'$cur'/) print $3}' ) )
400 elif type perl &>/dev/null; then
401 COMPREPLY=( $( compgen -W '$( perl -e '"'"'while (($gid) = (getgrent)[2]) { print $gid . "\n" }'"'"' )' -- $cur ) )
402 else
403 # make do with /etc/group
404 COMPREPLY=( $( awk 'BEGIN {FS=":"} {if ($3 ~ /^'$cur'/) print $3}'\
405 /etc/group ) )
406 fi
407 }
408
409 # This function completes on services
410 #
411 _services()
412 {
413 local sysvdir famdir
414 [ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d || sysvdir=/etc/init.d
415 famdir=/etc/xinetd.d
416 COMPREPLY=( $( builtin echo $sysvdir/!(*.rpmsave|*.rpmorig|*~|functions)) )
417
418 if [ -d $famdir ]; then
419 COMPREPLY=( "${COMPREPLY[@]}" $( builtin echo $famdir/!(*.rpmsave|*.rpmorig|*~)) )
420 fi
421
422 COMPREPLY=( $( compgen -W '${COMPREPLY[@]#@($sysvdir|$famdir)/}' -- $cur ) )
423 }
424
425 # This function complete on modules
426 #
427 _modules()
428 {
429 local modpath
430 modpath=/lib/modules/$1
431 COMPREPLY=( $( command ls -R $modpath | \
432 sed -ne 's/^\('$cur'.*\)\.k\?o\(\|.gz\)$/\1/p') )
433 }
434
435 # this function complete on user:group format
436 #
437 _usergroup()
438 {
439 local IFS=$'\n'
440 cur=${cur//\\\\ / }
441 if [[ $cur = *@(\\:|.)* ]] && [ -n "$bash205" ]; then
442 user=${cur%%*([^:.])}
443 COMPREPLY=( $(compgen -P ${user/\\\\} -g -- ${cur##*[.:]}) )
444 elif [[ $cur = *:* ]] && [ -n "$bash205" ]; then
445 COMPREPLY=( $( compgen -g -- ${cur##*[.:]} ) )
446 else
447 COMPREPLY=( $( compgen -S : -u -- $cur ) )
448 fi
449 }
450
451 # this function count the number of mandatory args
452 #
453 _count_args()
454 {
455 args=1
456 for (( i=1; i < COMP_CWORD; i++ )); do
457 if [[ "${COMP_WORDS[i]}" != -* ]]; then
458 args=$(($args+1))
459 fi
460 done
461 }
462
463 # start of section containing completion functions for bash built-ins
464
465 # bash alias completion
466 #
467 _alias()
468 {
469 local cur
470
471 COMPREPLY=()
472 cur=${COMP_WORDS[$COMP_CWORD]}
473
474 case "$COMP_LINE" in
475 *[^=])
476 COMPREPLY=( $( compgen -A alias -S '=' -- $cur ) )
477 ;;
478 *=)
479 COMPREPLY=( "$( alias ${cur%=} 2>/dev/null | \
480 sed -e 's|^alias '$cur'\(.*\)$|\1|' )" )
481 ;;
482 esac
483 }
484 complete -F _alias $nospace alias
485
486 # bash export completion
487 #
488 _export()
489 {
490 local cur
491
492 COMPREPLY=()
493 cur=${COMP_WORDS[$COMP_CWORD]}
494
495 case "$COMP_LINE" in
496 *=\$*)
497 COMPREPLY=( $( compgen -v -P '$' -- ${cur#*=\$} ) )
498 ;;
499 *[^=])
500 COMPREPLY=( $( compgen -v -S '=' -- $cur ) )
501 ;;
502 *=)
503 COMPREPLY=( "$( eval echo -n \"$`echo ${cur%=}`\" |
504 ( echo -n \'
505 sed -e 's/'\''/'\''\\\'\'''\''/g'
506 echo -n \' ) )" )
507 ;;
508 esac
509 }
510 complete -F _export $default $nospace export
511
512 # bash shell function completion
513 #
514 _function()
515 {
516 local cur prev
517
518 COMPREPLY=()
519 cur=`_get_cword`
520 prev=${COMP_WORDS[COMP_CWORD-1]}
521
522 if [[ $1 == @(declare|typeset) ]]; then
523 if [ "$prev" = -f ]; then
524 COMPREPLY=( $( compgen -A function -- $cur ) )
525 elif [[ "$cur" == -* ]]; then
526 COMPREPLY=( $( compgen -W '-a -f -F -i -r -x -p' -- \
527 $cur ) )
528 fi
529 elif [ $COMP_CWORD -eq 1 ]; then
530 COMPREPLY=( $( compgen -A function -- $cur ) )
531 else
532 COMPREPLY=( "() $( type -- ${COMP_WORDS[1]} | sed -e 1,2d )" )
533 fi
534 }
535 complete -F _function function declare typeset
536
537 # bash complete completion
538 #
539 _complete()
540 {
541 local cur prev options
542
543 COMPREPLY=()
544 cur=`_get_cword`
545 prev=${COMP_WORDS[COMP_CWORD-1]}
546
547 case $prev in
548 -o)
549 options="default dirnames filenames"
550 [ -n "$bash205b" ] && options="$options nospace"
551 [ -n "$bash3" ] && options="$options bashdefault plusdirs"
552 COMPREPLY=( $( compgen -W "$options" -- $cur ) )
553 return 0
554 ;;
555
556 -A)
557 COMPREPLY=( $( compgen -W 'alias arrayvar binding \
558 builtin command directory disabled enabled \
559 export file function group helptopic hostname \
560 job keyword running service setopt shopt \
561 signal stopped user variable' -- $cur ) )
562 return 0
563 ;;
564
565 -C)
566 COMPREPLY=( $( compgen -A command -- $cur ) )
567 return 0
568 ;;
569 -F)
570 COMPREPLY=( $( compgen -A function -- $cur ) )
571 return 0
572 ;;
573 -@(p|r))
574 COMPREPLY=( $( complete -p | sed -e 's|.* ||' | \
575 grep "^$cur" ) )
576 return 0
577 ;;
578
579 esac
580
581 if [[ "$cur" == -* ]]; then
582 # relevant options completion
583 options="-a -b -c -d -e -f -g -j -k -s -v -u -A -G -W -P -S -X -F -C"
584 [ -n "$bash205" ] && options="$options -o"
585 COMPREPLY=( $( compgen -W "$options" -- $cur ) )
586 else
587 COMPREPLY=( $( compgen -A command -- $cur ) )
588 fi
589 }
590 complete -F _complete complete
591
592 # start of section containing completion functions for external programs
593
594 # a little help for FreeBSD ports users
595 [ $UNAME = FreeBSD ] && complete -W 'index search fetch fetch-list \
596 extract patch configure build install reinstall \
597 deinstall clean clean-depends kernel buildworld' make
598
599 # This completes on a list of all available service scripts for the
600 # 'service' command and/or the SysV init.d directory, followed by
601 # that script's available commands
602 #
603 { have service || [ -d /etc/init.d/ ]; } &&
604 _service()
605 {
606 local cur sysvdir
607
608 COMPREPLY=()
609 prev=${COMP_WORDS[COMP_CWORD-1]}
610 cur=`_get_cword`
611
612 # don't complete for things like killall, ssh and mysql if it's
613 # the standalone command, rather than the init script
614 [[ ${COMP_WORDS[0]} != @(*init.d/!(functions|~)|service) ]] && return 0
615
616 # don't complete past 2nd token
617 [ $COMP_CWORD -gt 2 ] && return 0
618
619 [ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d \
620 || sysvdir=/etc/init.d
621
622 if [[ $COMP_CWORD -eq 1 ]] && [[ $prev == "service" ]]; then
623 _services
624 else
625 COMPREPLY=( $( compgen -W '`sed -ne "y/|/ /; \
626 s/^.*Usage.*{\(.*\)}.*$/\1/p" \
627 $sysvdir/${prev##*/} 2>/dev/null`' -- $cur ) )
628 fi
629
630 return 0
631 } &&
632 complete -F _service service
633 [ -d /etc/init.d/ ] && complete -F _service $default \
634 $(for i in /etc/init.d/*; do echo ${i##*/}; done)
635
636 # chown(1) completion
637 #
638 _chown()
639 {
640 local cur
641 cur=`_get_cword`
642
643 # options completion
644 if [[ "$cur" == -* ]]; then
645 COMPREPLY=( $( compgen -W '-c -h -f -R -v --changes \
646 --dereference --no-dereference --from= --silent --quiet \
647 --reference= --recursive --verbose --help --version' -- $cur ) )
648 else
649 _count_args
650
651 case $args in
652 1)
653 _usergroup
654 ;;
655 *)
656 _filedir
657 ;;
658 esac
659 fi
660 }
661 complete -F _chown $filenames chown
662
663 # chgrp(1) completion
664 #
665 _chgrp()
666 {
667 local cur prev
668
669 COMPREPLY=()
670 cur=`_get_cword`
671 cur=${cur//\\\\/}
672 prev=${COMP_WORDS[COMP_CWORD-1]}
673
674 # options completion
675 if [[ "$cur" == -* ]]; then
676 COMPREPLY=( $( compgen -W '-c -h -f -R -v --changes \
677 --dereference --no-dereference --silent --quiet \
678 --reference= --recursive --verbose --help --version' -- $cur ) )
679 return 0
680 fi
681
682 # first parameter on line or first since an option?
683 if [ $COMP_CWORD -eq 1 ] && [[ "$cur" != -* ]] || \
684 [[ "$prev" == -* ]] && [ -n "$bash205" ]; then
685 local IFS=$'\n'
686 COMPREPLY=( $( compgen -g $cur 2>/dev/null ) )
687 else
688 _filedir || return 0
689 fi
690
691 return 0
692 }
693 complete -F _chgrp $filenames chgrp
694
695 # umount(8) completion. This relies on the mount point being the third
696 # space-delimited field in the output of mount(8)
697 #
698 _umount()
699 {
700 local cur
701
702 COMPREPLY=()
703 cur=`_get_cword`
704
705 OLDIFS="$IFS"
706 IFS="\n"
707 COMPREPLY=( $( compgen -W '$( mount | cut -d" " -f 3 )' -- $cur ) )
708 IFS="$OLDIFS"
709
710 return 0
711 }
712 complete -F _umount $dirnames umount
713
714 # mount(8) completion. This will pull a list of possible mounts out of
715 # /etc/{,v}fstab, unless the word being completed contains a ':', which
716 # would indicate the specification of an NFS server. In that case, we
717 # query the server for a list of all available exports and complete on
718 # that instead.
719 #
720 _mount()
721 { local cur i sm host
722
723 COMPREPLY=()
724 cur=`_get_cword`
725 [[ "$cur" == \\ ]] && cur="/"
726
727 for i in {,/usr}/{,s}bin/showmount; do [ -x $i ] && sm=$i && break; done
728
729 if [ -n "$sm" ] && [[ "$cur" == *:* ]]; then
730 COMPREPLY=( $( $sm -e ${cur%%:*} | sed 1d | \
731 grep ^${cur#*:} | awk '{print $1}' ) )
732 elif [[ "$cur" == //* ]]; then
733 host=${cur#//}
734 host=${host%%/*}
735 if [ -n "$host" ]; then
736 COMPREPLY=( $( compgen -W "$( echo $( smbclient -d 0 -NL $host 2>/dev/null|
737 sed -ne '/^['"$'\t '"']*Sharename/,/^$/p' |
738 sed -ne '3,$s|^[^A-Za-z]*\([^'"$'\t '"']*\).*$|//'$host'/\1|p' ) )" -- "$cur" ) )
739 fi
740 elif [ -r /etc/vfstab ]; then
741 # Solaris
742 COMPREPLY=( $( awk '! /^[ \t]*#/ {if ($3 ~ /\//) print $3}' \
743 /etc/vfstab | grep "^$cur" ) )
744 elif [ ! -e /etc/fstab ]; then
745 # probably Cygwin
746 COMPREPLY=( $( mount | awk '! /^[ \t]*#/ {if ($3 ~ /\//) print $3}' \
747 | grep "^$cur" ) )
748 else
749 # probably Linux
750 COMPREPLY=( $( awk '! /^[ \t]*#/ {if ($2 ~ /\//) print $2}' \
751 /etc/fstab | grep "^$cur" ) )
752 fi
753
754 return 0
755 }
756 complete -F _mount $default $filenames mount
757
758 # Linux rmmod(8) completion. This completes on a list of all currently
759 # installed kernel modules.
760 #
761 have rmmod && {
762 _rmmod()
763 {
764 local cur
765
766 COMPREPLY=()
767 cur=`_get_cword`
768
769 COMPREPLY=( $( /sbin/lsmod | \
770 awk '{if (NR != 1 && $1 ~ /^'$cur'/) print $1}' 2>/dev/null ))
771 return 0
772 }
773 complete -F _rmmod rmmod
774
775 # Linux insmod(8), modprobe(8) and modinfo(8) completion. This completes on a
776 # list of all available modules for the version of the kernel currently
777 # running.
778 #
779 _insmod()
780 {
781 local cur prev modpath
782
783 COMPREPLY=()
784 cur=`_get_cword`
785 prev=${COMP_WORDS[COMP_CWORD-1]}
786
787 # behave like lsmod for modprobe -r
788 if [ $1 = "modprobe" ] &&
789 [ "${COMP_WORDS[1]}" = "-r" ]; then
790 COMPREPLY=( $( /sbin/lsmod | \
791 awk '{if (NR != 1 && $1 ~ /^'$cur'/) print $1}' ) )
792 return 0
793 fi
794
795 # do filename completion if we're giving a path to a module
796 if [[ "$cur" == */* ]]; then
797 _filedir '@(?(k)o?(.gz))'
798 return 0
799 fi
800
801 if [ $COMP_CWORD -gt 1 ] &&
802 [[ "${COMP_WORDS[COMP_CWORD-1]}" != -* ]]; then
803 # do module parameter completion
804 COMPREPLY=( $( /sbin/modinfo -p ${COMP_WORDS[1]} 2>/dev/null | \
805 awk '{if ($1 ~ /^parm:/ && $2 ~ /^'$cur'/) { print $2 } \
806 else if ($1 !~ /:/ && $1 ~ /^'$cur'/) { print $1 }}' ) )
807 else
808 _modules $(uname -r)
809 fi
810
811 return 0
812 }
813 complete -F _insmod $filenames insmod modprobe modinfo
814 }
815
816 # man(1) completion
817 #
818 [ $UNAME = GNU -o $UNAME = Linux -o $UNAME = Darwin \
819 -o $UNAME = FreeBSD -o $UNAME = SunOS -o $UNAME = Cygwin \
820 -o $UNAME = OpenBSD ] &&
821 _man()
822 {
823 local cur prev sect manpath UNAME
824
825 COMPREPLY=()
826 cur=`_get_cword`
827 prev=${COMP_WORDS[COMP_CWORD-1]}
828
829 _expand || return 0
830
831 # default completion if parameter contains /
832 if [[ "$cur" == */* ]]; then
833 _filedir
834 return 0
835 fi
836
837 UNAME=$( uname -s )
838 # strip OS type and version under Cygwin
839 UNAME=${UNAME/CYGWIN_*/Cygwin}
840 if [ $UNAME = GNU -o $UNAME = Linux -o $UNAME = FreeBSD \
841 -o $UNAME = Cygwin ]; then
842 manpath=$( manpath 2>/dev/null || command man --path )
843 else
844 manpath=$MANPATH
845 fi
846
847 if [ -z "$manpath" ]; then
848 COMPREPLY=( $( compgen -c -- $cur ) )
849 return 0
850 fi
851
852 # determine manual section to search
853 [[ "$prev" == [0-9ln] ]] && sect=$prev || sect='*'
854
855 manpath=$manpath:
856 if [ -n "$cur" ]; then
857 manpath="${manpath//://*man$sect/$cur* } ${manpath//://*cat$sect/$cur* }"
858 else
859 manpath="${manpath//://*man$sect/ } ${manpath//://*cat$sect/ }"
860 fi
861
862 # redirect stderr for when path doesn't exist
863 COMPREPLY=( $( eval command ls "$manpath" 2>/dev/null ) )
864 # weed out directory path names and paths to man pages
865 COMPREPLY=( ${COMPREPLY[@]##*/?(:)} )
866 # strip suffix from man pages
867 COMPREPLY=( ${COMPREPLY[@]%.@(gz|bz2)} )
868 COMPREPLY=( $( compgen -W '${COMPREPLY[@]%.*}' -- "${cur//\\\\/}" ) )
869
870 [[ "$prev" != [0-9ln] ]] && _filedir '[0-9ln]'
871
872 return 0
873 }
874 [ $UNAME = GNU -o $UNAME = Linux -o $UNAME = Darwin \
875 -o $UNAME = FreeBSD -o $UNAME = SunOS -o $UNAME = Cygwin \
876 -o $UNAME = OpenBSD ] && \
877 complete -F _man $filenames man apropos whatis
878
879 # renice(8) completion
880 #
881 _renice()
882 {
883 local command cur curopt i
884
885 COMPREPLY=()
886 cur=`_get_cword`
887 command=$1
888
889 i=0
890 # walk back through command line and find last option
891 while [ $i -le $COMP_CWORD -a ${#COMPREPLY[@]} -eq 0 ]; do
892 curopt=${COMP_WORDS[COMP_CWORD-$i]}
893 case "$curopt" in
894 -u)
895 COMPREPLY=( $( compgen -u -- $cur ) )
896 ;;
897 -g)
898 _pgids
899 ;;
900 -p|$command)
901 _pids
902 ;;
903 esac
904 i=$(( ++i ))
905 done
906 }
907 complete -F _renice renice
908
909 # kill(1) completion
910 #
911 _kill()
912 {
913 local cur
914
915 COMPREPLY=()
916 cur=`_get_cword`
917
918 if [ $COMP_CWORD -eq 1 ] && [[ "$cur" == -* ]]; then
919 # return list of available signals
920 _signals
921 else
922 # return list of available PIDs
923 _pids
924 fi
925 }
926 complete -F _kill kill
927
928 # Linux and FreeBSD killall(1) completion.
929 #
930 [ $UNAME = Linux -o $UNAME = FreeBSD ] &&
931 _killall()
932 {
933 local cur
934
935 COMPREPLY=()
936 cur=`_get_cword`
937
938 if [ $COMP_CWORD -eq 1 ] && [[ "$cur" == -* ]]; then
939 _signals
940 else
941 COMPREPLY=( $( compgen -W '$( command ps axo command | \
942 sed -ne "1d; s/^\[\?\([^-][^] ]*\).*$/\1/p" | \
943 sed -e "s/.*\///" )' -- $cur ) )
944 fi
945
946 return 0
947 }
948 [ $UNAME = Linux -o $UNAME = FreeBSD ] && complete -F _killall killall pkill
949
950 # Linux and FreeBSD pgrep(1) completion.
951 #
952 [ $UNAME = Linux -o $UNAME = FreeBSD ] &&
953 _pgrep()
954 {
955 local cur
956
957 COMPREPLY=()
958 cur=`_get_cword`
959
960 COMPREPLY=( $( compgen -W '$( command ps axo command | \
961 sed -ne "1d; s/^\[\?\([^-][^] ]*\).*$/\1/p" | \
962 sed -e "s/.*\///" )' -- $cur ) )
963
964 return 0
965 }
966 [ $UNAME = Linux -o $UNAME = FreeBSD ] && complete -F _pgrep pgrep
967 # Linux pidof(8) completion.
968 [ $UNAME = Linux ] && complete -F _pgrep pidof
969
970 # GNU find(1) completion. This makes heavy use of ksh style extended
971 # globs and contains Linux specific code for completing the parameter
972 # to the -fstype option.
973 #
974 _find()
975 {
976 local cur prev i exprfound onlyonce
977
978 COMPREPLY=()
979 cur=`_get_cword`
980 prev=${COMP_WORDS[COMP_CWORD-1]}
981
982 case "$prev" in
983 -@(max|min)depth)
984 COMPREPLY=( $( compgen -W '0 1 2 3 4 5 6 7 8 9' -- $cur ) )
985 return 0
986 ;;
987 -?(a|c)newer|-fls|-fprint?(0|f)|-?(i)?(l)name|-?(i)wholename)
988 _filedir
989 return 0
990 ;;
991 -fstype)
992 # this is highly non-portable
993 [ -e /proc/filesystems ] &&
994 COMPREPLY=( $( cut -d$'\t' -f 2 /proc/filesystems | \
995 grep "^$cur" ) )
996 return 0
997 ;;
998 -gid)
999 _gids
1000 return 0
1001 ;;
1002 -group)
1003 if [ -n "$bash205" ]; then
1004 COMPREPLY=( $( compgen -g -- $cur 2>/dev/null) )
1005 fi
1006 return 0
1007 ;;
1008 -?(x)type)
1009 COMPREPLY=( $( compgen -W 'b c d p f l s' -- $cur ) )
1010 return 0
1011 ;;
1012 -uid)
1013 _uids
1014 return 0
1015 ;;
1016 -user)
1017 COMPREPLY=( $( compgen -u -- $cur ) )
1018 return 0
1019 ;;
1020 -exec|-ok)
1021 COMP_WORDS=(COMP_WORDS[0] $cur)
1022 COMP_CWORD=1
1023 _command
1024 return 0
1025 ;;
1026 -[acm]min|-[acm]time|-?(i)?(l)name|-inum|-?(i)path|-?(i)regex| \
1027 -links|-perm|-size|-used|-printf)
1028 # do nothing, just wait for a parameter to be given
1029 return 0
1030 ;;
1031 esac
1032
1033 _expand || return 0
1034
1035 # set exprfound to 1 if there is already an expression present
1036 for i in ${COMP_WORDS[@]}; do
1037 [[ "$i" = [-\(\),\!]* ]] && exprfound=1 && break
1038 done
1039
1040 # handle case where first parameter is not a dash option
1041 if [ "$exprfound" != 1 ] && [[ "$cur" != [-\(\),\!]* ]]; then
1042 _filedir -d
1043 return 0
1044 fi
1045
1046 # complete using basic options
1047 COMPREPLY=( $( compgen -W '-daystart -depth -follow -help -maxdepth \
1048 -mindepth -mount -noleaf -version -xdev -amin -anewer \
1049 -atime -cmin -cnewer -ctime -empty -false -fstype \
1050 -gid -group -ilname -iname -inum -ipath -iregex \
1051 -wholename \
1052 -links -lname -mmin -mtime -name -newer -nouser \
1053 -nogroup -perm -regex -size -true -type -uid -used \
1054 -user -xtype -exec -fls -fprint -fprint0 -fprintf -ok \
1055 -print -print0 -printf -prune -ls' -- $cur ) )
1056
1057 # this removes any options from the list of completions that have
1058 # already been specified somewhere on the command line, as long as
1059 # these options can only be used once (in a word, "options", in
1060 # opposition to "tests" and "actions", as in the find(1) manpage).
1061 onlyonce=' -daystart -depth -follow -help -maxdepth -mindepth -mount \
1062 -noleaf -version -xdev '
1063 COMPREPLY=( $( echo "${COMP_WORDS[@]}" | \
1064 (while read -d ' ' i; do
1065 [ "$i" == "" ] ||
1066 [ "${onlyonce/ ${i%% *} / }" == "$onlyonce" ] &&
1067 continue
1068 # flatten array with spaces on either side,
1069 # otherwise we cannot grep on word boundaries of
1070 # first and last word
1071 COMPREPLY=" ${COMPREPLY[@]} "
1072 # remove word from list of completions
1073 COMPREPLY=( ${COMPREPLY/ ${i%% *} / } )
1074 done
1075 echo "${COMPREPLY[@]}")
1076 ) )
1077
1078 _filedir
1079
1080 return 0
1081 }
1082 complete -F _find $filenames find
1083
1084 # Linux iwconfig(8) completion
1085 #
1086 [ $UNAME = Linux ] && have iwconfig &&
1087 _iwconfig()
1088 {
1089 local cur prev
1090
1091 COMPREPLY=()
1092 cur=`_get_cword`
1093 prev=${COMP_WORDS[COMP_CWORD-1]}
1094
1095 case $prev in
1096 mode)
1097 COMPREPLY=( $( compgen -W 'managed ad-hoc master \
1098 repeater secondary monitor' -- $cur ) )
1099 return 0
1100 ;;
1101 essid)
1102 COMPREPLY=( $( compgen -W 'on off any' -- $cur ) )
1103 if [ -n "${COMP_IWLIST_SCAN:-}" ]; then
1104 COMPREPLY=( "${COMPREPLY[@]}" \
1105 $( iwlist ${COMP_WORDS[1]} scan | \
1106 awk -F '"' '/ESSID/ {print $2}' | \
1107 grep "^$cur" ))
1108 fi
1109 return 0
1110 ;;
1111 nwid)
1112 COMPREPLY=( $( compgen -W 'on off' -- $cur ) )
1113 return 0
1114 ;;
1115 channel)
1116 COMPREPLY=( $( iwlist ${COMP_WORDS[1]} channel | \
1117 awk '/^[[:space:]]*Channel/ {print $2}' | \
1118 grep "^$cur" ) )
1119 return 0
1120 ;;
1121
1122 freq)
1123 COMPREPLY=( $( iwlist ${COMP_WORDS[1]} channel | \
1124 awk '/^[[:space:]]*Channel/ {print $4"G"}' | \
1125 grep "^$cur" ) )
1126 return 0
1127 ;;
1128 ap)
1129 COMPREPLY=( $( compgen -W 'on off any' -- $cur ) )
1130 if [ -n "${COMP_IWLIST_SCAN:-}" ]; then
1131 COMPREPLY=( "${COMPREPLY[@]}" \
1132 $( iwlist ${COMP_WORDS[1]} scan | \
1133 awk -F ': ' '/Address/ {print $2}' | \
1134 grep "^$cur" ) )
1135 fi
1136 return 0
1137 ;;
1138 rate)
1139 COMPREPLY=( $( compgen -W 'auto fixed' -- $cur ) )
1140 COMPREPLY=( "${COMPREPLY[@]}" \
1141 $( iwlist ${COMP_WORDS[1]} rate | \
1142 awk '/^[[:space:]]*[0-9]/ {print $1"M"}' | \
1143 grep "^$cur" ) )
1144 return 0
1145 ;;
1146 rts)
1147 COMPREPLY=( $( compgen -W 'auto fixed off' -- $cur ) )
1148 return 0
1149 ;;
1150 frag)
1151 COMPREPLY=( $( compgen -W 'auto fixed off' -- $cur ) )
1152 return 0
1153 ;;
1154 key)
1155 COMPREPLY=( $( compgen -W 'off on open restricted' -- $cur ) )
1156 return 0
1157 ;;
1158 enc)
1159 COMPREPLY=( $( compgen -W 'off on open restricted' -- $cur ) )
1160 return 0
1161 ;;
1162 power)
1163 COMPREPLY=( $( compgen -W 'period timeout off on' -- $cur ) )
1164 return 0
1165 ;;
1166 txpower)
1167 COMPREPLY=( $( compgen -W 'off on auto' -- $cur ) )
1168 return 0
1169 ;;
1170 retry)
1171 COMPREPLY=( $( compgen -W 'limit lifetime' -- $cur ) )
1172 return 0
1173 ;;
1174 esac
1175
1176 if [ $COMP_CWORD -eq 1 ]; then
1177 if [[ "$cur" == -* ]]; then
1178 COMPREPLY=( $( compgen -W '--help --version' -- $cur ) )
1179 else
1180 _available_interfaces -w
1181 fi
1182 else
1183 COMPREPLY=( $( compgen -W 'essid nwid mode freq channel sens mode \
1184 ap nick rate rts frag enc key power txpower commit' -- $cur ) )
1185 fi
1186
1187 } &&
1188 complete -F _iwconfig iwconfig
1189
1190 # Linux iwlist(8) completion
1191 #
1192 [ $UNAME = Linux ] && have iwlist &&
1193 _iwlist()
1194 {
1195 local cur prev
1196
1197 COMPREPLY=()
1198 cur=`_get_cword`
1199 prev=${COMP_WORDS[COMP_CWORD-1]}
1200
1201 if [ $COMP_CWORD -eq 1 ]; then
1202 if [[ "$cur" == -* ]]; then
1203 COMPREPLY=( $( compgen -W '--help --version' -- $cur ) )
1204 else
1205 _available_interfaces -w
1206 fi
1207 else
1208 COMPREPLY=( $( compgen -W 'scan scanning freq frequency \
1209 channel rate bit bitrate key enc encryption power \
1210 txpower retry ap accesspoint peers event' -- $cur ) )
1211 fi
1212 } &&
1213 complete -F _iwlist iwlist
1214
1215 # Linux iwspy(8) completion
1216 #
1217 [ $UNAME = Linux ] && have iwspy &&
1218 _iwspy()
1219 {
1220 local cur
1221
1222 COMPREPLY=()
1223 cur=`_get_cword`
1224
1225 if [ $COMP_CWORD -eq 1 ]; then
1226 if [[ "$cur" == -* ]]; then
1227 COMPREPLY=( $( compgen -W '--help --version' -- $cur ) )
1228 else
1229 _available_interfaces -w
1230 fi
1231 else
1232 COMPREPLY=( $( compgen -W 'setthr getthr off' -- $cur ) )
1233 fi
1234 } &&
1235 complete -F _iwspy iwspy
1236
1237 # Linux iwpriv(8) completion
1238 #
1239 [ $UNAME = Linux ] && have iwpriv &&
1240 _iwpriv()
1241 {
1242 local cur prev
1243
1244 COMPREPLY=()
1245 cur=`_get_cword`
1246 prev=${COMP_WORDS[COMP_CWORD-1]}
1247
1248 case "$prev" in
1249 roam)
1250 COMPREPLY=( $( compgen -W 'on off' -- $cur ) )
1251 return 0
1252 ;;
1253 port)
1254 COMPREPLY=( $( compgen -W 'ad-hoc managed' -- $cur ) )
1255 return 0
1256 ;;
1257 esac
1258
1259 if [ $COMP_CWORD -eq 1 ]; then
1260 if [[ "$cur" == -* ]]; then
1261 COMPREPLY=( $( compgen -W '--help --version' -- $cur ) )
1262 else
1263 _available_interfaces -w
1264 fi
1265 else
1266 COMPREPLY=( $( compgen -W '--all roam port' -- $cur ) )
1267 fi
1268 } &&
1269 complete -F _iwpriv iwpriv
1270
1271 # RedHat & Debian GNU/Linux if{up,down} completion
1272 #
1273 [ $UNAME = Linux ] && { have ifup || have ifdown; } &&
1274 _ifupdown()
1275 {
1276 local cur
1277
1278 COMPREPLY=()
1279 cur=`_get_cword`
1280
1281 if [ $COMP_CWORD -eq 1 ]; then
1282 _configured_interfaces
1283 COMPREPLY=( $(compgen -W '${COMPREPLY[@]}' -- "$cur") )
1284 fi
1285
1286 return 0
1287 } &&
1288 complete -F _ifupdown ifup ifdown
1289 [ $UNAME = Linux ] && have ifstatus && complete -F _ifupdown ifstatus
1290
1291 # Linux ipsec(8) completion (for FreeS/WAN)
1292 #
1293 [ $UNAME = Linux ] && have ipsec &&
1294 _ipsec()
1295 {
1296 local cur
1297
1298 COMPREPLY=()
1299 cur=`_get_cword`
1300
1301
1302 if [ $COMP_CWORD -eq 1 ]; then
1303 COMPREPLY=( $( compgen -W 'auto barf eroute klipsdebug look \
1304 manual pluto ranbits rsasigkey \
1305 setup showdefaults showhostkey spi \
1306 spigrp tncfg whack' -- $cur ) )
1307 return 0
1308 fi
1309
1310 case ${COMP_WORDS[1]} in
1311 auto)
1312 COMPREPLY=( $( compgen -W '--asynchronous --up --add --delete \
1313 --replace --down --route --unroute \
1314 --ready --status --rereadsecrets' \
1315 -- $cur ) )
1316 ;;
1317 manual)
1318 COMPREPLY=( $( compgen -W '--up --down --route --unroute \
1319 --union' -- $cur ) )
1320 ;;
1321 ranbits)
1322 COMPREPLY=( $( compgen -W '--quick --continuous --bytes' \
1323 -- $cur ) )
1324 ;;
1325 setup)
1326 COMPREPLY=( $( compgen -W '--start --stop --restart' -- $cur ) )
1327 ;;
1328
1329 *)
1330 ;;
1331 esac
1332
1333 return 0
1334 } &&
1335 complete -F _ipsec ipsec
1336
1337 # Postfix completion.
1338 #
1339 have postfix && {
1340 # postfix(1)
1341 #
1342 _postfix()
1343 {
1344 local cur prev
1345
1346 cur=`_get_cword`
1347 prev=${COMP_WORDS[COMP_CWORD-1]}
1348
1349 if [[ $cur == '-' ]]; then
1350 COMPREPLY=(-c -D -v)
1351 return 0
1352 fi
1353 if [[ $prev == '-c' ]]; then
1354 _filedir -d
1355 return 0
1356 fi
1357 if [[ $prev == '-D' ]]; then
1358 COMPREPLY=( $( compgen -W 'start' -- "`get_cword`" ) )
1359 return 0
1360 fi
1361 COMPREPLY=( $( compgen -W 'start stop reload abort flush check' -- \
1362 "`get_cword`" ) )
1363 }
1364 complete -F _postfix postfix
1365
1366 # postalias(1) and postmap(1)
1367 #
1368 _postmap()
1369 {
1370 local cur prev len idx
1371
1372 cur=`_get_cword`
1373 prev=${COMP_WORDS[COMP_CWORD-1]}
1374
1375 if [[ $cur == '-' ]]; then
1376 COMPREPLY=(-N -f -i -n -o -p -r -v -w -c -d -q)
1377 return 0
1378 fi
1379 if [[ $prev == '-c' ]]; then
1380 _filedir -d
1381 return 0
1382 fi
1383 if [[ $prev == -[dq] ]]; then
1384 return 0
1385 fi
1386
1387 if [[ "$cur" == *:* ]]; then
1388 COMPREPLY=( $( compgen -f -- ${cur#*:} ) )
1389 else
1390 len=${#cur}
1391 idx=0
1392 for pval in $( /usr/sbin/postconf -m ); do
1393 if [[ "$cur" == "${pval:0:$len}" ]]; then
1394 COMPREPLY[$idx]="$pval:"
1395 idx=$(($idx+1))
1396 fi
1397 done
1398 if [[ $idx -eq 0 ]]; then
1399 COMPREPLY=( $( compgen -f -- "$cur" ) )
1400 fi
1401 fi
1402 return 0
1403 }
1404 complete -F _postmap postmap postalias
1405
1406 # postcat(1)
1407 #
1408 _postcat()
1409 {
1410 local cur prev pval len idx qfile
1411
1412 cur=`_get_cword`
1413 prev=${COMP_WORDS[COMP_CWORD-1]}
1414
1415 if [[ $cur == '-' ]]; then
1416 COMPREPLY=(-c -q -v)
1417 return 0
1418 fi
1419 if [[ $prev == '-c' ]]; then
1420 _filedir -d
1421 return 0
1422 fi
1423
1424 qfile=0
1425 for idx in "${COMP_WORDS[@]}"; do
1426 [[ "$idx" = -q ]] && qfile=1 && break
1427 done
1428 if [[ $qfile == 1 ]]; then
1429 len=${#cur}
1430 idx=0
1431 for pval in $( mailq | \
1432 sed -e '1d; $d; /^[^0-9A-Z]\|^$/d; s/[* !].*$//' ); do
1433 if [[ "$cur" == "${pval:0:$len}" ]]; then
1434 COMPREPLY[$idx]=$pval
1435 idx=$(($idx+1))
1436 fi
1437 done
1438 return 0
1439 else
1440 _filedir
1441 return 0
1442 fi
1443 }
1444 complete -F _postcat postcat
1445
1446 # postconf(1)
1447 #
1448 _postconf()
1449 {
1450 local cur prev pval len idx eqext
1451
1452 cur=`_get_cword`
1453 prev=${COMP_WORDS[COMP_CWORD-1]}
1454 if [[ $cur == '-' ]]; then
1455 COMPREPLY=(-c -d -e -h -m -l -n -v)
1456 return 0
1457 fi
1458 if [[ $prev == '-c' ]]; then
1459 _filedir -d
1460 return 0
1461 fi
1462 if [[ $prev == '-e' ]]; then
1463 cur=${cur#[\"\']}
1464 eqext='='
1465 fi
1466 len=${#cur}
1467 idx=0
1468 for pval in $( /usr/sbin/postconf | cut -d ' ' -f 1 ); do
1469 if [[ "$cur" == "${pval:0:$len}" ]]; then
1470 COMPREPLY[$idx]="$pval$eqext"
1471 idx=$(($idx+1))
1472 fi
1473 done
1474 return 0
1475 }
1476 complete -F _postconf postconf
1477
1478 # postsuper(1)
1479 #
1480 _postsuper()
1481 {
1482 local cur prev pval len idx
1483
1484 cur=`_get_cword`
1485 prev=${COMP_WORDS[COMP_CWORD-1]}
1486
1487 if [[ $cur == '-' ]]; then
1488 COMPREPLY=(-c -d -h -H -p -r -s -v)
1489 return 0
1490 fi
1491 case $prev in
1492 -[dr])
1493 len=${#cur}
1494 idx=0
1495 for pval in $( echo ALL; mailq | \
1496 sed -e '1d; $d; /^[^0-9A-Z]\|^$/d; s/[* !].*$//' ); do
1497 if [[ "$cur" == "${pval:0:$len}" ]]; then
1498 COMPREPLY[$idx]=$pval
1499 idx=$(($idx+1))
1500 fi
1501 done
1502 return 0
1503 ;;
1504 -h)
1505 len=${#cur}
1506 idx=0
1507 for pval in $( echo ALL; mailq | \
1508 sed -e '1d; $d; /^[^0-9A-Z]\|^$/d; s/[* ].*$//; /!$/d' ); do
1509 if [[ "$cur" == "${pval:0:$len}" ]]; then
1510 COMPREPLY[$idx]=$pval
1511 idx=$(($idx+1))
1512 fi
1513 done
1514 return 0
1515 ;;
1516 -H)
1517 len=${#cur}
1518 idx=0
1519 for pval in $( echo ALL; mailq | \
1520 sed -e '1d; $d; /^[^0-9A-Z]\|^$/d; /^[0-9A-Z]*[* ]/d; s/!.*$//' ); do
1521 if [[ "$cur" == "${pval:0:$len}" ]]; then
1522 COMPREPLY[$idx]=$pval
1523 idx=$(($idx+1))
1524 fi
1525 done
1526 return 0
1527 ;;
1528 esac
1529 COMPREPLY=( $( compgen -W 'hold incoming active deferred' -- $cur ) )
1530 return 0
1531 }
1532 complete -F _postsuper postsuper
1533 }
1534
1535 # cvs(1) completion
1536 #
1537 have cvs && {
1538 set_prefix()
1539 {
1540 [ -z ${prefix:-} ] || prefix=${cur%/*}/
1541 [ -r ${prefix:-}CVS/Entries ] || prefix=""
1542 }
1543
1544 get_entries()
1545 {
1546 local IFS=$'\n'
1547 [ -r ${prefix:-}CVS/Entries ] && \
1548 entries=$(cut -d/ -f2 -s ${prefix:-}CVS/Entries)
1549 }
1550
1551 get_modules()
1552 {
1553 if [ -n "$prefix" ]; then
1554 COMPREPLY=( $( command ls -d ${cvsroot}/${prefix}/!(CVSROOT) ) )
1555 else
1556 COMPREPLY=( $( command ls -d ${cvsroot}/!(CVSROOT) ) )
1557 fi
1558 }
1559
1560 _cvs()
1561 {
1562 local cur count mode i cvsroot cvsroots pwd
1563 local -a flags miss files entries changed newremoved
1564
1565 COMPREPLY=()
1566 cur=`_get_cword`
1567
1568 count=0
1569 for i in "${COMP_WORDS[@]}"; do
1570 [ $count -eq $COMP_CWORD ] && break
1571 # Last parameter was the CVSROOT, now go back to mode selection
1572 if [ "${COMP_WORDS[((count))]}" == "$cvsroot" -a "$mode" == "cvsroot" ]; then
1573 mode=""
1574 fi
1575 if [ -z "$mode" ]; then
1576 case $i in
1577 -d)
1578 mode=cvsroot
1579 cvsroot=${COMP_WORDS[((count+1))]}
1580 ;;
1581 @(ad?(d)|new))
1582 mode=add
1583 ;;
1584 @(adm?(in)|rcs))
1585 mode=admin
1586 ;;
1587 ann?(notate))
1588 mode=annotate
1589 ;;
1590 @(checkout|co|get))
1591 mode=checkout
1592 ;;
1593 @(com?(mit)|ci))
1594 mode=commit
1595 ;;
1596 di?(f?(f)))
1597 mode=diff
1598 ;;
1599 ex?(p?(ort)))
1600 mode=export
1601 ;;
1602 ?(un)edit)
1603 mode=$i
1604 ;;
1605 hi?(s?(tory)))
1606 mode=history
1607 ;;
1608 im?(p?(ort)))
1609 mode=import
1610 ;;
1611 re?(l?(ease)))
1612 mode=release
1613 ;;
1614 ?(r)log)
1615 mode=log
1616 ;;
1617 @(rdiff|patch))
1618 mode=rdiff
1619 ;;
1620 @(remove|rm|delete))
1621 mode=remove
1622 ;;
1623 @(rtag|rfreeze))
1624 mode=rtag
1625 ;;
1626 st?(at?(us)))
1627 mode=status
1628 ;;
1629 @(tag|freeze))
1630 mode=tag
1631 ;;
1632 up?(d?(ate)))
1633 mode=update
1634 ;;
1635 *)
1636 ;;
1637 esac
1638 elif [[ "$i" = -* ]]; then
1639 flags=( "${flags[@]}" $i )
1640 fi
1641 count=$((++count))
1642 done
1643
1644 case "$mode" in
1645 add)
1646 if [[ "$cur" != -* ]]; then
1647 set_prefix
1648 if [ $COMP_CWORD -gt 1 -a -r ${prefix:-}CVS/Entries ]; then
1649 get_entries
1650 [ -z "$cur" ] && \
1651 files=$( command ls -Ad !(CVS) ) || \
1652 files=$( command ls -d ${cur}* 2>/dev/null )
1653 for i in "${entries[@]}"; do
1654 files=( ${files[@]/#$i//} )
1655 done
1656 COMPREPLY=( $( compgen -W '${files[@]}' -- \
1657 $cur ) )
1658 fi
1659 else
1660 COMPREPLY=( $( compgen -W '-k -m' -- $cur ) )
1661 fi
1662 ;;
1663 admin)
1664 if [[ "$cur" = -* ]]; then
1665 COMPREPLY=( $( compgen -W '-i -a -A -e -b -c -k -l -u \
1666 -L -U -m -M -n -N -o -q -I \
1667 -s -t -t- -T -V -x -z' -- \
1668 $cur ) )
1669 fi
1670 ;;
1671 annotate)
1672 if [[ "$cur" = -* ]]; then
1673 COMPREPLY=( $( compgen -W '-D -F -f -l -R -r' -- $cur ) )
1674 else
1675 get_entries
1676 COMPREPLY=( $( compgen -W '${entries[@]}' -- $cur ) )
1677 fi
1678 ;;
1679 checkout)
1680 if [[ "$cur" != -* ]]; then
1681 [ -z "$cvsroot" ] && cvsroot=$CVSROOT
1682 COMPREPLY=( $( cvs -d "$cvsroot" co -c 2> /dev/null | \
1683 awk '{print $1}' ) )
1684 COMPREPLY=( $( compgen -W '${COMPREPLY[@]}' -- $cur ) )
1685 else
1686 COMPREPLY=( $( compgen -W '-A -N -P -R -c -f -l -n -p \
1687 -s -r -D -d -k -j' -- $cur ) )
1688 fi
1689 ;;
1690 commit)
1691 set_prefix
1692
1693 if [[ "$cur" != -* ]] && [ -r ${prefix:-}CVS/Entries ]; then
1694 # if $COMP_CVS_REMOTE is not null, 'cvs commit' will
1695 # complete on remotely checked-out files (requires
1696 # passwordless access to the remote repository
1697 if [ -n "${COMP_CVS_REMOTE:-}" ]; then
1698 # this is the least computationally intensive
1699 # way found so far, but other changes
1700 # (something other than changed/removed/new)
1701 # may be missing
1702 changed=( $( cvs -q diff --brief 2>&1 | \
1703 sed -ne 's/^Files [^ ]* and \([^ ]*\) differ$/\1/p' ) )
1704 newremoved=( $( cvs -q diff --brief 2>&1 | \
1705 sed -ne 's/^cvs diff: \([^ ]*\) .*, no comparison available$/\1/p' ) )
1706 COMPREPLY=( $( compgen -W '${changed[@]:-} \
1707 ${newremoved[@]:-}' -- $cur ) )
1708 else
1709 _filedir
1710 fi
1711 else
1712 COMPREPLY=( $( compgen -W '-n -R -l -f -F -m -r' -- \
1713 $cur ) )
1714 fi
1715 ;;
1716 cvsroot)
1717 if [ -r ~/.cvspass ]; then
1718 # Ugly escaping because of bash treating ':' specially
1719 cvsroots=$( sed 's/^[^ ]* //; s/:/\\:/g' ~/.cvspass )
1720 COMPREPLY=( $( compgen -W '$cvsroots' -- $cur ) )
1721 fi
1722 ;;
1723 export)
1724 if [[ "$cur" != -* ]]; then
1725 [ -z "$cvsroot" ] && cvsroot=$CVSROOT
1726 COMPREPLY=( $( cvs -d "$cvsroot" co -c | awk '{print $1}' ) )
1727 COMPREPLY=( $( compgen -W '${COMPREPLY[@]}' -- $cur ) )
1728 else
1729 COMPREPLY=( $( compgen -W '-N -f -l -R -n \
1730 -r -D -d -k' -- $cur ) )
1731 fi
1732 ;;
1733 diff)
1734 if [[ "$cur" == -* ]]; then
1735 _longopt diff
1736 else
1737 get_entries
1738 COMPREPLY=( $( compgen -W '${entries[@]:-}' -- $cur ) )
1739 fi
1740 ;;
1741 remove)
1742 if [[ "$cur" != -* ]]; then
1743 set_prefix
1744 if [ $COMP_CWORD -gt 1 -a -r ${prefix:-}CVS/Entries ]; then
1745 get_entries
1746 # find out what files are missing
1747 for i in "${entries[@]}"; do
1748 [ ! -r "$i" ] && miss=( "${miss[@]}" $i )
1749 done
1750 COMPREPLY=( $(compgen -W '${miss[@]:-}' -- $cur) )
1751 fi
1752 else
1753 COMPREPLY=( $( compgen -W '-f -l -R' -- $cur ) )
1754 fi
1755 ;;
1756 import)
1757 if [[ "$cur" != -* ]]; then
1758 # starts with same algorithm as checkout
1759 [ -z "$cvsroot" ] && cvsroot=$CVSROOT
1760 prefix=${cur%/*}
1761 if [ -r ${cvsroot}/${prefix} ]; then
1762 get_modules
1763 COMPREPLY=( ${COMPREPLY[@]#$cvsroot} )
1764 COMPREPLY=( ${COMPREPLY[@]#\/} )
1765 fi
1766 pwd=$( pwd )
1767 pwd=${pwd##*/}
1768 COMPREPLY=( $( compgen -W '${COMPREPLY[@]} $pwd' -- \
1769 $cur ) )
1770 else
1771 COMPREPLY=( $( compgen -W '-d -k -I -b -m -W' -- $cur ))
1772 fi
1773 ;;
1774 update)
1775 if [[ "$cur" = -* ]]; then
1776 COMPREPLY=( $( compgen -W '-A -P -C -d -f -l -R -p \
1777 -k -r -D -j -I -W' -- \
1778 $cur ) )
1779 fi
1780 ;;
1781 "")
1782 COMPREPLY=( $( compgen -W 'add admin annotate checkout ci co \
1783 commit diff delete edit export \
1784 freeze get history import log new \
1785 patch rcs rdiff release remove \
1786 rfreeze rlog rm rtag stat status \
1787 tag unedit up update -H -Q -q -b \
1788 -d -e -f -l -n -t -r -v -w -x -z \
1789 --help --version' -- $cur ) )
1790 ;;
1791 *)
1792 ;;
1793 esac
1794
1795 return 0
1796 }
1797 complete -F _cvs $default cvs
1798 }
1799
1800 have rpm && {
1801 # helper functions for rpm completion
1802 #
1803 _rpm_installed_packages()
1804 {
1805 local ver nodig nosig
1806
1807 if [ -r /var/log/rpmpkgs -a \
1808 /var/log/rpmpkgs -nt /var/lib/rpm/Packages ]; then
1809 # using RHL 7.2 or later - this is quicker than querying the DB
1810 COMPREPLY=( $( sed -ne \
1811 's|^\('$cur'.*\)-[0-9a-zA-Z._]\+-[0-9a-z.@]\+.*\.rpm$|\1|p' \
1812 /var/log/rpmpkgs ) )
1813 else
1814 nodig=""
1815 nosig=""
1816 ver=$(rpm --version)
1817 ver=${ver##* }
1818
1819 if [[ "$ver" > "4.0.4" ]]; then
1820 nodig="--nodigest"
1821 fi
1822 if [[ "$ver" > "4.0.99" ]]; then
1823 nosig="--nosignature"
1824 fi
1825
1826 COMPREPLY=( $( rpm -qa $nodig $nosig | sed -ne \
1827 's|^\('$cur'.*\)-[0-9a-zA-Z._]\+-[0-9a-z.@]\+$|\1|p' ) )
1828 fi
1829 }
1830
1831 _rpm_groups()
1832 {
1833 local IFS=$'\t'
1834 # remove trailing backslash, or grep will complain
1835 cur=${cur%"\\"}
1836 COMPREPLY=( $( rpm -qa $nodig $nosig --queryformat '%{group}\n' | \
1837 grep "^$cur" ) )
1838 # backslash escape spaces and translate newlines to tabs
1839 COMPREPLY=( $( echo "${COMPREPLY[@]}" | sed 's/ /\\ /g' | tr '\n' '\t' ) )
1840 }
1841
1842 # rpm(8) completion
1843 #
1844 _rpm()
1845 {
1846 local cur prev ver nodig nosig
1847
1848 COMPREPLY=()
1849 cur=`_get_cword`
1850 prev=${COMP_WORDS[COMP_CWORD-1]}
1851 nodig=""
1852 nosig=""
1853 ver=$(rpm --version); ver=${ver##* }
1854
1855 if [[ "$ver" > "4.0.4" ]]; then
1856 nodig="--nodigest"
1857 fi
1858 if [[ "$ver" > "4.0.99" ]]; then
1859 nosig="--nosignature"
1860 fi
1861
1862 if [ $COMP_CWORD -eq 1 ]; then
1863 # first parameter on line
1864 case "$cur" in
1865 -b*)
1866 COMPREPLY=( $( compgen -W '-ba -bb -bc -bi -bl -bp -bs'\
1867 -- $cur ) )
1868 ;;
1869 -t*)
1870 COMPREPLY=( $( compgen -W '-ta -tb -tc -ti -tl -tp -ts'\
1871 -- $cur ) )
1872 ;;
1873 --*)
1874 COMPREPLY=( $( compgen -W '--help --version --initdb \
1875 --checksig --recompile --rebuild --resign --addsign \
1876 --rebuilddb --showrc --setperms --setugids --tarbuild \
1877 --eval --install --upgrade --query --freshen --erase \
1878 --verify --querytags --rmsource --rmspec --clean \
1879 --import' -- $cur ) )
1880 ;;
1881 *)
1882 COMPREPLY=( $( compgen -W '-b -e -F -i -q -t -U -V' \
1883 -- $cur ) )
1884 ;;
1885 esac
1886
1887 return 0
1888 fi
1889
1890 case "$prev" in
1891 --@(@(db|exclude)path|prefix|relocate|root))
1892 _filedir -d
1893 return 0
1894 ;;
1895 --eval)
1896 # get a list of macros
1897 COMPREPLY=( $( sed -ne 's|^\(%'${cur#\%}'[^ '$'\t'']*\).*$|\1|p' \
1898 /usr/lib/rpm/macros ) )
1899 return 0
1900 ;;
1901 --pipe)
1902 COMPREPLY=( $( compgen -c -- $cur ) )
1903 return 0
1904 ;;
1905 --rcfile)
1906 _filedir
1907 return 0
1908 ;;
1909 --specfile)
1910 # complete on .spec files
1911 _filedir spec
1912 return 0
1913 ;;
1914 --whatprovides)
1915 if [[ "$cur" == */* ]]; then
1916 _filedir
1917 else
1918 # complete on capabilities
1919 COMPREPLY=( $( rpm -qa $nodig $nosig --queryformat \
1920 '%{providename}\n' | grep "^$cur" ) )
1921 fi
1922 return 0
1923 ;;
1924 --whatrequires)
1925 # complete on capabilities
1926 COMPREPLY=( $( rpm -qa $nodig $nosig --queryformat \
1927 '%{requirename}\n' | grep "^$cur" ) )
1928 return 0
1929 ;;
1930 esac
1931
1932 case "${COMP_WORDS[1]}" in
1933 -@([iFU]*|-install|-freshen|-upgrade))
1934 if [[ "$cur" == -* ]]; then
1935 COMPREPLY=( $( compgen -W '--percent --force --test \
1936 --replacepkgs --replacefiles --root --excludedocs \
1937 --includedocs --noscripts --rcfile --ignorearch \
1938 --dbpath --prefix --ignoreos --nodeps --allfiles \
1939 --ftpproxy --ftpport --justdb --httpproxy --httpport \
1940 --noorder --relocate --badreloc --notriggers \
1941 --excludepath --ignoresize --oldpackage --define \
1942 --eval --pipe --queryformat --repackage --nosuggests \
1943 --nodigest --nosignature' -- $cur ) )
1944 else
1945 _filedir 'rpm'
1946 fi
1947 ;;
1948 -@(e|-erase))
1949 if [[ "$cur" == -* ]]; then
1950 COMPREPLY=( $( compgen -W '--allmatches --noscripts \
1951 --notriggers --nodeps --test --repackage' -- $cur ) )
1952 else
1953 _rpm_installed_packages
1954 fi
1955 ;;
1956 -@(q*|-query))
1957 # check whether we're doing file completion
1958 if [ "${COMP_LINE#* -*([^ -])f}" != "$COMP_LINE" ]; then
1959 if [[ "$cur" == -* ]]; then
1960 COMPREPLY=( $( compgen -W '--scripts --root \
1961 --rcfile --requires --ftpport --ftpproxy \
1962 --httpproxy --httpport --provides --triggers \
1963 --dump --changelog --dbpath \
1964 --last --filesbypkg \
1965 --info --list --state \
1966 --docfiles --configfiles --queryformat \
1967 --conflicts --obsoletes \
1968 --nodigest --nosignature \
1969 --triggerscripts' -- $cur ) )
1970 else
1971 _filedir
1972 fi
1973 elif [ "${COMP_LINE#* -*([^ -])g}" != "$COMP_LINE" ]; then
1974 _rpm_groups
1975 elif [ "${COMP_LINE#* -*([^ -])p}" != "$COMP_LINE" ]; then
1976 # uninstalled package completion
1977 if [[ "$cur" == -* ]]; then
1978 COMPREPLY=( $( compgen -W '--scripts --root \
1979 --rcfile --whatprovides --whatrequires \
1980 --requires --triggeredby --ftpport --ftpproxy \
1981 --httpproxy --httpport --provides --triggers \
1982 --dump --changelog --dbpath --filesbypkg \
1983 --define --eval --pipe --showrc --info --list \
1984 --state --docfiles --configfiles --queryformat\
1985 --conflicts --obsoletes --nodigest \
1986 --nosignature' -- $cur ) )
1987 else
1988 _filedir 'rpm'
1989 fi
1990 else
1991 # installed package completion
1992 if [[ "$cur" == -* ]]; then
1993 COMPREPLY=( $( compgen -W '--scripts --root \
1994 --rcfile --whatprovides --whatrequires \
1995 --requires --triggeredby --ftpport --ftpproxy \
1996 --httpproxy --httpport --provides --triggers \
1997 --dump --changelog --dbpath --specfile \
1998 --querybynumber --last --filesbypkg --define \
1999 --eval --pipe --showrc --info --list --state \
2000 --docfiles --configfiles --queryformat \
2001 --conflicts --obsoletes --pkgid --hdrid \
2002 --fileid --tid --nodigest --nosignature \
2003 --triggerscripts' -- $cur ) )
2004 elif [ "${COMP_LINE#* -*([^ -])a}" == "$COMP_LINE" ]; then
2005 _rpm_installed_packages
2006 fi
2007 fi
2008 ;;
2009 -@(K*|-checksig))
2010 if [[ "$cur" == -* ]]; then
2011 COMPREPLY=( $( compgen -W '--nopgp --nogpg --nomd5 \
2012 --nodigest --nosignature' -- $cur ) )
2013 else
2014 _filedir 'rpm'
2015 fi
2016 ;;
2017 -@([Vy]*|-verify))
2018 if [[ "$cur" == -* ]]; then
2019 COMPREPLY=( $( compgen -W '--root --rcfile --dbpath \
2020 --nodeps --nogroup --nolinkto --nomode --nomtime \
2021 --nordev --nouser --nofiles --noscripts --nomd5 \
2022 --querytags --specfile --whatrequires --whatprovides \
2023 --nodigest --nosignature' -- $cur ) )
2024 # check whether we're doing file completion
2025 elif [ "${COMP_LINE#* -*([^ -])f}" != "$COMP_LINE" ]; then
2026 _filedir
2027 elif [ "${COMP_LINE#* -*([^ -])g}" != "$COMP_LINE" ]; then
2028 _rpm_groups
2029 elif [ "${COMP_LINE#* -*([^ -])p}" != "$COMP_LINE" ]; then
2030 _filedir 'rpm'
2031 else
2032 _rpm_installed_packages
2033 fi
2034 ;;
2035 -[bt]*)
2036 if [[ "$cur" == -* ]]; then
2037 COMPREPLY=( $( compgen -W '--short-circuit --timecheck \
2038 --clean --rmsource --rmspec --test --sign --buildroot \
2039 --target -- buildarch --buildos --nobuild --nodeps \
2040 --nodirtokens' -- $cur ) )
2041 elif [[ ${COMP_WORDS[1]} == -b* ]]; then
2042 _filedir 'spec'
2043 else
2044 _filedir '@(tgz|tar.@(gz|bz2))'
2045 fi
2046 ;;
2047 --re@(build|compile))
2048 if [[ "$cur" == -* ]]; then
2049 COMPREPLY=( $( compgen -W '--nodeps --rmsource \
2050 --rmspec --sign --nodirtokens --target' -- $cur ) )
2051 else
2052 _filedir '?(no)src.rpm'
2053 fi
2054 ;;
2055 --tarbuild)
2056 _filedir '@(tgz|tar.@(gz|bz2))'
2057 ;;
2058 --@(re|add)sign)
2059 _filedir 'rpm'
2060 ;;
2061 --set@(perms|gids))
2062 _rpm_installed_packages
2063 ;;
2064 --@(clean|rms@(ource|pec)))
2065 if [[ "$cur" == -* ]]; then
2066 COMPREPLY=( $( compgen -W '--clean --rmsource \
2067 --rmspec' -- $cur ) )
2068 else
2069 _filedir 'spec'
2070 fi
2071 ;;
2072 --@(import|dbpath|root))
2073 if [[ "$cur" == -* ]]; then
2074 COMPREPLY=( $( compgen -W '--import --dbpath --root' \
2075 -- $cur ) )
2076 else
2077 _filedir
2078 fi
2079 ;;
2080 esac
2081
2082 return 0
2083 }
2084 complete -F _rpm $filenames rpm rpmbuild
2085 }
2086
2087 # Debian apt-get(8) completion.
2088 #
2089 have apt-get &&
2090 _apt_get()
2091 {
2092 local cur prev special i
2093
2094 COMPREPLY=()
2095 cur=`_get_cword`
2096 prev=${COMP_WORDS[COMP_CWORD-1]}
2097
2098 for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
2099 if [[ ${COMP_WORDS[i]} == @(install|remove|purge|source|build-dep) ]]; then
2100 special=${COMP_WORDS[i]}
2101 fi
2102 done
2103
2104 if [ -n "$special" ]; then
2105 case $special in
2106 remove|purge)
2107 if [ -f /etc/debian_version ]; then
2108 # Debian system
2109 COMPREPLY=( $( _comp_dpkg_installed_packages \
2110 $cur ) )
2111 else
2112 # assume RPM based
2113 _rpm_installed_packages
2114 fi
2115 return 0
2116 ;;
2117 *)
2118 COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
2119 return 0
2120 ;;
2121
2122 esac
2123 fi
2124
2125 case "$prev" in
2126 -@(c|-config-file))
2127 _filedir
2128 return 0
2129 ;;
2130
2131 -@(t|-target-release|-default-release))
2132 COMPREPLY=( $( apt-cache policy | \
2133 grep "release.o=Debian,a=$cur" | \
2134 sed -e "s/.*a=\(\w*\).*/\1/" | uniq 2> /dev/null) )
2135 return 0
2136 ;;
2137
2138 esac
2139
2140 if [[ "$cur" == -* ]]; then
2141
2142 COMPREPLY=( $( compgen -W '-d -f -h -v -m -q -s -y \
2143 -u -t -b -c -o --download-only --fix-broken \
2144 --help --version --ignore-missing \
2145 --fix-missing --no-download --quiet --simulate \
2146 --just-print --dry-run --recon --no-act --yes \
2147 --assume-yes --show-upgraded --only-source \
2148 --compile --build --ignore-hold \
2149 --target-release --no-upgrade --force-yes \
2150 --print-uris --purge --reinstall \
2151 --list-cleanup --default-release \
2152 --trivial-only --no-remove --diff-only \
2153 --tar-only --config-file --option --auto-remove' -- $cur ) )
2154 else
2155
2156 COMPREPLY=( $( compgen -W 'update upgrade dselect-upgrade \
2157 dist-upgrade install remove purge source \
2158 build-dep check clean autoclean autoremove' \
2159 -- $cur ) )
2160
2161 fi
2162
2163
2164 return 0
2165 } &&
2166 complete -F _apt_get $filenames apt-get
2167
2168 # Debian apt-cache(8) completion.
2169 #
2170 have apt-cache &&
2171 _apt_cache()
2172 {
2173 local cur prev special i
2174
2175 COMPREPLY=()
2176 cur=`_get_cword`
2177 prev=${COMP_WORDS[COMP_CWORD-1]}
2178
2179
2180 if [ "$cur" != show ]; then
2181 for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
2182 if [[ ${COMP_WORDS[i]} == @(add|depends|dotty|policy|rdepends|madison|show?(pkg|src|)) ]]; then
2183 special=${COMP_WORDS[i]}
2184 fi
2185 done
2186 fi
2187
2188
2189 if [ -n "$special" ]; then
2190 case $special in
2191 add)
2192 _filedir
2193 return 0
2194 ;;
2195
2196 *)
2197 COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
2198 return 0
2199 ;;
2200
2201 esac
2202 fi
2203
2204
2205 case "$prev" in
2206 -@(c|p|s|-config-file|-@(pkg|src)-cache))
2207 _filedir
2208 return 0
2209 ;;
2210 search)
2211 if [[ "$cur" != -* ]]; then
2212 return 0
2213 fi
2214 ;;
2215 esac
2216
2217 if [[ "$cur" == -* ]]; then
2218
2219 COMPREPLY=( $( compgen -W '-h -v -p -s -q -i -f -a -g -c \
2220 -o --help --version --pkg-cache --src-cache \
2221 --quiet --important --full --all-versions \
2222 --no-all-versions --generate --no-generate \
2223 --names-only --all-names --recurse \
2224 --config-file --option' -- $cur ) )
2225 else
2226
2227 COMPREPLY=( $( compgen -W 'add gencaches show showpkg showsrc \
2228 stats dump dumpavail unmet search search \
2229 depends rdepends pkgnames dotty xvcg \
2230 policy madison' -- $cur ) )
2231
2232 fi
2233
2234
2235 return 0
2236 } &&
2237 complete -F _apt_cache $filenames apt-cache
2238
2239
2240 # Debian aptitude(1) completion
2241 #
2242 have aptitude && {
2243 have grep-status && {
2244 _comp_dpkg_hold_packages()
2245 {
2246 grep-status -P -e "^$1" -a -FStatus 'hold' -n -s Package
2247 }
2248 } || {
2249 _comp_dpkg_hold_packages()
2250 {
2251 grep -B 2 'hold' /var/lib/dpkg/status | grep "Package: $1" \
2252 | cut -d\ -f2
2253 }
2254 }
2255
2256 _aptitude()
2257 {
2258 local cur dashoptions prev special i
2259
2260 COMPREPLY=()
2261 cur=`_get_cword`
2262 prev=${COMP_WORDS[COMP_CWORD-1]}
2263
2264
2265 dashoptions='-S -u -i -h --help --version -s --simulate -d \
2266 --download-only -P --prompt -y --assume-yes -F \
2267 --display-format -O --sort -w --width -f -r -g \
2268 --with-recommends --with-suggests -R -G \
2269 --without-recommends --without-suggests -t \
2270 --target-release -V --show-versions -D --show-deps\
2271 -Z -v --verbose --purge-unused'
2272
2273 for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
2274 if [[ ${COMP_WORDS[i]} == @(install|reinstall|hold|unhold|markauto|unmarkauto|dist-upgrade|full-upgrade|download|show|forbid-version|purge|remove|changelog|why|why-not|keep|keep-all) ]]; then
2275 special=${COMP_WORDS[i]}
2276 fi
2277 #exclude some mutually exclusive options
2278 [[ ${COMP_WORDS[i]} == '-u' ]] && dashoptions=${dashoptions/-i}
2279 [[ ${COMP_WORDS[i]} == '-i' ]] && dashoptions=${dashoptions/-u}
2280 done
2281
2282 if [[ -n "$special" ]]; then
2283 case $special in
2284 @(install|hold|markauto|unmarkauto|dist-upgrade|full-upgrade|download|show|changelog|why|why-not))
2285 COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
2286 return 0
2287 ;;
2288 @(purge|remove|reinstall|forbid-version))
2289 COMPREPLY=( $( _comp_dpkg_installed_packages $cur ) )
2290 return 0
2291 ;;
2292 unhold)
2293 COMPREPLY=( $( _comp_dpkg_hold_packages $cur ) )
2294 return 0
2295 ;;
2296
2297 esac
2298 fi
2299
2300 case $prev in
2301 # don't complete anything if these options are found
2302 @(autoclean|clean|forget-new|search|upgrade|safe-upgrade|update|keep-all))
2303 return 0
2304 ;;
2305
2306 -S)
2307 _filedir
2308 return 0
2309 ;;
2310
2311 -@(t|-target-release|-default-release))
2312 COMPREPLY=( $( apt-cache policy | \
2313 grep "release.o=Debian,a=$cur" | \
2314 sed -e "s/.*a=\(\w*\).*/\1/" | uniq 2> /dev/null ) )
2315 return 0
2316 ;;
2317
2318 esac
2319
2320 if [[ "$cur" == -* ]]; then
2321 COMPREPLY=( $( compgen -W "$dashoptions" -- $cur ) )
2322 else
2323 COMPREPLY=( $( compgen -W 'update upgrade safe-upgrade forget-new clean \
2324 autoclean install reinstall remove \
2325 hold unhold purge markauto unmarkauto why why-not \
2326 dist-upgrade full-upgrade download search show \
2327 forbid-version changelog keep-all' -- $cur ) )
2328 fi
2329
2330
2331 return 0
2332 }
2333 complete -F _aptitude $default aptitude
2334 }
2335
2336 # Debian apt-build(1) completion.
2337 #
2338 have apt-build &&
2339 _apt_build()
2340 {
2341 local cur prev special i
2342
2343 COMPREPLY=()
2344 cur=`_get_cword`
2345 prev=${COMP_WORDS[COMP_CWORD-1]}
2346
2347 for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
2348 if [[ ${COMP_WORDS[i]} == @(install|remove|source|info|clean) ]]; then
2349 special=${COMP_WORDS[i]}
2350 fi
2351 done
2352
2353 if [ -n "$special" ]; then
2354 case $special in
2355 @(install|source|info))
2356 COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
2357 return 0
2358 ;;
2359 remove)
2360 COMPREPLY=( $( _comp_dpkg_installed_packages \
2361 $cur ) )
2362 return 0
2363 ;;
2364 *)
2365 return 0
2366 ;;
2367 esac
2368 fi
2369
2370 case "$prev" in
2371
2372 --@(patch|build-dir|repository-dir))
2373 _filedir
2374 return 0
2375 ;;
2376
2377 -@(h|-help))
2378 return 0
2379 ;;
2380
2381 esac
2382
2383 if [[ "$cur" == -* ]]; then
2384 COMPREPLY=( $( compgen -W '--help --show-upgraded -u --build-dir \
2385 --repository-dir --build-only \
2386 --build-command --reinstall --rebuild \
2387 --remove-builddep --no-wrapper --purge \
2388 --patch --patch-strip -p --yes -y \
2389 --version -v --no-source' -- $cur ) )
2390
2391 else
2392 COMPREPLY=( $( compgen -W 'update upgrade install remove \
2393 source dist-upgrade world clean info \
2394 clean-build update-repository ' -- $cur ) )
2395 fi
2396
2397
2398 return 0
2399 } &&
2400 complete -F _apt_build $filenames apt-build
2401
2402 # chsh(1) completion
2403 #
2404 _chsh()
2405 {
2406 local cur prev
2407
2408 COMPREPLY=()
2409 cur=`_get_cword`
2410 prev=${COMP_WORDS[COMP_CWORD-1]}
2411
2412 if [ "$prev" = "-s" ]; then
2413 if [ -f /etc/debian_version ]; then
2414 COMPREPLY=( $( </etc/shells ) )
2415 else
2416 COMPREPLY=( $( chsh -l | grep "^$cur" ) )
2417 fi
2418 else
2419 COMPREPLY=( $( compgen -u -- $cur ) )
2420 fi
2421
2422 return 0
2423 }
2424 complete -F _chsh chsh
2425
2426 # chkconfig(8) completion
2427 #
2428 have chkconfig &&
2429 _chkconfig()
2430 {
2431 local cur prev
2432
2433 COMPREPLY=()
2434 cur=`_get_cword`
2435 prev=${COMP_WORDS[COMP_CWORD-1]}
2436
2437 case "$prev" in
2438 @([1-6]|--@(list|add|del)))
2439 _services
2440 return 0
2441 ;;
2442 --level)
2443 COMPREPLY=( $( compgen -W '1 2 3 4 5 6' -- $cur ) )
2444 return 0
2445 ;;
2446 esac
2447
2448 if [[ "$cur" == -* ]]; then
2449 COMPREPLY=( $( compgen -W '--list --add --del --level' -- $cur ) )
2450 else
2451 if [ $COMP_CWORD -eq 2 -o $COMP_CWORD -eq 4 ]; then
2452 COMPREPLY=( $( compgen -W 'on off reset' -- $cur ) )
2453 else
2454 _services
2455 fi
2456 fi
2457 } &&
2458 complete -F _chkconfig chkconfig
2459
2460 # This function provides simple user@host completion
2461 #
2462 _user_at_host() {
2463 local cur
2464
2465 COMPREPLY=()
2466 cur=`_get_cword`
2467
2468 if [[ $cur == *@* ]]; then
2469 _known_hosts
2470 else
2471 COMPREPLY=( $( compgen -u -- "$cur" ) )
2472 fi
2473
2474 return 0
2475 }
2476 shopt -u hostcomplete && complete -F _user_at_host $nospace talk ytalk finger
2477
2478 # This function performs host completion based on ssh's known_hosts files,
2479 # defaulting to standard host completion if they don't exist.
2480 #
2481 _known_hosts()
2482 {
2483 local cur curd ocur user suffix aliases global_kh user_kh hosts i host
2484 local -a kh khd config
2485
2486 COMPREPLY=()
2487 cur=`_get_cword`
2488 ocur=$cur
2489
2490 [ "$1" = -a ] || [ "$2" = -a ] && aliases='yes'
2491 [ "$1" = -c ] || [ "$2" = -c ] && suffix=':'
2492 [[ $cur == *@* ]] && user=${cur%@*}@ && cur=${cur#*@}
2493 kh=()
2494
2495 # ssh config files
2496 [ -r /etc/ssh/ssh_config ] &&
2497 config=( "${config[@]}" "/etc/ssh/ssh_config" )
2498 [ -r "${HOME}/.ssh/config" ] &&
2499 config=( "${config[@]}" "${HOME}/.ssh/config" )
2500 [ -r "${HOME}/.ssh2/config" ] &&
2501 config=( "${config[@]}" "${HOME}/.ssh2/config" )
2502
2503 if [ ${#config[@]} -gt 0 ]; then
2504 # expand path (if present) to global known hosts file
2505 global_kh=$( eval echo $( sed -ne 's/^[ \t]*[Gg][Ll][Oo][Bb][Aa][Ll][Kk][Nn][Oo][Ww][Nn][Hh][Oo][Ss][Tt][Ss][Ff][Ii][Ll][Ee]['"$'\t '"']*\(.*\)$/\1/p' "${config[@]}" ) )
2506 # expand path (if present) to user known hosts file
2507 user_kh=$( eval echo $( sed -ne 's/^[ \t]*[Uu][Ss][Ee][Rr][Kk][Nn][Oo][Ww][Nn][Hh][Oo][Ss][Tt][Ss][Ff][Ii][Ll][Ee]['"$'\t '"']*\(.*\)$/\1/p' "${config[@]}" ) )
2508 fi
2509
2510 # Global known_hosts files
2511 [ -r "$global_kh" ] &&
2512 kh=( "${kh[@]}" "$global_kh" )
2513 [ -r /etc/ssh/ssh_known_hosts ] &&
2514 kh=( "${kh[@]}" /etc/ssh/ssh_known_hosts )
2515 [ -r /etc/ssh/ssh_known_hosts2 ] &&
2516 kh=( "${kh[@]}" /etc/ssh/ssh_known_hosts2 )
2517 [ -r /etc/known_hosts ] &&
2518 kh=( "${kh[@]}" /etc/known_hosts )
2519 [ -r /etc/known_hosts2 ] &&
2520 kh=( "${kh[@]}" /etc/known_hosts2 )
2521 [ -d /etc/ssh2/knownhosts ] &&
2522 khd=( "${khd[@]}" /etc/ssh2/knownhosts/*pub )
2523
2524 # User known_hosts files
2525 [ -r "$user_kh" ] &&
2526 kh=( "${kh[@]}" "$user_kh" )
2527 [ -r ~/.ssh/known_hosts ] &&
2528 kh=( "${kh[@]}" ~/.ssh/known_hosts )
2529 [ -r ~/.ssh/known_hosts2 ] &&
2530 kh=( "${kh[@]}" ~/.ssh/known_hosts2 )
2531 [ -d ~/.ssh2/hostkeys ] &&
2532 khd=( "${khd[@]}" ~/.ssh2/hostkeys/*pub )
2533
2534 # If we have known_hosts files to use
2535 if [ ${#kh[@]} -gt 0 -o ${#khd[@]} -gt 0 ]; then
2536 # Escape slashes and dots in paths for awk
2537 cur=${cur//\//\\\/}
2538 cur=${cur//\./\\\.}
2539 curd=$cur
2540
2541 if [[ "$cur" == [0-9]*.* ]]; then
2542 # Digits followed by a dot - just search for that
2543 cur="^$cur.*"
2544 elif [[ "$cur" == [0-9]* ]]; then
2545 # Digits followed by no dot - search for digits followed
2546 # by a dot
2547 cur="^$cur.*\."
2548 elif [ -z "$cur" ]; then
2549 # A blank - search for a dot or an alpha character
2550 cur="[a-z.]"
2551 else
2552 cur="^$cur"
2553 fi
2554
2555 if [ ${#kh[@]} -gt 0 ]; then
2556
2557 # FS needs to look for a comma separated list
2558 COMPREPLY=( $( awk 'BEGIN {FS=","}
2559 /^[^|]/ {for (i=1; i<=2; ++i) { \
2560 gsub(" .*$", "", $i); \
2561 if ($i ~ /'$cur'/) {print $i} \
2562 }}' "${kh[@]}" 2>/dev/null ) )
2563 fi
2564 if [ ${#khd[@]} -gt 0 ]; then
2565 # Needs to look for files called
2566 # .../.ssh2/key_22_<hostname>.pub
2567 # dont fork any processes, because in a cluster environment,
2568 # there can be hundreds of hostkeys
2569 for i in "${khd[@]}" ; do
2570 if [[ "$i" == *key_22_$curd*.pub ]] && [ -r "$i" ] ; then
2571 host=${i/#*key_22_/}
2572 host=${host/%.pub/}
2573 COMPREPLY=( "${COMPREPLY[@]}" $host )
2574 fi
2575 done
2576 fi
2577
2578 # append any available aliases from config files
2579 if [ ${#config[@]} -gt 0 ] && [ -n "$aliases" ]; then
2580 local host_aliases=$( sed -ne 's/^[Hh][Oo][Ss][Tt]\([Nn][Aa][Mm][Ee]\)\?['"$'\t '"']\+\([^*?]*\)$/\2/p' "${config[@]}" )
2581 hosts=$( compgen -W "$host_aliases" -- $ocur )
2582 COMPREPLY=( "${COMPREPLY[@]}" $hosts )
2583 fi
2584
2585 # Now add results of normal hostname completion
2586 COMPREPLY=( "${COMPREPLY[@]}" $( compgen -A hostname -- $ocur ) )
2587
2588 # apply suffix
2589 for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
2590 COMPREPLY[i]=$user${COMPREPLY[i]}$suffix
2591 done
2592 else
2593 # Just do normal hostname completion
2594 COMPREPLY=( $( compgen -A hostname -S "$suffix" -- $cur ) )
2595 fi
2596
2597 return 0
2598 }
2599 complete -F _known_hosts traceroute traceroute6 tracepath tracepath6 \
2600 ping ping6 fping fping6 telnet host nslookup rsh rlogin ftp dig ssh-installkeys mtr
2601
2602 # ssh(1) completion
2603 #
2604 have ssh && {
2605 _ssh()
2606 {
2607 local cur prev
2608 local -a config
2609
2610 COMPREPLY=()
2611 cur=`_get_cword`
2612 prev=${COMP_WORDS[COMP_CWORD-1]}
2613
2614 case "$prev" in
2615 -*c)
2616 COMPREPLY=( $( compgen -W 'blowfish 3des 3des-cbc blowfish-cbc \
2617 arcfour cast128-cbc' -- $cur ) )
2618 ;;
2619 -*i)
2620 _filedir
2621 ;;
2622 -*l)
2623 COMPREPLY=( $( compgen -u -- $cur ) )
2624 ;;
2625 *)
2626 _known_hosts -a
2627
2628 [ $COMP_CWORD -eq 1 ] || \
2629 COMPREPLY=( "${COMPREPLY[@]}" $( compgen -c -- $cur ) )
2630 esac
2631
2632 return 0
2633 }
2634 shopt -u hostcomplete && complete -F _ssh ssh slogin sftp xhost autossh
2635
2636 # scp(1) completion
2637 #
2638 _scp()
2639 {
2640 local cur userhost path
2641
2642 COMPREPLY=()
2643 cur=`_get_cword`
2644
2645 _expand || return 0
2646
2647 if [[ "$cur" == *:* ]]; then
2648 local IFS=$'\t\n'
2649 # remove backslash escape from :
2650 cur=${cur/\\:/:}
2651 userhost=${cur%%?(\\):*}
2652 path=${cur#*:}
2653 # unescape spaces
2654 path=${path//\\\\\\\\ / }
2655 if [ -z "$path" ]; then
2656 # default to home dir of specified user on remote host
2657 path=$(ssh -o 'Batchmode yes' $userhost pwd 2>/dev/null)
2658 fi
2659 # escape spaces; remove executables, aliases, pipes and sockets;
2660 # add space at end of file names
2661 COMPREPLY=( $( ssh -o 'Batchmode yes' $userhost \
2662 command ls -aF1d "$path*" 2>/dev/null | \
2663 sed -e "s/[][(){}<>\",:;^&!$&=?\`|\\ ']/\\\\\\\\\\\\&/g" \
2664 -e 's/[*@|=]$//g' -e 's/[^\/]$/& /g' ) )
2665 return 0
2666 fi
2667
2668 [[ "$cur" == */* ]] || _known_hosts -c -a
2669 local IFS=$'\t\n'
2670 COMPREPLY=( "${COMPREPLY[@]}" $( command ls -aF1d $cur* \
2671 2>/dev/null | sed \
2672 -e "s/[][(){}<>\",:;^&!$&=?\`|\\ ']/\\\\&/g" \
2673 -e 's/[*@|=]$//g' -e 's/[^\/]$/& /g' ) )
2674 return 0
2675 }
2676 complete -F _scp $nospace scp
2677 }
2678
2679 # rsync(1) completion
2680 #
2681 have rsync &&
2682 _rsync()
2683 {
2684 local cur prev shell i userhost path
2685
2686 COMPREPLY=()
2687 cur=`_get_cword`
2688 prev=${COMP_WORDS[COMP_CWORD-1]}
2689
2690 _expand || return 0
2691
2692 case "$prev" in
2693 --@(config|password-file|include-from|exclude-from))
2694 _filedir
2695 return 0
2696 ;;
2697 -@(T|-temp-dir|-compare-dest))
2698 _filedir -d
2699 return 0
2700 ;;
2701 -@(e|-rsh))
2702 COMPREPLY=( $( compgen -W 'rsh ssh' -- $cur ) )
2703 return 0
2704 ;;
2705 esac
2706
2707 case "$cur" in
2708 -*)
2709 COMPREPLY=( $( compgen -W '-v -q -c -a -r -R -b -u -l -L -H \
2710 -p -o -g -D -t -S -n -W -x -B -e -C -I -T -P \
2711 -z -h -4 -6 --verbose --quiet --checksum \
2712 --archive --recursive --relative --backup \
2713 --backup-dir --suffix= --update --links \
2714 --copy-links --copy-unsafe-links --safe-links \
2715 --hard-links --perms --owner --group --devices\
2716 --times --sparse --dry-run --whole-file \
2717 --no-whole-file --one-file-system \
2718 --block-size= --rsh= --rsync-path= \
2719 --cvs-exclude --existing --ignore-existing \
2720 --delete --delete-excluded --delete-after \
2721 --ignore-errors --max-delete= --partial \
2722 --force --numeric-ids --timeout= \
2723 --ignore-times --size-only --modify-window= \
2724 --temp-dir= --compare-dest= --compress \
2725 --exclude= --exclude-from= --include= \
2726 --include-from= --version --daemon --no-detach\
2727 --address= --config= --port= --blocking-io \
2728 --no-blocking-io --stats --progress \
2729 --log-format= --password-file= --bwlimit= \
2730 --write-batch= --read-batch= --help' -- $cur ))
2731 ;;
2732 *:*)
2733 # find which remote shell is used
2734 shell=rsh
2735 for (( i=1; i < COMP_CWORD; i++ )); do
2736 if [[ "${COMP_WORDS[i]}" == -@(e|-rsh) ]]; then
2737 shell=${COMP_WORDS[i+1]}
2738 break
2739 fi
2740 done
2741 if [[ "$shell" == ssh ]]; then
2742 # remove backslash escape from :
2743 cur=${cur/\\:/:}
2744 userhost=${cur%%?(\\):*}
2745 path=${cur#*:}
2746 # unescape spaces
2747 path=${path//\\\\\\\\ / }
2748 if [ -z "$path" ]; then
2749 # default to home dir of specified
2750 # user on remote host
2751 path=$(ssh -o 'Batchmode yes' \
2752 $userhost pwd 2>/dev/null)
2753 fi
2754 # escape spaces; remove executables, aliases, pipes
2755 # and sockets; add space at end of file names
2756 COMPREPLY=( $( ssh -o 'Batchmode yes' $userhost \
2757 command ls -aF1d "$path*" 2>/dev/null | \
2758 sed -e 's/ /\\\\\\\ /g' -e 's/[*@|=]$//g' \
2759 -e 's/[^\/]$/& /g' ) )
2760 fi
2761 ;;
2762 *)
2763 _known_hosts -c -a
2764 _filedir
2765 ;;
2766 esac
2767
2768 return 0
2769 } &&
2770 complete -F _rsync $nospace $filenames rsync
2771
2772 # Linux route(8) completion
2773 #
2774 [ $UNAME = Linux ] &&
2775 _route()
2776 {
2777 local cur prev
2778
2779 COMPREPLY=()
2780 cur=`_get_cword`
2781 prev=${COMP_WORDS[COMP_CWORD-1]}
2782
2783 if [ "$prev" = dev ]; then
2784 COMPREPLY=( $( ifconfig -a | sed -ne 's|^\('$cur'[^ ]*\).*$|\1|p' ))
2785 return 0
2786 fi
2787
2788 COMPREPLY=( $( compgen -W 'add del -host -net netmask metric mss \
2789 window irtt reject mod dyn reinstate dev \
2790 default gw' -- $cur ) )
2791
2792 COMPREPLY=( $( echo " ${COMP_WORDS[@]}" | \
2793 (while read -d ' ' i; do
2794 [ "$i" == "" ] && continue
2795 # flatten array with spaces on either side,
2796 # otherwise we cannot grep on word
2797 # boundaries of first and last word
2798 COMPREPLY=" ${COMPREPLY[@]} "
2799 # remove word from list of completions
2800 COMPREPLY=( ${COMPREPLY/ $i / } )
2801 done
2802 echo "${COMPREPLY[@]}")
2803 ) )
2804 return 0
2805 }
2806 [ $UNAME = Linux ] && complete -F _route route
2807
2808 # GNU make(1) completion
2809 #
2810 have make || have gmake || have gnumake || have pmake &&
2811 _make()
2812 {
2813 local file makef makef_dir="." makef_inc cur prev i
2814
2815 COMPREPLY=()
2816 cur=`_get_cword`
2817 prev=${COMP_WORDS[COMP_CWORD-1]}
2818
2819 # --name value style option
2820 case $prev in
2821 -@(f|o|W))
2822 _filedir
2823 return 0
2824 ;;
2825 -@(I|C))
2826 _filedir -d
2827 return 0
2828 ;;
2829 esac
2830
2831 # --name=value style option
2832 if [[ "$cur" == *=* ]]; then
2833 prev=${cur/=*/}
2834 cur=${cur/*=/}
2835 case "$prev" in
2836 --@(file|makefile))
2837 _filedir
2838 return 0
2839 ;;
2840 --@(directory|include-dir))
2841 _filedir -d
2842 return 0
2843 ;;
2844 esac
2845 fi
2846
2847 if [[ "$cur" == -* ]]; then
2848 COMPREPLY=( $( compgen -W '-b -m -B -C -d -e -f -h -i -I\
2849 -j -l -k -n -o -p -q -r -R - s -S -t -v -w -W \
2850 --always-make --directory= --debug \
2851 --environment-overrides --file= --makefile= --help \
2852 --ignore-errors --include-dir= --jobs --load-average \
2853 --max-load --keep-going --just-print --dry-run \
2854 --recon --old-file= --assume-old= --print-data-base \
2855 --question --no-builtin-rules --no-builtin-variables \
2856 --silent --quiet --no-keep-goind --stop --touch \
2857 --version --print-directory --no-print-directory \
2858 --what-if= --new-file= --assume-new= \
2859 --warn-undefined-variables' -- $cur ) )
2860 else
2861 # before we check for makefiles, see if a path was specified
2862 # with -C
2863 for (( i=0; i < ${#COMP_WORDS[@]}; i++ )); do
2864 if [[ ${COMP_WORDS[i]} == -C ]]; then
2865 # eval for tilde expansion
2866 eval makef_dir=${COMP_WORDS[i+1]}
2867 break
2868 fi
2869 done
2870
2871 # make reads `GNUmakefile', then `makefile', then `Makefile'
2872 if [ -f ${makef_dir}/GNUmakefile ]; then
2873 makef=${makef_dir}/GNUmakefile
2874 elif [ -f ${makef_dir}/makefile ]; then
2875 makef=${makef_dir}/makefile
2876 elif [ -f ${makef_dir}/Makefile ]; then
2877 makef=${makef_dir}/Makefile
2878 else
2879 makef=${makef_dir}/*.mk # local convention
2880 fi
2881
2882 # before we scan for targets, see if a Makefile name was
2883 # specified with -f
2884 for (( i=0; i < ${#COMP_WORDS[@]}; i++ )); do
2885 if [[ ${COMP_WORDS[i]} == -f ]]; then
2886 # eval for tilde expansion
2887 eval makef=${COMP_WORDS[i+1]}
2888 break
2889 fi
2890 done
2891
2892 [ ! -f $makef ] && return 0
2893
2894 # deal with included Makefiles
2895 makef_inc=$( grep -E '^-?include' $makef | sed -e "s,^.* ,"$makef_dir"/," )
2896
2897 for file in $makef_inc; do
2898 [ -f $file ] && makef="$makef $file"
2899 done
2900
2901 COMPREPLY=( $( awk -F':' '/^[a-zA-Z0-9][^$#\/\t=]*:([^=]|$)/ \
2902 {split($1,A,/ /);for(i in A)print A[i]}' \
2903 $makef 2>/dev/null | command grep "^$cur" ))
2904 fi
2905 } &&
2906 complete -f -F _make $filenames make gmake gnumake pmake
2907
2908 # GNU tar(1) completion
2909 #
2910 _tar()
2911 {
2912 local cur ext regex tar untar
2913
2914 COMPREPLY=()
2915 cur=`_get_cword`
2916
2917 if [ $COMP_CWORD -eq 1 ]; then
2918 COMPREPLY=( $( compgen -W 'c t x u r d A' -- $cur ) )
2919 return 0
2920 fi
2921
2922 case "${COMP_WORDS[1]}" in
2923 ?(-)[cr]*f)
2924 _filedir
2925 return 0
2926 ;;
2927 +([^IZzjy])f)
2928 ext='t@(ar?(.@(Z|gz|bz?(2)))|gz|bz?(2))'
2929 regex='t\(ar\(\.\(Z\|gz\|bz2\?\)\)\?\|gz\|bz2\?\)'
2930 ;;
2931 *[Zz]*f)
2932 ext='t?(ar.)@(gz|Z)'
2933 regex='t\(ar\.\)\?\(gz\|Z\)'
2934 ;;
2935 *[Ijy]*f)
2936 ext='t?(ar.)bz?(2)'
2937 regex='t\(ar\.\)\?bz2\?'
2938 ;;
2939 *)
2940 _filedir
2941 return 0
2942 ;;
2943
2944 esac
2945
2946 if [[ "$COMP_LINE" == *$ext' ' ]]; then
2947 # complete on files in tar file
2948 #
2949 # get name of tar file from command line
2950 tar=$( echo "$COMP_LINE" | \
2951 sed -e 's/^.* \([^ ]*'$regex'\) .*$/\1/' )
2952 # devise how to untar and list it
2953 untar=t${COMP_WORDS[1]//[^Izjyf]/}
2954
2955 COMPREPLY=( $( compgen -W "$( echo $( tar $untar $tar \
2956 2>/dev/null ) )" -- "$cur" ) )
2957 return 0
2958 fi
2959
2960 # file completion on relevant files
2961 _filedir "$ext"
2962
2963 return 0
2964 }
2965 [ -n "${COMP_TAR_INTERNAL_PATHS:-}" ] && complete -F _tar $dirnames tar ||
2966 complete -F _tar $filenames tar
2967
2968 # jar(1) completion
2969 #
2970 have jar &&
2971 _jar()
2972 {
2973 local cur
2974
2975 COMPREPLY=()
2976 cur=`_get_cword`
2977
2978 if [ $COMP_CWORD = 1 ]; then
2979 COMPREPLY=( $( compgen -W 'c t x u' -- $cur ) )
2980 return 0
2981 fi
2982
2983 case "${COMP_WORDS[1]}" in
2984 *c*f)
2985 _filedir
2986 ;;
2987 *f)
2988 _filedir '?(e|j|w)ar'
2989 ;;
2990 *)
2991 _filedir
2992 ;;
2993 esac
2994 } &&
2995 complete -F _jar $filenames jar
2996
2997 # Linux iptables(8) completion
2998 #
2999 have iptables &&
3000 _iptables()
3001 {
3002 local cur prev table chain
3003
3004 COMPREPLY=()
3005 cur=`_get_cword`
3006 prev=${COMP_WORDS[COMP_CWORD-1]}
3007 chain='s/^Chain \([^ ]\+\).*$/\1/p'
3008
3009 if [[ $COMP_LINE == *-t\ *filter* ]]; then
3010 table="-t filter"
3011 elif [[ $COMP_LINE == *-t\ *nat* ]]; then
3012 table="-t nat"
3013 elif [[ $COMP_LINE == *-t\ *mangle* ]]; then
3014 table="-t mangle"
3015 fi
3016
3017 case "$prev" in
3018 -*[AIDRPFXLZ])
3019 COMPREPLY=( $( compgen -W '`iptables $table -nL | \
3020 sed -ne "s/^Chain \([^ ]\+\).*$/\1/p"`' -- $cur ) )
3021 ;;
3022 -*t)
3023 COMPREPLY=( $( compgen -W 'nat filter mangle' -- $cur ) )
3024 ;;
3025 -j)
3026 if [ "$table" = "-t filter" -o "$table" = "" ]; then
3027 COMPREPLY=( $( compgen -W 'ACCEPT DROP LOG ULOG REJECT \
3028 `iptables $table -nL | sed -ne "$chain" \
3029 -e "s/INPUT|OUTPUT|FORWARD|PREROUTING|POSTROUTING//"`' -- \
3030 $cur ) )
3031 elif [ "$table" = "-t nat" ]; then
3032 COMPREPLY=( $( compgen -W 'ACCEPT DROP LOG ULOG REJECT \
3033 MIRROR SNAT DNAT MASQUERADE `iptables $table -nL | \
3034 sed -ne "$chain" -e "s/OUTPUT|PREROUTING|POSTROUTING//"`' \
3035 -- $cur ) )
3036 elif [ "$table" = "-t mangle" ]; then
3037 COMPREPLY=( $( compgen -W 'ACCEPT DROP LOG ULOG REJECT \
3038 MARK TOS `iptables $table -nL | sed -ne "$chain" \
3039 -e "s/INPUT|OUTPUT|FORWARD|PREROUTING|POSTROUTING//"`' -- \
3040 $cur ) )
3041 fi
3042 ;;
3043 *)
3044 if [[ "$cur" == -* ]]; then
3045 COMPREPLY=( $( compgen -W '-i -o -s -d -p -f -m --append \
3046 --delete --insert --replace --list --flush --zero --new \
3047 --delete-chain --policy --rename-chain --proto --source \
3048 --destination --in-interface --jump --match --numeric \
3049 --out-interface --table --verbose --line-numbers --exact \
3050 --fragment --modprobe= --set-counters --version' -- "$cur") )
3051 fi
3052 ;;
3053 esac
3054
3055 } &&
3056 complete -F _iptables iptables
3057
3058 # tcpdump(8) completion
3059 #
3060 have tcpdump &&
3061 _tcpdump()
3062 {
3063 local cur
3064
3065 COMPREPLY=()
3066 cur=`_get_cword`
3067 prev=${COMP_WORDS[COMP_CWORD-1]}
3068
3069 case "$prev" in
3070 -@(r|w|F))
3071 _filedir
3072 return 0
3073 ;;
3074 -i)
3075 _available_interfaces -a
3076 return 0
3077 ;;
3078 esac
3079
3080
3081 if [[ "$cur" == -* ]]; then
3082 COMPREPLY=( $( compgen -W '-a -d -e -f -l -n -N -O -p \
3083 -q -R -S -t -u -v -x -C -F -i -m -r -s -T -w \
3084 -E' -- $cur ) )
3085 fi
3086
3087 } &&
3088 complete -F _tcpdump tcpdump
3089
3090 # autorpm(8) completion
3091 #
3092 have autorpm &&
3093 _autorpm()
3094 {
3095 local cur
3096
3097 COMPREPLY=()
3098 cur=`_get_cword`
3099
3100 COMPREPLY=( $( compgen -W '--notty --debug --help --version \
3101 auto add fullinfo info help install list \
3102 remove set' -- $cur ) )
3103
3104 } &&
3105 complete -F _autorpm autorpm
3106
3107 # This meta-cd function observes the CDPATH variable, so that cd additionally
3108 # completes on directories under those specified in CDPATH.
3109 #
3110 _cd()
3111 {
3112 local IFS=$'\t\n' cur=`_get_cword` i j k
3113
3114 # try to allow variable completion
3115 if [[ "$cur" == ?(\\)\$* ]]; then
3116 COMPREPLY=( $( compgen -v -P '$' -- "${cur#?(\\)$}" ) )
3117 return 0
3118 fi
3119
3120 # Use standard dir completion if no CDPATH or parameter starts with /,
3121 # ./ or ../
3122 if [ -z "${CDPATH:-}" ] || [[ "$cur" == ?(.)?(.)/* ]]; then
3123 _filedir -d
3124 return 0
3125 fi
3126
3127 local -r mark_dirs=$(_rl_enabled mark-directories && echo y)
3128 local -r mark_symdirs=$(_rl_enabled mark-symlinked-directories && echo y)
3129
3130 # we have a CDPATH, so loop on its contents
3131 for i in ${CDPATH//:/$'\t'}; do
3132 # create an array of matched subdirs
3133 k="${#COMPREPLY[@]}"
3134 for j in $( compgen -d $i/$cur ); do
3135 if [[ ( $mark_symdirs && -h $j || $mark_dirs && ! -h $j ) && ! -d ${j#$i/} ]]; then
3136 j="${j}/"
3137 fi
3138 COMPREPLY[k++]=${j#$i/}
3139 done
3140 done
3141
3142 _filedir -d
3143
3144 if [[ ${#COMPREPLY[@]} -eq 1 ]]; then
3145 i=${COMPREPLY[0]}
3146 if [ "$i" == "$cur" ] && [[ $i != "*/" ]]; then
3147 COMPREPLY[0]="${i}/"
3148 fi
3149 fi
3150
3151 return 0
3152 }
3153 if shopt -q cdable_vars; then
3154 complete -v -F _cd $nospace $filenames cd
3155 else
3156 complete -F _cd $nospace $filenames cd
3157 fi
3158
3159 _remove_comp_word()
3160 {
3161 if [[ COMP_CWORD -eq 0 ]]; then
3162 return
3163 elif [[ ${#COMP_WORDS[@]} -ge 2 ]]; then
3164 local old_cw0="${COMP_WORDS[0]}"
3165 local new_cw0="${COMP_WORDS[1]}"
3166 local old_length="${#COMP_LINE}"
3167 COMP_LINE=${COMP_LINE#${old_cw0}}
3168 local head=${COMP_LINE:0:${#new_cw0}}
3169 local i=1
3170 while [[ $head != $new_cw0 ]]; do
3171 COMP_LINE=${COMP_LINE:1}
3172 head=${COMP_LINE:0:${#new_cw0}}
3173 if (( ++i > 10 )); then
3174 break
3175 fi
3176 done
3177 local new_length="${#COMP_LINE}"
3178 COMP_POINT=$(( COMP_POINT + new_length - old_length))
3179
3180 COMP_CWORD=$(( COMP_CWORD - 1 ))
3181 for (( i=0; i < ${#COMP_WORDS[@]} - 1; ++i )); do
3182 COMP_WORDS[i]="${COMP_WORDS[i+1]}"
3183 done
3184 unset COMP_WORDS[${#COMP_WORDS[@]}-1]
3185 else
3186 return
3187 fi
3188 }
3189
3190 # A meta-command completion function for commands like sudo(8), which need to
3191 # first complete on a command, then complete according to that command's own
3192 # completion definition - currently not quite foolproof (e.g. mount and umount
3193 # don't work properly), but still quite useful.
3194 #
3195 _command()
3196 {
3197 local cur func cline cspec noglob cmd done i \
3198 _COMMAND_FUNC _COMMAND_FUNC_ARGS
3199
3200 _remove_comp_word
3201 COMPREPLY=()
3202 cur=`_get_cword`
3203 # If the the first arguments following our meta-command-invoker are
3204 # switches, get rid of them. Most definitely not foolproof.
3205 done=
3206 while [ -z $done ] ; do
3207 cmd=${COMP_WORDS[0]}
3208 if [[ "$cmd" == -* ]] && [ $COMP_CWORD -ge 1 ]; then
3209 _remove_comp_word
3210 elif [[ "$cmd" == -* ]] && [[ $COMP_CWORD -eq 0 ]]; then
3211 return
3212 else
3213 done=1
3214 fi
3215 done
3216
3217 if [ $COMP_CWORD -eq 0 ]; then
3218 COMPREPLY=( $( compgen -c -- $cur ) )
3219 elif complete -p $cmd &>/dev/null; then
3220 cspec=$( complete -p $cmd )
3221 if [ "${cspec#* -F }" != "$cspec" ]; then
3222 # COMP_CWORD and COMP_WORDS() are not read-only,
3223 # so we can set them before handing off to regular
3224 # completion routine
3225
3226 # get function name
3227 func=${cspec#*-F }
3228 func=${func%% *}
3229
3230 if [[ ${#COMP_WORDS[@]} -ge 2 ]]; then
3231 $func $cmd "${COMP_WORDS[${#COMP_WORDS[@]}-1]}" "${COMP_WORDS[${#COMP_WORDS[@]}-2]}"
3232 else
3233 $func $cmd "${COMP_WORDS[${#COMP_WORDS[@]}-1]}"
3234 fi
3235
3236 # remove any \: generated by a command that doesn't
3237 # default to filenames or dirnames (e.g. sudo chown)
3238 # FIXME: I'm pretty sure this does not work!
3239 if [ "${cspec#*-o }" != "$cspec" ]; then
3240 cspec=${cspec#*-o }
3241 cspec=${cspec%% *}
3242 if [[ "$cspec" != @(dir|file)names ]]; then
3243 COMPREPLY=("${COMPREPLY[@]//\\\\:/:}")
3244 fi
3245 fi
3246 elif [ -n "$cspec" ]; then
3247 cspec=${cspec#complete};
3248 cspec=${cspec%%$cmd};
3249 COMPREPLY=( $( eval compgen "$cspec" -- "$cur" ) );
3250 fi
3251 fi
3252
3253 [ ${#COMPREPLY[@]} -eq 0 ] && _filedir
3254 }
3255 complete -F _command $filenames nohup exec nice eval strace time ltrace then \
3256 else do vsound command xargs
3257
3258 _root_command()
3259 {
3260 PATH=$PATH:/sbin:/usr/sbin:/usr/local/sbin _command $1 $2 $3
3261 }
3262 complete -F _root_command $filenames sudo fakeroot really
3263
3264 # ant(1) completion
3265 #
3266 have ant && {
3267 _ant()
3268 {
3269 local cur prev buildfile i
3270
3271 COMPREPLY=()
3272 cur=`_get_cword`
3273 prev=${COMP_WORDS[COMP_CWORD-1]}
3274
3275 case "$prev" in
3276 -buildfile|-f)
3277 _filedir 'xml'
3278 return 0
3279 ;;
3280 -logfile)
3281 _filedir
3282 return 0
3283 ;;
3284 esac
3285
3286 if [[ "$cur" == -* ]]; then
3287 # relevant options completion
3288 COMPREPLY=( $( compgen -W '-help -projecthelp -version -quiet \
3289 -verbose -debug -emacs -logfile -logger \
3290 -listener -buildfile -f -D -find' -- $cur ) )
3291 else
3292 # available targets completion
3293 # find which buildfile to use
3294 buildfile=build.xml
3295 for (( i=1; i < COMP_CWORD; i++ )); do
3296 if [[ "${COMP_WORDS[i]}" == -buildfile ]]; then
3297 buildfile=${COMP_WORDS[i+1]}
3298 break
3299 fi
3300 done
3301 [ ! -f $buildfile ] && return 0
3302
3303 # parse buildfile for targets
3304 COMPREPLY=( $( awk -F'"' '/<target name="/ {print $2}' \
3305 $buildfile | grep "^$cur" )
3306 $( awk -F"'" "/<target name='/ "'{print $2}' \
3307 $buildfile | grep "^$cur" )
3308 $( awk -F'"' '/<target [^n]/ {if ($1 ~ /name=/) { print $2 } else if ($3 ~ /name=/) {print $4} else if ($5 ~ /name=/) {print $6}}' \
3309 $buildfile | grep "^$cur" ) )
3310 fi
3311 }
3312 have complete-ant-cmd.pl && \
3313 complete -C complete-ant-cmd.pl -F _ant $filenames ant || \
3314 complete -F _ant $filenames ant
3315 }
3316
3317 have nslookup &&
3318 _nslookup()
3319 {
3320 local cur
3321
3322 COMPREPLY=()
3323 cur=${COMP_WORDS[COMP_CWORD]#-}
3324
3325 COMPREPLY=( $( compgen -P '-' -W 'all class= debug d2 domain= \
3326 srchlist= defname search port= querytype= \
3327 type= recurse retry root timeout vc \
3328 ignoretc' -- $cur ) )
3329 } &&
3330 complete -F _nslookup nslookup
3331
3332 # mysqladmin(1) completion
3333 #
3334 have mysqladmin &&
3335 _mysqladmin()
3336 {
3337 local cur prev
3338
3339 COMPREPLY=()
3340 cur=`_get_cword`
3341 prev=${COMP_WORDS[COMP_CWORD-1]}
3342
3343 case "$prev" in
3344 -u)
3345 COMPREPLY=( $( compgen -u -- $cur ) )
3346 return 0
3347 ;;
3348 *)
3349 ;;
3350 esac
3351
3352 COMPREPLY=( $( compgen -W '-# -f -? -C -h -p -P -i -r -E -s -S -t -u \
3353 -v -V -w' -- $cur ) )
3354
3355 COMPREPLY=( "${COMPREPLY[@]}" \
3356 $( compgen -W 'create drop extended-status flush-hosts \
3357 flush-logs flush-status flush-tables \
3358 flush-threads flush-privileges kill \
3359 password ping processlist reload refresh \
3360 shutdown status variables version' \
3361 -- $cur ) )
3362 } &&
3363 complete -F _mysqladmin mysqladmin
3364
3365 # gzip(1) completion
3366 #
3367 have gzip &&
3368 _gzip()
3369 {
3370 local cur prev xspec IFS=$'\t\n'
3371
3372 COMPREPLY=()
3373 cur=`_get_cword`
3374 prev=${COMP_WORDS[COMP_CWORD-1]}
3375
3376 if [[ "$cur" == -* ]]; then
3377 COMPREPLY=( $( compgen -W '-c -d -f \
3378 -h -l -L -n -N -q -r -S -t -v -V \
3379 -1 -2 -3 -4 -5 -6 -7 -8 -9 \
3380 --stdout --decompress --force --help --list \
3381 --license --no-name --name --quiet --recursive \
3382 --suffix --test --verbose --version --fast \
3383 --best' -- $cur ) )
3384 return 0
3385 fi
3386
3387 xspec="*.?(t)gz"
3388 if [[ "$prev" == --* ]]; then
3389 [[ "$prev" == --decompress || \
3390 "$prev" == --list || \
3391 "$prev" == --test ]] && xspec="!"$xspec
3392 [[ "$prev" == --force ]] && xspec=
3393 elif [[ "$prev" == -* ]]; then
3394 [[ "$prev" == -*[dlt]* ]] && xspec="!"$xspec
3395 [[ "$prev" == -*f* ]] && xspec=
3396 elif [ "$prev" = '>' ]; then
3397 xspec=
3398 elif [ "$prev" = '<' ]; then
3399 xspec=
3400 fi
3401
3402 _expand || return 0
3403
3404 COMPREPLY=( $( compgen -f -X "$xspec" -- $cur ) \
3405 $( compgen -d -- $cur ) )
3406 } &&
3407 complete -F _gzip $filenames gzip
3408
3409 # bzip2(1) completion
3410 #
3411 have bzip2 &&
3412 _bzip2()
3413 {
3414 local cur prev xspec IFS=$'\t\n'
3415
3416 COMPREPLY=()
3417 cur=`_get_cword`
3418 prev=${COMP_WORDS[COMP_CWORD-1]}
3419
3420 if [[ "$cur" == -* ]]; then
3421 COMPREPLY=( $( compgen -W '-c -d -f -h -k -L -q -s \
3422 -t -v -V -z -1 -2 -3 -4 -5 -6 -7 -8 -9 \
3423 --help --decompress --compress --keep --force \
3424 --test --stdout --quiet --verbose --license \
3425 --version --small --fast --best' -- $cur ) )
3426 return 0
3427 fi
3428
3429 xspec="*.bz2"
3430 if [[ "$prev" == --* ]]; then
3431 [[ "$prev" == --decompress || \
3432 "$prev" == --list || \
3433 "$prev" == --test ]] && xspec="!"$xspec
3434 [[ "$prev" == --compress ]] && xspec=
3435 elif [[ "$prev" == -* ]]; then
3436 [[ "$prev" == -*[dt]* ]] && xspec="!"$xspec
3437 [[ "$prev" == -*z* ]] && xspec=
3438 fi
3439
3440 _expand || return 0
3441
3442 COMPREPLY=( $( compgen -f -X "$xspec" -- $cur ) \
3443 $( compgen -d -- $cur ) )
3444 } &&
3445 complete -F _bzip2 $filenames bzip2
3446
3447 # openssl(1) completion
3448 #
3449 have openssl && {
3450 _openssl_sections()
3451 {
3452 local config
3453
3454 config=/etc/ssl/openssl.cnf
3455 [ ! -f $config ] && config=/usr/share/ssl/openssl.cnf
3456 for (( i=2; i < COMP_CWORD; i++ )); do
3457 if [[ "${COMP_WORDS[i]}" == -config ]]; then
3458 config=${COMP_WORDS[i+1]}
3459 break
3460 fi
3461 done
3462 [ ! -f $config ] && return 0
3463
3464 COMPREPLY=( $( awk '/\[.*\]/ {print $2} ' $config | grep "^$cur" ) )
3465 }
3466
3467 _openssl()
3468 {
3469 local cur prev
3470
3471 COMPREPLY=()
3472 cur=`_get_cword`
3473
3474 if [ $COMP_CWORD -eq 1 ]; then
3475 COMPREPLY=( $( compgen -W 'asn1parse ca ciphers crl crl2pkcs7 \
3476 dgst dh dhparam dsa dsaparam enc errstr gendh gendsa \
3477 genrsa nseq passwd pkcs12 pkcs7 pkcs8 rand req rsa \
3478 rsautl s_client s_server s_time sess_id smime speed \
3479 spkac verify version x509 md2 md4 md5 mdc2 rmd160 sha \
3480 sha1 base64 bf bf-cbc bf-cfb bf-ecb bf-ofb cast \
3481 cast-cbc cast5-cbc cast5-cfb cast5-ecb cast5-ofb des \
3482 des-cbc des-cfb des-ecb des-ede des-ede-cbc \
3483 des-ede-cfb des-ede-ofb des-ede3 des-ede3-cbc \
3484 des-ede3-cfb des-ede3-ofb des-ofb des3 desx rc2 \
3485 rc2-40-cbc rc2-64-cbc rc2-cbc rc2-cfb rc2-ecb rc2-ofb \
3486 rc4 rc4-40' -- $cur ) )
3487 else
3488 prev=${COMP_WORDS[COMP_CWORD-1]}
3489 case ${COMP_WORDS[1]} in
3490 asn1parse)
3491 case $prev in
3492 -inform)
3493 COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
3494 return 0
3495 ;;
3496 -@(in|out|oid))
3497 _filedir
3498 return 0
3499 ;;
3500 esac
3501
3502 if [[ "$cur" == -* ]]; then
3503 COMPREPLY=( $( compgen -W '-inform -in -out -noout -offset \
3504 -length -i -oid -strparse' -- $cur ) )
3505 fi
3506 ;;
3507 ca)
3508 case $prev in
3509 -@(config|revoke|cert|in|out|spkac|ss_cert))
3510 _filedir
3511 return 0
3512 ;;
3513 -outdir)
3514 _filedir -d
3515 return 0
3516 ;;
3517 -@(name|crlexts|extensions))
3518 _openssl_sections
3519 return 0
3520 ;;
3521 esac
3522
3523 if [[ "$cur" == -* ]]; then
3524 COMPREPLY=( $( compgen -W '-verbose -config -name \
3525 -gencrl -revoke -crldays -crlhours -crlexts \
3526 -startdate -enddate -days -md -policy -keyfile \
3527 -key -passin -cert -in -out -notext -outdir \
3528 -infiles -spkac -ss_cert -preserveDN -batch \
3529 -msie_hack -extensions' -- $cur ) )
3530 fi
3531 ;;
3532 ciphers)
3533 if [[ "$cur" == -* ]]; then
3534 COMPREPLY=( $( compgen -W '-v -ssl2 -ssl3 -tls1' -- $cur ) )
3535 fi
3536 ;;
3537 crl)
3538 case $prev in
3539 -@(in|out)form)
3540 COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
3541 return 0
3542 ;;
3543 -@(in|out|CAfile))
3544 _filedir
3545 return 0
3546 ;;
3547 -CAPath)
3548 _filedir -d
3549 return 0
3550 ;;
3551 esac
3552
3553 if [[ "$cur" == -* ]]; then
3554 COMPREPLY=( $( compgen -W '-inform -outform -text -in -out -noout \
3555 -hash -issuer -lastupdate -nextupdate -CAfile -CApath' -- $cur ) )
3556 fi
3557 ;;
3558 crl2pkcs7)
3559 case $prev in
3560 -@(in|out)form)
3561 COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
3562 return 0
3563 ;;
3564 -@(in|out))
3565 _filedir
3566 return 0
3567 ;;
3568 esac
3569
3570 if [[ "$cur" == -* ]]; then
3571 COMPREPLY=( $( compgen -W '-inform -outform -in -out -print_certs' -- $cur ) )
3572 fi
3573 ;;
3574 dgst)
3575 case $prev in
3576 -@(out|sign|verify|prvrify|signature))
3577 _filedir
3578 return 0
3579 ;;
3580 esac
3581
3582 if [[ "$cur" == -* ]]; then
3583 COMPREPLY=( $( compgen -W '-md5 -md4 -md2 -sha1 -sha -mdc2 -ripemd160 -dss1 \
3584 -c -d -hex -binary -out -sign -verify -prverify -signature' -- $cur ) )
3585 else
3586 _filedir
3587 fi
3588 ;;
3589 dsa)
3590 case $prev in
3591 -@(in|out)form)
3592 COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
3593 return 0
3594 ;;
3595 -@(in|out))
3596 _filedir
3597 return 0
3598 ;;
3599 esac
3600
3601 if [[ "$cur" == -* ]]; then
3602 COMPREPLY=( $( compgen -W '-inform -outform -in -passin -out -passout -des -des3 -idea -text -noout \
3603 -modulus -pubin -pubout' -- $cur ) )
3604 fi
3605 ;;
3606 dsaparam)
3607 case $prev in
3608 -@(in|out)form)
3609 COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
3610 return 0
3611 ;;
3612 -@(in|out|rand))
3613 _filedir
3614 return 0
3615 ;;
3616 esac
3617
3618 if [[ "$cur" == -* ]]; then
3619 COMPREPLY=( $( compgen -W '-inform -outform -in -out -noout \
3620 -text -C -rand -genkey' -- $cur ) )
3621 fi
3622 ;;
3623 enc)
3624 case $prev in
3625 -@(in|out|kfile))
3626 _filedir
3627 return 0
3628 ;;
3629 esac
3630
3631 if [[ "$cur" == -* ]]; then
3632 COMPREPLY=( $( compgen -W '-ciphername -in -out -pass \
3633 -e -d -a -A -k -kfile -S -K -iv -p -P -bufsize -debug' -- $cur ) )
3634 fi
3635 ;;
3636 dhparam)
3637 case $prev in
3638 -@(in|out)form)
3639 COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
3640 return 0
3641 ;;
3642 -@(in|out|rand))
3643 _filedir
3644 return 0
3645 ;;
3646 esac
3647
3648 if [[ "$cur" == -* ]]; then
3649 COMPREPLY=( $( compgen -W '-inform -outform -in -out -dsaparam -noout \
3650 -text -C -2 -5 -rand' -- $cur ) )
3651 fi
3652 ;;
3653 gendsa)
3654 case $prev in
3655 -@(out|rand))
3656 _filedir
3657 return 0
3658 ;;
3659 esac
3660
3661 if [[ "$cur" == -* ]]; then
3662 COMPREPLY=( $( compgen -W '-out -des -des3 -idea -rand' -- $cur ) )
3663 else
3664 _filedir
3665 fi
3666 ;;
3667 genrsa)
3668 case $prev in
3669 -@(out|rand))
3670 _filedir
3671 return 0
3672 ;;
3673 esac
3674
3675 if [[ "$cur" == -* ]]; then
3676 COMPREPLY=( $( compgen -W '-out -passout -des -des3 -idea -f4 -3 -rand' -- $cur ) )
3677 fi
3678 ;;
3679 pkcs7)
3680 case $prev in
3681 -@(in|out)form)
3682 COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
3683 return 0
3684 ;;
3685 -@(in|out))
3686 _filedir
3687 return 0
3688 ;;
3689 esac
3690
3691 if [[ "$cur" == -* ]]; then
3692 COMPREPLY=( $( compgen -W '-inform -outform -in -out -print_certs -text -noout' -- $cur ) )
3693 fi
3694 ;;
3695 rand)
3696 case $prev in
3697 -@(out|rand))
3698 _filedir
3699 return 0
3700 ;;
3701 esac
3702
3703 if [[ "$cur" == -* ]]; then
3704 COMPREPLY=( $( compgen -W '-out -rand -base64' -- $cur ) )
3705 fi
3706 ;;
3707 req)
3708 case "$prev" in
3709 -@(in|out|key)form)
3710 COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
3711 return 0
3712 ;;
3713
3714 -@(in|out|rand|key|keyout|config))
3715 _filedir
3716 return 0
3717 ;;
3718 -extensions)
3719 _openssl_sections
3720 return 0
3721 ;;
3722 esac
3723
3724 if [[ "$cur" == -* ]]; then
3725 COMPREPLY=( $( compgen -W '-inform -outform -in \
3726 -passin -out -passout -text -noout -verify \
3727 -modulus -new -rand -newkey -newkey -nodes \
3728 -key -keyform -keyout -md5 -sha1 -md2 -mdc2 \
3729 -config -x509 -days -asn1-kludge -newhdr \
3730 -extensions -reqexts section' -- $cur ) )
3731 fi
3732 ;;
3733 rsa)
3734 case $prev in
3735 -@(in|out)form)
3736 COMPREPLY=( $( compgen -W 'DER NET PEM' -- $cur ) )
3737 return 0
3738 ;;
3739 -@(in|out))
3740 _filedir
3741 return 0
3742 ;;
3743 esac
3744
3745 if [[ "$cur" == -* ]]; then
3746 COMPREPLY=( $( compgen -W '-inform -outform -in -passin -out -passout \
3747 -sgckey -des -des3 -idea -text -noout -modulus -check -pubin \
3748 -pubout -engine' -- $cur ) )
3749 fi
3750 ;;
3751 rsautl)
3752 case $prev in
3753 -@(in|out|inkey))
3754 _filedir
3755 return 0
3756 ;;
3757 esac
3758
3759 if [[ "$cur" == -* ]]; then
3760 COMPREPLY=( $( compgen -W '-in -out -inkey -pubin -certin -sign -verify \
3761 -encrypt -decrypt -pkcs -ssl -raw -hexdump -asn1parse' -- $cur ) )
3762 fi
3763 ;;
3764 s_client)
3765 case $prev in
3766 -connect)
3767 _known_hosts
3768 return 0
3769 ;;
3770 -@(cert|key|CAfile|rand))
3771 _filedir
3772 return 0
3773 ;;
3774 -CApath)
3775 _filedir -d
3776 return 0
3777 ;;
3778 esac
3779
3780 if [[ "$cur" == -* ]]; then
3781 COMPREPLY=( $( compgen -W '-connect -verify -cert -key -CApath -CAfile \
3782 -reconnect -pause -showcerts -debug -msg -nbio_test -state -nbio \
3783 -crlf -ign_eof -quiet -ssl2 -ssl3 -tls1 -no_ssl2 -no_ssl3 -no_tls1 \
3784 -bugs -cipher -starttls -engine -rand' -- $cur ) )
3785 fi
3786 ;;
3787 s_server)
3788 case $prev in
3789 -@(cert|key|dcert|dkey|dhparam|CAfile|rand))
3790 _filedir
3791 return 0
3792 ;;
3793 -CApath)
3794 _filedir -d
3795 return 0
3796 ;;
3797 esac
3798
3799 if [[ "$cur" == -* ]]; then
3800 COMPREPLY=( $( compgen -W '-accept -context -verify -Verify -cert -key \
3801 -dcert -dkey -dhparam -nbio -nbio_test -crlf -debug -msg -state -CApath \
3802 -CAfile -nocert -cipher -quiet -no_tmp_rsa -ssl2 -ssl3 -tls1 -no_ssl2 \
3803 -no_ssl3 -no_tls1 -no_dhe -bugs -hack -www -WWW -HTTP -engine -id_prefix \
3804 -rand' -- $cur ) )
3805 fi
3806 ;;
3807 s_time)
3808 case $prev in
3809 -connect)
3810 _known_hosts
3811 return 0
3812 ;;
3813 -@(cert|key|CAfile))
3814 _filedir
3815 return 0
3816 ;;
3817 -CApath)
3818 _filedir -d
3819 return 0
3820 ;;
3821 esac
3822
3823 if [[ "$cur" == -* ]]; then
3824 COMPREPLY=( $( compgen -W '-connect -www -cert -key -CApath -CAfile -reuse \
3825 -new -verify -nbio -time -ssl2 -ssl3 -bugs -cipher' -- $cur ) )
3826 fi
3827 ;;
3828
3829 sess_id)
3830 case $prev in
3831 -@(in|out)form)
3832 COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
3833 return 0
3834 ;;
3835 -@(in|out))
3836 _filedir
3837 return 0
3838 ;;
3839 esac
3840
3841
3842 if [[ "$cur" == -* ]]; then
3843 COMPREPLY=( $( compgen -W '-inform -outform -in -out -text -noout \
3844 -context ID' -- $cur ) )
3845 fi
3846 ;;
3847 smime)
3848 case $prev in
3849 -@(in|out)form)
3850 COMPREPLY=( $( compgen -W 'SMIME DER PEM' -- $cur ) )
3851 return 0
3852 ;;
3853 -@(in|out|certfile|signer|recip|inkey|content|rand))
3854 _filedir
3855 return 0
3856 ;;
3857 esac
3858
3859 if [[ "$cur" == -* ]]; then
3860 COMPREPLY=( $( compgen -W '-encrypt -decrypt -sign -verify -pk7out -des -des3 \
3861 -rc2-40 -rc2-64 -rc2-128 -aes128 -aes192 -aes256 -in -certfile -signer \
3862 -recip -inform -passin -inkey -out -outform -content -to -from -subject \
3863 -text -rand' -- $cur ) )
3864 else
3865 _filedir
3866 fi
3867 ;;
3868 speed)
3869 if [[ "$cur" == -* ]]; then
3870 COMPREPLY=( $( compgen -W '-engine' -- $cur ) )
3871 else
3872 COMPREPLY=( $( compgen -W 'md2 mdc2 md5 hmac sha1 rmd160 idea-cbc \
3873 rc2-cbc rc5-cbc bf-cbc des-cbc des-ede3 rc4 rsa512 rsa1024 rsa2048 \
3874 rsa4096 dsa512 dsa1024 dsa2048 idea rc2 des rsa blowfish' -- $cur ) )
3875 fi
3876 ;;
3877 verify)
3878 case $prev in
3879 -@(CAfile|untrusted))
3880 _filedir
3881 return 0
3882 ;;
3883 -CApath)
3884 _filedir -d
3885 return 0
3886 ;;
3887 esac
3888
3889 if [[ "$cur" == -* ]]; then
3890 COMPREPLY=( $( compgen -W '-CApath -CAfile -purpose -untrusted -help -issuer_checks \
3891 -verbose -certificates' -- $cur ) )
3892 else
3893 _filedir
3894 fi
3895 ;;
3896 x509)
3897 case "$prev" in
3898 -@(in|out|CA|CAkey|CAserial|extfile))
3899 _filedir
3900 return 0
3901 ;;
3902 -@(in|out)form)
3903 COMPREPLY=( $( compgen -W 'DER PEM NET' -- $cur ) )
3904 return 0
3905 ;;
3906 -@(key|CA|CAkey)form)
3907 COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
3908 return 0
3909 ;;
3910 -extensions)
3911 _openssl_sections
3912 return 0
3913 ;;
3914 esac
3915
3916 if [[ "$cur" == -* ]]; then
3917 COMPREPLY=( $( compgen -W '-inform -outform \
3918 -keyform -CAform -CAkeyform -in -out \
3919 -serial -hash -subject -issuer -nameopt \
3920 -email -startdate -enddate -purpose \
3921 -dates -modulus -fingerprint -alias \
3922 -noout -trustout -clrtrust -clrreject \
3923 -addtrust -addreject -setalias -days \
3924 -set_serial -signkey -x509toreq -req \
3925 -CA -CAkey -CAcreateserial -CAserial \
3926 -text -C -md2 -md5 -sha1 -mdc2 -clrext \
3927 -extfile -extensions -engine' -- $cur ) )
3928 fi
3929 ;;
3930 @(md5|md4|md2|sha1|sha|mdc2|ripemd160))
3931 if [[ "$cur" == -* ]]; then
3932 COMPREPLY=( $( compgen -W '-c -d' -- $cur ) )
3933 else
3934 _filedir
3935 fi
3936 ;;
3937 esac
3938 fi
3939
3940 return 0
3941 }
3942 complete -F _openssl $default openssl
3943 }
3944
3945 # screen(1) completion
3946 #
3947 have screen &&
3948 _screen()
3949 {
3950 local cur prev preprev
3951
3952 COMPREPLY=()
3953 cur=`_get_cword`
3954 prev=${COMP_WORDS[COMP_CWORD-1]}
3955
3956 [ "$COMP_CWORD" -ge 2 ] && preprev=${COMP_WORDS[COMP_CWORD-2]}
3957
3958 if [ "$preprev" = "-d" -o "$preprev" = "-D" -a "$prev" = "-r" -o \
3959 "$prev" = "-R" ]; then
3960 # list all
3961 COMPREPLY=( $( command screen -ls | \
3962 sed -ne 's|^['$'\t'']\+\('$cur'[0-9]\+\.[^'$'\t'']\+\).*$|\1|p' ) )
3963 else
3964 case "$prev" in
3965 -[rR])
3966 # list detached
3967 COMPREPLY=( $( command screen -ls | \
3968 sed -ne 's|^['$'\t'']\+\('$cur'[0-9]\+\.[^'$'\t'']\+\).*Detached.*$|\1|p' ) )
3969 ;;
3970 -[dDx])
3971 # list attached
3972 COMPREPLY=( $( command screen -ls | \
3973 sed -ne 's|^['$'\t'']\+\('$cur'[0-9]\+\.[^'$'\t'']\+\).*Attached.*$|\1|p' ) )
3974 ;;
3975 -s)
3976 # shells
3977 COMPREPLY=( $( grep ^${cur:-[^#]} /etc/shells ) )
3978 ;;
3979 *)
3980 ;;
3981 esac
3982 fi
3983
3984 return 0
3985 } &&
3986 complete -F _screen $default screen
3987
3988 # lftp(1) bookmark completion
3989 #
3990 have lftp &&
3991 _lftp()
3992 {
3993 local cur
3994
3995 COMPREPLY=()
3996 cur=`_get_cword`
3997
3998 if [ $COMP_CWORD -eq 1 ] && [ -f ~/.lftp/bookmarks ]; then
3999 COMPREPLY=( $( compgen -W '$( sed -ne "s/^\(.*\)'$'\t''.*$/\1/p" \
4000 ~/.lftp/bookmarks )' -- $cur ) )
4001 fi
4002
4003 return 0
4004 } &&
4005 complete -F _lftp $default lftp
4006
4007 # ncftp(1) bookmark completion
4008 #
4009 have ncftp &&
4010 _ncftp()
4011 {
4012 local cur
4013
4014 COMPREPLY=()
4015 cur=`_get_cword`
4016
4017 if [ $COMP_CWORD -eq 1 ] && [ -f ~/.ncftp/bookmarks ]; then
4018 COMPREPLY=( $( compgen -W '$( sed -ne "s/^\([^,]\{1,\}\),.*$/\1/p" \
4019 ~/.ncftp/bookmarks )' -- $cur ) )
4020 fi
4021
4022 return 0
4023 } &&
4024 complete -F _ncftp $default ncftp
4025
4026 # gdb(1) completion
4027 #
4028 have gdb &&
4029 _gdb()
4030 {
4031 local cur prev
4032
4033 COMPREPLY=()
4034 cur=`_get_cword`
4035 prev=${COMP_WORDS[COMP_CWORD-1]}
4036
4037 if [ $COMP_CWORD -eq 1 ]; then
4038 COMPREPLY=( $( compgen -c -- $cur ) )
4039 elif [ $COMP_CWORD -eq 2 ]; then
4040 prev=${prev##*/}
4041 COMPREPLY=( $( compgen -fW "$( command ps axo comm,pid | \
4042 awk '{if ($1 ~ /^'"$prev"'/) print $2}' ) )" \
4043 -- "$cur" ) )
4044 fi
4045 } &&
4046 complete -F _gdb $filenames gdb
4047
4048 # Postgresql completion
4049 #
4050 have psql && {
4051 _pg_databases()
4052 {
4053 return
4054 COMPREPLY=( $( psql -l 2>/dev/null | \
4055 sed -e '1,/^-/d' -e '/^(/,$d' | \
4056 awk '{print $1}' | grep "^$cur" ) )
4057 }
4058
4059 _pg_users()
4060 {
4061 #COMPREPLY=( $( psql -qtc 'select usename from pg_user' template1 2>/dev/null | \
4062 # grep "^ $cur" ) )
4063 #[ ${#COMPREPLY[@]} -eq 0 ] &&
4064 COMPREPLY=( $( compgen -u -- $cur ) )
4065 }
4066
4067 # createdb(1) completion
4068 #
4069 _createdb()
4070 {
4071 local cur prev
4072
4073 COMPREPLY=()
4074 cur=`_get_cword`
4075 prev=${COMP_WORDS[COMP_CWORD-1]}
4076
4077 case "$prev" in
4078 -@(h|-host=))
4079 _known_hosts
4080 return 0
4081 ;;
4082 -@(U|-username=))
4083 _pg_users
4084 return 0
4085 ;;
4086 esac
4087
4088 if [[ "$cur" == -* ]]; then
4089 COMPREPLY=( $( compgen -W '-D -T -E -h -p -U -W -e -q \
4090 --location= --template= --encoding= --host= --port= \
4091 --username= --password --echo --quiet --help' -- $cur ))
4092 else
4093 _pg_databases
4094 fi
4095 }
4096 complete -F _createdb $default createdb
4097
4098 # dropdb(1) completion
4099 #
4100 _dropdb()
4101 {
4102 local cur prev
4103
4104 COMPREPLY=()
4105 cur=`_get_cword`
4106 prev=${COMP_WORDS[COMP_CWORD-1]}
4107
4108 case "$prev" in
4109 -@(h|-host=))
4110 _known_hosts
4111 return 0
4112 ;;
4113 -@(U|-username=))
4114 _pg_users
4115 return 0
4116 ;;
4117 esac
4118
4119 if [[ "$cur" == -* ]]; then
4120 COMPREPLY=( $( compgen -W '-h -p -U -W -e -q \
4121 --host= --port= --username= --password \
4122 --interactive --echo --quiet --help' -- $cur ) )
4123 else
4124 _pg_databases
4125 fi
4126 }
4127 complete -F _dropdb $default dropdb
4128
4129 # psql(1) completion
4130 #
4131 _psql()
4132 {
4133 local cur prev
4134
4135 COMPREPLY=()
4136 cur=`_get_cword`
4137 prev=${COMP_WORDS[COMP_CWORD-1]}
4138
4139 case "$prev" in
4140 -h|--host)
4141 _known_hosts
4142 return 0
4143 ;;
4144 -U|--username)
4145 _pg_users
4146 return 0
4147 ;;
4148 -d|--dbname)
4149 _pg_databases
4150 return 0
4151 ;;
4152 -@(o|f)|--output|--file)
4153 _filedir
4154 return 0
4155 ;;
4156 esac
4157
4158 if [[ "$cur" == -* ]]; then
4159 # return list of available options
4160 COMPREPLY=( $( compgen -W '-a --echo-all -A --no-align \
4161 -c --command -d --dbname -e --echo-queries \
4162 -E --echo-hidden -f --file -F --filed-separator \
4163 -h --host -H --html -l --list -n -o --output \
4164 -p --port -P --pset -q -R --record-separator \
4165 -s --single-step -S --single-line -t --tuples-only \
4166 -T --table-attr -U --username -v --variable \
4167 -V --version -W --password -x --expanded -X --nopsqlrc \
4168 -? --help ' -- $cur ) )
4169 else
4170 # return list of available databases
4171 _pg_databases
4172 fi
4173 }
4174 complete -F _psql $default psql
4175 }
4176
4177 _longopt()
4178 {
4179 local cur opt
4180
4181 cur=`_get_cword`
4182
4183 if [[ "$cur" == --*=* ]]; then
4184 opt=${cur%%=*}
4185 # cut backslash that gets inserted before '=' sign
4186 opt=${opt%\\*}
4187 cur=${cur#*=}
4188 _filedir
4189 COMPREPLY=( $( compgen -P "$opt=" -W '${COMPREPLY[@]}' -- $cur))
4190 return 0
4191 fi
4192
4193 if [[ "$cur" == -* ]]; then
4194 COMPREPLY=( $( $1 --help 2>&1 | sed -e '/--/!d' \
4195 -e 's/.*\(--[-A-Za-z0-9]\+=\?\).*/\1/' | \
4196 command grep "^$cur" | sort -u ) )
4197 elif [[ "$1" == @(mk|rm)dir ]]; then
4198 _filedir -d
4199 else
4200 _filedir
4201 fi
4202 }
4203 # makeinfo and texi2dvi are defined elsewhere.
4204 for i in a2ps autoconf automake bc gprof ld nm objcopy objdump readelf strip \
4205 bison cpio diff patch enscript cp df dir du ln ls mkfifo mknod mv rm \
4206 touch vdir awk gperf grep grub indent less m4 sed shar date \
4207 tee who texindex cat csplit cut expand fmt fold head \
4208 md5sum nl od paste pr ptx sha1sum sort split tac tail tr unexpand \
4209 uniq wc ldd bash id irb mkdir rmdir; do
4210 have $i && complete -F _longopt $filenames $i
4211 done
4212
4213 # These commands use filenames, so '-o filenames' is not needed.
4214 for i in env netstat seq uname units wget; do
4215 have $i && complete -F _longopt $default $i
4216 done
4217 unset i
4218
4219 # gcc(1) completion
4220 #
4221 # The only unusual feature is that we don't parse "gcc --help -v" output
4222 # directly, because that would include the options of all the other backend
4223 # tools (linker, assembler, preprocessor, etc) without any indication that
4224 # you cannot feed such options to the gcc driver directly. (For example, the
4225 # linker takes a -z option, but you must type -Wl,-z for gcc.) Instead, we
4226 # ask the driver ("g++") for the name of the compiler ("cc1"), and parse the
4227 # --help output of the compiler.
4228 #
4229 have gcc &&
4230 _gcc()
4231 {
4232 local cur cc backend
4233
4234 COMPREPLY=()
4235 cur=`_get_cword`
4236
4237 _expand || return 0
4238
4239 case "$1" in
4240 gcj)
4241 backend=jc1
4242 ;;
4243 gpc)
4244 backend=gpc1
4245 ;;
4246 *77)
4247 backend=f771
4248 ;;
4249 *)
4250 backend=cc1 # (near-)universal backend
4251 ;;
4252 esac
4253
4254 if [[ "$cur" == -* ]]; then
4255 cc=$( $1 -print-prog-name=$backend )
4256 # sink stderr:
4257 # for C/C++/ObjectiveC it's useless
4258 # for FORTRAN/Java it's an error
4259 COMPREPLY=( $( $cc --help 2>/dev/null | tr '\t' ' ' | \
4260 sed -e '/^ *-/!d' -e 's/ *-\([^ ]*\).*/-\1/' | \
4261 command grep "^$cur" | sort -u ) )
4262 else
4263 _filedir
4264 fi
4265 } &&
4266 complete $filenames -F _gcc gcc g++ c++ g77 gcj gpc
4267 [ $UNAME = GNU -o $UNAME = Linux -o $UNAME = Cygwin ] && \
4268 [ -n "${have:-}" ] && complete $filenames -F _gcc cc
4269
4270 # Linux cardctl(8) completion
4271 #
4272 have cardctl &&
4273 _cardctl()
4274 {
4275 local cur
4276
4277 COMPREPLY=()
4278 cur=`_get_cword`
4279
4280 if [ $COMP_CWORD -eq 1 ]; then
4281 COMPREPLY=( $( compgen -W 'status config ident suspend \
4282 resume reset eject insert scheme' \
4283 -- $cur ) )
4284 fi
4285 } &&
4286 complete -F _cardctl cardctl
4287
4288 # This function is required by _dpkg() and _dpkg-reconfigure()
4289 #
4290 have dpkg && {
4291 _comp_dpkg_installed_packages()
4292 {
4293 grep -A 1 "Package: $1" /var/lib/dpkg/status | \
4294 grep -B 1 -E "ok installed|half-installed|unpacked| \
4295 half-configured|config-files" | \
4296 grep "Package: $1" | cut -d\ -f2
4297 }
4298
4299 # Debian dpkg(8) completion
4300 #
4301 _dpkg()
4302 {
4303 local cur prev i
4304
4305 COMPREPLY=()
4306 cur=`_get_cword`
4307 prev=${COMP_WORDS[COMP_CWORD-1]}
4308 i=$COMP_CWORD
4309
4310 _expand || return 0
4311
4312 # find the last option flag
4313 if [[ $cur != -* ]]; then
4314 while [[ $prev != -* && $i != 1 ]]; do
4315 i=$((i-1))
4316 prev=${COMP_WORDS[i-1]}
4317 done
4318 fi
4319
4320 case "$prev" in
4321 -@(c|i|A|I|f|e|x|X|-@(install|unpack|record-avail|contents|info|fsys-tarfile|field|control|extract)))
4322 _filedir '?(u)deb'
4323 return 0
4324 ;;
4325 -@(b|-build))
4326 _filedir -d
4327 return 0
4328 ;;
4329 -@(s|p|l|-@(status|print-avail|list)))
4330 COMPREPLY=( $( apt-cache pkgnames $cur 2>/dev/null ) )
4331 return 0
4332 ;;
4333 -@(S|-search))
4334 _filedir
4335 return 0
4336 ;;
4337 -@(r|L|P|-@(remove|purge|listfiles)))
4338 COMPREPLY=( $( _comp_dpkg_installed_packages $cur ) )
4339 return 0
4340 ;;
4341 *)
4342
4343 COMPREPLY=( $( compgen -W '-i --install --unpack -A --record-avail \
4344 --configure -r --remove -P --purge --get-selections \
4345 --set-selections --update-avail --merge-avail \
4346 --clear-avail --command-fd --forget-old-unavail -s \
4347 --status -p --print-avail -L --listfiles -l --list \
4348 -S --search -C --audit --print-architecture \
4349 --print-gnu-build-architecture \
4350 --print-installation-architecture \
4351 --compare-versions --help --version --force-help \
4352 --force-all --force-auto-select --force-downgrade \
4353 --force-configure-any --force-hold --force-bad-path \
4354 --force-not-root --force-overwrite \
4355 --force-overwrite-diverted --force-bad-verify \
4356 --force-depends-version --force-depends \
4357 --force-confnew --force-confold --force-confdef \
4358 --force-confmiss --force-conflicts --force-architecture\
4359 --force-overwrite-dir --force-remove-reinstreq \
4360 --force-remove-essential -Dh \
4361 --debug=help --licence --admindir= --root= --instdir= \
4362 -O --selected-only -E --skip-same-version \
4363 -G --refuse-downgrade -B --auto-deconfigure \
4364 --no-debsig --no-act -D --debug= --status-fd \
4365 -b --build -I --info -f --field -c --contents \
4366 -x --extract -X --vextract --fsys-tarfile -e --control \
4367 --ignore-depends= --abort-after' -- $cur ) )
4368 ;;
4369 esac
4370
4371
4372 }
4373 complete -F _dpkg $filenames dpkg dpkg-deb
4374 }
4375
4376 # Debian GNU dpkg-reconfigure(8) completion
4377 #
4378 have dpkg-reconfigure &&
4379 _dpkg_reconfigure()
4380 {
4381 local cur prev opt
4382
4383 COMPREPLY=()
4384 cur=`_get_cword`
4385 prev=${COMP_WORDS[COMP_CWORD-1]}
4386
4387
4388 case "$prev" in
4389 -@(f|-frontend))
4390 opt=( $( echo /usr/share/perl5/Debconf/FrontEnd/* ) )
4391 opt=( ${opt[@]##*/} )
4392 opt=( ${opt[@]%.pm} )
4393 COMPREPLY=( $( compgen -W '${opt[@]}' -- $cur ) )
4394 return 0
4395 ;;
4396 -@(p|-priority))
4397 COMPREPLY=( $( compgen -W 'low medium high critical' -- $cur ) )
4398 return 0
4399 ;;
4400 esac
4401
4402 if [[ "$cur" == -* ]]; then
4403 COMPREPLY=( $( compgen -W '-f --frontend -p --priority -a --all \
4404 -u --unseen-only -h --help -s --showold \
4405 --force --terse' -- $cur ) )
4406 else
4407 COMPREPLY=( $( _comp_dpkg_installed_packages $cur ) )
4408 fi
4409 } &&
4410 complete -F _dpkg_reconfigure $default dpkg-reconfigure
4411
4412 # Debian dpkg-source completion
4413 #
4414 have dpkg-source &&
4415 _dpkg_source()
4416 {
4417 local cur prev options work i action packopts unpackopts
4418
4419 packopts="-c -l -F -V -T -D -U -W -E -sa -i -I -sk -sp -su -sr -ss -sn -sA -sK -sP -sU -sR"
4420 unpackopts="-sp -sn -su"
4421 options=`echo "-x -b $packopts $unpackopts" | xargs echo | sort -u | xargs echo`
4422
4423 COMPREPLY=()
4424 if [ "$1" != "dpkg-source" ]; then
4425 exit 1
4426 fi
4427 cur=`_get_cword`
4428 prev=${COMP_WORDS[COMP_CWORD-1]}
4429 action="options"
4430 for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
4431 if [[ ${COMP_WORDS[$i]} == "-x" ]]; then
4432 action=unpack
4433 elif [[ ${COMP_WORDS[$i]} == "-b" ]]; then
4434 action=pack
4435 elif [[ ${COMP_WORDS[$i]} == "-h" ]]; then
4436 action=help
4437 fi
4438 done
4439 # if currently seeing a complete option, return just itself.
4440 for i in $options; do
4441 if [ "$cur" = "$i" ]; then
4442 COMPREPLY=( "$cur" )
4443 return 0
4444 fi
4445 done
4446 case "$action" in
4447 "unpack")
4448 if [ "$cur" = "-" -o "$cur" = "-s" ]; then
4449 COMPREPLY=( $unpackots )
4450 return 0
4451 fi
4452 case "$prev" in
4453 "-x")
4454 COMPREPLY=( $( compgen -d -- "$cur" ) \
4455 $( compgen -f -X '!*.dsc' -- "$cur" ) )
4456 return 0
4457 ;;
4458 *)
4459 COMPREPLY=( $unpackopts $(compgen -d -f -- "$cur" ) )
4460 return 0
4461 ;;
4462 esac
4463 return 0
4464 ;;
4465 "pack")
4466 if [ "$cur" = "-" ]; then
4467 COMPREPLY=( $packopts )
4468 return 0
4469 fi
4470 if [ "$cur" = "-s" ]; then
4471 COMPREPLY=( "-sa" "-sk" "-sp" "-su" "-sr" "-ss" "-sn" \
4472 "-sA" "-sK" "-sP" "-sU" "-sR" )
4473 return 0
4474 fi
4475 case "$prev" in
4476 "-b")
4477 COMPREPLY=( $( compgen -d -- "$cur" ) )
4478 return 0
4479 ;;
4480 "-c"|"-l"|"-T"|"-i"|"-I")
4481 # -c: get controlfile
4482 # -l: get per-version info from this file
4483 # -T: read variables here, not debian/substvars
4484 # -i: <regexp> filter out files to ignore diffs of.
4485 # -I: filter out files when building tarballs.
4486 # return directory names and file names
4487 COMPREPLY=( $( compgen -d -f ) )
4488 return 0
4489 ;;
4490 "-F")
4491 # -F: force change log format
4492 COMPREPLY=( $( ( cd /usr/lib/dpkg/parsechangelog; compgen -f "$cur" ) ) )
4493 return 0
4494 ;;
4495 "-V"|"-D")
4496 # -V: set a substitution variable
4497 # we don't know anything about possible variables or values
4498 # so we don't try to suggest any completion.
4499 COMPREPLY=()
4500 return 0
4501 ;;
4502 "-D")
4503 # -D: override or add a .dsc field and value
4504 # if $cur doesn't contain a = yet, suggest variable names
4505 if echo -- "$cur" | grep -q "="; then
4506 # $cur contains a "="
4507 COMPREPLY=()
4508 return 0
4509 else
4510 COMPREPLY=( Format Source Version Binary Maintainer Uploader Architecture Standards-Version Build-Depends Files )
4511 return 0
4512 fi
4513 ;;
4514 "-U")
4515 # -U: remove a field
4516 # Suggest possible fieldnames
4517 COMPREPLY=( Format Source Version Binary Maintainer Uploader Architecture Standards-Version Build-Depends Files )
4518 return 0
4519 ;;
4520 *)
4521 COMPREPLY=( $packopts )
4522 return 0
4523 ;;
4524 esac
4525 return 0
4526 ;;
4527 *)
4528 # if seeing a partial option, return possible completions.
4529 if [ "$cur" = "-s" ]; then
4530 COMPREPLY=( "-sa" "-sk" "-sp" "-su" "-sr" "-ss" "-sn" \
4531 "-sA" "-sK" "-sP" "-sU" "-sR" )
4532 return 0
4533 fi
4534 # else return all possible options.
4535 COMPREPLY=( $options )
4536 return 0
4537 ;;
4538 esac
4539 } &&
4540 complete -F _dpkg_source dpkg-source
4541
4542 # Debian Linux dselect(8) completion.
4543 #
4544 have dselect &&
4545 _dselect()
4546 {
4547 local cur prev
4548
4549 COMPREPLY=()
4550 cur=`_get_cword`
4551 prev=${COMP_WORDS[COMP_CWORD-1]}
4552
4553 case "$prev" in
4554 --admindir)
4555 _filedir -d
4556 return 0
4557 ;;
4558
4559 -@(D|debug))
4560 _filedir
4561 return 0
4562 ;;
4563 esac
4564
4565 if [[ "$cur" == -* ]]; then
4566 COMPREPLY=( $( compgen -W '--admindir --help --version --licence \
4567 --license --expert --debug' -- $cur ) )
4568 else
4569 COMPREPLY=( $( compgen -W 'access update select install config \
4570 remove quit' -- $cur ) )
4571 fi
4572
4573
4574 return 0
4575 } &&
4576 complete -F _dselect $filenames dselect
4577
4578 # Java completion
4579 #
4580
4581 # available path elements completion
4582 have java && {
4583 _java_path()
4584 {
4585 cur=${cur##*:}
4586 _filedir '@(jar|zip)'
4587 }
4588
4589 # exact classpath determination
4590 _java_find_classpath()
4591 {
4592 local i
4593
4594 # search first in current options
4595 for (( i=1; i < COMP_CWORD; i++ )); do
4596 if [[ "${COMP_WORDS[i]}" == -@(cp|classpath) ]]; then
4597 classpath=${COMP_WORDS[i+1]}
4598 break
4599 fi
4600 done
4601
4602 # default to environment
4603 [ -z "$classpath" ] && classpath=$CLASSPATH
4604
4605 # default to current directory
4606 [ -z "$classpath" ] && classpath=.
4607 }
4608
4609 # exact sourcepath determination
4610 _java_find_sourcepath()
4611 {
4612 local i
4613
4614 # search first in current options
4615 for (( i=1; i < COMP_CWORD; i++ )); do
4616 if [[ "${COMP_WORDS[i]}" == -sourcepath ]]; then
4617 sourcepath=${COMP_WORDS[i+1]}
4618 break
4619 fi
4620 done
4621
4622 # default to classpath
4623 [ -z "$sourcepath" ] && _java_find_classpath
4624 sourcepath=$classpath
4625 }
4626
4627 # available classes completion
4628 _java_classes()
4629 {
4630 local classpath i
4631
4632 # find which classpath to use
4633 _java_find_classpath
4634
4635 # convert package syntax to path syntax
4636 cur=${cur//.//}
4637 # parse each classpath element for classes
4638 for i in ${classpath//:/ }; do
4639 if [ -r $i ] && [[ "$i" == *.@(jar|zip) ]]; then
4640 if type zipinfo &> /dev/null; then
4641 COMPREPLY=( "${COMPREPLY[@]}" $( zipinfo -1 \
4642 "$i" | grep "^$cur" | grep '\.class$' | \
4643 grep -v "\\$" ) )
4644 else
4645 COMPREPLY=( "${COMPREPLY[@]}" $( jar tf "$i" \
4646 "$cur" | grep "\.class$" | grep -v "\\$" ) )
4647 fi
4648
4649 elif [ -d $i ]; then
4650 i=${i%/}
4651 COMPREPLY=( "${COMPREPLY[@]}" $( find "$i" -type f \
4652 -path "$i/$cur*.class" 2>/dev/null | \
4653 grep -v "\\$" | sed -e "s|^$i/||" ) )
4654 fi
4655 done
4656
4657 # remove class extension
4658 COMPREPLY=( ${COMPREPLY[@]%.class} )
4659 # convert path syntax to package syntax
4660 COMPREPLY=( ${COMPREPLY[@]//\//.} )
4661 }
4662
4663 # available packages completion
4664 _java_packages()
4665 {
4666 local sourcepath i
4667
4668 # find wich sourcepath to use
4669 _java_find_sourcepath
4670
4671 # convert package syntax to path syntax
4672 cur=${cur//.//}
4673 # parse each sourcepath element for packages
4674 for i in ${sourcepath//:/ }; do
4675 if [ -d $i ]; then
4676 COMPREPLY=( "${COMPREPLY[@]}" $( command ls -F -d \
4677 $i/$cur* 2>/dev/null | sed -e 's|^'$i'/||' ) )
4678 fi
4679 done
4680 # keep only packages
4681 COMPREPLY=( $( echo "${COMPREPLY[@]}" | tr " " "\n" | grep "/$" ) )
4682 # remove packages extension
4683 COMPREPLY=( ${COMPREPLY[@]%/} )
4684 # convert path syntax to package syntax
4685 cur=${COMPREPLY[@]//\//.}
4686 }
4687
4688 # java completion
4689 #
4690 _java()
4691 {
4692 local cur prev i
4693
4694 COMPREPLY=()
4695 cur=`_get_cword`
4696 prev=${COMP_WORDS[COMP_CWORD-1]}
4697
4698 for ((i=1; i < $COMP_CWORD; i++)); do
4699 case ${COMP_WORDS[$i]} in
4700 -cp|-classpath)
4701 ((i++)) # skip the classpath string.
4702 ;;
4703 -*)
4704 # this is an option, not a class/jarfile name.
4705 ;;
4706 *)
4707 # once we've seen a class, just do filename completion
4708 _filedir
4709 return 0
4710 ;;
4711 esac
4712 done
4713
4714 case $prev in
4715 -@(cp|classpath))
4716 _java_path
4717 return 0
4718 ;;
4719 esac
4720
4721 if [[ "$cur" == -* ]]; then
4722 # relevant options completion
4723 COMPREPLY=( $( compgen -W '-client -hotspot -server -classic \
4724 -cp -classpath -D -verbose -verbose:class \
4725 -verbose:gc -version:jni -version \
4726 -showversion -? -help -X -jar \
4727 -ea -enableassertions -da -disableassertions \
4728 -esa -enablesystemassertions \
4729 -dsa -disablesystemassertions ' -- $cur ) )
4730 else
4731 if [[ "$prev" == -jar ]]; then
4732 # jar file completion
4733 _filedir jar
4734 else
4735 # classes completion
4736 _java_classes
4737 fi
4738 fi
4739 }
4740 complete -F _java $filenames java
4741 }
4742
4743 # javadoc completion
4744 #
4745 have javadoc &&
4746 _javadoc()
4747 {
4748 COMPREPLY=()
4749 local cur prev
4750
4751 cur=`_get_cword`
4752 prev=${COMP_WORDS[COMP_CWORD-1]}
4753
4754 case $prev in
4755 -@(overview|helpfile|stylesheetfile))
4756 _filedir
4757 return 0
4758 ;;
4759 -d)
4760 _filedir -d
4761 return 0
4762 ;;
4763 -@(classpath|bootclasspath|docletpath|sourcepath|extdirs))
4764 _java_path
4765 return 0
4766 ;;
4767 esac
4768
4769 if [[ "$cur" == -* ]]; then
4770 # relevant options completion
4771 COMPREPLY=( $( compgen -W '-overview -public -protected \
4772 -package -private -help -doclet -docletpath \
4773 -sourcepath -classpath -exclude -subpackages \
4774 -breakiterator -bootclasspath -source -extdirs \
4775 -verbose -locale -encoding -J -d -use -version \
4776 -author -docfilessubdirs -splitindex \
4777 -windowtitle -doctitle -header -footer -bottom \
4778 -link -linkoffline -excludedocfilessubdir \
4779 -group -nocomment -nodeprecated -noqualifier \
4780 -nosince -nodeprecatedlist -notree -noindex \
4781 -nohelp -nonavbar -quiet -serialwarn -tag \
4782 -taglet -tagletpath -charset -helpfile \
4783 -linksource -stylesheetfile -docencoding' -- \
4784 $cur ) )
4785 else
4786 # source files completion
4787 _filedir java
4788 # packages completion
4789 _java_packages
4790 fi
4791 } &&
4792 complete -F _javadoc $filenames javadoc
4793
4794 # javac completion
4795 #
4796 have javac &&
4797 _javac()
4798 {
4799 COMPREPLY=()
4800 local cur prev
4801
4802 cur=`_get_cword`
4803 prev=${COMP_WORDS[COMP_CWORD-1]}
4804
4805 case $prev in
4806 -d)
4807 _filedir -d
4808 return 0
4809 ;;
4810 -@(classpath|bootclasspath|sourcepath|extdirs))
4811 _java_path
4812 return 0
4813 ;;
4814 esac
4815
4816 if [[ "$cur" == -* ]]; then
4817 # relevant options completion
4818 COMPREPLY=( $( compgen -W '-g -g:none -g:lines -g:vars\
4819 -g:source -O -nowarn -verbose -deprecation -classpath\
4820 -sourcepath -bootclasspath -extdirs -d -encoding -source\
4821 -target -help' -- $cur ) )
4822 else
4823 # source files completion
4824 _filedir java
4825 fi
4826 } &&
4827 complete -F _javac $filenames javac
4828
4829 # PINE address-book completion
4830 #
4831 have pine &&
4832 _pineaddr()
4833 {
4834 local cur
4835
4836 COMPREPLY=()
4837 cur=`_get_cword`
4838
4839 COMPREPLY=( $( compgen -W '$( awk "{print \$1}" ~/.addressbook 2>/dev/null)' \
4840 -- $cur ) )
4841 } &&
4842 complete -F _pineaddr $default pine
4843
4844 # mutt completion
4845 #
4846 # Mutt doesn't have an "addressbook" like Pine, but it has aliases and
4847 # a "query" function to retrieve addresses, so that's what we use here.
4848 have mutt || have muttng && {
4849 _muttaddr()
4850 {
4851 _muttaliases
4852 _muttquery
4853 return 0
4854 }
4855
4856 _muttconffiles()
4857 {
4858 local file sofar
4859 local -a newconffiles
4860
4861 sofar=" $1 "
4862 shift
4863 while [[ "$1" ]]; do
4864 newconffiles=( $(sed -rn 's|^source[[:space:]]+([^[:space:]]+).*$|\1|p' $(eval echo $1) ) )
4865 for file in "${newconffiles[@]}"; do
4866 [[ ! "$file" ]] || [[ "${sofar/ ${file} / }" != "$sofar" ]] &&
4867 continue
4868 sofar="$sofar $file"
4869 sofar=" $(eval _muttconffiles \"$sofar\" $file) "
4870 done
4871 shift
4872 done
4873 echo $sofar
4874 }
4875
4876 _muttaliases()
4877 {
4878 local cur muttrc
4879 local -a conffiles aliases
4880 cur=`_get_cword`
4881
4882 [ -f ~/.${muttcmd}/${muttcmd}rc ] && muttrc="~/.${muttcmd}/${muttcmd}rc"
4883 [ -f ~/.${muttcmd}rc ] && muttrc="~/.${muttcmd}rc"
4884 [ -z "$muttrc" ] && return 0
4885
4886 conffiles=( $(eval _muttconffiles $muttrc $muttrc) )
4887 aliases=( $( sed -rn 's|^alias[[:space:]]+([^[:space:]]+).*$|\1|p' \
4888 $(eval echo "${conffiles[@]}") ) )
4889 COMPREPLY=( "${COMPREPLY[@]}" $( compgen -W "${aliases[*]}" -- $cur ) )
4890
4891 return 0
4892 }
4893
4894 _muttquery()
4895 {
4896 local cur querycmd
4897 local -a queryresults
4898 cur=`_get_cword`
4899
4900 querycmd="$( $muttcmd -Q query_command | sed -r 's|^query_command=\"(.*)\"$|\1|; s|%s|'$cur'|' )"
4901 if [ -z "$cur" -o -z "$querycmd" ]; then
4902 queryresults=()
4903 else
4904 queryresults=( $( $querycmd | \
4905 sed -nr '2,$s|^([^[:space:]]+).*|\1|p' ) )
4906 fi
4907
4908 COMPREPLY=( "${COMPREPLY[@]}" $( compgen -W "${queryresults[*]}" \
4909 -- $cur ) )
4910
4911 return 0
4912 }
4913
4914 _muttfiledir()
4915 {
4916 local cur folder spoolfile
4917 cur=`_get_cword`
4918
4919 # This is currently not working so well. Perhaps this function should
4920 # just call _filedir() for the moment.
4921 if [[ $cur == [=+]* ]]; then
4922 folder="$( $muttcmd -Q folder | sed -r 's|^folder=\"(.*)\"$|\1|' )"
4923 : folder:=~/Mail
4924
4925 # Match any file in $folder beginning with $cur
4926 # (minus the leading '=' sign).
4927 COMPREPLY=( $( compgen -f -- "$folder/${cur:1}" ) )
4928 COMPREPLY=( ${COMPREPLY[@]#$folder/} )
4929 return 0
4930 elif [ "$cur" == !* ]; then
4931 spoolfile="$( $muttcmd -Q spoolfile | sed -r 's|^spoolfile=\"(.*)\"$|\1|' )"
4932 [ ! -z "$spoolfile" ] && eval cur="${cur/^!/$spoolfile}";
4933 fi
4934 _filedir
4935
4936 return 0
4937 }
4938
4939 _mutt()
4940 {
4941 local cur prev
4942 cur=`_get_cword`
4943 prev=${COMP_WORDS[COMP_CWORD-1]}
4944
4945 COMPREPLY=()
4946
4947 [ ${COMP_WORDS[0]} == muttng ] && muttcmd="muttng" || muttcmd="mutt"
4948
4949 case "$cur" in
4950 -*)
4951 COMPREPLY=( $( compgen -W '-A -a -b -c -e -f -F -H -i -m -n \
4952 -p -Q -R -s -v -x -y -z -Z -h' \
4953 -- $cur ) )
4954 return 0
4955 ;;
4956 *)
4957 case "$prev" in
4958 -@(a|f|F|H|i))
4959 _muttfiledir
4960 return 0
4961 ;;
4962 -A)
4963 _muttaliases
4964 return 0
4965 ;;
4966 -@(e|m|Q|s|h|p|R|v|y|z|Z))
4967 return 0
4968 ;;
4969 *)
4970 _muttaddr
4971 return 0
4972 ;;
4973 esac
4974 ;;
4975 esac
4976
4977 }
4978 complete -F _mutt $default $filenames mutt muttng
4979 }
4980
4981 _configure_func()
4982 {
4983 local cur
4984
4985 COMPREPLY=()
4986 cur=`_get_cword`
4987
4988 # if $COMP_CONFIGURE_HINTS is not null, then completions of the form
4989 # --option=SETTING will include 'SETTING' as a contextual hint
4990 [[ "$cur" != -* ]] && return 0
4991
4992 if [ -n "$COMP_CONFIGURE_HINTS" ]; then
4993 COMPREPLY=( $( $1 --help | awk '/^ --[A-Za-z]/ { print $1; if ($2 ~ /--[A-Za-z]/) print $2 }' | sed -e 's/[[,].*//g' | grep ^$cur ) )
4994
4995 else
4996 COMPREPLY=( $( $1 --help | awk '/^ --[A-Za-z]/ { print $1; if ($2 ~ /--[A-Za-z]/) print $2 }' | sed -e 's/[[,=].*//g' | grep ^$cur ) )
4997 fi
4998 }
4999 complete -F _configure_func $default configure
5000
5001 # Debian reportbug(1) completion
5002 #
5003 have reportbug &&
5004 _reportbug()
5005 {
5006 local cur prev
5007
5008 COMPREPLY=()
5009 cur=`_get_cword`
5010 prev=${COMP_WORDS[COMP_CWORD-1]}
5011
5012 case "$prev" in
5013 -f|--filename|-i|--include|--mta|-o|--output)
5014 _filedir
5015 return 0
5016 ;;
5017 -B|--bts)
5018 COMPREPLY=( $( compgen -W "debian guug kde mandrake help" -- \
5019 $cur ))
5020 return 0
5021 ;;
5022 -e|--editor|--mua)
5023 COMP_WORDS=(COMP_WORDS[0] $cur)
5024 COMP_CWORD=1
5025 _command
5026 return 0
5027 ;;
5028 --mode)
5029 COMPREPLY=( $( compgen -W "novice standard expert" -- $cur ) )
5030 return 0
5031 ;;
5032 -S|--severity)
5033 COMPREPLY=( $( compgen -W "grave serious important normal \
5034 minor wishlist" -- $cur ) )
5035 return 0
5036 ;;
5037 -u|--ui|--interface)
5038 COMPREPLY=( $( compgen -W "newt text gnome" -- $cur ) )
5039 return 0
5040 ;;
5041 -t|--type)
5042 COMPREPLY=( $( compgen -W "gnats debbugs" -- $cur ) )
5043 return 0
5044 ;;
5045 -T|--tags)
5046 COMPREPLY=( $( compgen -W "none patch security upstream sid \
5047 woody potato sarge fixed" -- $cur ))
5048 return 0
5049 ;;
5050 *)
5051 ;;
5052 esac
5053
5054 COMPREPLY=($( compgen -W '-h --help -v --version -a --af -b \
5055 --no-query-bts --query-bts -B --bts -c --configure \
5056 --no-config-files --check-available -d --debug \
5057 --no-check-available -e --editor --email -f \
5058 --filename -g --gnupg -H --header -i --include -j \
5059 --justification -l --ldap --no-ldap -L --list-cc -m \
5060 --maintonly --mode --mua --mta --mutt -n --mh --nmh \
5061 -o --output -p --print -P --pgp --proxy --http_proxy\
5062 -q --quiet -Q --query-only --realname --report-quiet \
5063 --reply-to --replyto -s --subject -S --severity \
5064 --smtphost -t --type -T --tags --template -V -x \
5065 --no-cc --package-version -z --no-compress \
5066 --ui --interface -u \
5067 wnpp boot-floppies kernel-image' -- $cur ) \
5068 $( apt-cache pkgnames -- $cur 2> /dev/null ) )
5069 _filedir
5070 return 0
5071 } &&
5072 complete -F _reportbug $filenames reportbug
5073
5074 # Debian querybts(1) completion
5075 #
5076 have querybts &&
5077 _querybts()
5078 {
5079 local cur prev
5080
5081 COMPREPLY=()
5082 cur=`_get_cword`
5083 prev=${COMP_WORDS[COMP_CWORD-1]}
5084
5085 case "$prev" in
5086 -B|--bts)
5087 COMPREPLY=( $( compgen -W "debian guug kde mandrake help" -- \
5088 $cur ))
5089 return 0
5090 ;;
5091 -u|--ui|--interface)
5092 COMPREPLY=($( compgen -W "newt text gnome" -- $cur ))
5093 return 0
5094 ;;
5095 *)
5096 ;;
5097 esac
5098
5099 COMPREPLY=($( compgen -W '-h --help -v --version -A --archive \
5100 -B --bts -l --ldap --no-ldap --proxy= --http_proxy= \
5101 -s --source -w --web -u --ui --interface \
5102 wnpp boot-floppies' -- $cur ) \
5103 $( apt-cache pkgnames -- $cur 2> /dev/null ) )
5104 } &&
5105 complete -F _querybts $filenames querybts
5106
5107 # update-alternatives completion
5108 #
5109 have update-alternatives && {
5110 installed_alternatives()
5111 {
5112 local admindir
5113 # find the admin dir
5114 for i in alternatives dpkg/alternatives rpm/alternatives; do
5115 [ -d /var/lib/$i ] && admindir=/var/lib/$i && break
5116 done
5117 for (( i=1; i < COMP_CWORD; i++ )); do
5118 if [[ "${COMP_WORDS[i]}" == --admindir ]]; then
5119 admindir=${COMP_WORDS[i+1]}
5120 break
5121 fi
5122 done
5123 COMPREPLY=( $( command ls $admindir | grep "^$cur" ) )
5124 }
5125
5126 _update_alternatives()
5127 {
5128 local cur prev mode args i
5129
5130 COMPREPLY=()
5131 cur=`_get_cword`
5132 prev=${COMP_WORDS[COMP_CWORD-1]}
5133
5134 case "$prev" in
5135 --@(altdir|admindir))
5136 _filedir -d
5137 return 0
5138 ;;
5139 --@(help|version))
5140 return 0
5141 ;;
5142 esac
5143
5144 # find wich mode to use and how many real args used so far
5145 for (( i=1; i < COMP_CWORD; i++ )); do
5146 if [[ "${COMP_WORDS[i]}" == --@(install|remove|auto|display|config|remove-all) ]]; then
5147 mode=${COMP_WORDS[i]}
5148 args=$(($COMP_CWORD - i))
5149 break
5150 fi
5151 done
5152
5153 case $mode in
5154 --install)
5155 case $args in
5156 1)
5157 _filedir
5158 ;;
5159 2)
5160 installed_alternatives
5161 ;;
5162 3)
5163 _filedir
5164 ;;
5165 esac
5166 ;;
5167 --remove)
5168 case $args in
5169 1)
5170 installed_alternatives
5171 ;;
5172 2)
5173 _filedir
5174 ;;
5175 esac
5176 ;;
5177 --auto)
5178 installed_alternatives
5179 ;;
5180 --remove-all)
5181 installed_alternatives
5182 ;;
5183 --display)
5184 installed_alternatives
5185 ;;
5186 --config)
5187 installed_alternatives
5188 ;;
5189 *)
5190 COMPREPLY=( $( compgen -W '--verbose --quiet --help --version \
5191 --altdir --admindir' -- $cur ) \
5192 $( compgen -W '--install --remove --auto --display \
5193 --config' -- $cur ) )
5194 esac
5195 }
5196 complete -F _update_alternatives update-alternatives
5197 }
5198
5199 # Python completion
5200 #
5201 have python &&
5202 _python()
5203 {
5204 local prev cur
5205
5206 COMPREPLY=()
5207 cur=`_get_cword`
5208 prev=${COMP_WORDS[COMP_CWORD-1]##*/}
5209
5210 case "$prev" in
5211 -Q)
5212 COMPREPLY=( $( compgen -W "old new warn warnall" -- $cur ) )
5213 return 0
5214 ;;
5215 -W)
5216 COMPREPLY=( $( compgen -W "ignore default all module once error" -- $cur ) )
5217 return 0
5218 ;;
5219 -c)
5220 _filedir '@(py|pyc|pyo)'
5221 return 0
5222 ;;
5223 !(python|-?))
5224 [[ ${COMP_WORDS[COMP_CWORD-2]} != -@(Q|W) ]] && _filedir
5225 ;;
5226 esac
5227
5228
5229 # if '-c' is already given, complete all kind of files.
5230 for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
5231 if [[ ${COMP_WORDS[i]} == -c ]]; then
5232 _filedir
5233 fi
5234 done
5235
5236
5237 if [[ "$cur" != -* ]]; then
5238 _filedir '@(py|pyc|pyo)'
5239 else
5240 COMPREPLY=( $( compgen -W "- -d -E -h -i -O -Q -S -t -u \
5241 -U -v -V -W -x -c" -- $cur ) )
5242 fi
5243
5244
5245
5246 return 0
5247 } &&
5248 complete -F _python $filenames python
5249
5250 # Perl completion
5251 #
5252 have perl &&
5253 {
5254 _perlmodules()
5255 {
5256 COMPREPLY=( $( compgen -P "$prefix" -W "$( perl -e 'sub mods { my ($base,$dir)=@_; return if $base !~ /^\Q$ENV{cur}/; chdir($dir) or return; for (glob(q[*.pm])) {s/\.pm$//; print qq[$base$_\n]}; mods(/^(?:[.\d]+|$Config{archname}-$Config{osname}|auto)$/ ? undef : qq[${base}${_}\\\\:\\\\:],qq[$dir/$_]) for grep {-d} glob(q[*]); } mods(undef,$_) for @INC;' )" -- $cur ) )
5257 }
5258
5259 _perl()
5260 {
5261 local cur prev prefix temp
5262
5263 COMPREPLY=()
5264 cur=`_get_cword`
5265 prev=${COMP_WORDS[COMP_CWORD-1]}
5266 prefix=""
5267
5268 # completing an option (may or may not be separated by a space)
5269 if [[ "$cur" == -?* ]]; then
5270 temp=$cur
5271 prev=${temp:0:2}
5272 cur=${temp:2}
5273 prefix=$prev
5274 fi
5275
5276 # only handle module completion for now
5277 case "$prev" in
5278 -I|-x)
5279 COMPREPLY=( $( compgen -d -P "$prev" -- "$cur" ) )
5280 return 0
5281 ;;
5282 -m|-M)
5283 _perlmodules
5284 return 0
5285 ;;
5286 esac
5287
5288 # handle case where first parameter is not a dash option
5289 if [[ "${COMP_WORDS[COMP_CWORD]}" != -* ]]; then
5290 _filedir
5291 return 0
5292 fi
5293
5294 # complete using basic options
5295 COMPREPLY=( $( compgen -W '-C -s -T -u -U -W -X -h -v -V -c -w -d -D -p \
5296 -n -a -F -l -0 -I -m -M -P -S -x -i -e ' -- $cur ) )
5297 return 0
5298 }
5299 complete -F _perl $filenames perl
5300
5301 _perldoc()
5302 {
5303 local cur prev prefix temp
5304
5305 COMPREPLY=()
5306 cur=`_get_cword`
5307 prev=${COMP_WORDS[COMP_CWORD-1]}
5308 prefix=""
5309
5310 # completing an option (may or may not be separated by a space)
5311 if [[ "$cur" == -?* ]]; then
5312 temp=$cur
5313 prev=${temp:0:2}
5314 cur=${temp:2}
5315 prefix=$prev
5316 fi
5317
5318 # complete builtin perl functions
5319 case $prev in
5320 -f)
5321 COMPREPLY=( $( compgen -W 'chomp chop chr crypt hex index lc \
5322 lcfirst length oct ord pack q qq reverse rindex sprintf \
5323 substr tr uc ucfirst y m pos quotemeta s split study qr abs \
5324 atan2 cos exp hex int log oct rand sin sqrt srand pop push \
5325 shift splice unshift grep join map qw reverse sort unpack \
5326 delete each exists keys values binmode close closedir \
5327 dbmclose dbmopen die eof fileno flock format getc print \
5328 printf read readdir rewinddir seek seekdir select syscall \
5329 sysread sysseek syswrite tell telldir truncate warn write \
5330 pack read syscall sysread syswrite unpack vec -X chdir chmod \
5331 chown chroot fcntl glob ioctl link lstat mkdir open opendir \
5332 readlink rename rmdir stat symlink umask unlink utime caller \
5333 continue do dump eval exit goto last next redo return \
5334 sub wantarray caller import local my our package use defined \
5335 formline reset scalar undef \
5336 alarm exec fork getpgrp getppid getpriority kill pipe qx \
5337 setpgrp setpriority sleep system times wait waitpid \
5338 import no package require use bless dbmclose dbmopen package \
5339 ref tie tied untie use accept bind connect getpeername \
5340 getsockname getsockopt listen recv send setsockopt shutdown \
5341 socket socketpair msgctl msgget msgrcv msgsnd semctl semget \
5342 semop shmctl shmget shmread shmwrite endgrent endhostent \
5343 endnetent endpwent getgrent getgrgid getgrnam getlogin \
5344 getpwent getpwnam getpwuid setgrent setpwent endprotoent \
5345 endservent gethostbyaddr gethostbyname gethostent \
5346 getnetbyaddr getnetbyname getnetent getprotobyname \
5347 getprotobynumber getprotoent getservbyname getservbyport \
5348 getservent sethostent setnetent setprotoent setservent \
5349 gmtime localtime time times' -- $cur ) )
5350 return 0
5351 ;;
5352 esac
5353
5354 case $cur in
5355 -*)
5356 COMPREPLY=( $( compgen -W '-h -v -t -u -m -l -F -X -f -q' -- $cur ))
5357 return 0
5358 ;;
5359 */*)
5360 return 0
5361 ;;
5362 *)
5363 _perlmodules
5364 COMPREPLY=( "${COMPREPLY[@]}" $( compgen -W '$( PAGER=cat man perl 2>/dev/null | sed -ne "/perl.*Perl overview/,/perlwin32/s/^[^a-z0-9]*\([a-z0-9]*\).*$/\1/p")' -- $cur ) )
5365
5366 return 0
5367 ;;
5368 esac
5369 }
5370 complete -F _perldoc $default perldoc
5371 }
5372
5373 # rcs(1) completion
5374 #
5375 have rcs &&
5376 _rcs()
5377 {
5378 local cur prev file dir i
5379
5380 COMPREPLY=()
5381 cur=`_get_cword`
5382 prev=${COMP_WORDS[COMP_CWORD-1]}
5383
5384 file=${cur##*/}
5385 dir=${cur%/*}
5386
5387 # deal with relative directory
5388 [ "$file" = "$dir" ] && dir=.
5389
5390 COMPREPLY=( $( compgen -f "$dir/RCS/$file" ) )
5391
5392 for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
5393 file=${COMPREPLY[$i]##*/}
5394 dir=${COMPREPLY[$i]%RCS/*}
5395 COMPREPLY[$i]=$dir$file
5396 done
5397
5398 COMPREPLY=( "${COMPREPLY[@]}" $( compgen -G "$dir/$file*,v" ) )
5399
5400 for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
5401 COMPREPLY[$i]=${COMPREPLY[$i]%,v}
5402 done
5403
5404 # default to files if nothing returned and we're checking in.
5405 # otherwise, default to directories
5406 [ ${#COMPREPLY[@]} -eq 0 -a $1 = ci ] && _filedir || _filedir -d
5407 } &&
5408 complete -F _rcs $filenames ci co rlog rcs rcsdiff
5409
5410 # lilo(8) completion
5411 #
5412 have lilo && {
5413 _lilo_labels()
5414 {
5415 COMPREPLY=( $( awk -F'=' '/label/ {print $2}' \
5416 /etc/lilo.conf | sed -e 's/"//g' | grep "^$cur" ) )
5417 }
5418
5419 _lilo()
5420 {
5421 local cur prev
5422
5423 COMPREPLY=()
5424 cur=`_get_cword`
5425 prev=${COMP_WORDS[COMP_CWORD-1]}
5426
5427 case $prev in
5428 -@(C|i|m|s|S))
5429 _filedir
5430 return 0
5431 ;;
5432 -r)
5433 _filedir -d
5434 return 0
5435 ;;
5436 -@(I|D|R))
5437 # label completion
5438 _lilo_labels
5439 return 0
5440 ;;
5441 -@(A|b|M|u|U))
5442 # device completion
5443 cur=${cur:=/dev/}
5444 _filedir
5445 return 0
5446 ;;
5447 -T)
5448 # topic completion
5449 COMPREPLY=( $( compgen -W 'help ChRul EBDA geom geom= \
5450 table= video' -- $cur ) )
5451 return 0
5452 ;;
5453 esac
5454
5455 if [[ "$cur" == -* ]]; then
5456 # relevant options completion
5457 COMPREPLY=( $( compgen -W '-A -b -c -C -d -f -g -i -I -l -L -m \
5458 -M -p -P -q -r -R -s -S -t -T -u -U -v -V -w -x -z' -- \
5459 $cur ) )
5460 fi
5461 }
5462 complete -F _lilo lilo
5463 }
5464
5465 # links completion
5466 #
5467 have links &&
5468 _links()
5469 {
5470 local cur
5471
5472 COMPREPLY=()
5473 cur=`_get_cword`
5474
5475 case "$cur" in
5476 --*)
5477 COMPREPLY=( $( compgen -W '--help' -- $cur ) )
5478 ;;
5479 -*)
5480 COMPREPLY=( $( compgen -W '-async-dns -max-connections \
5481 -max-connections-to-host -retries \
5482 -receive-timeout -unrestartable-receive-timeout\
5483 -format-cache-size -memory-cache-size \
5484 -http-proxy -ftp-proxy -download-dir \
5485 -assume-codepage -anonymous -dump -no-connect \
5486 -source -version -help' -- $cur ) )
5487 ;;
5488 *)
5489 if [ -r ~/.links/links.his ]; then
5490 COMPREPLY=( $( compgen -W '$( < ~/.links/links.his )' \
5491 -- $cur ) )
5492 fi
5493 _filedir '@(htm|html)'
5494 return 0
5495 ;;
5496 esac
5497
5498 return 0
5499 } &&
5500 complete -F _links $filenames links
5501
5502 [ $UNAME = FreeBSD ] && {
5503 # FreeBSD package management tool completion
5504 #
5505 _pkg_delete()
5506 {
5507 local cur pkgdir prev
5508
5509 pkgdir=${PKG_DBDIR:-/var/db/pkg}/
5510 cur=`_get_cword`
5511 prev=${COMP_WORDS[COMP_CWORD-1]}
5512
5513 [ "$prev" = "-o" -o "$prev" = "-p" -o "$prev" = "-W" ] && return 0
5514
5515 COMPREPLY=( $( compgen -d $pkgdir$cur ) )
5516 COMPREPLY=( ${COMPREPLY[@]#$pkgdir} )
5517
5518 return 0
5519 }
5520 complete -F _pkg_delete $dirnames pkg_delete pkg_info
5521 have pkg_deinstall && complete -F _pkg_delete $dirnames pkg_deinstall
5522
5523 # FreeBSD kernel module commands
5524 #
5525 _kldload()
5526 {
5527 local cur moddir
5528
5529 moddir=/modules/
5530 [ -d $moddir ] || moddir=/boot/kernel/
5531 cur=`_get_cword`
5532
5533 COMPREPLY=( $( compgen -f $moddir$cur ) )
5534 COMPREPLY=( ${COMPREPLY[@]#$moddir} )
5535 COMPREPLY=( ${COMPREPLY[@]%.ko} )
5536
5537 return 0
5538 }
5539 complete -F _kldload $filenames kldload
5540
5541 _kldunload()
5542 {
5543 local cur
5544 cur=`_get_cword`
5545 COMPREPLY=( $(kldstat | sed -ne "s/^.*[ \t]\+\($cur[a-z_]\+\).ko$/\1/p") )
5546 }
5547 complete -F _kldunload $filenames kldunload
5548 }
5549
5550 # FreeBSD portupgrade completion
5551 #
5552 have portupgrade &&
5553 _portupgrade()
5554 {
5555 local cur pkgdir prev
5556
5557 pkgdir=${PKG_DBDIR:-/var/db/pkg}/
5558 cur=`_get_cword`
5559 prev=${COMP_WORDS[COMP_CWORD-1]}
5560
5561 [ "$prev" = "-l" -o "$prev" = "-L" -o "$prev" = "-o" ] && return 0
5562
5563 COMPREPLY=( $( compgen -d $pkgdir$cur ) )
5564 COMPREPLY=( ${COMPREPLY[@]#$pkgdir} )
5565 COMPREPLY=( ${COMPREPLY[@]%-*} )
5566
5567 return 0
5568 } &&
5569 complete -F _portupgrade $dirnames portupgrade
5570
5571 # FreeBSD portinstall completion
5572 #
5573 have portinstall &&
5574 _portinstall()
5575 {
5576 local cur portsdir prev indexfile
5577 local -a COMPREPLY2
5578
5579 portsdir=${PORTSDIR:-/usr/ports}/
5580 cur=`_get_cword`
5581 prev=${COMP_WORDS[COMP_CWORD-1]}
5582 # First try INDEX-5
5583 indexfile=$portsdir/INDEX-5
5584 # Then INDEX if INDEX-5 does not exist or system is not FreeBSD 5.x
5585 [ "${OSTYPE%.*}" = "freebsd5" -a -f $indexfile ] ||
5586 indexfile=$portsdir/INDEX
5587
5588 [ "$prev" = "-l" -o "$prev" = "-L" -o "$prev" = "-o" ] && return 0
5589
5590 COMPREPLY=( $( egrep "^$cur" < $indexfile | cut -d'|' -f1 ) )
5591 COMPREPLY2=( $( egrep "^[^\|]+\|$portsdir$cur" < $indexfile | \
5592 cut -d'|' -f2 ) )
5593 COMPREPLY2=( ${COMPREPLY2[@]#$portsdir} )
5594 COMPREPLY=( "${COMPREPLY[@]}" "${COMPREPLY2[@]}" )
5595
5596 return 0
5597 } &&
5598 complete -F _portinstall $dirnames portinstall
5599
5600 # Slackware Linux removepkg completion
5601 #
5602 have removepkg && [ -f /etc/slackware-version ] &&
5603 _removepkg()
5604 {
5605 local packages cur
5606
5607 COMPREPLY=()
5608 cur=`_get_cword`
5609
5610 COMPREPLY=( $( (cd /var/log/packages; compgen -f -- "$cur") ) )
5611 } &&
5612 complete -F _removepkg $filenames removepkg &&
5613 complete $dirnames -f -X '!*.tgz' installpkg upgradepkg explodepkg
5614
5615 # look(1) completion
5616 #
5617 have look &&
5618 _look()
5619 {
5620 local cur
5621
5622 COMPREPLY=()
5623 cur=`_get_cword`
5624
5625 if [ $COMP_CWORD = 1 ]; then
5626 COMPREPLY=( $( compgen -W '$(look $cur)' ) )
5627 fi
5628 } &&
5629 complete -F _look $default look
5630
5631 # ypcat(1) and ypmatch(1) completion
5632 #
5633 have ypmatch &&
5634 _ypmatch()
5635 {
5636 local cur map
5637
5638 COMPREPLY=()
5639 cur=`_get_cword`
5640
5641 [ $1 = ypcat ] && [ $COMP_CWORD -gt 1 ] && return 0
5642 [ $1 = ypmatch ] && [ $COMP_CWORD -gt 2 ] && return 0
5643
5644 if [ $1 = ypmatch ] && [ $COMP_CWORD -eq 1 ] && \
5645 [ ${#COMP_WORDS[@]} -eq 3 ]; then
5646 map=${COMP_WORDS[2]}
5647 COMPREPLY=( $( compgen -W '$( ypcat $map | \
5648 cut -d':' -f 1 )' -- $cur) )
5649 else
5650 [ $1 = ypmatch ] && [ $COMP_CWORD -ne 2 ] && return 0
5651 COMPREPLY=( $( compgen -W \
5652 '$( echo $(ypcat -x | cut -d"\"" -f 2))' -- $cur))
5653 fi
5654
5655 return 0
5656 } &&
5657 complete -F _ypmatch ypmatch ypcat
5658
5659 # mplayer(1) completion
5660 #
5661 have mplayer && {
5662 _mplayer_options_list()
5663 {
5664 cur=${cur%\\}
5665 COMPREPLY=( $( $1 $2 help 2> /dev/null | \
5666 sed -e '1,/^Available/d' | awk '{print $1}' | \
5667 sed -e 's/:$//' -e 's/^'${2#-}'$//' -e 's/<.*//' | \
5668 grep "^$cur" ) )
5669 }
5670
5671 _mplayer()
5672 {
5673 local cmd cur prev skinsdir IFS=$' \t\n' i j k=0
5674
5675 COMPREPLY=()
5676 cmd=${COMP_WORDS[0]}
5677 cur=`_get_cword`
5678 prev=${COMP_WORDS[COMP_CWORD-1]}
5679
5680 case "$prev" in
5681 -@(ac|afm|vc|vfm|ao|vo|vop|fstype))
5682 _mplayer_options_list mplayer $prev
5683 return 0
5684 ;;
5685 -@(oac|ovc|of))
5686 _mplayer_options_list mencoder $prev
5687 return 0
5688 ;;
5689 -audiofile)
5690 _filedir '@(mp3|MP3|mpg|MPG|ogg|OGG|wav|WAV|mid|MID|flac|FLAC|mka|MKA)'
5691 return 0
5692 ;;
5693 -font)
5694 _filedir '@(desc|ttf)'
5695 return 0
5696 ;;
5697 -sub)
5698 _filedir '@(srt|SRT|sub|SUB|txt|TXT|utf|UTF|rar|RAR|mpsub|smi|js|ssa|SSA|aas|AAS)'
5699 return 0
5700 ;;
5701 -vobsub)
5702 _filedir '@(idx|IDX|ifo|IFO|sub|SUB)'
5703 IFS=$'\t\n'
5704 COMPREPLY=( $( for i in "${COMPREPLY[@]}"; do
5705 if [ -f $i -a -r $i ]; then
5706 echo ${i%.*}
5707 else
5708 echo $i
5709 fi
5710 done ) )
5711 IFS=$' \t\n'
5712 return 0
5713 ;;
5714 -ifo)
5715 _filedir '@(ifo|IFO)'
5716 return 0
5717 ;;
5718 -cuefile)
5719 _filedir '@(bin|BIN|cue|CUE)'
5720 return 0
5721 ;;
5722 -skin)
5723 # if you don't have installed mplayer in /usr/local you
5724 # may want to set the MPLAYER_SKINS_DIR global variable
5725 if [ -n "$MPLAYER_SKINS_DIR" ]; then
5726 skinsdir=$MPLAYER_SKINS_DIR
5727 else
5728 skinsdir=/usr/local/share/mplayer/Skin
5729 fi
5730
5731 IFS=$'\t\n'
5732 for i in ~/.mplayer/Skin $skinsdir; do
5733 if [ -d $i -a -r $i ]; then
5734 for j in $( compgen -d $i/$cur ); do
5735 COMPREPLY[$k]=${j#$i/}
5736 k=$((++k))
5737 done
5738 fi
5739 done
5740 IFS=$' \t\n'
5741 return 0
5742 ;;
5743 -@(mixer|@(cdrom|dvd)-device|dvdauth|fb|zrdev))
5744 cur=${cur:=/dev/}
5745 _filedir
5746 return 0
5747 ;;
5748 -@(edl?(out)|lircconf|menu-cfg|playlist|csslib|dumpfile)| \
5749 -@(subfile|vobsub|aofile|fbmodeconfig|include|o|dvdkey)| \
5750 -passlogfile)
5751 _filedir
5752 return 0
5753 ;;
5754 -@(auto@(q|sync)|loop|menu-root|speed|sstep|aid|alang)| \
5755 -@(?(@(audio|sub)-)demuxer|bandwidth|cache|chapter)| \
5756 -@(dvd?(angle)|fps|frames|mc|passwd|user|sb|srate|ss|vcd)| \
5757 -@(vi?(d|vo)|ffactor|sid|slang|spu@(align|aa|gauss))| \
5758 -@(vobsubid|delay|bpp|brightness|contrast|dfbopts|display)| \
5759 -@(fbmode|geometry|guiwid|hue|icelayer|screen[wh]|wid)| \
5760 -@(monitor@(aspect|-@(dotclock|[hv]freq))|panscan|saturation)| \
5761 -@(xineramascreen|zr@(crop|norm|quality|[xy]doff|[vh]dec))| \
5762 -@(aspect|pp|x|y|xy|z|stereo|audio-@(density|delay|preload))| \
5763 -@(endpos|osdlevel|ffourcc|sws|channels|skiplimit|format)| \
5764 -@(ofps|aa@(driver|@(osd|sub)color)|vobsubout?(i@(ndex|d)))| \
5765 -sub@(-bg-@(alpha|color)|cp|delay|fps|pos|align|width)| \
5766 -sub@(font-@(blur|outline|autoscale|encoding|@(osd|text)-scale)))
5767 return 0
5768 ;;
5769 -lavdopts)
5770 COMPREPLY=( $( compgen -W 'ec er= bug= idct= gray' \
5771 -- $cur ) )
5772 return 0
5773 ;;
5774 -lavcopts)
5775 COMPREPLY=( $( compgen -W 'vcodec= vqmin= vqscale= \
5776 vqmax= mbqmin= mbqmax= vqdiff= \
5777 vmax_b_frames= vme= vhq v4mv \
5778 keyint= vb_strategy= vpass= \
5779 aspect= vbitrate= vratetol= \
5780 vrc_maxrate= vrc_minrate= \
5781 vrc_buf_size= vb_qfactor= vi_qfactor= \
5782 vb_qoffset= vi_qoffset= vqblur= \
5783 vqcomp= vrc_eq= vrc_override= \
5784 vrc_init_cplx= vqsquish= vlelim= \
5785 vcelim= vstrict= vdpart vpsize= gray \
5786 vfdct= idct= lumi_mask= dark_mask= \
5787 tcplx_mask= scplx_mask= naq ildct \
5788 format= pred qpel precmp= cmp= \
5789 subcmp= predia= dia= trell last_pred= \
5790 preme= subq= psnr mpeg_quant aic umv' \
5791 -- $cur ) )
5792 return 0
5793 ;;
5794 -ssf)
5795 COMPREPLY=( $( compgen -W 'lgb= cgb= ls= cs= chs= \
5796 cvs=' -- $cur ) )
5797 return 0
5798 ;;
5799 -jpeg)
5800 COMPREPLY=( $( compgen -W 'noprogressive progressive \
5801 nobaseline baseline optimize= \
5802 smooth= quality= outdir=' -- $cur ) )
5803 return 0
5804 ;;
5805 -xvidopts)
5806 COMPREPLY=( $( compgen -W 'dr2 nodr2' -- $cur ) )
5807 return 0
5808 ;;
5809 -xvidencopts)
5810 COMPREPLY=( $( compgen -W 'pass= bitrate= \
5811 fixed_quant= me_quality= 4mv \
5812 rc_reaction_delay_factor= \
5813 rc_averaging_period= rc_buffer= \
5814 quant_range= min_key_interval= \
5815 max_key_interval= mpeg_quant \
5816 mod_quant lumi_mask hintedme \
5817 hintfile debug keyframe_boost= \
5818 kfthreshold= kfreduction=' -- $cur ) )
5819 return 0
5820 ;;
5821 -divx4opts)
5822 COMPREPLY=( $( compgen -W 'br= key= deinterlace q= \
5823 min_quant= max_quant= rc_period= \
5824 rc_reaction_period= crispness= \
5825 rc_reaction_ratio= pass= vbrpass= \
5826 help' -- $cur ) )
5827 return 0
5828 ;;
5829 -info)
5830 COMPREPLY=( $( compgen -W 'name= artist= genre= \
5831 subject= copyright= srcform= \
5832 comment= help' -- $cur ) )
5833 return 0
5834 ;;
5835 -lameopts)
5836 COMPREPLY=( $( compgen -W 'vbr= abr cbr br= q= aq= \
5837 ratio= vol= mode= padding= fast \
5838 preset= help' -- $cur ) )
5839 return 0
5840 ;;
5841 -rawaudio)
5842 COMPREPLY=( $( compgen -W 'on channels= rate= \
5843 samplesize= format=' -- $cur ) )
5844 return 0
5845 ;;
5846 -rawvideo)
5847 COMPREPLY=( $( compgen -W 'on fps= sqcif qcif cif \
5848 4cif pal ntsc w= h= y420 yv12 yuy2 \
5849 y8 format= size=' -- $cur ) )
5850 return 0
5851 ;;
5852 -aop)
5853 COMPREPLY=( $( compgen -W 'list= delay= format= fout= \
5854 volume= mul= softclip' -- $cur ) )
5855 return 0
5856 ;;
5857 -dxr2)
5858 COMPREPLY=( $( compgen -W 'ar-mode= iec958-encoded \
5859 iec958-decoded mute ucode= 75ire bw \
5860 color interlaced macrovision= norm= \
5861 square-pixel ccir601-pixel cr-left= \
5862 cr-right= cr-top= cr-bot= ck-rmin= \
5863 ck-gmin= ck-bmin= ck-rmax= ck-gmax= \
5864 ck-bmax= ck-r= ck-g= ck-b= \
5865 ignore-cache= ol-osd= olh-cor= \
5866 olw-cor= olx-cor= oly-cor= overlay \
5867 overlay-ratio= update-cache' -- $cur ))
5868 return 0
5869 ;;
5870 -tv)
5871 COMPREPLY=( $( compgen -W 'on noaudio driver= device= \
5872 input= freq= outfmt= width= height= \
5873 buffersize= norm= channel= chanlist= \
5874 audiorate= forceaudio alsa amode= \
5875 forcechan= adevice= audioid= volume= \
5876 bass= treble= balance= fps= \
5877 channels= immediatemode=' -- $cur ) )
5878 return 0
5879 ;;
5880 -mf)
5881 COMPREPLY=( $( compgen -W 'on w= h= fps= type=' \
5882 -- $cur ) )
5883 return 0
5884 ;;
5885 -cdda)
5886 COMPREPLY=( $( compgen -W 'speed= paranoia= \
5887 generic-dev= sector-size= overlap= \
5888 toc-bias toc-offset= skip noskip' \
5889 -- $cur ) )
5890 return 0
5891 ;;
5892 -input)
5893 COMPREPLY=( $( compgen -W 'conf= ar-delay ar-rate \
5894 keylist cmdlist js-dev file' -- $cur ) )
5895 return 0
5896 ;;
5897 -af)
5898 COMPREPLY=( $( compgen -W 'resample resample= \
5899 channels channels= format format= \
5900 volume volume= delay delay= pan \
5901 pan= sub sub= surround surround=' \
5902 -- $cur ) )
5903 return 0
5904 ;;
5905 -af-adv)
5906 COMPREPLY=( $( compgen -W 'force= list=' -- $cur ) )
5907 return 0
5908 ;;
5909 esac
5910
5911 case "$cur" in
5912 -*)
5913 COMPREPLY=( $( compgen -W '-aid -alang -audio-demuxer \
5914 -audiofile -cdrom-device -cache -cdda \
5915 -channels -chapter -csslib -demuxer \
5916 -dvd -dvd-device -dvdangle -dvdauth \
5917 -dvdkey -dvdnav -forceidx -fps -frames \
5918 -hr-mp3-seek -idx -mc -mf -ni -nobps \
5919 -passwd -rawaudio -rtsp-stream-over-tcp\
5920 -skipopening -sb -srate -ss -tv -user \
5921 -vcd -vid -vivo -ifo -ffactor -font \
5922 -noautosub -nooverlapsub -sid -slang \
5923 -sub -subcc -subcp -sub-demuxer \
5924 -subdelay -subfont-autoscale \
5925 -subfont-blur -subfont-encoding \
5926 -subfont-osd-scale -subfont-outline \
5927 -subfont-text-scale -subfps -subfile \
5928 -subpos -unicode -utf8 -vobsub \
5929 -vobsubid -ac -afm -aspect -flip \
5930 -lavdopts -noaspect -nosound -pp -ssf \
5931 -stereo -sws -vc -vfm -vop -xvidopts\
5932 -xy -zoom -bandwidth -cuefile \
5933 -noextbased -rawvideo -overlapsub \
5934 -sub-bg-alpha -sub-bg-color -subalign \
5935 -subwidth -sub-no-text-pp -spualign \
5936 -spuaa -spugauss -pphelp -verbose -v \
5937 -noni -noidx -nohr-mp3-seek -extbased \
5938 -bps -oldpp -nozoom -noflip -nounicode \
5939 -noutf8' -- $cur ) )
5940 # add mplayer specific options
5941 [[ "$cmd" == @(?(g)mplayer) ]] && COMPREPLY=( "${COMPREPLY[@]}" \
5942 $(compgen -W '-autoq -autosync -benchmark \
5943 -framedrop -h -help -hardframedrop \
5944 -identify -input -lircconf -loop \
5945 -nojoystick -nolirc -nortc -playlist \
5946 -quiet -really-quiet -rnd -sdp -skin \
5947 -slave -softsleep -speed -sstep \
5948 -use-stdin -dumpaudio -dumpfile \
5949 -dumpstream -dumpvideo -dumpmicrodvdsub\
5950 -dumpmpsub -dumpsrtsub -dumpjacosub \
5951 -dumpsami -dumpsub -osdlevel -af \
5952 -af-adv -ao -aofile -aop -delay -mixer \
5953 -nowaveheader -bpp -brightness \
5954 -contrast -display -double -dr -dxr2 \
5955 -fb -fbmode -fbmodeconfig -forcexv -fs \
5956 -geometry -hue -icelayer -jpeg \
5957 -monitor-dotclock -monitor-hfreq \
5958 -monitor-vfreq -monitoraspect \
5959 -nograbpointer -noslices -panscan \
5960 -rootwin -saturation -screenw -screenh \
5961 -stop-xscreensaver -vm -vo -vsync -wid \
5962 -xineramascreen -z -zrbw -zrcrop \
5963 -zrdev -zrfd -zrhelp -zrnorm -zrquality \
5964 -zrvdec -zrhdec -zrxdoff -zrydoff -y \
5965 -edl -edlout -enqueue -fixed-vo \
5966 -menu -menu-root -menu-cfg -shuffle \
5967 -format -aahelp -dfbopts -fstype \
5968 -guiwid -nokeepaspect -x --help \
5969 -aaosdcolor -aasubcolor -aadriver \
5970 -aaextended -aaeight' -- $cur) )
5971 # add mencoder specific options
5972 [[ "$cmd" = mencoder ]] && COMPREPLY=( "${COMPREPLY[@]}" \
5973 $(compgen -W '-audio-density -audio-delay \
5974 -audio-preload -divx4opts -endpos \
5975 -ffourcc -include -info -lameopts \
5976 -lavcopts -noskip -o -oac -ofps -ovc \
5977 -passlogfile -skiplimit -vobsubout \
5978 -vobsuboutindex -vobsuboutid \
5979 -xvidencopts -of --verbose' -- $cur) )
5980 ;;
5981 *)
5982 _filedir '@(mp?(e)g|MP?(E)G|wm[av]|WM[AV]|avi|AVI|asf|ASF|vob|VOB|bin|BIN|dat|DAT|vcd|VCD|ps|PS|pes|PES|fli|FLI|flv|FLV|viv|VIV|rm?(j)|RM?(J)|ra?(m)|RA?(M)|yuv|YUV|mov|MOV|qt|QT|mp[34]|MP[34]|m4v|M4V|og[gm]|OG[GM]|wav|WAV|dump|DUMP|mk[av]|MK[AV]|m4a|M4A|aac|AAC|m2v|M2V|dv|DV|rmvb|RMVB|mid|MID|ts|TS|3gp|mpc|MPC|flac|FLAC|flv|FLV|divx|DIVX)'
5983 ;;
5984 esac
5985
5986 return 0
5987 }
5988 complete $filenames -F _mplayer mplayer mencoder gmplayer kplayer
5989 }
5990
5991 # KDE dcop completion
5992 #
5993 have dcop &&
5994 _dcop()
5995 {
5996 local cur compstr
5997
5998 COMPREPLY=()
5999 cur=`_get_cword`
6000 if [ -z $cur ]; then
6001 compstr=${COMP_WORDS[*]}
6002 else
6003 compstr=$( command echo ${COMP_WORDS[*]} | sed "s/ $cur$//" )
6004 fi
6005 COMPREPLY=( $( compgen -W '$( command $compstr | sed s/\(.*\)// )' -- $cur ) )
6006 } &&
6007 complete -F _dcop dcop
6008
6009 # wvdial(1) completion
6010 #
6011 have wvdial &&
6012 _wvdial()
6013 {
6014 local cur prev config i IFS=$'\t\n'
6015
6016 COMPREPLY=()
6017 cur=`_get_cword`
6018 prev=${COMP_WORDS[COMP_CWORD-1]}
6019
6020 case $prev in
6021 --config)
6022 _filedir
6023 return 0
6024 ;;
6025 esac
6026
6027 case $cur in
6028 -*)
6029 COMPREPLY=( $( compgen -W '--config --chat \
6030 --remotename --help --version --no-syslog' \
6031 -- $cur ) )
6032 ;;
6033 *)
6034 # start with global and personal config files
6035 config="/etc/wvdial.conf"$'\t'"$HOME/.wvdialrc"
6036 # replace with command line config file if present
6037 for (( i=1; i < COMP_CWORD; i++ )); do
6038 if [[ "${COMP_WORDS[i]}" == "--config" ]]; then
6039 config=${COMP_WORDS[i+1]}
6040 break
6041 fi
6042 done
6043 # parse config files for sections and
6044 # remove default section
6045 COMPREPLY=( $( sed -ne \
6046 "s|^\[Dialer \($cur.*\)\]$|\1|p" \
6047 $config 2>/dev/null |grep -v '^Defaults$'))
6048 # escape spaces
6049 COMPREPLY=${COMPREPLY// /\\ }
6050 ;;
6051 esac
6052
6053 } &&
6054 complete -F _wvdial wvdial
6055
6056 # gpg(1) completion
6057 #
6058 have gpg &&
6059 _gpg()
6060 {
6061 local cur prev
6062
6063 COMPREPLY=()
6064 cur=`_get_cword`
6065 prev=${COMP_WORDS[COMP_CWORD-1]}
6066
6067 case "$prev" in
6068 -@(s|-sign|-clearsign|-decrypt-files|-load-extension))
6069 _filedir
6070 return 0
6071 ;;
6072 --@(export|@(?(l|nr|nrl)sign|edit)-key))
6073 # return list of public keys
6074 COMPREPLY=( $( compgen -W "$( gpg --list-keys 2>/dev/null | sed -ne 's@^pub.*/\([^ ]*\).*\(<\([^>]*\)>\).*$@\1 \3@p')" -- "$cur" ))
6075 return 0
6076 ;;
6077 -@(r|-recipient))
6078 COMPREPLY=( $( compgen -W "$( gpg --list-keys 2>/dev/null | sed -ne 's@^pub.*<\([^>]*\)>.*$@\1@p')" -- "$cur" ))
6079 if [ -e ~/.gnupg/gpg.conf ]; then
6080 COMPREPLY=( "${COMPREPLY[@]}" $( compgen -W "$( sed -ne 's@^[ \t]*group[ \t][ \t]*\([^=]*\).*$@\1@p' ~/.gnupg/gpg.conf )" -- "$cur") )
6081 fi
6082 return 0
6083 ;;
6084 esac
6085
6086 if [[ "$cur" == -* ]]; then
6087 COMPREPLY=( $( compgen -W '-s -b -e -f -c -d -a -r -u -Z -o -v\
6088 -q -n -N $(gpg --dump-options)' -- $cur ) )
6089 fi
6090
6091 } &&
6092 complete -F _gpg $default gpg
6093
6094 # iconv(1) completion
6095 #
6096 have iconv &&
6097 _iconv()
6098 {
6099 local cur prev
6100
6101 COMPREPLY=()
6102 cur=`_get_cword`
6103 prev=${COMP_WORDS[COMP_CWORD-1]}
6104
6105 case "$prev" in
6106 -@(f|t|-@(from|to)-code))
6107 COMPREPLY=( $( compgen -W \
6108 '$( iconv --list | sed -e "s@//@@;" )' -- "$cur" ) )
6109 return 0
6110 ;;
6111 esac
6112
6113
6114 if [[ "$cur" = -* ]]; then
6115 COMPREPLY=( $( compgen -W '--from-code -f --to-code -t --list
6116 --output -o --verbose' -- "$cur" ) )
6117 return 0
6118 fi
6119 } &&
6120 complete -F _iconv $default iconv
6121
6122 # dict(1) completion
6123 #
6124 { have dict || have rdict; } && {
6125 _dictdata()
6126 {
6127 dict $host $port $1 2>/dev/null | sed -ne \
6128 's/^['$'\t '']['$'\t '']*\([^'$'\t '']*\).*$/\1/p'
6129 }
6130
6131 _dict()
6132 {
6133 local cur prev host port db dictfile
6134
6135 COMPREPLY=()
6136 cur=`_get_cword`
6137 prev=${COMP_WORDS[COMP_CWORD-1]}
6138 dictfile=/usr/share/dict/words
6139
6140 for (( i=1; i < COMP_CWORD; i++ )); do
6141 case "${COMP_WORDS[i]}" in
6142 -@(h|--host))
6143 host=${COMP_WORDS[i+1]}
6144 [ -n "$host" ] && host="-h $host"
6145 i=$((++i))
6146 ;;
6147 -@(p|-port))
6148 port=${COMP_WORDS[i+1]}
6149 [ -n "$port" ] && port="-p $port"
6150 i=$((++i))
6151 ;;
6152 -@(d|-database))
6153 db=${COMP_WORDS[i+1]}
6154 [ -n "$db" ] && host="-d $db"
6155 i=$((++i))
6156 ;;
6157 *)
6158 ;;
6159 esac
6160 done
6161
6162 if [[ "$cur" = -* ]]; then
6163 COMPREPLY=( $( compgen -W '-h --host -p --port -d --database \
6164 -m --match -s --strategy -c --config -C \
6165 --nocorrect -D --dbs -S --strats -H \
6166 --serverhelp -i --info -I --serverinfo \
6167 -a --noauth -u --user -k --key -V --version \
6168 -L --license --help -v --verbose -r --raw \
6169 -P --pager --debug --html --pipesize --client' \
6170 -- "$cur" ) )
6171 return 0
6172 fi
6173
6174 case "$prev" in
6175 -@(d|-database|i|info))
6176 COMPREPLY=( $( compgen -W '$( _dictdata -D )' -- "$cur" ) )
6177 return 0
6178 ;;
6179 -@(s|-strategy))
6180 COMPREPLY=( $( compgen -W '$( _dictdata -S )' -- "$cur" ) )
6181 return 0
6182 ;;
6183 *)
6184 ;;
6185 esac
6186
6187 [ -r $dictfile ] && \
6188 COMPREPLY=( $( compgen -W '$( cat $dictfile )' -- "$cur" ) )
6189 }
6190 complete -F _dict $default dict rdict
6191 }
6192
6193 # cdrecord(1) completion
6194 #
6195 have cdrecord &&
6196 _cdrecord()
6197 {
6198 local cur prev i generic_options track_options track_mode
6199
6200 COMPREPLY=()
6201 cur=`_get_cword`
6202 prev=${COMP_WORDS[COMP_CWORD-1]}
6203
6204 # foo=bar style option
6205 if [[ "$cur" == *=* ]]; then
6206 prev=${cur/=*/}
6207 cur=${cur/*=/}
6208 case "$prev" in
6209 @(text|cue)file)
6210 _filedir
6211 return 0
6212 ;;
6213 blank)
6214 COMPREPLY=( $( compgen -W 'help all fast \
6215 track unreserve trtail unclose session' \
6216 -- $cur ) )
6217 return 0
6218 ;;
6219 driveropts)
6220 COMPREPLY=( $( compgen -W 'burnfree noburnfree\
6221 varirec= audiomaster forcespeed noforcespeed\
6222 speedread nospeedread singlesession \
6223 nosinglesession hidecdr nohidecdr tattooinfo\
6224 tattoofile=' -- $cur ) )
6225 return 0
6226 ;;
6227 esac
6228 fi
6229
6230 generic_options=(-version -v -V -d -silent -s -force -immed -dummy \
6231 -dao -raw -raw96r -raw96p -raw16 -multi -msinfo -toc \
6232 -atip -fix -nofix -waiti -load -lock -eject -format \
6233 -setdropts -checkdrive -prcap -inq -scanbus -reset \
6234 -abort -overburn -ignsize -useinfo -packet -noclose \
6235 -text debug= kdebug= kd= minbuf= speed= blank= fs= \
6236 dev= gracetime= timeout= driver= driveropts= \
6237 defpregap= pktsize= mcn= textfile= cuefile=)
6238 track_options=(-audio -swab -data -mode2 -xa -xa1 -xa2 -xamix -cdi \
6239 -isosize -pad padsize= -nopad -shorttrack -noshorttrack\
6240 pregap= -preemp -nopreemp -copy -nocopy -scms tcsize= \
6241 isrc= index=)
6242 # look if previous was either a file or a track option
6243 track_mode=0
6244 if [ $COMP_CWORD -gt 1 ]; then
6245 if [ -f "$prev" ]; then
6246 track_mode=1
6247 else
6248 for (( i=0; i < ${#track_options[@]}; i++ )); do
6249 if [[ "${track_options[i]}" == "$prev" ]]; then
6250 track_mode=1
6251 break
6252 fi
6253 done
6254 fi
6255 fi
6256
6257 # files are always eligible completion
6258 _filedir
6259 # track options are always available
6260 COMPREPLY=( "${COMPREPLY[@]}" $( compgen -W '${track_options[@]}' -- $cur ) )
6261 # general options are no more available after file or track option
6262 if [ $track_mode -eq 0 ]; then
6263 COMPREPLY=( "${COMPREPLY[@]}" \
6264 $( compgen -W '${generic_options[@]}' -- $cur ) )
6265 fi
6266
6267 } &&
6268 complete -F _cdrecord $filenames cdrecord
6269
6270 # mkisofs(8) completion
6271 #
6272 have mkisofs &&
6273 _mkisofs()
6274 {
6275 local cur prev
6276
6277 COMPREPLY=()
6278 cur=`_get_cword`
6279 prev=${COMP_WORDS[COMP_CWORD-1]}
6280
6281 case "$prev" in
6282 -@(o|abstract|biblio|check-session|copyright|log-file|root-info|prep-boot|*-list))
6283 _filedir
6284 return 0
6285 ;;
6286 -*-charset)
6287 COMPREPLY=( $( mkisofs -input-charset help 2>&1 | \
6288 tail +3 | grep "^$cur") )
6289 return 0
6290 ;;
6291 -uid)
6292 _uids
6293 return 0
6294 ;;
6295 -gid)
6296 _gids
6297 return 0
6298 ;;
6299 esac
6300
6301 if [[ "$cur" == -* ]]; then
6302 COMPREPLY=( $( compgen -W '-abstract -A -allow-lowercase \
6303 -allow-multidot -biblio -cache-inodes \
6304 -no-cache-inodes -b -eltorito-alt-boot -B -G \
6305 -hard-disk-boot -no-emul-boot -no-boot \
6306 -boot-load-seg -boot-load-size \
6307 -boot-info-table -C -c -check-oldname \
6308 -check-session -copyright -d -D -dir-mode \
6309 -dvd-video -f -file-mode -gid -gui \
6310 -graft-points -hide -hide-list -hidden \
6311 -hidden-list -hide-joliet -hide-joliet-list \
6312 -hide-joliet-trans-tbl -hide-rr-moved \
6313 -input-charset -output-charset -iso-level -J \
6314 -joliet-long -jcharset -l -L -log-file -m \
6315 -exclude-list -max-iso9660-filenames -M -N \
6316 -new-dir-mode -nobak -no-bak -force-rr -no-rr \
6317 -no-split-symlink-components \
6318 -no-split-symlink-fields -o -pad -no-pad \
6319 -path-list -P -p -print-size -quiet -R -r \
6320 -relaxed-filenames -sort -split-output \
6321 -stream-media-size -stream-file-name -sysid -T\
6322 -table-name -ucs-level -udf -uid \
6323 -use-fileversion -U -no-iso-translate -V \
6324 -volset -volset-size -volset-seqno -v -x -z \
6325 -hfs -apple -map -magic -hfs-creator \
6326 -hfs-type -probe -no-desktop -mac-name \
6327 -boot-hfs-file -part -auto -cluster-size \
6328 -hide-hfs -hide-hfs-list -hfs-volid \
6329 -icon-position -root-info -prep-boot \
6330 -input-hfs-charset -output-hfs-charset \
6331 -hfs-unlock -hfs-bless -hfs-parms --cap \
6332 --netatalk --double --ethershare --ushare \
6333 --exchange --sgi --xinet --macbin --single \
6334 --dave --sfm --osx-double --osx-hfs' -- $cur ))
6335 else
6336 _filedir
6337 fi
6338
6339 } &&
6340 complete -F _mkisofs $filenames mkisofs
6341
6342 # mc(1) completion
6343 #
6344 have mc &&
6345 _mc()
6346 {
6347 local cur prev
6348
6349 COMPREPLY=()
6350 cur=`_get_cword`
6351 prev=${COMP_WORDS[COMP_CWORD-1]}
6352
6353 # -name value style option
6354 case "$prev" in
6355 -@(e|v|l|P))
6356 _filedir
6357 return 0
6358 ;;
6359 esac
6360
6361 # --name=value style option
6362 if [[ "$cur" == *=* ]]; then
6363 prev=${cur/=*/}
6364 cur=${cur/*=/}
6365 case "$prev" in
6366 --@(edit|view|ftplog|printwd))
6367 _filedir
6368 return 0
6369 ;;
6370 esac
6371 fi
6372
6373 if [[ "$cur" == -* ]]; then
6374 COMPREPLY=( $( compgen -W '-a --stickchars -b --nocolor -c \
6375 --color -C --colors= -d --nomouse -e --edit= -f \
6376 --datadir -k --resetsoft -l --ftplog= -P --printwd= \
6377 -s --slow -t --termcap -u --nosubshell -U --subshell \
6378 -v --view= -V --version -x --xterm -h --help' -- $cur ) )
6379 else
6380 _filedir -d
6381 fi
6382 } &&
6383 complete -F _mc $filenames mc
6384
6385 # yum(8) completion
6386 #
6387 have yum && {
6388 _yum()
6389 {
6390 local cur prev special
6391
6392 COMPREPLY=()
6393 cur=`_get_cword`
6394 prev=${COMP_WORDS[COMP_CWORD-1]}
6395
6396 for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
6397 if [[ ${COMP_WORDS[i]} == @(install|update|upgrade|remove|erase|deplist) ]]; then
6398 special=${COMP_WORDS[i]}
6399 fi
6400 done
6401
6402 if [ -n "$special" ]; then
6403 case $special in
6404 install|deplist)
6405 COMPREPLY=( $( compgen -W '$( yum -C list | cut -d" " -f1 )' -- $cur ) )
6406 return 0
6407 ;;
6408 *)
6409 _rpm_installed_packages
6410 return 0
6411 ;;
6412 esac
6413 fi
6414
6415 case $cur in
6416 --*)
6417 COMPREPLY=( $( compgen -W '--installroot --version --help --enablerepo --disablerepo --exclude --obsoletes --noplugins' -- $cur ) )
6418 return 0
6419 ;;
6420 -*)
6421 COMPREPLY=( $( compgen -W '-c -e -d -y -t -R -C -h' -- $cur ) )
6422 return 0
6423 ;;
6424 esac
6425
6426 case $prev in
6427 list)
6428 COMPREPLY=( $( compgen -W 'all available updates installed extras obsoletes recent' -- $cur ) )
6429 ;;
6430 clean)
6431 COMPREPLY=( $( compgen -W 'packages headers metadata cache dbcache all' -- $cur ) )
6432 ;;
6433 localinstall)
6434 _filedir rpm
6435 ;;
6436 -c)
6437 _filedir
6438 ;;
6439 --installroot)
6440 _filedir -d
6441 ;;
6442 *)
6443 COMPREPLY=( $( compgen -W 'install update check-update upgrade remove list \
6444 search info provides clean groupinstall groupupdate \
6445 grouplist deplist erase groupinfo groupremove \
6446 localinstall localupdate makecache resolvedep \
6447 shell whatprovides' -- $cur ) )
6448 ;;
6449 esac
6450 }
6451 complete -F _yum $filenames yum
6452
6453 # yum-arch(8) completion
6454 #
6455 _yum_arch()
6456 {
6457 local cur
6458 COMPREPLY=()
6459 cur=`_get_cword`
6460
6461 case "$cur" in
6462 -*)
6463 COMPREPLY=( $( compgen -W '-d -v -vv -n -c -z -s -l -q' -- $cur ) )
6464 ;;
6465 *)
6466 _filedir -d
6467 ;;
6468 esac
6469
6470 return 0
6471
6472 }
6473 complete -F _yum_arch $filenames yum-arch
6474 }
6475
6476 # ImageMagick completion
6477 #
6478 have convert && {
6479 _ImageMagick()
6480 {
6481 local prev
6482 prev=${COMP_WORDS[COMP_CWORD-1]}
6483
6484 case "$prev" in
6485 -channel)
6486 COMPREPLY=( $( compgen -W 'Red Green Blue Opacity \
6487 Matte Cyan Magenta Yellow Black' -- $cur ) )
6488 return 0
6489 ;;
6490 -colormap)
6491 COMPREPLY=( $( compgen -W 'shared private' -- $cur ) )
6492 return 0
6493 ;;
6494 -colorspace)
6495 COMPREPLY=( $( compgen -W 'GRAY OHTA RGB Transparent \
6496 XYZ YCbCr YIQ YPbPr YUV CMYK' -- $cur ) )
6497 return 0
6498 ;;
6499 -compose)
6500 COMPREPLY=( $( compgen -W 'Over In Out Atop Xor Plus \
6501 Minus Add Subtract Difference Multiply Bumpmap\
6502 Copy CopyRed CopyGreen CopyBlue CopyOpacity' \
6503 -- $cur ) )
6504 return 0
6505 ;;
6506 -compress)
6507 COMPREPLY=( $( compgen -W 'None BZip Fax Group4 JPEG \
6508 Lossless LZW RLE Zip' -- $cur ) )
6509 return 0
6510 ;;
6511 -dispose)
6512 COMPREPLY=( $( compgen -W 'Undefined None Background \
6513 Previous' -- $cur ) )
6514 return 0
6515 ;;
6516 -encoding)
6517 COMPREPLY=( $( compgen -W 'AdobeCustom AdobeExpert \
6518 AdobeStandard AppleRoman BIG5 GB2312 Latin2 \
6519 None SJIScode Symbol Unicode Wansung' -- $cur))
6520 return 0
6521 ;;
6522 -endian)
6523 COMPREPLY=( $( compgen -W 'MSB LSB' -- $cur ) )
6524 return 0
6525 ;;
6526 -filter)
6527 COMPREPLY=( $( compgen -W 'Point Box Triangle Hermite \
6528 Hanning Hamming Blackman Gaussian Quadratic \
6529 Cubic Catrom Mitchell Lanczos Bessel Sinc' \
6530 -- $cur ) )
6531 return 0
6532 ;;
6533 -format)
6534 COMPREPLY=( $( convert -list format | \
6535 awk '/ [r-][w-][+-] / {print $1}' | \
6536 tr -d '*' | tr [:upper:] [:lower:] | \
6537 grep "^$cur" ) )
6538 return 0
6539 ;;
6540 -gravity)
6541 COMPREPLY=( $( compgen -W 'Northwest North NorthEast \
6542 West Center East SouthWest South SouthEast' \
6543 -- $cur ) )
6544 return 0
6545 ;;
6546 -intent)
6547 COMPREPLY=( $( compgen -W 'Absolute Perceptual \
6548 Relative Saturation' -- $cur ) )
6549 return 0
6550 ;;
6551 -interlace)
6552 COMPREPLY=( $( compgen -W 'None Line Plane Partition' \
6553 -- $cur ) )
6554 return 0
6555 ;;
6556 -limit)
6557 COMPREPLY=( $( compgen -W 'Disk File Map Memory' \
6558 -- $cur ) )
6559 return 0
6560 ;;
6561 -list)
6562 COMPREPLY=( $( compgen -W 'Delegate Format Magic \
6563 Module Resource Type' -- $cur ) )
6564 return 0
6565 ;;
6566 -map)
6567 COMPREPLY=( $( compgen -W 'best default gray red \
6568 green blue' -- $cur ) )
6569 _filedir
6570 return 0
6571 ;;
6572 -noise)
6573 COMPREPLY=( $( compgen -W 'Uniform Gaussian \
6574 Multiplicative \
6575 Impulse Laplacian Poisson' -- $cur ) )
6576 return 0
6577 ;;
6578 -preview)
6579 COMPREPLY=( $( compgen -W 'Rotate Shear Roll Hue \
6580 Saturation Brightness Gamma Spiff \
6581 Dull Grayscale Quantize Despeckle \
6582 ReduceNoise AddNoise Sharpen Blur \
6583 Treshold EdgeDetect Spread Shade \
6584 Raise Segment Solarize Swirl Implode \
6585 Wave OilPaint CharcoalDrawing JPEG' \
6586 -- $cur ) )
6587 return 0
6588 ;;
6589 -@(mask|profile|texture|tile|write))
6590 _filedir
6591 return 0
6592 ;;
6593 -type)
6594 COMPREPLY=( $( compgen -W 'Bilevel Grayscale Palette \
6595 PaletteMatte TrueColor TrueColorMatte \
6596 ColorSeparation ColorSeparationlMatte \
6597 Optimize' -- $cur ) )
6598 return 0
6599 ;;
6600 -units)
6601 COMPREPLY=( $( compgen -W 'Undefined PixelsPerInch \
6602 PixelsPerCentimeter' -- $cur ) )
6603 return 0
6604 ;;
6605 -virtual-pixel)
6606 COMPREPLY=( $( compgen -W 'Constant Edge mirror tile' \
6607 -- $cur ) )
6608 return 0
6609 ;;
6610 -visual)
6611 COMPREPLY=( $( compgen -W 'StaticGray GrayScale \
6612 StaticColor PseudoColor TrueColor \
6613 DirectColor defaut visualid' -- $cur ))
6614 return 0
6615 ;;
6616 esac
6617 }
6618
6619 _convert()
6620 {
6621 local cur
6622
6623 COMPREPLY=()
6624 cur=`_get_cword`
6625
6626 _ImageMagick
6627
6628 if [[ "$cur" == -* ]]; then
6629 COMPREPLY=( $( compgen -W '-adjoin -affine -antialias -append \
6630 -authenticate -average -background -black-threshold \
6631 -blue-primary -blur -border -bordercolor -channel \
6632 -charcoal -chop -clip -coalesce -colorize -colors \
6633 -colorspace -comment -compress -contrast -convolve \
6634 -crop -cycle -debug -deconstruct -delay -density \
6635 -depth -despeckle -display -dispose -dither -draw \
6636 -edge -emboss -encoding -endian -enhance -equalize \
6637 -extract -fill -filter -flatten -flip -flop -font \
6638 -frame -fuzz -gamma -gaussian -geometry \
6639 -green-primary -gravity -help -implode -intent \
6640 -interlace -label -lat -level -limit -list -log -loop \
6641 -map -mask -matte -median -modulate -monochrome \
6642 -morph -mosaic -negate -noop -noise -normalize \
6643 -opaque -ordered-dither -page -paint -ping -pointsize \
6644 -preview -profile -quality -raise -random-threshold \
6645 -region -raise -red-primary -render -resize -resample \
6646 -roll -rotate -sample -sampling-factor -scale -scene \
6647 -seed -segment -shade -sharpen -shave -shear -size \
6648 -solarize -spread -stroke -strokewidth -swirl \
6649 -texture -threshold -thumbnail -tile -transform \
6650 -transparent -treedepth -trim -type -undercolor \
6651 -units -unsharp -verbose -version -view \
6652 -virtual-pixel -wave -white-point -white-threshold \
6653 -write' -- $cur ) )
6654 elif [[ "$cur" == +* ]]; then
6655 COMPREPLY=( $( compgen -W '+adjoin +append +compress \
6656 +contrast +debug +dither +endian +gamma +label +map \
6657 +mask +matte +negate +noise +page +raise +render \
6658 +write' -- $cur ) )
6659 else
6660 _filedir
6661 fi
6662 }
6663 complete -F _convert $filenames convert
6664
6665 _mogrify()
6666 {
6667 local cur
6668
6669 COMPREPLY=()
6670 cur=`_get_cword`
6671
6672 _ImageMagick
6673
6674 if [[ "$cur" == -* ]]; then
6675 COMPREPLY=( $( compgen -W '-affine -antialias -authenticate \
6676 -background -black-threshold -blue-primary -blur \
6677 -border -bordercolor -channel -charcoal -chop \
6678 -colorize -colors -colorspace -comment -compress \
6679 -contrast -convolve -crop -cycle -debug -delay \
6680 -density -depth -despeckle -display -dispose -dither \
6681 -draw -edge -emboss -encoding -endian -enhance \
6682 -equalize -extract -fill -filter -flip -flop -font \
6683 -format -frame -fuzz -gamma -gaussian -geometry \
6684 -green-primary -implode -interlace -help -label -lat \
6685 -level -limit -list -log -loop -map -mask -matte \
6686 -median -modulate -monochrome -negate -noop \
6687 -normalize -opaque -page -paint -fill -ordered-dither \
6688 -pointsize -profile -quality -raise -random-threshold \
6689 -red-primary -region -resample -resize -roll -rotate \
6690 -sample -sampling-factor -scale -scene -seed -segment \
6691 -shade -sharpen -shear -size -solarize -spread \
6692 -stroke -strokewidth -swirl -texture -threshold \
6693 -thumbnail -tile -transform -transparent -treedepth \
6694 -trim -type -undercolor -units -unsharp -verbose \
6695 -version -view -virtual-pixel -wave -white-point \
6696 -white-threshold' -- $cur ) )
6697 elif [[ "$cur" == +* ]]; then
6698 COMPREPLY=( $( compgen -W '+compress +contrast +debug +dither \
6699 +endian +gamma +label +map +mask +matte +negate +page \
6700 +raise' -- $cur ) )
6701 else
6702 _filedir
6703 fi
6704 }
6705 complete -F _mogrify $filenames mogrify
6706
6707 _display()
6708 {
6709 local cur
6710
6711 COMPREPLY=()
6712 cur=`_get_cword`
6713
6714 _ImageMagick
6715
6716 if [[ "$cur" == -* ]]; then
6717 COMPREPLY=( $( compgen -W '-authenticate -backdrop -border \
6718 -colormap -colors -colorspace -comment -compress \
6719 -contrast -crop -debug -delay -density -depth \
6720 -despeckle -display -dispose -dither -edge -endian \
6721 -enhance -extract -filter -flip -flop -frame -gamma \
6722 -geometry -help -immutable -interlace -label -limit \
6723 -log -map -matte -monochrome -negate -noop -page \
6724 -quality -raise -remote -roll -rotate -sample \
6725 -sampling-factor -scene -segment -sharpen -size \
6726 -texture -treedepth -trim -update -verbose -version \
6727 -virtual-pixel -window -window_group -write' -- $cur))
6728 elif [[ "$cur" == +* ]]; then
6729 COMPREPLY=( $( compgen -W '+compress +contrast +debug +dither \
6730 +endian +gamma +label +map +matte +negate +page \
6731 +raise +write' -- $cur ) )
6732 else
6733 _filedir
6734 fi
6735 }
6736 complete -F _display $filenames display
6737
6738 _animate()
6739 {
6740 local cur
6741
6742 COMPREPLY=()
6743 cur=`_get_cword`
6744
6745 _ImageMagick
6746
6747 if [[ "$cur" == -* ]]; then
6748 COMPREPLY=( $( compgen -W '-authenticate -backdrop -colormap \
6749 -colors -colorspace -crop -debug -delay -density \
6750 -depth -display -dither -extract -gamma -geometry \
6751 -help -interlace -limit -log -matte -map -monochrome \
6752 -noop -pause -remote -rotate -sampling-factor -scene \
6753 -size -treedepth -trim -verbose -version -visual \
6754 -virtual-pixel -window' -- $cur ) )
6755 elif [[ "$cur" == +* ]]; then
6756 COMPREPLY=( $( compgen -W '+debug +dither +gamma +map +matte' -- $cur ) )
6757 else
6758 _filedir
6759 fi
6760 }
6761 complete -F _animate $filenames animate
6762
6763 _identify()
6764 {
6765 local cur
6766
6767 COMPREPLY=()
6768 cur=`_get_cword`
6769
6770 _ImageMagick
6771
6772 if [[ "$cur" == -* ]]; then
6773 COMPREPLY=( $( compgen -W '-authenticate -debug -density \
6774 -depth -extract -format -help -interlace -limit -list \
6775 -log -size -sampling-factor -verbose -version \
6776 -virtual-pixel' -- $cur ) )
6777 elif [[ "$cur" == +* ]]; then
6778 COMPREPLY=( $( compgen -W '+debug ' -- $cur ) )
6779 else
6780 _filedir
6781 fi
6782 }
6783 complete -F _identify $filenames identify
6784
6785 _montage()
6786 {
6787 local cur
6788
6789 COMPREPLY=()
6790 cur=`_get_cword`
6791
6792 _ImageMagick
6793
6794 if [[ "$cur" == -* ]]; then
6795 COMPREPLY=( $( compgen -W '-adjoin -affine -authenticate \
6796 -blue-primary -blur -colors -colorspace -comment \
6797 -compose -compress -crop -debug -density -depth \
6798 -display -dispose -dither -draw -encoding -endian \
6799 -extract -fill -filter -flip -flop -frame -gamma \
6800 -geometry -gravity -green-primary -interlace -help \
6801 -label -limit -log -matte -mode -monochrome -noop \
6802 -page -pointsize -quality -red-primary -resize \
6803 -rotate -sampling-factor -scene -shadow -size \
6804 -stroke -texture -thumbnail -tile -transform \
6805 -transparent -treedepth -trim -type -verbose \
6806 -version -virtual-pixel -white-point' -- $cur ) )
6807 elif [[ "$cur" == +* ]]; then
6808 COMPREPLY=( $( compgen -W '+adjoin +compress +debug +dither \
6809 +endian +gamma +label +matte +page' -- $cur ) )
6810 else
6811 _filedir
6812 fi
6813 }
6814 complete -F _montage $filenames montage
6815
6816 _composite()
6817 {
6818 local cur
6819
6820 COMPREPLY=()
6821 cur=`_get_cword`
6822
6823 _ImageMagick
6824
6825 if [[ "$cur" == -* ]]; then
6826 COMPREPLY=( $( compgen -W '-affine -authenticate \
6827 -blue-primary -colors -colorspace -comment -compose \
6828 -compress -debug -density -depth -displace -display \
6829 -dispose -dissolve -dither -encoding -endian -extract \
6830 -filter -font -geometry -gravity -green-primary -help \
6831 -interlace -label -limit -log -matte -monochrome \
6832 -negate -page -profile -quality -red-primary -rotate \
6833 -resize -sampling-factor -scene -sharpen -size \
6834 -stegano -stereo -thumbnail -tile -transform \
6835 -treedepth -type -units -unsharp -verbose -version \
6836 -virtual-pixel -watermark -white-point -write' \
6837 -- $cur ) )
6838 elif [[ "$cur" == +* ]]; then
6839 COMPREPLY=( $( compgen -W '+compress +debug +dither +endian +label \
6840 +matte +negate +page +write' -- $cur ) )
6841 else
6842 _filedir
6843 fi
6844 }
6845 complete -F _composite $filenames composite
6846 }
6847
6848 # dd(1) completion
6849 #
6850 have dd &&
6851 _dd()
6852 {
6853 local cur
6854
6855 COMPREPLY=()
6856 cur=`_get_cword`
6857
6858 case "$cur" in
6859 if=*|of=*)
6860 cur=${cur#*=}
6861 _filedir
6862 return 0
6863 ;;
6864 conv=*)
6865 cur=${cur#*=}
6866 COMPREPLY=( $( compgen -W 'ascii ebcdic ibm block unblock \
6867 lcase notrunc ucase swab noerror sync' \
6868 -- $cur ) )
6869 return 0
6870 ;;
6871 esac
6872
6873 _expand || return 0
6874
6875 COMPREPLY=( $( compgen -W '--help --version' -- $cur ) \
6876 $( compgen -W 'bs cbs conv count ibs if obs of seek skip'\
6877 -S '=' -- $cur ) )
6878 } &&
6879 complete -F _dd $nospace $filenames dd
6880
6881 # CUPS cancel(1) completion
6882 #
6883 have cancel &&
6884 _cancel()
6885 {
6886 local cur
6887
6888 COMPREPLY=()
6889 cur=`_get_cword`
6890
6891 COMPREPLY=( $( lpstat | cut -d' ' -f1 | grep "^$cur" ) )
6892 } &&
6893 complete -F _cancel $filenames cancel
6894
6895 # aspell(1) completion
6896 #
6897 have aspell && {
6898 _aspell_dictionary()
6899 {
6900 local datadir
6901 datadir=/usr/lib/aspell
6902 COMPREPLY=( $( command ls $datadir/*.@(multi|alias) ) )
6903 COMPREPLY=( ${COMPREPLY[@]%.@(multi|alias)} )
6904 COMPREPLY=( $( compgen -W '${COMPREPLY[@]#$datadir/}' -- $cur ) )
6905 }
6906
6907 _aspell()
6908 {
6909 local cur prev
6910
6911 COMPREPLY=()
6912 cur=`_get_cword`
6913 prev=${COMP_WORDS[COMP_CWORD-1]}
6914
6915 # --name value style option
6916 case "$prev" in
6917 @(-c|-p|check))
6918 _filedir
6919 return 0
6920 ;;
6921 @(dump|create|merge))
6922 COMPREPLY=( $( compgen -W 'master personal repl' -- $cur ) )
6923 return 0
6924 ;;
6925 -d)
6926 _aspell_dictionary
6927 return 0
6928 ;;
6929 esac
6930
6931 # --name=value style option
6932 if [[ "$cur" == *=* ]]; then
6933 prev=${cur/=*/}
6934 cur=${cur/*=/}
6935 case "$prev" in
6936 --@(conf|personal|repl|per-conf))
6937 _filedir
6938 return 0
6939 ;;
6940 --@(conf-dir|data-dir|dict-dir|home-dir|local-data-dir|prefix))
6941 _filedir -d
6942 return 0
6943 ;;
6944 --master)
6945 _aspell_dictionary
6946 return 0
6947 ;;
6948 --mode)
6949 COMPREPLY=( $( compgen -W 'none url email sgml tex' -- $cur ) )
6950 return 0
6951 ;;
6952 --sug-mode)
6953 COMPREPLY=( $( compgen -W 'ultra fast normal bad-speller' -- $cur ) )
6954 return 0
6955 ;;
6956 --keymapping)
6957 COMPREPLY=( $( compgen -W 'aspell ispell' -- $cur ) )
6958 return 0
6959 ;;
6960 esac
6961 fi
6962
6963 if [[ "$cur" == -* ]]; then
6964 COMPREPLY=( $( compgen -W '--conf= --conf-dir= --data-dir= --dict-dir= \
6965 --encoding= --add-filter= --rem-filter= --mode= -e \
6966 -H -t --add-extra-dicts= --rem-extra-dicts= \
6967 --home-dir= -W --ignore= --ignore-accents \
6968 --dont-ignore-accents --ignore-case --dont-ignore-case \
6969 --ignore-repl --dont-ignore-repl --jargon= --keyboard= \
6970 --lang= --language-tag= --local-data-dir= -d --master= \
6971 --module= --add-module-search-order= \
6972 --rem-module-search-order= --per-conf= -p --personal= \
6973 --prefix= --repl= -C -B --run-together --dont-run-together \
6974 --run-together-limit= --run-together-min= --save-repl \
6975 --dont-save-repl --set-prefix --dont-set-prefix --size= \
6976 --spelling= --strip-accents --dont-strip-accents \
6977 --sug-mode= --add-word-list-path= --rem-word-list-path= \
6978 -b -x --backup -b|-x --dont-backup --reverse --dont-reverse \
6979 --time --dont-time --keymapping= --add-email-quote= \
6980 --rem-email-quote= --email-margin= --add-tex-command= \
6981 --rem-tex-command= --tex-check-comments \
6982 --dont-tex-check-comments --add-tex-extension= \
6983 --rem-tex-extension= --add-sgml-check= --rem-sgml-check= \
6984 --add-sgml-extension= --rem-sgml-extension=' -- $cur ) )
6985 else
6986 COMPREPLY=( $( compgen -W '-? help -c check -a pipe -l list \
6987 config config soundslike filter -v version dump \
6988 create merge' -- $cur ) )
6989 fi
6990
6991 }
6992 complete -F _aspell $filenames aspell
6993 }
6994
6995 # xmms(1) completion
6996 #
6997 have xmms &&
6998 _xmms()
6999 {
7000 local cur
7001
7002 COMPREPLY=()
7003 cur=`_get_cword`
7004
7005 if [[ "$cur" == -* ]]; then
7006 COMPREPLY=( $( compgen -W '-h --help -r --rew -p --play \
7007 -u --pause -s --stop -t --play-pause -f --fwd -e \
7008 --enqueue -m --show-main-window -i --sm-client-id \
7009 -v --version' -- $cur ) )
7010 else
7011 _filedir '@(mp[23]|MP[23]|ogg|OGG|wav|WAV|pls|m3u|xm|mod|s[3t]m|it|mtm|ult|flac)'
7012
7013 fi
7014
7015 } &&
7016 complete -F _xmms $filenames xmms
7017
7018 # info(1) completion
7019 #
7020 have info &&
7021 _info()
7022 {
7023 local cur infopath UNAME
7024
7025 COMPREPLY=()
7026 cur=`_get_cword`
7027
7028 _expand || return 0
7029
7030 # default completion if parameter contains /
7031 if [[ "$cur" == */* ]]; then
7032 _filedir
7033 return 0
7034 fi
7035
7036 infopath='/usr/share/info'
7037
7038 if [ "${INFOPATH: -1:1}" == ':' ]; then
7039 infopath=${INFOPATH}${infopath}
7040 elif [ ${INFOPATH:+set} ]; then
7041 infopath=$INFOPATH
7042 fi
7043
7044 infopath=$infopath:
7045 if [ -n "$cur" ]; then
7046 infopath="${infopath//://$cur* }"
7047 else
7048 infopath="${infopath//:// }"
7049 fi
7050
7051 # redirect stderr for when path doesn't exist
7052 COMPREPLY=( $( eval command ls "$infopath" 2>/dev/null ) )
7053 # weed out directory path names and paths to info pages
7054 COMPREPLY=( ${COMPREPLY[@]##*/?(:)} )
7055 # weed out info dir file
7056 for (( i=0 ; i < ${#COMPREPLY[@]} ; ++i )); do
7057 if [ "${COMPREPLY[$i]}" == 'dir' ]; then
7058 unset COMPREPLY[$i];
7059 fi;
7060 done
7061 # strip suffix from info pages
7062 COMPREPLY=( ${COMPREPLY[@]%.@(gz|bz2)} )
7063 COMPREPLY=( $( compgen -W '${COMPREPLY[@]%.*}' -- "${cur//\\\\/}" ) )
7064
7065 return 0
7066 } &&
7067 complete -F _info $filenames info
7068
7069 # dhclient(1) completion
7070 #
7071 have dhclient && _dhclient()
7072 {
7073 local cur prev
7074
7075 COMPREPLY=()
7076 cur=`_get_cword`
7077 prev=${COMP_WORDS[COMP_CWORD-1]}
7078
7079 case "$prev" in
7080 -@(cf|lf|pf|sf))
7081 _filedir
7082 return 0
7083 ;;
7084 -s)
7085 _known_hosts
7086 return 0
7087 ;;
7088 esac
7089
7090 if [[ "$cur" == -* ]]; then
7091 COMPREPLY=( $( compgen -W '-p -d -q -1 -r -lf -pf \
7092 -cf -sf -s -g -n -nw -w' -- $cur ) )
7093 else
7094 _available_interfaces
7095 fi
7096 } &&
7097 complete -F _dhclient dhclient
7098
7099 # lvm(8) completion
7100 #
7101 have lvm && {
7102 _volumegroups()
7103 {
7104 COMPREPLY=( $(compgen -W "$( vgscan 2>/dev/null | \
7105 sed -n -e 's|.*Found.*"\(.*\)".*$|\1|p' )" -- $cur ) )
7106 }
7107
7108 _physicalvolumes()
7109 {
7110 COMPREPLY=( $(compgen -W "$( pvscan 2>/dev/null | \
7111 sed -n -e 's|^.*PV \(.*\) VG.*$|\1|p' )" -- $cur ) )
7112 }
7113
7114 _logicalvolumes()
7115 {
7116 COMPREPLY=( $(compgen -W "$( lvscan 2>/dev/null | \
7117 sed -n -e "s|^.*'\(.*\)'.*$|\1|p" )" -- $cur ) )
7118 }
7119
7120 _units()
7121 {
7122 COMPREPLY=( $( compgen -W 'h s b k m g t H K M G T' -- $cur ) )
7123 }
7124
7125 _sizes()
7126 {
7127 COMPREPLY=( $( compgen -W 'k K m M g G t T' -- $cur ) )
7128 }
7129
7130 _args()
7131 {
7132 args=0
7133 if [[ "${COMP_WORDS[0]}" == lvm ]]; then
7134 offset=2
7135 else
7136 offset=1
7137 fi
7138 for (( i=$offset; i < COMP_CWORD; i++ )); do
7139 if [[ "${COMP_WORDS[i]}" != -* ]]; then
7140 args=$(($args + 1))
7141 fi
7142 done
7143 }
7144
7145 _lvmdiskscan()
7146 {
7147 local cur
7148
7149 COMPREPLY=()
7150 cur=`_get_cword`
7151
7152 if [[ "$cur" == -* ]]; then
7153 COMPREPLY=( $( compgen -W '-d --debug -h -? --help -l \
7154 --lvmpartition -v --verbose --version' -- $cur ) )
7155 fi
7156 }
7157 complete -F _lvmdiskscan lvmdiskscan
7158
7159 _pvscan()
7160 {
7161 local cur
7162
7163 COMPREPLY=()
7164 cur=`_get_cword`
7165
7166 if [[ "$cur" == -* ]]; then
7167 COMPREPLY=( $( compgen -W '-d --debug -e \
7168 --exported -n --novolumegroup -h -? \
7169 --help --ignorelockingfailure -P \
7170 --partial -s --short -u --uuid -v \
7171 --verbose --version' -- $cur ) )
7172 fi
7173 }
7174 complete -F _pvscan pvscan
7175
7176 _pvs()
7177 {
7178 local cur prev
7179
7180 COMPREPLY=()
7181 cur=`_get_cword`
7182 prev=${COMP_WORDS[COMP_CWORD-1]}
7183
7184 case "$prev" in
7185 -@(o|O|-options|-sort))
7186 COMPREPLY=( $( compgen -W 'pv_fmt pv_uuid \
7187 pv_size pv_free pv_used pv_name \
7188 pv_attr pv_pe_count \
7189 pv_pe_alloc_count' -- $cur ) )
7190 return 0
7191 ;;
7192 --units)
7193 _units
7194 return 0
7195 ;;
7196 esac
7197
7198 if [[ "$cur" == -* ]]; then
7199 COMPREPLY=( $( compgen -W '--aligned -a --all -d --debug \
7200 -h -? --help --ignorelockingfailure --noheadings \
7201 --nosuffix -o --options -O --sort \
7202 --separator --unbuffered --units \
7203 -v --verbose --version' -- $cur ) )
7204 else
7205 _physicalvolumes
7206 fi
7207 }
7208 complete -F _pvs pvs
7209
7210 _pvdisplay()
7211 {
7212 local cur prev
7213
7214 COMPREPLY=()
7215 cur=`_get_cword`
7216 prev=${COMP_WORDS[COMP_CWORD-1]}
7217
7218 case "$prev" in
7219 --units)
7220 _units
7221 return 0
7222 ;;
7223 esac
7224
7225 if [[ "$cur" == -* ]]; then
7226 COMPREPLY=( $( compgen -W '-c --colon -C --columns --units \
7227 -v --verbose -d --debug -h --help --version' -- $cur ) )
7228 else
7229 _physicalvolumes
7230 fi
7231 }
7232 complete -F _pvdisplay pvdisplay
7233
7234 _pvchange()
7235 {
7236 local cur prev
7237
7238 COMPREPLY=()
7239 cur=`_get_cword`
7240 prev=${COMP_WORDS[COMP_CWORD-1]}
7241
7242 case "$prev" in
7243 -@(A|x|-autobackup|--allocatable))
7244 COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
7245 return 0
7246 ;;
7247 esac
7248
7249 if [[ "$cur" == -* ]]; then
7250 COMPREPLY=( $( compgen -W '-a --all -A --autobackup \
7251 -d --debug -h --help -t --test -u --uuid -x \
7252 --allocatable -v --verbose --addtag --deltag \
7253 --version' -- $cur ) )
7254 else
7255 _physicalvolumes
7256 fi
7257 }
7258 complete -F _pvchange pvchange
7259
7260 _pvcreate()
7261 {
7262 local cur prev
7263
7264 COMPREPLY=()
7265 cur=`_get_cword`
7266 prev=${COMP_WORDS[COMP_CWORD-1]}
7267
7268 case "$prev" in
7269 --restorefile)
7270 _filedir
7271 return 0
7272 ;;
7273 -@(M|-metadatatype))
7274 COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
7275 return 0
7276 ;;
7277 --metadatacopies)
7278 COMPREPLY=( $( compgen -W '0 1 2' -- $cur ) )
7279 return 0
7280 ;;
7281 --@(metadatasize|setphysicalvolumesize))
7282 _sizes
7283 return 0
7284 ;;
7285 esac
7286
7287 if [[ "$cur" == -* ]]; then
7288 COMPREPLY=( $( compgen -W '--restorefile -d --debug -f \
7289 --force -h -? --help --labelsector -M --metadatatype \
7290 --metadatacopies --metadatasize \
7291 --setphysicalvolumesize -t --test -u --uuid uuid -v \
7292 --verbose -y --yes --version' -- $cur ) )
7293 else
7294 _physicalvolumes
7295 fi
7296 }
7297 complete -F _pvcreate pvcreate
7298
7299 _pvmove()
7300 {
7301 local cur prev
7302
7303 COMPREPLY=()
7304 cur=`_get_cword`
7305 prev=${COMP_WORDS[COMP_CWORD-1]}
7306
7307 case "$prev" in
7308 -@(A|-autobackup))
7309 COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
7310 return 0
7311 ;;
7312 -@(n|-name))
7313 _logicalvolumes
7314 return 0
7315 esac
7316
7317 if [[ "$cur" == -* ]]; then
7318 COMPREPLY=( $( compgen -W '--abort -A --autobackup \
7319 -b --background -d --debug -f --force -h -? \
7320 --help -i --interval -t --test -v --verbose \
7321 --version -n --name' -- $cur ) )
7322 else
7323 _physicalvolumes
7324 fi
7325 }
7326 complete -F _pvmove pvmove
7327
7328 _pvremove()
7329 {
7330 local cur
7331
7332 COMPREPLY=()
7333 cur=`_get_cword`
7334
7335 if [[ "$cur" == -* ]]; then
7336 COMPREPLY=( $( compgen -W '-d --debug -f --force -h -? \
7337 --help -y --yes -t --test -v --verbose \
7338 --version' -- $cur ) )
7339 else
7340 _physicalvolumes
7341 fi
7342 }
7343 complete -F _pvremove pvremove
7344
7345 _vgscan()
7346 {
7347 local cur
7348
7349 COMPREPLY=()
7350 cur=`_get_cword`
7351
7352 if [[ "$cur" == -* ]]; then
7353 COMPREPLY=( $( compgen -W '-d --debug -h --help \
7354 --ignorelockingfailure --mknodes -P \
7355 --partial -v --verbose --version' -- $cur ) )
7356 fi
7357 }
7358 complete -F _vgscan vgscan
7359
7360 _vgs()
7361 {
7362 local cur prev
7363
7364 COMPREPLY=()
7365 cur=`_get_cword`
7366 prev=${COMP_WORDS[COMP_CWORD-1]}
7367
7368 case "$prev" in
7369 -@(o|O|-options|-sort))
7370 COMPREPLY=( $( compgen -W 'vg_fmt vg_uuid vg_name \
7371 vg_attr vg_size vg_free vg_sysid \
7372 vg_extent_size vg_extent_count vg_free_count \
7373 max_lv max_pv pv_count lv_count snap_count \
7374 vg_seqno' -- $cur ) )
7375 return 0
7376 ;;
7377 --units)
7378 _units
7379 return 0
7380 ;;
7381 esac
7382
7383 if [[ "$cur" == -* ]]; then
7384 COMPREPLY=( $( compgen -W '--aligned -d --debug \
7385 -h --help --ignorelockingfailure --noheadings \
7386 --nosuffix -o --options -O --sort -P --partial \
7387 --separator --unbuffered --units \
7388 -v --verbose --version' -- $cur ) )
7389 else
7390 _volumegroups
7391 fi
7392 }
7393 complete -F _vgs vgs
7394
7395 _vgdisplay()
7396 {
7397 local cur prev
7398
7399 COMPREPLY=()
7400 cur=`_get_cword`
7401 prev=${COMP_WORDS[COMP_CWORD-1]}
7402
7403 case "$prev" in
7404 --units)
7405 _units
7406 return 0
7407 ;;
7408 esac
7409
7410 if [[ "$cur" == -* ]]; then
7411 COMPREPLY=( $( compgen -W '-c --colon -C --columns --units \
7412 -P --partial -A --activevolumegroups -v --verbose \
7413 -d --debug -h --help --version' -- $cur ) )
7414 else
7415 _volumegroups
7416 fi
7417 }
7418 complete -F _vgdisplay vgdisplay
7419
7420 _vgchange()
7421 {
7422 local cur prev
7423
7424 COMPREPLY=()
7425 cur=`_get_cword`
7426 prev=${COMP_WORDS[COMP_CWORD-1]}
7427
7428 case "$prev" in
7429 -@(a|A|x|-available|-autobackup|-resizeable))
7430 COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
7431 return 0
7432 ;;
7433 esac
7434
7435 if [[ "$cur" == -* ]]; then
7436 COMPREPLY=( $( compgen -W '-A --autobackup --alloc -P \
7437 --partial -d --debug -h --help --ignorelockingfailure \
7438 -t --test -u --uuid -v --verbose --version -a \
7439 --available -x --resizeable -l --logicalvolume \
7440 --addtag --deltag' -- $cur ) )
7441 else
7442 _volumegroups
7443 fi
7444 }
7445 complete -F _vgchange vgchange
7446
7447 _vgcreate()
7448 {
7449 local cur prev
7450
7451 COMPREPLY=()
7452 cur=`_get_cword`
7453 prev=${COMP_WORDS[COMP_CWORD-1]}
7454
7455 case "$prev" in
7456 -@(A|-autobackup))
7457 COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
7458 return 0
7459 ;;
7460 -@(M|-metadatatype))
7461 COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
7462 return 0
7463 ;;
7464 -@(s|-physicalextentsize))
7465 _sizes
7466 return 0
7467 ;;
7468 esac
7469
7470 if [[ "$cur" == -* ]]; then
7471 COMPREPLY=( $( compgen -W '-A --autobackup --addtag \
7472 --alloc -d --debug -h --help -l --maxlogicalvolumes \
7473 -M --metadatatype -p --maxphysicalvolumes -s \
7474 --physicalextentsize -t --test -v --verbose \
7475 --version' -- $cur ) )
7476 else
7477 _args
7478 if [ $args -eq 0 ]; then
7479 _volumegroups
7480 else
7481 _physicalvolumes
7482 fi
7483 fi
7484 }
7485 complete -F _vgcreate vgcreate
7486
7487 _vgremove()
7488 {
7489 local cur
7490
7491 COMPREPLY=()
7492 cur=`_get_cword`
7493
7494 if [[ "$cur" == -* ]]; then
7495 COMPREPLY=( $( compgen -W '-d --debug -h --help -t --test \
7496 -v --verbose --version' -- $cur ) )
7497 else
7498 _volumegroups
7499 fi
7500 }
7501 complete -F _vgremove vgremove
7502
7503 _vgrename()
7504 {
7505 local cur prev
7506
7507 COMPREPLY=()
7508 cur=`_get_cword`
7509 prev=${COMP_WORDS[COMP_CWORD-1]}
7510
7511 case "$prev" in
7512 -@(A|-autobackup))
7513 COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
7514 return 0
7515 ;;
7516 esac
7517
7518 if [[ "$cur" == -* ]]; then
7519 COMPREPLY=( $( compgen -W '-A --autobackup -d --debug -h \
7520 -? --help -t --test -v --verbose --version' -- $cur ) )
7521 else
7522 _volumegroups
7523 fi
7524 }
7525 complete -F _vgrename vgrename
7526
7527 _vgreduce()
7528 {
7529 local cur prev
7530
7531 COMPREPLY=()
7532 cur=`_get_cword`
7533 prev=${COMP_WORDS[COMP_CWORD-1]}
7534
7535 case "$prev" in
7536 -@(A|-autobackup))
7537 COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
7538 return 0
7539 ;;
7540 esac
7541
7542 if [[ "$cur" == -* ]]; then
7543 COMPREPLY=( $( compgen -W '-a --all -A --autobackup -d \
7544 --debug -h --help --removemissing -t --test -v \
7545 --verbose --version' -- $cur ) )
7546
7547 else
7548 _args
7549 if [ $args -eq 0 ]; then
7550 _volumegroups
7551 else
7552 _physicalvolumes
7553 fi
7554 fi
7555 }
7556 complete -F _vgreduce vgreduce
7557
7558 _vgextend()
7559 {
7560 local cur prev
7561
7562 COMPREPLY=()
7563 cur=`_get_cword`
7564 prev=${COMP_WORDS[COMP_CWORD-1]}
7565
7566 case "$prev" in
7567 -@(A|-autobackup))
7568 COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
7569 return 0
7570 ;;
7571 -@(L|-size))
7572 _sizes
7573 return 0
7574 ;;
7575 esac
7576
7577 if [[ "$cur" == -* ]]; then
7578 COMPREPLY=( $( compgen -W '-A --autobackup -d --debug -h \
7579 -? --help -t --test -v --verbose --version' -- $cur ) )
7580 else
7581 _args
7582 if [ $args -eq 0 ]; then
7583 _volumegroups
7584 else
7585 _physicalvolumes
7586 fi
7587 fi
7588 }
7589 complete -F _vgextend vgextend
7590
7591 _vgport()
7592 {
7593 local cur prev
7594
7595 COMPREPLY=()
7596 cur=`_get_cword`
7597
7598 if [[ "$cur" == -* ]]; then
7599 COMPREPLY=( $( compgen -W '-a --all -d --debug -h \
7600 -? --help -v --verbose --version' -- $cur ) )
7601 else
7602 _volumegroups
7603 fi
7604 }
7605 complete -F _vgport vgimport vgexport
7606
7607 _vgck()
7608 {
7609 local cur prev
7610
7611 COMPREPLY=()
7612 cur=`_get_cword`
7613
7614 if [[ "$cur" == -* ]]; then
7615 COMPREPLY=( $( compgen -W '-d --debug -h \
7616 -? --help -v --verbose --version' -- $cur ) )
7617 else
7618 _volumegroups
7619 fi
7620 }
7621 complete -F _vgck vgck
7622
7623 _vgconvert()
7624 {
7625 local cur prev
7626
7627 COMPREPLY=()
7628 cur=`_get_cword`
7629 prev=${COMP_WORDS[COMP_CWORD-1]}
7630
7631 case "$prev" in
7632 -@(M|-metadatatype))
7633 COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
7634 return 0
7635 ;;
7636 --metadatacopies)
7637 COMPREPLY=( $( compgen -W '0 1 2' -- $cur ) )
7638 return 0
7639 ;;
7640 --metadatasize)
7641 _sizes
7642 return 0
7643 ;;
7644 esac
7645
7646 if [[ "$cur" == -* ]]; then
7647 COMPREPLY=( $( compgen -W '-d --debug -h --help --labelsector \
7648 -M --metadatatype --metadatacopies --metadatasize \
7649 -t --test -v --verbose --version' -- $cur ) )
7650 else
7651 _volumegroups
7652 fi
7653 }
7654 complete -F _vgconvert vgconvert
7655
7656 _vgcfgbackup()
7657 {
7658 local cur prev
7659
7660 COMPREPLY=()
7661 cur=`_get_cword`
7662 prev=${COMP_WORDS[COMP_CWORD-1]}
7663
7664 case "$prev" in
7665 -@(f|-file))
7666 _filedir
7667 return 0
7668 ;;
7669 esac
7670
7671 if [[ "$cur" == -* ]]; then
7672 COMPREPLY=( $( compgen -W '-d --debug -f --file -h --help \
7673 --ignorelockingfailure -P --partial -v --verbose \
7674 --version' -- $cur ) )
7675 else
7676 _volumegroups
7677 fi
7678 }
7679 complete -F _vgcfgbackup vgcfgbackup
7680
7681 _vgcfgrestore()
7682 {
7683 local cur prev
7684
7685 COMPREPLY=()
7686 cur=`_get_cword`
7687 prev=${COMP_WORDS[COMP_CWORD-1]}
7688
7689 case "$prev" in
7690 -@(f|-file))
7691 _filedir
7692 return 0
7693 ;;
7694 -@(M|-metadatatype))
7695 COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
7696 return 0
7697 ;;
7698 -@(n|-name))
7699 _volumegroups
7700 return 0
7701 ;;
7702 esac
7703
7704 if [[ "$cur" == -* ]]; then
7705 COMPREPLY=( $( compgen -W '-d --debug -f --file -l --list \
7706 -h --help -M --Metadatatype -n --name -t --test \
7707 -v --verbose --version' -- $cur ) )
7708 else
7709 _volumegroups
7710 fi
7711 }
7712 complete -F _vgcfgrestore vgcfgrestore
7713
7714 _vgmerge()
7715 {
7716 local cur prev
7717
7718 COMPREPLY=()
7719 cur=`_get_cword`
7720 prev=${COMP_WORDS[COMP_CWORD-1]}
7721
7722 case "$prev" in
7723 -@(A|-autobackup))
7724 COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
7725 return 0
7726 ;;
7727 esac
7728
7729 if [[ "$cur" == -* ]]; then
7730 COMPREPLY=( $( compgen -W '-A --autobackup -d --debug \
7731 -h --help -l --list -t --test -v --verbose \
7732 --version' -- $cur ) )
7733 else
7734 _volumegroups
7735 fi
7736 }
7737 complete -F _vgmerge vgmerge
7738
7739 _vgsplit()
7740 {
7741 local cur prev
7742
7743 COMPREPLY=()
7744 cur=`_get_cword`
7745 prev=${COMP_WORDS[COMP_CWORD-1]}
7746
7747 case "$prev" in
7748 -@(A|-autobackup))
7749 COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
7750 return 0
7751 ;;
7752 -@(M|-metadatatype))
7753 COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
7754 return 0
7755 ;;
7756 esac
7757
7758 if [[ "$cur" == -* ]]; then
7759 COMPREPLY=( $( compgen -W '-A --autobackup -d --debug \
7760 -h --help -l --list -M --metadatatype -t --test \
7761 -v --verbose --version' -- $cur ) )
7762 else
7763 _args
7764 if [ $args -eq 0 -o $args -eq 1 ]; then
7765 _volumegroups
7766 else
7767 _physicalvolumes
7768 fi
7769 fi
7770 }
7771 complete -F _vgsplit vgsplit
7772
7773 _vgmknodes()
7774 {
7775 local cur
7776
7777 COMPREPLY=()
7778 cur=`_get_cword`
7779
7780 if [[ "$cur" == -* ]]; then
7781 COMPREPLY=( $( compgen -W '-d --debug -h --help -v --verbose \
7782 --version' -- $cur ) )
7783 else
7784 _volumegroups
7785 fi
7786 }
7787 complete -F _vgmknodes vgmknodes
7788
7789 _lvscan()
7790 {
7791 local cur
7792
7793 COMPREPLY=()
7794 cur=`_get_cword`
7795
7796 if [[ "$cur" == -* ]]; then
7797 COMPREPLY=( $( compgen -W '-b --blockdevice -d --debug \
7798 -h -? --help --ignorelockingfailure -P \
7799 --partial -v --verbose --version' -- $cur ) )
7800 fi
7801 }
7802 complete -F _lvscan lvscan
7803
7804 _lvs()
7805 {
7806 local cur prev
7807
7808 COMPREPLY=()
7809 cur=`_get_cword`
7810 prev=${COMP_WORDS[COMP_CWORD-1]}
7811
7812 case "$prev" in
7813 -@(o|O|-options|-sort))
7814 COMPREPLY=( $( compgen -W 'lv_uuid lv_name \
7815 lv_attr lv_minor lv_size seg_count \
7816 origin snap_percent segtype stripes \
7817 stripesize chunksize seg_start \
7818 seg_size' -- $cur ) )
7819 return 0
7820 ;;
7821 --units)
7822 _units
7823 return 0
7824 ;;
7825 esac
7826
7827 if [[ "$cur" == -* ]]; then
7828 COMPREPLY=( $( compgen -W '--aligned -d --debug \
7829 -h --help --ignorelockingfailure --noheadings \
7830 --nosuffix -o --options -O --sort -P --partial \
7831 --segments --separator --unbuffered --units \
7832 -v --verbose --version' -- $cur ) )
7833 else
7834 _logicalvolumes
7835 fi
7836 }
7837 complete -F _lvs lvs
7838
7839 _lvdisplay()
7840 {
7841 local cur prev
7842
7843 COMPREPLY=()
7844 cur=`_get_cword`
7845 prev=${COMP_WORDS[COMP_CWORD-1]}
7846
7847 case "$prev" in
7848 --units)
7849 _units
7850 return 0
7851 ;;
7852 esac
7853
7854 if [[ "$cur" == -* ]]; then
7855 COMPREPLY=( $( compgen -W '-c --colon -C --columns --units \
7856 -P --partial -m --maps -v --verbose -d --debug -h \
7857 --help --version' -- $cur ) )
7858 else
7859 _logicalvolumes
7860 fi
7861 }
7862 complete -F _lvdisplay lvdisplay
7863
7864 _lvchange()
7865 {
7866 local cur prev
7867
7868 COMPREPLY=()
7869 cur=`_get_cword`
7870 prev=${COMP_WORDS[COMP_CWORD-1]}
7871
7872 case "$prev" in
7873 -@(a|A|C|M|-available|-autobackup|-continguous|-persistent))
7874 COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
7875 return 0
7876 ;;
7877 -@(p|-permission))
7878 COMPREPLY=( $( compgen -W 'r rw' -- $cur ) )
7879 return 0
7880 ;;
7881 esac
7882
7883 if [[ "$cur" == -* ]]; then
7884 COMPREPLY=( $( compgen -W '-A --autobackup -a --available \
7885 --addtag --alloc -C --contiguous -d --debug --deltag \
7886 -f --force -h --help --ignorelockingfailure -M \
7887 --persistent --major major --minor minor -P --partial \
7888 -p --permission -r --readahead --refresh -t --test \
7889 -v --verbose --version' -- $cur ) )
7890 else
7891 _logicalvolumes
7892 fi
7893 }
7894 complete -F _lvchange lvchange
7895
7896 _lvcreate()
7897 {
7898 local cur prev
7899
7900 COMPREPLY=()
7901 cur=`_get_cword`
7902 prev=${COMP_WORDS[COMP_CWORD-1]}
7903
7904 case "$prev" in
7905 -@(A|C|M|Z|-autobackup|-continguous|-persistent|-zero))
7906 COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
7907 return 0
7908 ;;
7909 -@(L|-size))
7910 _sizes
7911 return 0
7912 ;;
7913 -@(p|-permission))
7914 COMPREPLY=( $( compgen -W 'r rw' -- $cur ) )
7915 return 0
7916 ;;
7917 -@(n|-name))
7918 _logicalvolumes
7919 return 0
7920 ;;
7921 esac
7922
7923 if [[ "$cur" == -* ]]; then
7924 COMPREPLY=( $( compgen -W '-A --autobackup --addtag --alloc \
7925 -C --contiguous -d --debug -h -? --help -i --stripes \
7926 -I --stripesize -l --extents -L --size -M --persistent \
7927 --major --minor -n --name -p --permission -r \
7928 --readahead -t --test --type -v --verbose -Z --zero \
7929 --version' -- $cur ) )
7930 else
7931 _args
7932 if [ $args -eq 0 ]; then
7933 _volumegroups
7934 else
7935 _physicalvolumes
7936 fi
7937 fi
7938 }
7939 complete -F _lvcreate lvcreate
7940
7941 _lvremove()
7942 {
7943 local cur prev
7944
7945 COMPREPLY=()
7946 cur=`_get_cword`
7947 prev=${COMP_WORDS[COMP_CWORD-1]}
7948
7949 case "$prev" in
7950 -@(A|-autobackup))
7951 COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
7952 return 0
7953 ;;
7954 esac
7955
7956 if [[ "$cur" == -* ]]; then
7957 COMPREPLY=( $( compgen -W '-A --autobackup -d --debug -f \
7958 --force -h -? --help -t --test -v --verbose \
7959 --version' -- $cur ) )
7960 else
7961 _logicalvolumes
7962 fi
7963 }
7964 complete -F _lvremove lvremove
7965
7966 _lvrename()
7967 {
7968 local cur prev
7969
7970 COMPREPLY=()
7971 cur=`_get_cword`
7972 prev=${COMP_WORDS[COMP_CWORD-1]}
7973
7974 case "$prev" in
7975 -@(A|-autobackup))
7976 COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
7977 return 0
7978 ;;
7979 esac
7980
7981 if [[ "$cur" == -* ]]; then
7982 COMPREPLY=( $( compgen -W '-A --autobackup -d --debug -h \
7983 -? --help -t --test -v --verbose --version' -- $cur ) )
7984 else
7985 _logicalvolumes
7986 fi
7987 }
7988 complete -F _lvrename lvrename
7989
7990 _lvreduce()
7991 {
7992 local cur prev
7993
7994 COMPREPLY=()
7995 cur=`_get_cword`
7996 prev=${COMP_WORDS[COMP_CWORD-1]}
7997
7998 case "$prev" in
7999 -@(A|-autobackup))
8000 COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
8001 return 0
8002 ;;
8003 -@(L|-size))
8004 _sizes
8005 return 0
8006 ;;
8007 esac
8008
8009 if [[ "$cur" == -* ]]; then
8010 COMPREPLY=( $( compgen -W '-A --autobackup -d \
8011 --debug -f --force -h --help -l --extents \
8012 -L --size -n --nofsck -r --resizefs -t --test \
8013 -v --verbose --version' -- $cur ) )
8014 else
8015 _logicalvolumes
8016 fi
8017 }
8018 complete -F _lvreduce lvreduce
8019
8020 _lvresize()
8021 {
8022 local cur prev
8023
8024 COMPREPLY=()
8025 cur=`_get_cword`
8026 prev=${COMP_WORDS[COMP_CWORD-1]}
8027
8028 case "$prev" in
8029 -@(A|-autobackup))
8030 COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
8031 return 0
8032 ;;
8033 -@(L|-size))
8034 _sizes
8035 return 0
8036 ;;
8037 esac
8038
8039 if [[ "$cur" == -* ]]; then
8040 COMPREPLY=( $( compgen -W '-A --autobackup --alloc -d \
8041 --debug -h --help -i --stripes -I --stripesize \
8042 -l --extents -L --size -n --nofsck -r --resizefs \
8043 -t --test --type -v --verbose --version' -- $cur ) )
8044 else
8045 _args
8046 if [ $args -eq 0 ]; then
8047 _logicalvolumes
8048 else
8049 _physicalvolumes
8050 fi
8051 fi
8052 }
8053 complete -F _lvresize lvresize
8054
8055 _lvextend()
8056 {
8057 local cur prev
8058
8059 COMPREPLY=()
8060 cur=`_get_cword`
8061 prev=${COMP_WORDS[COMP_CWORD-1]}
8062
8063 case "$prev" in
8064 -@(A|-autobackup))
8065 COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
8066 return 0
8067 ;;
8068 -@(L|-size))
8069 _sizes
8070 return 0
8071 ;;
8072 esac
8073
8074 if [[ "$cur" == -* ]]; then
8075 COMPREPLY=( $( compgen -W '-A --autobackup --alloc -d \
8076 --debug -h --help -i --stripes -I --stripesize \
8077 -l --extents -L --size -n --nofsck -r --resizefs \
8078 -t --test --type -v --verbose --version' -- $cur ) )
8079 else
8080 _args
8081 if [ $args -eq 0 ]; then
8082 _logicalvolumes
8083 else
8084 _physicalvolumes
8085 fi
8086 fi
8087 }
8088 complete -F _lvextend lvextend
8089
8090 _lvm()
8091 {
8092 local prev
8093
8094 COMPREPLY=()
8095 cur=`_get_cword`
8096
8097 if [ $COMP_CWORD -eq 1 ]; then
8098 COMPREPLY=( $( compgen -W 'dumpconfig help lvchange \
8099 lvcreate lvdisplay lvextend lvmchange \
8100 lvmdiskscan lvmsadc lvmsar lvreduce \
8101 lvremove lvrename lvresize lvs lvscan \
8102 pvchange pvcreate pvdata pvdisplay pvmove \
8103 pvremove pvresize pvs pvscan vgcfgbackup \
8104 vgcfgrestore vgchange vgck vgconvert \
8105 vgcreate vgdisplay vgexport vgextend \
8106 vgimport vgmerge vgmknodes vgreduce \
8107 vgremove vgrename vgs vgscan vgsplit \
8108 version' -- $cur ) )
8109 else
8110 case ${COMP_WORDS[1]} in
8111 pvchange)
8112 _pvchange
8113 ;;
8114 pvcreate)
8115 _pvcreate
8116 ;;
8117 pvdisplay)
8118 _pvdisplay
8119 ;;
8120 pvmove)
8121 _pvmove
8122 ;;
8123 pvremove)
8124 _pvremove
8125 ;;
8126 pvresize)
8127 _pvresize
8128 ;;
8129 pvs)
8130 _pvs
8131 ;;
8132 pvscan)
8133 _pvscan
8134 ;;
8135 vgcfgbackup)
8136 _vgcfgbackup
8137 ;;
8138 vgcfgrestore)
8139 _vgcfgrestore
8140 ;;
8141 vgchange)
8142 _vgchange
8143 ;;
8144 vgck)
8145 _vgck
8146 ;;
8147 vgconvert)
8148 _vgconvert
8149 ;;
8150 vgcreate)
8151 _vgcreate
8152 ;;
8153 vgdisplay)
8154 _vgdisplay
8155 ;;
8156 vgexport)
8157 _vgexport
8158 ;;
8159 vgextend)
8160 _vgextend
8161 ;;
8162 vgimport)
8163 _vgimport
8164 ;;
8165 vgmerge)
8166 _vgmerge
8167 ;;
8168 vgmknodes)
8169 _vgmknodes
8170 ;;
8171 vgreduce)
8172 _vgreduce
8173 ;;
8174 vgremove)
8175 _vgremove
8176 ;;
8177 vgrename)
8178 _vgrename
8179 ;;
8180 vgs)
8181 _vgs
8182 ;;
8183 vgscan)
8184 _vgscan
8185 ;;
8186 vgsplit)
8187 _vgsplit
8188 ;;
8189 lvchange)
8190 _lvchange
8191 ;;
8192 lvcreate)
8193 _lvcreate
8194 ;;
8195 lvdisplay)
8196 _lvdisplay
8197 ;;
8198 lvextend)
8199 _lvextend
8200 ;;
8201 lvreduce)
8202 _lvreduce
8203 ;;
8204 lvremove)
8205 _lvremove
8206 ;;
8207 lvrename)
8208 _lvrename
8209 ;;
8210 lvresize)
8211 _lvresize
8212 ;;
8213 lvs)
8214 _lvs
8215 ;;
8216 lvscan)
8217 _lvscan
8218 ;;
8219 esac
8220 fi
8221 }
8222 complete -F _lvm lvm
8223 }
8224
8225 # mkinitrd(8) completion
8226 #
8227 have mkinitrd &&
8228 _mkinitrd()
8229 {
8230 local cur args
8231
8232 COMPREPLY=()
8233 cur=`_get_cword`
8234 prev=${COMP_WORDS[COMP_CWORD-1]}
8235
8236 # --name value style option
8237 case "$prev" in
8238 --preload)
8239 _modules
8240 return 0
8241 ;;
8242 esac
8243
8244 # --name=value style option
8245 if [[ "$cur" == *=* ]]; then
8246 prev=${cur/=*/}
8247 cur=${cur/*=/}
8248 case "$prev" in
8249 --@(with|builtin))
8250 _modules
8251 return 0
8252 ;;
8253 --@(fstab|dsdt))
8254 _filedir
8255 return 0
8256 ;;
8257 --tmpdir)
8258 _filedir -d
8259 return 0
8260 ;;
8261 esac
8262 fi
8263
8264
8265 if [[ "$cur" == -* ]]; then
8266 COMPREPLY=( $( compgen -W '--version -v -f --preload \
8267 --with= --omit-scsi-modules --omit-raid-modules \
8268 --images-version --fstab= --nocompress --builtin= \
8269 --nopivot --noudev --allow-missing --tmpdir= \
8270 --initrdfs= --dsdt= --lvm-version= --froce-usb' \
8271 -- $cur ) )
8272 else
8273 _count_args
8274
8275 case $args in
8276 1)
8277 _filedir
8278 ;;
8279 2)
8280 COMPREPLY=( $( command ls /lib/modules | grep "^$cur" ) )
8281 ;;
8282 esac
8283 fi
8284
8285 } &&
8286 complete -F _mkinitrd mkinitrd
8287
8288 # pkgconfig(1) completion
8289 #
8290 have pkg-config &&
8291 _pkg_config()
8292 {
8293 local cur
8294
8295 COMPREPLY=()
8296 cur=`_get_cword`
8297
8298 if [[ "$cur" == -* ]]; then
8299 # return list of available options
8300 COMPREPLY=( $( compgen -W '-version --modversion \
8301 --atleast-pkgconfig-version= --libs --libs-only-l \
8302 --libs-only-other --libs-only-L --cflags \
8303 --cflags-only-I --cflags-only-other --variable= \
8304 --define-variable= --exists --uninstalled \
8305 --atleast-version= --exact-version= --max-version= \
8306 --list-all --debug --print-errors --silence-errors \
8307 --errors-to-stdout -? --help --usage' -- $cur))
8308 else
8309 COMPREPLY=( $( pkg-config --list-all 2>/dev/null | \
8310 awk '{print $1}' | grep "^$cur" ) )
8311 fi
8312 } &&
8313 complete -F _pkg_config pkg-config
8314
8315
8316 # cpio(1) completion
8317 #
8318 have cpio && {
8319 _cpio_format()
8320 {
8321 COMPREPLY=( $( compgen -W 'bin odc newc crc tar ustar hpbin hpodc' -- $cur ) )
8322 }
8323
8324 _cpio()
8325 {
8326 local cur
8327
8328 COMPREPLY=()
8329 cur=`_get_cword`
8330 prev=${COMP_WORDS[COMP_CWORD-1]}
8331
8332 # --name value style option
8333 case $prev in
8334 -H)
8335 _cpio_format
8336 return 0
8337 ;;
8338 -@(E|F|I))
8339 _filedir
8340 return 0
8341 ;;
8342 -R)
8343 _usergroup
8344 return 0
8345 ;;
8346 esac
8347
8348 # --name=value style option
8349 if [[ "$cur" == *=* ]]; then
8350 prev=${cur/=*/}
8351 cur=${cur/*=/}
8352 case $prev in
8353 --format)
8354 _cpio_format
8355 return 0
8356 ;;
8357 --@(file|pattern-file))
8358 _filedir
8359 return 0
8360 ;;
8361 --owner)
8362 _usergroup
8363 return 0
8364 ;;
8365 --rsh-command)
8366 COMPREPLY=( $( compgen -c -- $cur ) )
8367 return 0
8368 ;;
8369 esac
8370 fi
8371
8372 if [ $COMP_CWORD -eq 1 ]; then
8373 COMPREPLY=( $( compgen -W '-o --create -i --extract -p --pass-through' -- $cur) )
8374 else
8375 case ${COMP_WORDS[1]} in
8376 -@(o|-create))
8377 if [[ "$cur" == -* ]]; then
8378 COMPREPLY=( $( compgen -W '-0 -a -c -v -A -B\
8379 -L -V -C -H -M -O -F --file= --format=\
8380 --message= --null --reset-access-time\
8381 --verbose --dot --append --block-size=\
8382 --dereference --io-size= --quiet\
8383 --force-local --rsh-command= --help\
8384 --version' -- $cur ) )
8385 fi
8386 ;;
8387 -@(i|-extract))
8388 if [[ "$cur" == -* ]]; then
8389 COMPREPLY=( $( compgen -W '-b -c -d -f -m -n -r\
8390 -t -s -u -v -B -S -V -C -E -H -M -R -I\
8391 -F --file= --make-directories\
8392 --nonmatching\
8393 --preserve-modification-time\
8394 --numeric-uid-gid --rename -t --list\
8395 --swap-bytes --swap --dot\
8396 --unconditional --verbose --block-size=\
8397 --swap-halfwords --io-size=\
8398 --pattern-file= --format= --owner=\
8399 --no-preserve-owner --message=\
8400 --force-local --no-absolute-filenames\
8401 --sparse --only-verify-crc --quiet\
8402 --rsh-command= --help\
8403 --version' -- $cur ) )
8404 fi
8405 ;;
8406 -@(p|-pass-through))
8407 if [[ "$cur" == -* ]]; then
8408 COMPREPLY=( $( compgen -W '-0 -a -d -l -m -u -v\
8409 -L -V -R --null --reset-access-time\
8410 --make-directories --link --quiet\
8411 --preserve-modification-time\
8412 --unconditional --verbose --dot\
8413 --dereference --owner=\
8414 --no-preserve-owner --sparse --help\
8415 --version' -- $cur ) )
8416 else
8417 _filedir -d
8418 fi
8419 ;;
8420 esac
8421 fi
8422 }
8423 complete -F _cpio cpio
8424 }
8425
8426 # id(1) completion
8427 #
8428 have id &&
8429 _id()
8430 {
8431 local cur
8432
8433 COMPREPLY=()
8434 cur=`_get_cword`
8435
8436 if [[ "$cur" == -* ]]; then
8437 COMPREPLY=( $( compgen -W '-a -g --group -G --groups -n --name\
8438 -r --real -u --user --help --version' -- $cur ) )
8439 else
8440 COMPREPLY=( $( compgen -u $cur ) )
8441 fi
8442 } &&
8443 complete -F _id id
8444
8445 # getent(1) completion
8446 #
8447 have getent &&
8448 _getent()
8449 {
8450 local cur prev
8451
8452 COMPREPLY=()
8453 cur=`_get_cword`
8454 prev=${COMP_WORDS[COMP_CWORD-1]}
8455
8456 case $prev in
8457 passwd)
8458 COMPREPLY=( $( compgen -u $cur ) )
8459 return 0
8460 ;;
8461 group)
8462 COMPREPLY=( $( compgen -g $cur ) )
8463 return 0
8464 ;;
8465 services)
8466 COMPREPLY=( $( compgen -s $cur ) )
8467 return 0
8468 ;;
8469 hosts)
8470 COMPREPLY=( $( compgen -A hostname $cur ) )
8471 return 0
8472 ;;
8473 protocols)
8474 COMPREPLY=( $( getent protocols | awk '{print $1}' | grep "^$cur" ) )
8475 return 0
8476 ;;
8477 networks)
8478 COMPREPLY=( $( getent networks | awk '{print $1}' | grep "^$cur" ) )
8479 return 0
8480 ;;
8481 esac
8482
8483
8484 if [ $COMP_CWORD -eq 1 ]; then
8485 COMPREPLY=( $( compgen -W 'passwd group hosts services protocols networks' -- $cur ) )
8486 fi
8487 } &&
8488 complete -F _getent getent
8489
8490 # ntpdate(1) completion
8491 #
8492 have ntpdate &&
8493 _ntpdate()
8494 {
8495 local cur prev
8496
8497 COMPREPLY=()
8498 cur=`_get_cword`
8499 prev=${COMP_WORDS[COMP_CWORD-1]}
8500
8501 case $prev in
8502 -k)
8503 _filedir
8504 return 0
8505 ;;
8506 -U)
8507 COMPREPLY=( $( compgen -u $cur ) )
8508 return 0
8509 ;;
8510 esac
8511
8512 if [[ "$cur" == -* ]]; then
8513 COMPREPLY=( $( compgen -W '-4 -6 -b -B -d -Q -q -s -u -v -a\
8514 -e -k -p -o -r -t' -- $cur ) )
8515 else
8516 _known_hosts
8517 fi
8518 } &&
8519 complete -F _ntpdate ntpdate
8520
8521 # smartctl(8) completion
8522 #
8523 have smartctl && {
8524 _smartctl_quietmode()
8525 {
8526 COMPREPLY=( $( compgen -W 'errorsonly silent' -- $cur ) )
8527 }
8528 _smartctl_device()
8529 {
8530 COMPREPLY=( $( compgen -W 'ata scsi 3ware' -- $cur ) )
8531 }
8532 _smartctl_tolerance()
8533 {
8534 COMPREPLY=( $( compgen -W 'warn exit ignore' -- $cur ) )
8535 }
8536 _smartctl_badsum()
8537 {
8538 COMPREPLY=( $( compgen -W 'normal conservative permissive verypermissive' -- $cur ) )
8539 }
8540 _smartctl_report()
8541 {
8542 COMPREPLY=( $( compgen -W 'ioctl ataioctl scsiioctl' -- $cur ) )
8543 }
8544 _smartctl_feature()
8545 {
8546 COMPREPLY=( $( compgen -W 'on off' -- $cur ) )
8547 }
8548 _smartctl_log()
8549 {
8550 COMPREPLY=( $( compgen -W 'error selftest selective directory' -- $cur ) )
8551 }
8552 _smartctl_vendorattribute()
8553 {
8554 COMPREPLY=( $( compgen -W 'help 9,minutes 9,seconds 9,halfminutes \
8555 9,temp 192,emergencyretractcyclect 193,loadunload \
8556 194,10xCelsius 194,unknown 198,offlinescanuncsectorct \
8557 200,writeerrorcount 201,detectedtacount 220,temp' -- $cur ) )
8558 }
8559 _smartctl_firmwarebug()
8560 {
8561 COMPREPLY=( $( compgen -W 'none samsung samsung2' -- $cur ) )
8562 }
8563 _smartctl_presets()
8564 {
8565 COMPREPLY=( $( compgen -W 'use ignore show showall' -- $cur ) )
8566 }
8567 _smartctl_test()
8568 {
8569 COMPREPLY=( $( compgen -W 'offline short long conveyance select afterselect,on afterselect,off pending' -- $cur ) )
8570 }
8571
8572 _smartctl()
8573 {
8574 local cur prev
8575
8576 COMPREPLY=()
8577 cur=`_get_cword`
8578 prev=${COMP_WORDS[COMP_CWORD-1]}
8579
8580 # --name value style option
8581 case "$prev" in
8582 -q)
8583 _smartctl_quietmode
8584 ;;
8585 -d)
8586 _smartctl_device
8587 return 0
8588 ;;
8589 -t)
8590 _smartctl_tolerance
8591 return 0
8592 ;;
8593 -b)
8594 _smartctl_badsum
8595 return 0
8596 ;;
8597 -r)
8598 _smartctl_report
8599 return 0
8600 ;;
8601 -s)
8602 _smartctl_feature
8603 return 0
8604 ;;
8605 -o)
8606 _smartctl_feature
8607 return 0
8608 ;;
8609 -S)
8610 _smartctl_feature
8611 return 0
8612 ;;
8613 -l)
8614 _smartctl_log
8615 return 0
8616 ;;
8617 -v)
8618 _smartctl_vendorattribute
8619 return 0
8620 ;;
8621 -F)
8622 _smartctl_firmwarebug
8623 return 0
8624 ;;
8625 -P)
8626 _smartctl_presets
8627 return 0
8628 ;;
8629 -t)
8630 _smartctl_test
8631 return 0
8632 ;;
8633 esac
8634
8635 # --name=value style option
8636 if [[ "$cur" == *=* ]]; then
8637 prev=${cur/=*/}
8638 cur=${cur/*=/}
8639 case "$prev" in
8640 --quietmode)
8641 _smartctl_quietmode
8642 return 0
8643 ;;
8644 --device)
8645 _smartctl_device
8646 return 0
8647 ;;
8648 --tolerance)
8649 _smartctl_tolerance
8650 return 0
8651 ;;
8652 --badsum)
8653 _smartctl_badsum
8654 return 0
8655 ;;
8656 --report)
8657 _smartctl_report
8658 return 0
8659 ;;
8660 --smart)
8661 _smartctl_feature
8662 return 0
8663 ;;
8664 --offlineauto)
8665 _smartctl_feature
8666 return 0
8667 ;;
8668 --saveauto)
8669 _smartctl_feature
8670 return 0
8671 ;;
8672 --log)
8673 _smartctl_log
8674 return 0
8675 ;;
8676 --vendorattribute)
8677 _smartctl_vendorattribute
8678 return 0
8679 ;;
8680 --firmwarebug)
8681 _smartctl_firmwarebug
8682 return 0
8683 ;;
8684 --presets)
8685 _smartctl_presets
8686 return 0
8687 ;;
8688 --test)
8689 _smartctl_test
8690 return 0
8691 ;;
8692 esac
8693 fi
8694
8695
8696 if [[ "$cur" == -* ]]; then
8697 COMPREPLY=( $( compgen -W '-h --help --usage -V --version \
8698 --copyright --license-i --info -a --all -q \
8699 --quietmode= -d --device= -T --tolerance= -b --badsum= \
8700 -r --report= -s --smart= -o --offlineauto= -S \
8701 --saveauto= -H --health -c --capabilities -A \
8702 --attributes -l --log= -v --vendorattribute= -F \
8703 --firmwarebug= -P --presets= -t --test= -C \
8704 --captive -X --abort' -- $cur ) )
8705 else
8706 cur=${cur:=/dev/}
8707 _filedir
8708 fi
8709 }
8710 complete -F _smartctl smartctl
8711 }
8712
8713 # vncviewer(1) completion
8714 #
8715 have vncviewer &&
8716 _vncviewer()
8717 {
8718 local cur prev
8719 local -a config
8720
8721 COMPREPLY=()
8722 cur=`_get_cword`
8723 prev=${COMP_WORDS[COMP_CWORD-1]}
8724
8725 case "$prev" in
8726 -via)
8727 _known_hosts -a
8728 ;;
8729 *)
8730 # ssh into the the server, find and ping the broadcast address, then
8731 # sort and show the results.
8732 COMPREPLY=( $( ssh -o 'Batchmode yes' $prev \
8733 "ping -bnc 4 255.255.255.255" 2>/dev/null | \
8734 awk -F ' ' '{print $4}' | \
8735 sort -n | uniq | egrep '[0-9]+\.[0-9]+\.' 2>/dev/null ) )
8736 esac
8737
8738 return 0
8739 } &&
8740 complete -F _vncviewer vncviewer
8741
8742 # sysctl(8) completion
8743 #
8744 have sysctl &&
8745 _sysctl()
8746 {
8747 local cur
8748
8749 COMPREPLY=()
8750 cur=`_get_cword`
8751
8752 COMPREPLY=( $( compgen -W "$(sysctl -N -a 2>/dev/null)" -- $cur ) )
8753
8754 return 0
8755 } &&
8756 complete -F _sysctl sysctl
8757
8758 # update-rc.d(8) completion
8759 #
8760 # Copyright (C) 2004 Servilio Afre Puentes <servilio@gmail.com>
8761 #
8762 have update-rc.d &&
8763 _update_rc_d()
8764 {
8765 local cur prev sysvdir services options valid_options
8766
8767 cur=`_get_cword`
8768 prev=${COMP_WORDS[COMP_CWORD-1]}
8769
8770 [ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d \
8771 || sysvdir=/etc/init.d
8772
8773 services=( $(echo $sysvdir/!(README*|*.sh|*.dpkg*|*.rpm*)) )
8774 services=( ${services[@]#$sysvdir/} )
8775 options=( -f -n )
8776
8777 if [[ $COMP_CWORD -eq 1 || "$prev" == -* ]]; then
8778 valid_options=( $( \
8779 echo "${COMP_WORDS[@]} ${options[@]}" \
8780 | tr " " "\n" \
8781 | sed -ne "/$( echo "${options[@]}" | sed "s/ /\\|/g" )/p" \
8782 | sort | uniq -u \
8783 ) )
8784 COMPREPLY=( $( compgen -W '${options[@]} ${services[@]}' \
8785 -X '$( echo ${COMP_WORDS[@]} | tr " " "|" )' -- $cur ) )
8786 elif [[ "$prev" == ?($( echo ${services[@]} | tr " " "|" )) ]]; then
8787 COMPREPLY=( $( compgen -W 'remove defaults start stop' -- $cur ) )
8788 elif [[ "$prev" == defaults && "$cur" == [0-9] ]]; then
8789 COMPREPLY=( 0 1 2 3 4 5 6 7 8 9 )
8790 elif [[ "$prev" == defaults && "$cur" == [sk]?([0-9]) ]]; then
8791 COMPREPLY=( 0 1 2 3 4 5 6 7 8 9 )
8792 elif [[ "$prev" == defaults && -z "$cur" ]]; then
8793 COMPREPLY=( 0 1 2 3 4 5 6 7 8 9 s k )
8794 elif [[ "$prev" == ?(start|stop) ]]; then
8795 if [[ "$cur" == [0-9] || -z "$cur" ]]; then
8796 COMPREPLY=( 0 1 2 3 4 5 6 7 8 9 )
8797 elif [[ "$cur" == [0-9][0-9] ]]; then
8798 COMPREPLY=( $cur )
8799 else
8800 COMPREPLY=()
8801 fi
8802 elif [[ "$prev" == ?([0-9][0-9]|[0-6S]) ]]; then
8803 if [[ -z "$cur" ]]; then
8804 if [[ $prev == [0-9][0-9] ]]; then
8805 COMPREPLY=( 0 1 2 3 4 5 6 S )
8806 else
8807 COMPREPLY=( 0 1 2 3 4 5 6 S . )
8808 fi
8809 elif [[ "$cur" == [0-6S.] ]]; then
8810 COMPREPLY=( $cur )
8811 else
8812 COMPREPLY=()
8813 fi
8814 elif [[ "$prev" == "." ]]; then
8815 COMPREPLY=( $(compgen -W "start stop" -- $cur) )
8816 else
8817 COMPREPLY=()
8818 fi
8819
8820 return 0
8821 } &&
8822 complete -F _update_rc_d update-rc.d
8823
8824 # invoke-rc.d(8) completion
8825 #
8826 # Copyright (C) 2004 Servilio Afre Puentes <servilio@gmail.com>
8827 #
8828 have invoke-rc.d &&
8829 _invoke_rc_d()
8830 {
8831 local cur prev sysvdir services options valid_options
8832
8833 cur=`_get_cword`
8834 prev=${COMP_WORDS[COMP_CWORD-1]}
8835
8836 [ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d \
8837 || sysvdir=/etc/init.d
8838
8839 services=( $(echo $sysvdir/!(README*|*.sh|*.dpkg*|*.rpm*)) )
8840 services=( ${services[@]#$sysvdir/} )
8841 options=( --help --quiet --force --try-anyway --disclose-deny --query --no-fallback )
8842
8843 if [[ ($COMP_CWORD -eq 1) || ("$prev" == --* ) ]]; then
8844 valid_options=( $( \
8845 echo ${COMP_WORDS[@]} ${options[@]} \
8846 | tr " " "\n" \
8847 | sed -ne "/$( echo ${options[@]} | sed "s/ /\\\\|/g" )/p" \
8848 | sort | uniq -u \
8849 ) )
8850 COMPREPLY=( $( compgen -W '${valid_options[@]} ${services[@]}' -- \
8851 $cur ) )
8852 elif [ -x $sysvdir/$prev ]; then
8853 COMPREPLY=( $( compgen -W '`sed -ne "y/|/ /; \
8854 s/^.*Usage:[ ]*[^ ]*[ ]*{*\([^}\"]*\).*$/\1/p" \
8855 $sysvdir/$prev`' -- \
8856 $cur ) )
8857 else
8858 COMPREPLY=()
8859 fi
8860
8861 return 0
8862 } &&
8863 complete -F _invoke_rc_d invoke-rc.d
8864
8865 # minicom(1) completion
8866 #
8867 have minicom &&
8868 _minicom()
8869 {
8870 local cur prev
8871
8872 COMPREPLY=()
8873 cur=`_get_cword`
8874 prev=${COMP_WORDS[COMP_CWORD-1]}
8875
8876 case $prev in
8877 -@(a|c))
8878 COMPREPLY=( $( compgen -W 'on off' -- $cur ) )
8879 return 0
8880 ;;
8881 -@(S|C))
8882 _filedir
8883 return 0
8884 ;;
8885 -P)
8886 COMPREPLY=( $( command ls /dev/tty* ) )
8887 COMPREPLY=( $( compgen -W '${COMPREPLY[@]} ${COMPREPLY[@]#/dev/}' -- $cur ) )
8888 return 0
8889 ;;
8890 esac
8891
8892
8893 if [[ "$cur" == -* ]]; then
8894 COMPREPLY=( $( compgen -W '-s -o -m -M -z -l -L -w -a -t \
8895 -c -S -d -p -C -T -8' -- $cur ) )
8896 else
8897 COMPREPLY=( $( command ls /etc/minicom/minirc.* 2>/dev/null | sed -e 's|/etc/minicom/minirc.||' | grep "^$cur" ) )
8898 fi
8899 } &&
8900 complete -F _minicom minicom
8901
8902 # svn completion
8903 #
8904 have svn &&
8905 {
8906 _svn()
8907 {
8908 local cur prev commands options command
8909
8910 COMPREPLY=()
8911 cur=`_get_cword`
8912
8913 commands='add blame praise annotate ann cat checkout co cleanup commit \
8914 ci copy cp delete del remove rm diff di export help ? h import \
8915 info list ls lock log merge mkdir move mv rename ren \
8916 propdel pdel pd propedit pedit pe propget pget pg \
8917 proplist plist pl propset pset ps resolved revert \
8918 status stat st switch sw unlock update up'
8919
8920 if [[ $COMP_CWORD -eq 1 ]] ; then
8921 if [[ "$cur" == -* ]]; then
8922 COMPREPLY=( $( compgen -W '--version' -- $cur ) )
8923 else
8924 COMPREPLY=( $( compgen -W "$commands" -- $cur ) )
8925 fi
8926 else
8927
8928 prev=${COMP_WORDS[COMP_CWORD-1]}
8929 case $prev in
8930 --config-dir)
8931 _filedir -d
8932 return 0;
8933 ;;
8934 -@(F|-file|-targets))
8935 _filedir
8936 return 0;
8937 ;;
8938 --encoding)
8939 COMPREPLY=( $( compgen -W \
8940 '$( iconv --list | sed -e "s@//@@;" )' \
8941 -- "$cur" ) )
8942 return 0;
8943 ;;
8944 --@(editor|diff|diff3)-cmd)
8945 COMP_WORDS=(COMP_WORDS[0] $cur)
8946 COMP_CWORD=1
8947 _command
8948 return 0;
8949 ;;
8950 esac
8951
8952 command=${COMP_WORDS[1]}
8953
8954 if [[ "$cur" == -* ]]; then
8955 # possible options for the command
8956 case $command in
8957 add)
8958 options='--auto-props --no-auto-props \
8959 --force --targets --no-ignore \
8960 --non-recursive -N -q --quiet'
8961 ;;
8962 @(blame|annotate|ann|praise))
8963 options='-r --revisions --username \
8964 --password --no-auth-cache \
8965 --non-interactive -v \
8966 --verbose --incremental --xml'
8967 ;;
8968 cat)
8969 options='-r --revision --username \
8970 --password --no-auth-cache \
8971 --non-interactive'
8972 ;;
8973 @(checkout|co))
8974 options='-r --revision -q --quiet -N \
8975 --non-recursive --username \
8976 --password --no-auth-cache \
8977 --non-interactive \
8978 --ignore-externals'
8979 ;;
8980 cleanup)
8981 options='--diff3-cmd'
8982 ;;
8983 @(commit|ci))
8984 options='-m --message -F --file \
8985 --encoding --force-log -q \
8986 --quiet --non-recursive -N \
8987 --targets --editor-cmd \
8988 --username --password \
8989 --no-auth-cache \
8990 --non-interactive --no-unlock'
8991 ;;
8992 @(copy|cp))
8993 options='-m --message -F --file \
8994 --encoding --force-log -r \
8995 --revision -q --quiet \
8996 --editor-cmd -username \
8997 --password --no-auth-cache \
8998 --non-interactive'
8999 ;;
9000 @(delete|del|remove|rm))
9001 options='--force -m --message -F \
9002 --file --encoding --force-log \
9003 -q --quiet --targets \
9004 --editor-cmd -username \
9005 --password --no-auth-cache \
9006 --non-interactive'
9007 ;;
9008 @(diff|di))
9009 options='-r --revision -x --extensions \
9010 --diff-cmd --no-diff-deleted \
9011 -N --non-recursive --username \
9012 --password --no-auth-cache \
9013 --non-interactive --force \
9014 --old --new --notice-ancestry'
9015 ;;
9016 export)
9017 options='-r --revision -q --quiet \
9018 --username --password \
9019 --no-auth-cache \
9020 --non-interactive -N \
9021 --non-recursive --force \
9022 --native-eol --ignore-externals'
9023 ;;
9024 import)
9025 options='--auto-props --no-auto-props \
9026 -m --message -F --file \
9027 --encoding --force-log -q \
9028 --quiet --non-recursive \
9029 --no-ignore --editor-cmd \
9030 --username --password \
9031 --no-auth-cache \
9032 --non-interactive'
9033 ;;
9034 info)
9035 options='--username --password \
9036 --no-auth-cache \
9037 --non-interactive -r \
9038 --revision --xml --targets \
9039 -R --recursive --incremental'
9040 ;;
9041 @(list|ls))
9042 options='-r --revision -v --verbose -R \
9043 --recursive --username \
9044 --password --no-auth-cache \
9045 --non-interactive \
9046 --incremental --xml'
9047 ;;
9048 lock)
9049 options='-m --message -F --file \
9050 --encoding --force-log \
9051 --targets --force --username \
9052 --password --no-auth-cache \
9053 --non-interactive'
9054 ;;
9055 log)
9056 options='-r --revision -v --verbose \
9057 --targets --username \
9058 --password --no-auth-cache \
9059 --non-interactive \
9060 --stop-on-copy --incremental \
9061 --xml -q --quiet --limit'
9062 ;;
9063 merge)
9064 options='-r --revision -N \
9065 --non-recursive -q --quiet \
9066 --force --dry-run --diff3-cmd \
9067 --username --password \
9068 --no-auth-cache \
9069 --non-interactive \
9070 --ignore-ancestry'
9071 ;;
9072 mkdir)
9073 options='-m --message -F --file \
9074 --encoding --force-log -q \
9075 --quiet --editor-cmd \
9076 --username --password \
9077 --no-auth-cache \
9078 --non-interactive'
9079 ;;
9080 @(move|mv|rename|ren))
9081 options='-m --message -F --file \
9082 --encoding --force-log -r \
9083 --revision -q --quiet \
9084 --force --editor-cmd \
9085 --username --password \
9086 --no-auth-cache \
9087 --non-interactive'
9088 ;;
9089 @(propdel|pdel|pd))
9090 options='-q --quiet -R --recursive -r \
9091 --revision --revprop \
9092 --username --password \
9093 --no-auth-cache \
9094 --non-interactive'
9095 ;;
9096 @(propedit|pedit|pe))
9097 options='-r --revision --revprop \
9098 --encoding --editor-cmd \
9099 --username --password \
9100 --no-auth-cache \
9101 --non-interactive --force'
9102 ;;
9103 @(propget|pget|pg))
9104 options='-R --recursive -r --revision \
9105 --revprop --strict --username \
9106 --password --no-auth-cache \
9107 --non-interactive'
9108 ;;
9109 @(proplist|plist|pl))
9110 options='-v --verbose -R --recursive \
9111 -r --revision --revprop -q \
9112 --quiet --username --password \
9113 --no-auth-cache \
9114 --non-interactive'
9115 ;;
9116 @(propset|pset|ps))
9117 options='-F --file -q --quiet \
9118 --targets -R --recursive \
9119 --revprop --encoding \
9120 --username --password \
9121 --no-auth-cache \
9122 --non-interactive -r \
9123 --revision --force'
9124 ;;
9125 resolved)
9126 options='--targets -R --recursive -q \
9127 --quiet'
9128 ;;
9129 revert)
9130 options='--targets -R --recursive -q \
9131 --quiet'
9132 ;;
9133 @(status|stat|st))
9134 options='-u --show-updates -v \
9135 --verbose -N --non-recursive \
9136 -q --quiet --username \
9137 --password --no-auth-cache \
9138 --non-interactive --no-ignore \
9139 --ignore-externals \
9140 --incremental --xml'
9141 ;;
9142 @(switch|sw))
9143 options='--relocate -r --revision -N \
9144 --non-recursive -q --quiet \
9145 --username --password \
9146 --no-auth-cache \
9147 --non-interactive --diff3-cmd'
9148 ;;
9149 unlock)
9150 options='--targets --force --username \
9151 --password --no-auth-cache \
9152 --non-interactive'
9153 ;;
9154 @(update|up))
9155 options='-r --revision -N \
9156 --non-recursive -q --quiet \
9157 --username --password \
9158 --no-auth-cache \
9159 --non-interactive \
9160 --diff3-cmd --ignore-externals'
9161 ;;
9162 esac
9163 options="$options --help -h --config-dir"
9164
9165 COMPREPLY=( $( compgen -W "$options" -- $cur ) )
9166 else
9167 if [[ "$command" == @(help|h|\?) ]]; then
9168 COMPREPLY=( $( compgen -W "$commands" -- $cur ) )
9169 else
9170 _filedir
9171 fi
9172 fi
9173 fi
9174
9175 return 0
9176 }
9177 complete -F _svn $default svn
9178
9179 _svnadmin()
9180 {
9181 local cur prev commands options mode
9182
9183 COMPREPLY=()
9184 cur=`_get_cword`
9185
9186 commands='create deltify dump help ? hotcopy list-dblogs \
9187 list-unused-dblogs load lslocks lstxns recover rmlocks \
9188 rmtxns setlog verify'
9189
9190 if [[ $COMP_CWORD -eq 1 ]] ; then
9191 if [[ "$cur" == -* ]]; then
9192 COMPREPLY=( $( compgen -W '--version' -- $cur ) )
9193 else
9194 COMPREPLY=( $( compgen -W "$commands" -- $cur ) )
9195 fi
9196 else
9197 prev=${COMP_WORDS[COMP_CWORD-1]}
9198 case $prev in
9199 --config-dir)
9200 _filedir -d
9201 return 0;
9202 ;;
9203 --fs-type)
9204 COMPREPLY=( $( compgen -W 'fsfs bdb' -- $cur ) )
9205 return 0;
9206 ;;
9207 esac
9208
9209 command=${COMP_WORDS[1]}
9210
9211 if [[ "$cur" == -* ]]; then
9212 # possible options for the command
9213 case $command in
9214 create)
9215 options='--bdb-txn-nosync \
9216 --bdb-log-keep --config-dir \
9217 --fs-type'
9218 ;;
9219 deltify)
9220 options='-r --revision -q --quiet'
9221 ;;
9222 dump)
9223 options='-r --revision --incremental \
9224 -q --quiet --deltas'
9225 ;;
9226 hotcopy)
9227 options='--clean-logs'
9228 ;;
9229 load)
9230 options='--ignore-uuid --force-uuid \
9231 --parent-dir -q --quiet \
9232 --use-pre-commit-hook \
9233 --use-post-commit-hook'
9234 ;;
9235 rmtxns)
9236 options='-q --quiet'
9237 ;;
9238 setlog)
9239 options='-r --revision --bypass-hooks'
9240 ;;
9241 esac
9242
9243 options="$options --help -h"
9244 COMPREPLY=( $( compgen -W "$options" -- $cur ) )
9245 else
9246 if [[ "$command" == @(help|h|\?) ]]; then
9247 COMPREPLY=( $( compgen -W "$commands" -- $cur ) )
9248 else
9249 _filedir
9250 fi
9251 fi
9252 fi
9253
9254 return 0
9255 }
9256 complete -F _svnadmin $default svnadmin
9257
9258 _svnlook()
9259 {
9260 local cur prev commands options mode
9261
9262 COMPREPLY=()
9263 cur=`_get_cword`
9264
9265 commands='author cat changed date diff dirs-changed help ? h history \
9266 info lock log propget pget pg proplist plist pl tree uuid \
9267 youngest'
9268
9269 if [[ $COMP_CWORD -eq 1 ]] ; then
9270 if [[ "$cur" == -* ]]; then
9271 COMPREPLY=( $( compgen -W '--version' -- $cur ) )
9272 else
9273 COMPREPLY=( $( compgen -W "$commands" -- $cur ) )
9274 fi
9275 else
9276 command=${COMP_WORDS[1]}
9277
9278 if [[ "$cur" == -* ]]; then
9279 # possible options for the command
9280 case $command in
9281 @(author|cat|date|dirs-changed|info|log))
9282 options='-r --revision -t \
9283 --transaction'
9284 ;;
9285 changed)
9286 options='-r --revision -t \
9287 --transaction --copy-info'
9288 ;;
9289 diff)
9290 options='-r --revision -t \
9291 --transaction \
9292 --no-diff-deleted \
9293 --no-diff-added \
9294 --diff-copy-from'
9295 ;;
9296 history)
9297 options='-r --revision --show-ids'
9298 ;;
9299 prop@(get|list))
9300 options='-r --revision -t \
9301 --transaction --revprop'
9302 ;;
9303 tree)
9304 options='-r --revision -t \
9305 --transaction --show-ids \
9306 --full-paths'
9307 ;;
9308 esac
9309
9310 options="$options --help -h"
9311 COMPREPLY=( $( compgen -W "$options" -- $cur ) )
9312 else
9313 if [[ "$command" == @(help|h|\?) ]]; then
9314 COMPREPLY=( $( compgen -W "$commands" -- $cur ) )
9315 else
9316 _filedir
9317 fi
9318 fi
9319 fi
9320
9321 return 0
9322 }
9323 complete -F _svnlook $default svnlook
9324 }
9325
9326 _filedir_xspec()
9327 {
9328 local IFS cur xspec
9329
9330 IFS=$'\t\n'
9331 COMPREPLY=()
9332 cur=`_get_cword`
9333
9334 _expand || return 0
9335
9336 # get first exclusion compspec that matches this command
9337 xspec=$( sed -ne $'/^complete .*[ \t]'${1##*/}$'\([ \t]\|$\)/{p;q;}' \
9338 $BASH_COMPLETION )
9339 # prune to leave nothing but the -X spec
9340 xspec=${xspec#*-X }
9341 xspec=${xspec%% *}
9342
9343 local toks=( ) tmp
9344
9345 while read -r tmp; do
9346 [[ -n $tmp ]] && toks[${#toks[@]}]=$tmp
9347 done < <( compgen -d -- "$(quote_readline "$cur")" )
9348
9349 while read -r tmp; do
9350 [[ -n $tmp ]] && toks[${#toks[@]}]=$tmp
9351 done < <( eval compgen -f -X $xspec -- "\$(quote_readline "\$cur")" )
9352
9353 COMPREPLY=( "${toks[@]}" )
9354 }
9355 list=( $( sed -ne '/^# START exclude/,/^# FINISH exclude/p' \
9356 $BASH_COMPLETION | \
9357 # read exclusion compspecs
9358 (
9359 while read line
9360 do
9361 # ignore compspecs that are commented out
9362 if [ "${line#\#}" != "$line" ]; then continue; fi
9363 line=${line%# START exclude*}
9364 line=${line%# FINISH exclude*}
9365 line=${line##*\'}
9366 list=( "${list[@]}" $line )
9367 done
9368 echo "${list[@]}"
9369 )
9370 ) )
9371 # remove previous compspecs
9372 if [ ${#list[@]} -gt 0 ]; then
9373 eval complete -r ${list[@]}
9374 # install new compspecs
9375 eval complete -F _filedir_xspec $filenames "${list[@]}"
9376 fi
9377 unset list
9378
9379 # source completion directory definitions
9380 if [ -d $BASH_COMPLETION_DIR -a -r $BASH_COMPLETION_DIR -a \
9381 -x $BASH_COMPLETION_DIR ]; then
9382 for i in $BASH_COMPLETION_DIR/*; do
9383 [[ ${i##*/} != @(*~|*.bak|*.swp|\#*\#|*.dpkg*|.rpm*) ]] &&
9384 [ \( -f $i -o -h $i \) -a -r $i ] && . $i
9385 done
9386 fi
9387 unset i
9388
9389 # source user completion file
9390 [ $BASH_COMPLETION != ~/.bash_completion -a -r ~/.bash_completion ] \
9391 && . ~/.bash_completion
9392 unset -f have
9393 unset UNAME RELEASE default dirnames filenames have nospace bashdefault \
9394 plusdirs
9395
9396 set $BASH_COMPLETION_ORIGINAL_V_VALUE
9397 unset BASH_COMPLETION_ORIGINAL_V_VALUE
9398
9399 ### Local Variables:
9400 ### mode: shell-script
9401 ### End:
Unnamed repository; edit this file 'description' to name the repository.