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