· 9 years ago · May 23, 2017, 04:34 PM
1BASH=/bin/bash
2BASHOPTS=checkwinsize:cmdhist:expand_aliases:extglob:extquote:force_fignore:histappend:interactive_comments:login_shell:progcomp:promptvars:sourcepath
3BASH_ALIASES=()
4BASH_ARGC=()
5BASH_ARGV=()
6BASH_CMDS=()
7BASH_COMPLETION=/etc/bash_completion
8BASH_COMPLETION_COMPAT_DIR=/etc/bash_completion.d
9BASH_COMPLETION_DIR=/etc/bash_completion.d
10BASH_LINENO=()
11BASH_SOURCE=()
12BASH_VERSINFO=([0]="4" [1]="1" [2]="5" [3]="2" [4]="release" [5]="i686-pc-linux-gnu")
13BASH_VERSION='4.1.5(2)-release'
14COLUMNS=80
15DIRSTACK=()
16EUID=1000
17GROUPS=()
18G_BROKEN_FILENAMES=1
19HISTCONTROL=ignoreboth
20HISTFILE=/home/mgtd/.bash_history
21HISTFILESIZE=1000
22HISTSIZE=1000
23HOME=/home/mgtd
24HOSTNAME=chakrabox
25HOSTTYPE=i686
26HUSHLOGIN=FALSE
27IFS=$' \t\n'
28INPUTRC=/etc/inputrc
29LANG=de_DE.utf8
30LESS=-R
31LINES=25
32LOGNAME=mgtd
33MACHTYPE=i686-pc-linux-gnu
34MAIL=/var/spool/mail/mgtd
35MAILCHECK=60
36MOZ_PLUGIN_PATH=/usr/lib/mozilla/plugins
37OPTERR=1
38OPTIND=1
39OSTYPE=linux-gnu
40PATH=/bin:/usr/bin:/sbin:/usr/sbin:/usr/bin/perlbin/site:/usr/bin/perlbin/vendor:/usr/bin/perlbin/core
41PIPESTATUS=([0]="1")
42PKG_CONFIG_PATH=/usr/lib/pkgconfig
43PPID=3631
44PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\$ '
45PS2='> '
46PS3='> '
47PS4='+ '
48PWD=/home/mgtd
49SHELL=/bin/bash
50SHELLOPTS=braceexpand:emacs:hashall:histexpand:history:interactive-comments:monitor
51SHLVL=1
52TERM=linux
53UID=1000
54USER=mgtd
55XDG_CACHE_HOME=/home/mgtd/.cache
56XDG_CONFIG_DIRS=/etc/xdg
57XDG_CONFIG_HOME=/home/mgtd/.config
58XDG_DATA_DIRS=/usr/share:/usr/local/share
59XDG_DATA_HOME=/home/mgtd/.local/share
60_=']'
61bash205='4.1.5(2)-release'
62bash205b='4.1.5(2)-release'
63bash3='4.1.5(2)-release'
64bash4='4.1.5(2)-release'
65shell=bash
66_ImageMagick ()
67{
68 local prev;
69 prev=${COMP_WORDS[COMP_CWORD-1]};
70 case "$prev" in
71 -channel)
72 COMPREPLY=($( compgen -W 'Red Green Blue Opacity \
73 Matte Cyan Magenta Yellow Black' -- "$cur" ));
74 return 0
75 ;;
76 -colormap)
77 COMPREPLY=($( compgen -W 'shared private' -- "$cur" ));
78 return 0
79 ;;
80 -colorspace)
81 COMPREPLY=($( compgen -W 'GRAY OHTA RGB Transparent \
82 XYZ YCbCr YIQ YPbPr YUV CMYK' -- "$cur" ));
83 return 0
84 ;;
85 -compose)
86 COMPREPLY=($( compgen -W 'Over In Out Atop Xor Plus \
87 Minus Add Subtract Difference Multiply Bumpmap\
88 Copy CopyRed CopyGreen CopyBlue CopyOpacity' -- "$cur" ));
89 return 0
90 ;;
91 -compress)
92 COMPREPLY=($( compgen -W 'None BZip Fax Group4 JPEG \
93 Lossless LZW RLE Zip' -- "$cur" ));
94 return 0
95 ;;
96 -dispose)
97 COMPREPLY=($( compgen -W 'Undefined None Background Previous' -- "$cur" ));
98 return 0
99 ;;
100 -encoding)
101 COMPREPLY=($( compgen -W 'AdobeCustom AdobeExpert \
102 AdobeStandard AppleRoman BIG5 GB2312 Latin2 \
103 None SJIScode Symbol Unicode Wansung' -- "$cur"));
104 return 0
105 ;;
106 -endian)
107 COMPREPLY=($( compgen -W 'MSB LSB' -- "$cur" ));
108 return 0
109 ;;
110 -filter)
111 COMPREPLY=($( compgen -W 'Point Box Triangle Hermite \
112 Hanning Hamming Blackman Gaussian Quadratic \
113 Cubic Catrom Mitchell Lanczos Bessel Sinc' -- "$cur" ));
114 return 0
115 ;;
116 -format)
117 COMPREPLY=($( compgen -W "$( convert -list format | awk '/ [r-][w-][+-] / {print $1}' | tr -d '*' | tr [:upper:] [:lower:] )" -- "$cur" ));
118 return 0
119 ;;
120 -gravity)
121 COMPREPLY=($( compgen -W 'Northwest North NorthEast \
122 West Center East SouthWest South SouthEast' -- "$cur" ));
123 return 0
124 ;;
125 -intent)
126 COMPREPLY=($( compgen -W 'Absolute Perceptual \
127 Relative Saturation' -- "$cur" ));
128 return 0
129 ;;
130 -interlace)
131 COMPREPLY=($( compgen -W 'None Line Plane Partition' -- "$cur" ));
132 return 0
133 ;;
134 -limit)
135 COMPREPLY=($( compgen -W 'Disk File Map Memory' -- "$cur" ));
136 return 0
137 ;;
138 -list)
139 COMPREPLY=($( compgen -W 'Delegate Format Magic Module Resource \
140 Type' -- "$cur" ));
141 return 0
142 ;;
143 -map)
144 COMPREPLY=($( compgen -W 'best default gray red green blue' -- "$cur" ));
145 _filedir;
146 return 0
147 ;;
148 -noise)
149 COMPREPLY=($( compgen -W 'Uniform Gaussian Multiplicative \
150 Impulse Laplacian Poisson' -- "$cur" ));
151 return 0
152 ;;
153 -preview)
154 COMPREPLY=($( compgen -W 'Rotate Shear Roll Hue \
155 Saturation Brightness Gamma Spiff \
156 Dull Grayscale Quantize Despeckle \
157 ReduceNoise AddNoise Sharpen Blur \
158 Treshold EdgeDetect Spread Shade \
159 Raise Segment Solarize Swirl Implode \
160 Wave OilPaint CharcoalDrawing JPEG' -- "$cur" ));
161 return 0
162 ;;
163 -@(mask|profile|texture|tile|write))
164 _filedir;
165 return 0
166 ;;
167 -type)
168 COMPREPLY=($( compgen -W 'Bilevel Grayscale Palette PaletteMatte \
169 TrueColor TrueColorMatte ColorSeparation ColorSeparationlMatte \
170 Optimize' -- "$cur" ));
171 return 0
172 ;;
173 -units)
174 COMPREPLY=($( compgen -W 'Undefined PixelsPerInch \
175 PixelsPerCentimeter' -- "$cur" ));
176 return 0
177 ;;
178 -virtual-pixel)
179 COMPREPLY=($( compgen -W 'Constant Edge mirror tile' -- "$cur" ));
180 return 0
181 ;;
182 -visual)
183 COMPREPLY=($( compgen -W 'StaticGray GrayScale StaticColor \
184 PseudoColor TrueColor DirectColor defaut visualid' -- "$cur" ));
185 return 0
186 ;;
187 esac
188}
189__get_cword3 ()
190{
191 if [[ "${#COMP_WORDS[COMP_CWORD]}" -eq 0 ]] || [[ "$COMP_POINT" == "${#COMP_LINE}" ]]; then
192 printf "%s" "${COMP_WORDS[COMP_CWORD]}";
193 else
194 local i;
195 local cur="$COMP_LINE";
196 local index="$COMP_POINT";
197 for ((i = 0; i <= COMP_CWORD; ++i ))
198 do
199 while [[ "${#cur}" -ge ${#COMP_WORDS[i]} && "${cur:0:${#COMP_WORDS[i]}}" != "${COMP_WORDS[i]}" ]]; do
200 cur="${cur:1}";
201 index="$(( index - 1 ))";
202 done;
203 if [[ "$i" -lt "$COMP_CWORD" ]]; then
204 local old_size="${#cur}";
205 cur="${cur#${COMP_WORDS[i]}}";
206 local new_size="${#cur}";
207 index="$(( index - old_size + new_size ))";
208 fi;
209 done;
210 if [[ "${COMP_WORDS[COMP_CWORD]:0:${#cur}}" != "$cur" ]]; then
211 printf "%s" "${COMP_WORDS[COMP_CWORD]}";
212 else
213 printf "%s" "${cur:0:$index}";
214 fi;
215 fi
216}
217__get_cword4 ()
218{
219 local i;
220 local LC_CTYPE=C;
221 local WORDBREAKS=$COMP_WORDBREAKS;
222 WORDBREAKS=${WORDBREAKS//\"/};
223 WORDBREAKS=${WORDBREAKS//\'/};
224 if [ -n "$1" ]; then
225 for ((i=0; i<${#1}; ++i ))
226 do
227 local char=${1:$i:1};
228 WORDBREAKS=${WORDBREAKS//$char/};
229 done;
230 fi;
231 local cur=${COMP_LINE:0:$COMP_POINT};
232 local tmp=$cur;
233 local word_start=`expr "$tmp" : '.*['"$WORDBREAKS"']'`;
234 while [ "$word_start" -ge 2 ]; do
235 local char=${cur:$(( $word_start - 2 )):1};
236 if [ "$char" != "\\" ]; then
237 break;
238 fi;
239 tmp=${COMP_LINE:0:$(( $word_start - 2 ))};
240 word_start=`expr "$tmp" : '.*['"$WORDBREAKS"']'`;
241 done;
242 cur=${cur:$word_start};
243 printf "%s" "$cur"
244}
245_alias ()
246{
247 local cur;
248 COMPREPLY=();
249 cur=`_get_cword`;
250 case "$COMP_LINE" in
251 *[^=])
252 COMPREPLY=($( compgen -A alias -- "$cur" ))
253 ;;
254 *=)
255 COMPREPLY=("$( alias ${cur%=} 2>/dev/null | sed -e 's|^alias '"$cur"'\(.*\)$|\1|' )")
256 ;;
257 esac
258}
259_animate ()
260{
261 local cur;
262 COMPREPLY=();
263 cur=`_get_cword`;
264 _ImageMagick;
265 if [[ "$cur" == -* ]]; then
266 COMPREPLY=($( compgen -W '-alpha -authenticate -backdrop \
267 -background -bordercolor -borderwidth -channel \
268 -coalesce -colormap -colors -colorspace -crop -debug \
269 -decipher -define -delay -density -depth -display \
270 -dispose -dither -extract -filter -flatten -font \
271 -foreground -format -gamma -geometry -help \
272 -iconGeometry -iconic -identify -immutable -interlace \
273 -interpolate -limit -list -log -loop -map -mattecolor \
274 -mattecolor -monitor -monochrome -name -page -pause \
275 -quantize -quiet -regard-warnings -remote -repage \
276 -resample -resize -respect-parenthesis -rotate \
277 -sampling-factor -scenes -seed -set -shared-memory \
278 -size -strip -title -transparent-color -treedepth \
279 -trim -verbose -version -virtual-pixel -visual \
280 -window' -- "$cur" ));
281 else
282 if [[ "$cur" == +* ]]; then
283 COMPREPLY=($( compgen -W '+debug +dither +gamma +map +matte' -- "$cur" ));
284 else
285 _filedir;
286 fi;
287 fi
288}
289_arch ()
290{
291 local cur prev split=false;
292 COMPREPLY=();
293 cur=`_get_cword`;
294 prev=${COMP_WORDS[COMP_CWORD-1]};
295 _split_longopt && split=true;
296 case "$prev" in
297 -@(w|g|d|--welcome-msg|-goodbye-msg|-digest))
298 COMPREPLY=($( compgen -W 'y n' -- "$cur"));
299 return 0
300 ;;
301 -@(d|-file))
302 _filedir;
303 return 0
304 ;;
305 esac;
306 $split && return 0;
307 if [[ "$cur" == -* ]]; then
308 COMPREPLY=($( compgen -W '--wipe -s --start -e --end -q --quiet -h \
309 --help' -- "$cur" ));
310 else
311 args=$COMP_CWORD;
312 for ((i=1; i < COMP_CWORD; i++ ))
313 do
314 if [[ "${COMP_WORDS[i]}" == -* ]]; then
315 args=$(($args-1));
316 fi;
317 done;
318 case $args in
319 1)
320 _mailman_lists
321 ;;
322 2)
323 _filedir
324 ;;
325 esac;
326 fi
327}
328_args ()
329{
330 args=0;
331 if [[ "${COMP_WORDS[0]}" == lvm ]]; then
332 offset=2;
333 else
334 offset=1;
335 fi;
336 for ((i=$offset; i < COMP_CWORD; i++ ))
337 do
338 if [[ "${COMP_WORDS[i]}" != -* ]]; then
339 args=$(($args + 1));
340 fi;
341 done
342}
343_aspell ()
344{
345 local cur prev split=false;
346 COMPREPLY=();
347 cur=`_get_cword`;
348 prev=${COMP_WORDS[COMP_CWORD-1]};
349 _split_longopt && split=true;
350 case "$prev" in
351 -c | -p | check | --@(conf|personal|repl|per-conf))
352 _filedir;
353 return 0
354 ;;
355 --@(conf-dir|data-dir|dict-dir|home-dir|local-data-dir|prefix))
356 _filedir -d;
357 return 0
358 ;;
359 dump | create | merge)
360 COMPREPLY=($( compgen -W 'master personal repl' -- "$cur" ));
361 return 0
362 ;;
363 --mode)
364 COMPREPLY=($( compgen -W 'none url email sgml tex' -- "$cur" ));
365 return 0
366 ;;
367 --sug-mode)
368 COMPREPLY=($( compgen -W 'ultra fast normal bad-speller' -- "$cur" ));
369 return 0
370 ;;
371 --keymapping)
372 COMPREPLY=($( compgen -W 'aspell ispell' -- "$cur" ));
373 return 0
374 ;;
375 -d | --master)
376 _aspell_dictionary;
377 return 0
378 ;;
379 esac;
380 $split && return 0;
381 if [[ "$cur" == -* ]]; then
382 COMPREPLY=($( compgen -W '--conf --conf-dir --data-dir --dict-dir \
383 --encoding --add-filter --rem-filter --mode -e \
384 -H -t --add-extra-dicts --rem-extra-dicts \
385 --home-dir -W --ignore --ignore-accents \
386 --dont-ignore-accents --ignore-case --dont-ignore-case \
387 --ignore-repl --dont-ignore-repl --jargon --keyboard \
388 --lang --language-tag --local-data-dir -d --master \
389 --module --add-module-search-order \
390 --rem-module-search-order --per-conf -p --personal \
391 --prefix --repl -C -B --run-together --dont-run-together \
392 --run-together-limit --run-together-min --save-repl \
393 --dont-save-repl --set-prefix --dont-set-prefix --size \
394 --spelling --strip-accents --dont-strip-accents \
395 --sug-mode --add-word-list-path --rem-word-list-path \
396 -b -x --backup -b|-x --dont-backup --reverse --dont-reverse \
397 --time --dont-time --keymapping --add-email-quote \
398 --rem-email-quote --email-margin --add-tex-command \
399 --rem-tex-command --tex-check-comments \
400 --dont-tex-check-comments --add-tex-extension \
401 --rem-tex-extension --add-sgml-check --rem-sgml-check \
402 --add-sgml-extension --rem-sgml-extension' -- "$cur" ));
403 else
404 COMPREPLY=($( compgen -W '-? help -c check -a pipe -l list \
405 config config soundslike filter -v version dump \
406 create merge' -- "$cur" ));
407 fi
408}
409_aspell_dictionary ()
410{
411 local datadir;
412 datadir=$( aspell config data-dir 2>/dev/null || echo /usr/lib/aspell );
413 COMPREPLY=($( command ls $datadir/*.alias 2>/dev/null ));
414 COMPREPLY=(${COMPREPLY[@]%.alias});
415 COMPREPLY=(${COMPREPLY[@]#$datadir/});
416 COMPREPLY=("${COMPREPLY[@]}" $( aspell dicts 2>/dev/null ));
417 COMPREPLY=($( compgen -W '${COMPREPLY[@]}' -- "$cur" ))
418}
419_available_groups ()
420{
421 local available_groups;
422 local enabled_repos;
423 enabled_repos=$( grep '\[' /etc/pacman.conf | grep -v -e 'options' -e '^#' | tr -d '[]' );
424 available_groups=$( for r in $enabled_repos; do sed '/%GROUPS%/,/^$/{//d; p}' /var/lib/pacman/sync/$r/*/desc | sort -u; done );
425 COMPREPLY=($( compgen -W "$( for i in $available_groups; do echo ${i%-*-*}; done )" -- $cur ))
426}
427_available_interfaces ()
428{
429 local cmd;
430 if [ "${1:-}" = -w ]; then
431 cmd="iwconfig";
432 else
433 if [ "${1:-}" = -a ]; then
434 cmd="ifconfig";
435 else
436 cmd="ifconfig -a";
437 fi;
438 fi;
439 COMPREPLY=($( eval $cmd 2>/dev/null | sed -ne 's|^\('"$cur"'[^[:space:][:punct:]]\{1,\}\).*$|\1|p'))
440}
441_available_pkgs ()
442{
443 local available_pkgs;
444 local enabled_repos;
445 enabled_repos=$( grep '\[' /etc/pacman.conf | grep -v -e 'options' -e '^#' | tr -d '[]' );
446 available_pkgs=$( for r in $enabled_repos; do echo /var/lib/pacman/sync/$r/*; done );
447 COMPREPLY=($( compgen -W "$( for i in $available_pkgs; do j=${i##*/}; echo ${j%-*-*}; done )" -- $cur ))
448}
449_available_repos ()
450{
451 COMPREPLY=($( compgen -W "$(grep '\[' /etc/pacman.conf | grep -v -e 'options' -e '^#' | tr -d '[]' )" -- $cur ))
452}
453_avctrl ()
454{
455 local cur;
456 COMPREPLY=();
457 cur=`_get_cword`;
458 if [[ "$cur" == -* ]]; then
459 COMPREPLY=($( compgen -W '-h --help -q --quiet' -- "$cur" ));
460 else
461 _count_args;
462 if [ $args -eq 1 ]; then
463 COMPREPLY=($( compgen -W 'discover switch' -- "$cur" ));
464 fi;
465 fi
466}
467_bluetooth_adresses ()
468{
469 if [ -n "${COMP_BLUETOOTH_SCAN:-}" ]; then
470 COMPREPLY=(${COMPREPLY[@]:-} $( compgen -W "$( hcitool scan | awk '/^\t/{print $1}' )" -- "$cur" ));
471 fi
472}
473_bluetooth_devices ()
474{
475 COMPREPLY=(${COMPREPLY[@]:-} $( compgen -W "$( hcitool dev | awk '/^\t/{print $1}' )" -- "$cur" ))
476}
477_bluetooth_packet_types ()
478{
479 COMPREPLY=($( compgen -W 'DM1 DM3 DM5 DH1 DH3 DH5 HV1 HV2 HV3' -- "$cur" ))
480}
481_bluetooth_services ()
482{
483 COMPREPLY=($( compgen -W 'DID SP DUN LAN FAX OPUSH FTP HS HF HFAG \
484 SAP NAP GN PANU HCRP HID CIP A2SRC A2SNK AVRCT AVRTG UDIUE \
485 UDITE SYNCML' -- "$cur" ))
486}
487_bzip2 ()
488{
489 local cur prev xspec;
490 COMPREPLY=();
491 cur=`_get_cword`;
492 prev=${COMP_WORDS[COMP_CWORD-1]};
493 if [[ "$cur" == -* ]]; then
494 COMPREPLY=($( compgen -W '-c -d -f -h -k -L -q -s \
495 -t -v -V -z -1 -2 -3 -4 -5 -6 -7 -8 -9 \
496 --help --decompress --compress --keep --force \
497 --test --stdout --quiet --verbose --license \
498 --version --small --fast --best' -- "$cur" ));
499 return 0;
500 fi;
501 local IFS='
502';
503 xspec="*.bz2";
504 if [[ "$prev" == --* ]]; then
505 [[ "$prev" == --decompress || "$prev" == --list || "$prev" == --test ]] && xspec="!"$xspec;
506 [[ "$prev" == --compress ]] && xspec=;
507 else
508 if [[ "$prev" == -* ]]; then
509 [[ "$prev" == -*[dt]* ]] && xspec="!"$xspec;
510 [[ "$prev" == -*z* ]] && xspec=;
511 fi;
512 fi;
513 _expand || return 0;
514 COMPREPLY=($( compgen -f -X "$xspec" -- "$cur" ) $( compgen -d -- "$cur" ))
515}
516_cancel ()
517{
518 local cur;
519 COMPREPLY=();
520 cur=`_get_cword`;
521 COMPREPLY=($( compgen -W "$( lpstat | cut -d' ' -f1 )" -- "$cur" ))
522}
523_cd ()
524{
525 local IFS='
526' cur=`_get_cword` i j k;
527 if [[ "$cur" == ?(\\)\$* ]]; then
528 COMPREPLY=($( compgen -v -P '$' -- "${cur#?(\\)$}" ));
529 return 0;
530 fi;
531 compgen -f /non-existing-dir/ > /dev/null;
532 if [ -z "${CDPATH:-}" ] || [[ "$cur" == ?(.)?(.)/* ]]; then
533 _filedir -d;
534 return 0;
535 fi;
536 local -r mark_dirs=$(_rl_enabled mark-directories && echo y);
537 local -r mark_symdirs=$(_rl_enabled mark-symlinked-directories && echo y);
538 for i in ${CDPATH//:/' '};
539 do
540 k="${#COMPREPLY[@]}";
541 for j in $( compgen -d $i/$cur );
542 do
543 if [[ ( -n $mark_symdirs && -h $j || -n $mark_dirs && ! -h $j ) && ! -d ${j#$i/} ]]; then
544 j="${j}/";
545 fi;
546 COMPREPLY[k++]=${j#$i/};
547 done;
548 done;
549 _filedir -d;
550 if [[ ${#COMPREPLY[@]} -eq 1 ]]; then
551 i=${COMPREPLY[0]};
552 if [ "$i" == "$cur" ] && [[ $i != "*/" ]]; then
553 COMPREPLY[0]="${i}/";
554 fi;
555 fi;
556 return 0
557}
558_cdrecord ()
559{
560 local cur prev i generic_options track_options track_mode;
561 COMPREPLY=();
562 cur=`_get_cword`;
563 prev=${COMP_WORDS[COMP_CWORD-1]};
564 if [[ "$cur" == *=* ]]; then
565 prev=${cur/=*/};
566 cur=${cur/*=/};
567 case "$prev" in
568 @(text|cue)file)
569 _filedir;
570 return 0
571 ;;
572 blank)
573 COMPREPLY=($( compgen -W 'help all fast \
574 track unreserve trtail unclose session' -- "$cur" ));
575 return 0
576 ;;
577 driveropts)
578 COMPREPLY=($( compgen -W 'burnfree noburnfree\
579 varirec= audiomaster forcespeed noforcespeed\
580 speedread nospeedread singlesession \
581 nosinglesession hidecdr nohidecdr tattooinfo\
582 tattoofile=' -- "$cur" ));
583 return 0
584 ;;
585 esac;
586 fi;
587 generic_options=(-version -v -V -d -silent -s -force -immed -dummy -dao -raw -raw96r -raw96p -raw16 -multi -msinfo -toc -atip -fix -nofix -waiti -load -lock -eject -format -setdropts -checkdrive -prcap -inq -scanbus -reset -abort -overburn -ignsize -useinfo -packet -noclose -text debug= kdebug= kd= minbuf= speed= blank= fs= dev= gracetime= timeout= driver= driveropts= defpregap= pktsize= mcn= textfile= cuefile=);
588 track_options=(-audio -swab -data -mode2 -xa -xa1 -xa2 -xamix -cdi -isosize -pad padsize= -nopad -shorttrack -noshorttrack pregap= -preemp -nopreemp -copy -nocopy -scms tcsize= isrc= index=);
589 track_mode=0;
590 if [ $COMP_CWORD -gt 1 ]; then
591 if [ -f "$prev" ]; then
592 track_mode=1;
593 else
594 for ((i=0; i < ${#track_options[@]}; i++ ))
595 do
596 if [[ "${track_options[i]}" == "$prev" ]]; then
597 track_mode=1;
598 break;
599 fi;
600 done;
601 fi;
602 fi;
603 _filedir;
604 COMPREPLY=("${COMPREPLY[@]}" $( compgen -W '${track_options[@]}' -- "$cur" ));
605 if [ $track_mode -eq 0 ]; then
606 COMPREPLY=("${COMPREPLY[@]}" $( compgen -W '${generic_options[@]}' -- "$cur" ));
607 fi
608}
609_chage ()
610{
611 local cur prev split=false;
612 COMPREPLY=();
613 cur=`_get_cword`;
614 prev=${COMP_WORDS[COMP_CWORD-1]};
615 _split_longopt && split=true;
616 case "$prev" in
617 -d | --lastday | -E | --expiredate | -h | --help | -I | --inactive | -m | --mindays | -M | --maxdays | -W | --warndays)
618 return 0
619 ;;
620 esac;
621 $split && return 0;
622 if [[ "$cur" == -* ]]; then
623 COMPREPLY=($( compgen -W '-d --lastday -E --expiredate \
624 -h --help -I --inactive -l --list -m --mindays \
625 -M --maxdays -W --warndays' -- "$cur" ));
626 return 0;
627 fi;
628 COMPREPLY=($( compgen -u -- "$cur" ))
629}
630_chgrp ()
631{
632 local cur prev split=false;
633 COMPREPLY=();
634 cur=`_get_cword`;
635 cur=${cur//\\\\/};
636 prev=${COMP_WORDS[COMP_CWORD-1]};
637 _split_longopt && split=true;
638 if [[ "$prev" == --reference ]]; then
639 _filedir;
640 return 0;
641 fi;
642 $split && return 0;
643 if [[ "$cur" == -* ]]; then
644 COMPREPLY=($( compgen -W '-c -h -f -R -v --changes \
645 --dereference --no-dereference --silent --quiet \
646 --reference --recursive --verbose --help --version' -- "$cur" ));
647 return 0;
648 fi;
649 if [ $COMP_CWORD -eq 1 ] && [[ "$cur" != -* ]] || [[ "$prev" == -* ]] && [ -n "$bash205" ]; then
650 local IFS='
651';
652 COMPREPLY=($( compgen -g "$cur" 2>/dev/null ));
653 else
654 _filedir || return 0;
655 fi;
656 return 0
657}
658_chown ()
659{
660 local cur prev split=false;
661 cur=`_get_cword`;
662 prev=${COMP_WORDS[COMP_CWORD-1]};
663 _split_longopt && split=true;
664 case "$prev" in
665 --from)
666 _usergroup;
667 return 0
668 ;;
669 --reference)
670 _filedir;
671 return 0
672 ;;
673 esac;
674 $split && return 0;
675 if [[ "$cur" == -* ]]; then
676 COMPREPLY=($( compgen -W '-c -h -f -R -v --changes \
677 --dereference --no-dereference --from --silent --quiet \
678 --reference --recursive --verbose --help --version' -- "$cur" ));
679 else
680 _count_args;
681 case $args in
682 1)
683 _usergroup
684 ;;
685 *)
686 _filedir
687 ;;
688 esac;
689 fi
690}
691_chpasswd ()
692{
693 local cur prev split=false;
694 COMPREPLY=();
695 cur=`_get_cword`;
696 prev=${COMP_WORDS[COMP_CWORD-1]};
697 _split_longopt && split=true;
698 case "$prev" in
699 -c | --crypt)
700 COMPREPLY=($( compgen -W 'DES MD5 NONE SHA256 SHA512' -- "$cur" ));
701 return 0
702 ;;
703 -s | --sha-rounds)
704 return 0
705 ;;
706 esac;
707 $split && return 0;
708 if [[ "$cur" == -* ]]; then
709 COMPREPLY=($( compgen -W '-c --crypt-method -e --encrypted \
710 -h --help -m --md5 -s --sha-rounds' -- "$cur" ));
711 return 0;
712 fi
713}
714_chsh ()
715{
716 local cur prev;
717 COMPREPLY=();
718 cur=`_get_cword`;
719 prev=${COMP_WORDS[COMP_CWORD-1]};
720 if [ "$prev" = "-s" ]; then
721 _shells;
722 else
723 COMPREPLY=($( compgen -u -- "$cur" ));
724 fi;
725 return 0
726}
727_ciptool ()
728{
729 local cur prev;
730 COMPREPLY=();
731 cur=`_get_cword`;
732 prev=${COMP_WORDS[COMP_CWORD-1]};
733 case $prev in
734 -i)
735 _bluetooth_devices;
736 _bluetooth_adresses;
737 return 0
738 ;;
739 esac;
740 _get_command;
741 if [ -z $command ]; then
742 if [[ "$cur" == -* ]]; then
743 COMPREPLY=($( compgen -W '-h --help -i' -- "$cur" ));
744 else
745 COMPREPLY=($( compgen -W 'show search connect release \
746 loopback' -- "$cur" ));
747 fi;
748 else
749 case $command in
750 @(connect|release|loopback))
751 _count_args;
752 if [ $args -eq 2 ]; then
753 _bluetooth_adresses;
754 fi
755 ;;
756 esac;
757 fi
758}
759_command ()
760{
761 local offset i;
762 offset=1;
763 for ((i=1; i <= COMP_CWORD; i++ ))
764 do
765 if [[ "${COMP_WORDS[i]}" != -* ]]; then
766 offset=$i;
767 break;
768 fi;
769 done;
770 _command_offset $offset
771}
772_command_offset ()
773{
774 local cur func cline cspec noglob cmd i char_offset word_offset _COMMAND_FUNC _COMMAND_FUNC_ARGS;
775 word_offset=$1;
776 local first_word=${COMP_WORDS[$word_offset]};
777 for ((i=0; i <= ${#COMP_LINE}; i++ ))
778 do
779 if [[ "${COMP_LINE:$i:${#first_word}}" == "$first_word" ]]; then
780 char_offset=$i;
781 break;
782 fi;
783 done;
784 COMP_LINE=${COMP_LINE:$char_offset};
785 COMP_POINT=$(( COMP_POINT - $char_offset ));
786 for ((i=0; i <= COMP_CWORD - $word_offset; i++ ))
787 do
788 COMP_WORDS[i]=${COMP_WORDS[i+$word_offset]};
789 done;
790 for ((i; i <= COMP_CWORD; i++ ))
791 do
792 unset COMP_WORDS[i];
793 done;
794 COMP_CWORD=$(( $COMP_CWORD - $word_offset ));
795 COMPREPLY=();
796 cur=`_get_cword`;
797 if [[ $COMP_CWORD -eq 0 ]]; then
798 COMPREPLY=($( compgen -c -- "$cur" ));
799 else
800 cmd=${COMP_WORDS[0]};
801 if complete -p $cmd &>/dev/null; then
802 cspec=$( complete -p $cmd );
803 if [ "${cspec#* -F }" != "$cspec" ]; then
804 func=${cspec#*-F };
805 func=${func%% *};
806 if [[ ${#COMP_WORDS[@]} -ge 2 ]]; then
807 $func $cmd "${COMP_WORDS[${#COMP_WORDS[@]}-1]}" "${COMP_WORDS[${#COMP_WORDS[@]}-2]}";
808 else
809 $func $cmd "${COMP_WORDS[${#COMP_WORDS[@]}-1]}";
810 fi;
811 if [ "${cspec#*-o }" != "$cspec" ]; then
812 cspec=${cspec#*-o };
813 cspec=${cspec%% *};
814 if [[ "$cspec" != @(dir|file)names ]]; then
815 COMPREPLY=("${COMPREPLY[@]//\\\\:/:}");
816 fi;
817 fi;
818 else
819 if [ -n "$cspec" ]; then
820 cspec=${cspec#complete};
821 cspec=${cspec%%$cmd};
822 COMPREPLY=($( eval compgen "$cspec" -- "$cur" ));
823 fi;
824 fi;
825 fi;
826 fi;
827 [ ${#COMPREPLY[@]} -eq 0 ] && _filedir
828}
829_compare ()
830{
831 local cur;
832 COMPREPLY=();
833 cur=`_get_cword`;
834 _ImageMagick;
835 if [[ "$cur" == -* ]]; then
836 COMPREPLY=($( compgen -W '-alpha -authenticate -channel \
837 -colorspace -compress -debug -decipher -define \
838 -density -depth -encipher -extract -format -fuzz \
839 -help -highlight-color -identify -interlace -limit \
840 -list -log -metric -monitor -passphrase -profile \
841 -quality -quantize -quiet -regard-warnings \
842 -respect-parenthesis -sampling-factor -seed -set \
843 -size -transparent-color -type -verbose -version \
844 -virtual-pixel' -- "$cur" ));
845 else
846 if [[ "$cur" == +* ]]; then
847 COMPREPLY=($( compgen -W '+debug' -- "$cur" ));
848 else
849 _filedir;
850 fi;
851 fi
852}
853_complete ()
854{
855 local cur prev options;
856 COMPREPLY=();
857 cur=`_get_cword`;
858 prev=${COMP_WORDS[COMP_CWORD-1]};
859 case $prev in
860 -o)
861 options="default dirnames filenames";
862 [ -n "$bash205b" ] && options="$options nospace";
863 [ -n "$bash3" ] && options="$options bashdefault plusdirs";
864 COMPREPLY=($( compgen -W "$options" -- "$cur" ));
865 return 0
866 ;;
867 -A)
868 COMPREPLY=($( compgen -W 'alias arrayvar binding \
869 builtin command directory disabled enabled \
870 export file function group helptopic hostname \
871 job keyword running service setopt shopt \
872 signal stopped user variable' -- "$cur" ));
873 return 0
874 ;;
875 -C)
876 COMPREPLY=($( compgen -A command -- "$cur" ));
877 return 0
878 ;;
879 -F)
880 COMPREPLY=($( compgen -A function -- "$cur" ));
881 return 0
882 ;;
883 -@(p|r))
884 COMPREPLY=($( complete -p | sed -e 's|.* ||' ));
885 COMPREPLY=($( compgen -W '${COMPREPLY[@]}' -- "$cur" ));
886 return 0
887 ;;
888 esac;
889 if [[ "$cur" == -* ]]; then
890 options="-a -b -c -d -e -f -g -j -k -s -v -u -A -G -W -P -S -X -F -C";
891 [ -n "$bash205" ] && options="$options -o";
892 COMPREPLY=($( compgen -W "$options" -- "$cur" ));
893 else
894 COMPREPLY=($( compgen -A command -- "$cur" ));
895 fi
896}
897_composite ()
898{
899 local cur;
900 COMPREPLY=();
901 cur=`_get_cword`;
902 _ImageMagick;
903 if [[ "$cur" == -* ]]; then
904 COMPREPLY=($( compgen -W '-affine -alpha -authenticate \
905 -blend -blue-primary -border -bordercolor -channel \
906 -colors -colorspace -comment -compose -compress \
907 -debug -decipher -define -density -depth -displace \
908 -display -dispose -dissolve -dither -encipher \
909 -encoding -endian -extract -filter -font -format \
910 -geometry -gravity -green-primary -help -identify \
911 -interlace -interpolate -label -limit -list -log \
912 -monitor -monochrome -negate -page -profile -quality \
913 -quantize -quiet -red-primary -regard-warnings \
914 -repage -resize -respect-parenthesis -rotate \
915 -sampling-factor -scene -seed -sharpen -shave -size \
916 -stegano -stereo -strip -swap -thumbnail -tile \
917 -transform -transparent-color -treedepth -type -units \
918 -unsharp -verbose -version -virtual-pixel -watermark \
919 -white-point -write' -- "$cur" ));
920 else
921 if [[ "$cur" == +* ]]; then
922 COMPREPLY=($( compgen -W '+compress +debug +dither +endian +label \
923 +matte +negate +page +write' -- "$cur" ));
924 else
925 _filedir;
926 fi;
927 fi
928}
929_configure ()
930{
931 local cur;
932 COMPREPLY=();
933 cur=`_get_cword`;
934 [[ "$cur" != -* ]] && return 0;
935 if [ -n "$COMP_CONFIGURE_HINTS" ]; then
936 COMPREPLY=($( $1 --help 2>&1 | awk '/^ --[A-Za-z]/ { print $1; \
937 if ($2 ~ /--[A-Za-z]/) print $2 }' | sed -e 's/[[,].*//g' | grep ^$cur ));
938 else
939 COMPREPLY=($( $1 --help 2>&1 | awk '/^ --[A-Za-z]/ { print $1; \
940 if ($2 ~ /--[A-Za-z]/) print $2 }' | sed -e 's/[[,=].*//g' | grep ^$cur ));
941 fi
942}
943_configured_interfaces ()
944{
945 if [ -f /etc/debian_version ]; then
946 COMPREPLY=($( sed -ne 's|^iface \([^ ]\+\).*$|\1|p' /etc/network/interfaces ));
947 else
948 if [ -f /etc/SuSE-release ]; then
949 COMPREPLY=($( command ls /etc/sysconfig/network/ifcfg-* | sed -ne 's|.*ifcfg-\('"$cur"'.*\)|\1|p' ));
950 else
951 if [ -f /etc/pld-release ]; then
952 COMPREPLY=($( command ls -B /etc/sysconfig/interfaces | sed -ne 's|.*ifcfg-\('"$cur"'.*\)|\1|p' ));
953 else
954 COMPREPLY=($( command ls /etc/sysconfig/network-scripts/ifcfg-* | sed -ne 's|.*ifcfg-\('"$cur"'.*\)|\1|p' ));
955 fi;
956 fi;
957 fi
958}
959_conjure ()
960{
961 local cur;
962 COMPREPLY=();
963 cur=`_get_cword`;
964 _ImageMagick;
965 if [[ "$cur" == -* ]]; then
966 COMPREPLY=($( compgen -W '-debug -help -list -log -monitor -quiet \
967 -regard-warnings -seed -verbose -version' -- "$cur" ));
968 else
969 if [[ "$cur" == +* ]]; then
970 COMPREPLY=($( compgen -W '+debug' -- "$cur" ));
971 else
972 _filedir;
973 fi;
974 fi
975}
976_connected_intfs ()
977{
978 COMPREPLY=($( compgen -W "$( ls /var/run/network/interfaces/)" -- $cur ))
979}
980_connected_prfls ()
981{
982 COMPREPLY=($( compgen -W "$( ls /var/run/network/profiles/ )" -- $cur ))
983}
984_convert ()
985{
986 local cur;
987 COMPREPLY=();
988 cur=`_get_cword`;
989 _ImageMagick;
990 if [[ "$cur" == -* ]]; then
991 COMPREPLY=($( compgen -W '-adaptive-blur -adaptive-resize \
992 -adaptive-sharpen -adjoin -affine -alpha -annotate \
993 -antialias -append -attenuate -authenticate \
994 -auto-orient -average -background -bench -bias \
995 -black-point-compensation -black-threshold \
996 -blue-primary -blur -border -bordercolor -caption \
997 -channel -charcoal -chop -clip -clip-mask -clip-path \
998 -clone -clut -coalesce -colorize -colors -colorspace \
999 -combine -comment -compose -composite -compress \
1000 -contrast -contrast-stretch -convolve -crop -cycle \
1001 -debug -decipher -deconstruct -define -delay -delete \
1002 -density -depth -despeckle -display -dispose -distort \
1003 -dither -draw -edge -emboss -encipher -encoding \
1004 -endian -enhance -equalize -evaluate -extent -extract \
1005 -family -fill -filter -flatten -flip -floodfill -flop \
1006 -font -format -frame -fuzz -fx -gamma -gaussian-blur \
1007 -geometry -gravity -green-primary -help -identify \
1008 -implode -insert -intent -interlace -interpolate \
1009 -label -lat -layers -level -limit -linear-stretch \
1010 -liquid-rescale -list -log -loop -map -mask \
1011 -mattecolor -median -modulate -monitor -monochrome \
1012 -morph -mosaic -motion-blur -negate -noise -normalize \
1013 -opaque -ordered-dither -orient -page -paint -ping \
1014 -pointsize -polaroid -posterize -preview -print \
1015 -process -profile -quality -quantize -quiet \
1016 -radial-blur -raise -random-threshold -recolor \
1017 -red-primary -regard-warnings -region -render -repage \
1018 -resample -resize -respect-parenthesis -reverse -roll \
1019 -rotate -sample -sampling-factor -scale -scene -seed \
1020 -segment -separate -sepia-tone -set -shade -shadow \
1021 -sharpen -shave -shear -sigmoidal-contrast -size \
1022 -sketch -solarize -splice -spread -stretch -strip \
1023 -stroke -strokewidth -style -swap -swirl -taint \
1024 -texture -threshold -thumbnail -tile -tile-offset \
1025 -tint -transform -transparent -transparent-color \
1026 -transpose -transverse -treedepth -trim -type \
1027 -undercolor -unique-colors -units -unsharp -verbose \
1028 -version -view -vignette -virtual-pixel -wave \
1029 -weight -white-point -white-threshold \
1030 -write' -- "$cur" ));
1031 else
1032 if [[ "$cur" == +* ]]; then
1033 COMPREPLY=($( compgen -W '+adjoin +append +compress \
1034 +contrast +debug +dither +endian +gamma +label +map \
1035 +mask +matte +negate +noise +page +raise +render \
1036 +write' -- "$cur" ));
1037 else
1038 _filedir;
1039 fi;
1040 fi
1041}
1042_count_args ()
1043{
1044 args=1;
1045 for ((i=1; i < COMP_CWORD; i++ ))
1046 do
1047 if [[ "${COMP_WORDS[i]}" != -* ]]; then
1048 args=$(($args+1));
1049 fi;
1050 done
1051}
1052_cowsay ()
1053{
1054 local cur prev opts x;
1055 COMPREPLY=();
1056 cur="${COMP_WORDS[COMP_CWORD]}";
1057 prev="${COMP_WORDS[COMP_CWORD-1]}";
1058 opts="-e -f -h -l -n -T -W -b -d -g -p -s -t -w -y";
1059 if [[ "${cur}" == -* || ${COMP_CWORD} -eq 1 ]]; then
1060 COMPREPLY=($(compgen -W "${opts}" -- ${cur}));
1061 return 0;
1062 fi;
1063 case "${prev}" in
1064 -f)
1065 COMPREPLY=($( command ls /usr/share/cowsay| sed -ne 's/^\('$cur'.*\)\.cow$/\1/p'));
1066 return 0
1067 ;;
1068 -[eTW])
1069 COMPREPLY=()
1070 ;;
1071 esac
1072}
1073_cpan2dist ()
1074{
1075 local cur prev packagelist cpandirs;
1076 COMPREPLY=();
1077 cur=`_get_cword`;
1078 prev=${COMP_WORDS[COMP_CWORD-1]};
1079 case $prev in
1080 --format)
1081 COMPREPLY=($( compgen -W '$(perl -MCPANPLUS::Dist -e \
1082 "print map { \"\$_\n\" } CPANPLUS::Dist->dist_types")' -- "$cur" ));
1083 return 0
1084 ;;
1085 --@(banlist|ignorelist|modulelist|logfile))
1086 _filedir;
1087 return 0
1088 ;;
1089 esac;
1090 if [[ "$cur" == -* ]]; then
1091 COMPREPLY=($( compgen -W '--help --skiptest --force --install \
1092 --verbose --keepsource --makefile --buildprereq \
1093 --archive --flushcache --defaults --edit-metafile \
1094 --format --ban --banlist --ignore --ignorelist \
1095 --modulelist --logfile --timeout --set-config \
1096 --set-program --dist-opts --default-banlist \
1097 --default-ignorelist' -- $cur ));
1098 else
1099 cpandirs=("$HOME/.cpanplus/" "$HOME/.cpan/source/modules/");
1100 for dir in ${cpandirs[@]};
1101 do
1102 [ -d "$dir" -a -r "$dir/02packages.details.txt.gz" ] && packagelist="$dir/02packages.details.txt.gz";
1103 done;
1104 COMPREPLY=($( zgrep "^${cur//-/::}" $packagelist 2>/dev/null | awk '{print $1}' | sed -e 's/::/-/g' ));
1105 fi
1106}
1107_cpio ()
1108{
1109 local cur prev split=false;
1110 COMPREPLY=();
1111 cur=`_get_cword`;
1112 prev=${COMP_WORDS[COMP_CWORD-1]};
1113 _split_longopt && split=true;
1114 case $prev in
1115 -H | --format)
1116 _cpio_format;
1117 return 0
1118 ;;
1119 -@(E|F|I|-?(pattern-)file))
1120 _filedir;
1121 return 0
1122 ;;
1123 -R | --owner)
1124 _usergroup;
1125 return 0
1126 ;;
1127 --rsh-command)
1128 COMPREPLY=($( compgen -c -- "$cur" ));
1129 return 0
1130 ;;
1131 esac;
1132 $split && return 0;
1133 if [ $COMP_CWORD -eq 1 ]; then
1134 COMPREPLY=($( compgen -W '-o --create -i --extract -p --pass-through' -- "$cur" ));
1135 else
1136 case ${COMP_WORDS[1]} in
1137 -@(o|-create))
1138 if [[ "$cur" == -* ]]; then
1139 COMPREPLY=($( compgen -W '-0 -a -c -v -A -B\
1140 -L -V -C -H -M -O -F --file --format\
1141 --message --null --reset-access-time\
1142 --verbose --dot --append --block-size\
1143 --dereference --io-size --quiet\
1144 --force-local --rsh-command --help\
1145 --version' -- "$cur" ));
1146 fi
1147 ;;
1148 -@(i|-extract))
1149 if [[ "$cur" == -* ]]; then
1150 COMPREPLY=($( compgen -W '-b -c -d -f -m -n -r\
1151 -t -s -u -v -B -S -V -C -E -H -M -R -I\
1152 -F --file --make-directories\
1153 --nonmatching\
1154 --preserve-modification-time\
1155 --numeric-uid-gid --rename -t --list\
1156 --swap-bytes --swap --dot\
1157 --unconditional --verbose --block-size\
1158 --swap-halfwords --io-size\
1159 --pattern-file --format --owner\
1160 --no-preserve-owner --message\
1161 --force-local --no-absolute-filenames\
1162 --sparse --only-verify-crc --quiet\
1163 --rsh-command --help\
1164 --version' -- "$cur" ));
1165 fi
1166 ;;
1167 -@(p|-pass-through))
1168 if [[ "$cur" == -* ]]; then
1169 COMPREPLY=($( compgen -W '-0 -a -d -l -m -u -v\
1170 -L -V -R --null --reset-access-time\
1171 --make-directories --link --quiet\
1172 --preserve-modification-time\
1173 --unconditional --verbose --dot\
1174 --dereference --owner\
1175 --no-preserve-owner --sparse --help\
1176 --version' -- "$cur" ));
1177 else
1178 _filedir -d;
1179 fi
1180 ;;
1181 esac;
1182 fi
1183}
1184_cpio_format ()
1185{
1186 COMPREPLY=($( compgen -W 'bin odc newc crc tar ustar hpbin hpodc' -- "$cur" ))
1187}
1188_dd ()
1189{
1190 local cur;
1191 COMPREPLY=();
1192 cur=`_get_cword =`;
1193 case "$cur" in
1194 if=* | of=*)
1195 cur=${cur#*=};
1196 _filedir;
1197 return 0
1198 ;;
1199 conv=*)
1200 cur=${cur#*=};
1201 COMPREPLY=($( compgen -W 'ascii ebcdic ibm block unblock \
1202 lcase notrunc ucase swab noerror sync' -- "$cur" ));
1203 return 0
1204 ;;
1205 esac;
1206 _expand || return 0;
1207 COMPREPLY=($( compgen -W '--help --version' -- "$cur" ) $( compgen -W 'bs cbs conv count ibs if obs of seek skip' -S '=' -- "$cur" ))
1208}
1209_dfutool ()
1210{
1211 local cur prev;
1212 COMPREPLY=();
1213 cur=`_get_cword`;
1214 prev=${COMP_WORDS[COMP_CWORD-1]};
1215 case $prev in
1216 -@(d|-device))
1217 _bluetooth_devices;
1218 return 0
1219 ;;
1220 esac;
1221 if [[ "$cur" == -* ]]; then
1222 COMPREPLY=($( compgen -W '-h --help -d --device' -- "$cur" ));
1223 else
1224 _count_args;
1225 case $args in
1226 1)
1227 COMPREPLY=($( compgen -W 'verify modify \
1228 upgrade archive' -- "$cur" ))
1229 ;;
1230 2)
1231 _filedir
1232 ;;
1233 esac;
1234 fi
1235}
1236_display ()
1237{
1238 local cur;
1239 COMPREPLY=();
1240 cur=`_get_cword`;
1241 _ImageMagick;
1242 if [[ "$cur" == -* ]]; then
1243 COMPREPLY=($( compgen -W '-alpha -antialias -authenticate \
1244 -auto-orient -backdrop -background -border \
1245 -bordercolor -borderwidth -channel -clip \
1246 -clip-path -coalesce -colormap -colors -colorspace \
1247 -comment -compress -contrast -crop -debug -decipher \
1248 -define -delay -density -depth -despeckle -display \
1249 -dispose -dither -edge -endian -enhance -extract \
1250 -filter -flatten -flip -flop -font -foreground \
1251 -format -frame -gamma -geometry -help -iconGeometry \
1252 -iconic -identify -immutable -interlace -interpolate \
1253 -label -limit -list -log -loop -map -mattecolor \
1254 -monitor -monochrome -name -negate -page -profile \
1255 -quality -quantize -quiet -raise -regard-warnings \
1256 -remote -repage -resample -resize \
1257 -respect-parenthesis -roll -rotate -sample \
1258 -sampling-factor -scenes -seed -segment -set \
1259 -shared-memory -sharpen -size -strip -texture -title \
1260 -transparent-color -treedepth -trim -update \
1261 -usePixmap -verbose -version -virtual-pixel -visual \
1262 -window -window-group -write' -- "$cur" ));
1263 else
1264 if [[ "$cur" == +* ]]; then
1265 COMPREPLY=($( compgen -W '+compress +contrast +debug +dither \
1266 +endian +gamma +label +map +matte +negate +page \
1267 +raise +write' -- "$cur" ));
1268 else
1269 _filedir;
1270 fi;
1271 fi
1272}
1273_expand ()
1274{
1275 if [[ "$cur" == \~*/* ]]; then
1276 eval cur=$cur;
1277 else
1278 if [[ "$cur" == \~* ]]; then
1279 cur=${cur#\~};
1280 COMPREPLY=($( compgen -P '~' -u "$cur" ));
1281 [ ${#COMPREPLY[@]} -eq 1 ] && eval COMPREPLY[0]=${COMPREPLY[0]};
1282 return ${#COMPREPLY[@]};
1283 fi;
1284 fi
1285}
1286_export ()
1287{
1288 local cur;
1289 COMPREPLY=();
1290 cur=`_get_cword`;
1291 case "$COMP_LINE" in
1292 *=\$*)
1293 COMPREPLY=($( compgen -v -P '$' -- "${cur#*=\$}" ))
1294 ;;
1295 *[^=])
1296 COMPREPLY=($( compgen -v -S '=' -- "$cur" ))
1297 ;;
1298 *=)
1299 COMPREPLY=("$( eval echo -n \"$`echo ${cur%=}`\" |
1300 ( echo -n \'
1301 sed -e 's/'\''/'\''\\\'\'''\''/g'
1302 echo -n \' ) )")
1303 ;;
1304 esac
1305}
1306_faillog ()
1307{
1308 local cur prev split=false;
1309 COMPREPLY=();
1310 cur=`_get_cword`;
1311 prev=${COMP_WORDS[COMP_CWORD-1]};
1312 _split_longopt && split=true;
1313 case "$prev" in
1314 -h | --help | -l | --lock-time | -m | --maximum | -t | --time)
1315 return 0
1316 ;;
1317 -u | --user)
1318 COMPREPLY=($( compgen -u -- "$cur" ));
1319 return 0
1320 ;;
1321 esac;
1322 $split && return 0;
1323 if [[ "$cur" == -* ]]; then
1324 COMPREPLY=($( compgen -W '-a --all -h --help -l --lock-time \
1325 -m --maximum -r --reset -t --time -u --user' -- "$cur" ));
1326 return 0;
1327 fi
1328}
1329_filedir ()
1330{
1331 local IFS='
1332' xspec;
1333 _expand || return 0;
1334 local -a toks;
1335 local tmp;
1336 toks=(${toks[@]-} $(
1337 compgen -d -- "$(quote_readline "$cur")" | {
1338 while read -r tmp; do
1339 echo $tmp
1340 done
1341}
1342));
1343 if [[ "$1" != -d ]]; then
1344 xspec=${1:+"!*.$1"};
1345 toks=(${toks[@]-} $(
1346 compgen -f -X "$xspec" -- "$(quote_readline "$cur")" | {
1347 while read -r tmp; do
1348 [ -n $tmp ] && echo $tmp
1349 done
1350}
1351));
1352 fi;
1353 COMPREPLY=("${COMPREPLY[@]}" "${toks[@]}")
1354}
1355_filedir_xspec ()
1356{
1357 local IFS cur xspec;
1358 IFS='
1359';
1360 COMPREPLY=();
1361 cur=`_get_cword`;
1362 _expand || return 0;
1363 xspec=$( sed -ne '/^complete .*[ ]'${1##*/}'\([ ]\|$\)/{p;q;}' $BASH_COMPLETION );
1364 xspec=${xspec#*-X };
1365 xspec=${xspec%% *};
1366 local -a toks;
1367 local tmp;
1368 toks=(${toks[@]-} $(
1369 compgen -d -- "$(quote_readline "$cur")" | {
1370 while read -r tmp; do
1371 # see long TODO comment in _filedir() --David
1372 echo $tmp
1373 done
1374 }
1375 ));
1376 toks=(${toks[@]-} $(
1377 eval compgen -f -X "$xspec" -- "\$(quote_readline "\$cur")" | {
1378 while read -r tmp; do
1379 [ -n $tmp ] && echo $tmp
1380 done
1381 }
1382 ));
1383 COMPREPLY=("${toks[@]}")
1384}
1385_find ()
1386{
1387 local cur prev i exprfound onlyonce;
1388 COMPREPLY=();
1389 cur=`_get_cword`;
1390 prev=${COMP_WORDS[COMP_CWORD-1]};
1391 case "$prev" in
1392 -@(max|min)depth)
1393 COMPREPLY=($( compgen -W '0 1 2 3 4 5 6 7 8 9' -- "$cur" ));
1394 return 0
1395 ;;
1396 -?(a|c)newer | -fls | -fprint?(0|f) | -?(i)?(l)name | -?(i)wholename)
1397 _filedir;
1398 return 0
1399 ;;
1400 -fstype)
1401 [ -e /proc/filesystems ] && COMPREPLY=($( compgen -W "$( cut -d' ' -f2 /proc/filesystems )" -- "$cur" ));
1402 return 0
1403 ;;
1404 -gid)
1405 _gids;
1406 return 0
1407 ;;
1408 -group)
1409 if [ -n "$bash205" ]; then
1410 COMPREPLY=($( compgen -g -- $cur 2>/dev/null));
1411 fi;
1412 return 0
1413 ;;
1414 -?(x)type)
1415 COMPREPLY=($( compgen -W 'b c d p f l s' -- "$cur" ));
1416 return 0
1417 ;;
1418 -uid)
1419 _uids;
1420 return 0
1421 ;;
1422 -user)
1423 COMPREPLY=($( compgen -u -- "$cur" ));
1424 return 0
1425 ;;
1426 -exec | -ok)
1427 COMP_WORDS=(COMP_WORDS[0] "$cur");
1428 COMP_CWORD=1;
1429 _command;
1430 return 0
1431 ;;
1432 -[acm]min | -[acm]time | -?(i)?(l)?(whole)name | -inum | -?(i)path | -?(i)regex | -links | -perm | -size | -used | -printf)
1433 return 0
1434 ;;
1435 esac;
1436 _expand || return 0;
1437 for i in ${COMP_WORDS[@]};
1438 do
1439 [[ "$i" = [-\(\),\!]* ]] && exprfound=1 && break;
1440 done;
1441 if [ "$exprfound" != 1 ] && [[ "$cur" != [-\(\),\!]* ]]; then
1442 _filedir -d;
1443 return 0;
1444 fi;
1445 COMPREPLY=($( compgen -W '-daystart -depth -follow -help -maxdepth \
1446 -mindepth -mount -noleaf -version -xdev -amin -anewer \
1447 -atime -cmin -cnewer -ctime -empty -false -fstype \
1448 -gid -group -ilname -iname -inum -ipath -iregex \
1449 -wholename \
1450 -links -lname -mmin -mtime -name -newer -nouser \
1451 -nogroup -perm -regex -size -true -type -uid -used \
1452 -user -xtype -exec -fls -fprint -fprint0 -fprintf -ok \
1453 -print -print0 -printf -prune -ls -wholename -iwholename' -- "$cur" ));
1454 onlyonce=' -daystart -depth -follow -help -maxdepth -mindepth -mount \
1455 -noleaf -version -xdev ';
1456 COMPREPLY=($( echo "${COMP_WORDS[@]}" | (while read -d ' ' i; do
1457 [ "$i" == "" ] ||
1458 [ "${onlyonce/ ${i%% *} / }" == "$onlyonce" ] &&
1459 continue
1460 # flatten array with spaces on either side,
1461 # otherwise we cannot grep on word boundaries of
1462 # first and last word
1463 COMPREPLY=" ${COMPREPLY[@]} "
1464 # remove word from list of completions
1465 COMPREPLY=( ${COMPREPLY/ ${i%% *} / } )
1466 done
1467 echo "${COMPREPLY[@]}")
1468 ));
1469 _filedir;
1470 return 0
1471}
1472_function ()
1473{
1474 local cur prev;
1475 COMPREPLY=();
1476 cur=`_get_cword`;
1477 prev=${COMP_WORDS[COMP_CWORD-1]};
1478 if [[ $1 == @(declare|typeset) ]]; then
1479 if [ "$prev" = -f ]; then
1480 COMPREPLY=($( compgen -A function -- "$cur" ));
1481 else
1482 if [[ "$cur" == -* ]]; then
1483 COMPREPLY=($( compgen -W '-a -f -F -i -r -x -p' -- "$cur" ));
1484 fi;
1485 fi;
1486 else
1487 if [ $COMP_CWORD -eq 1 ]; then
1488 COMPREPLY=($( compgen -A function -- "$cur" ));
1489 else
1490 COMPREPLY=("() $( type -- ${COMP_WORDS[1]} | sed -e 1,2d )");
1491 fi;
1492 fi
1493}
1494_gdb ()
1495{
1496 local cur prev;
1497 COMPREPLY=();
1498 cur=`_get_cword`;
1499 prev=${COMP_WORDS[COMP_CWORD-1]};
1500 if [ $COMP_CWORD -eq 1 ]; then
1501 local IFS;
1502 if [[ "$cur" == */* ]]; then
1503 IFS='
1504';
1505 COMPREPLY=($( PATH="$PATH:." compgen -d -c -- "$cur" ));
1506 else
1507 IFS=":";
1508 local path_array=($(echo "$PATH" | sed 's/::\+/:/g;s/^:\|:$//g'));
1509 IFS='
1510';
1511 COMPREPLY=($( compgen -d -W '$(find "${path_array[@]}" . \
1512 -mindepth 1 -maxdepth 1 -not -type d -executable \
1513 -printf "%f\\n" 2>/dev/null)' -- "$cur" ));
1514 fi;
1515 else
1516 if [ $COMP_CWORD -eq 2 ]; then
1517 prev=${prev##*/};
1518 COMPREPLY=($( compgen -fW "$( command ps axo comm,pid | awk '{if ($1 ~ /^'"$prev"'/) print $2}' )" -- "$cur" ));
1519 fi;
1520 fi
1521}
1522_get_command ()
1523{
1524 local i;
1525 command=;
1526 for ((i=1; i < COMP_CWORD; i++ ))
1527 do
1528 if [[ "${COMP_WORDS[i]}" != -* ]]; then
1529 command=${COMP_WORDS[i]};
1530 break;
1531 fi;
1532 done
1533}
1534_get_cword ()
1535{
1536 if [ -n "$bash4" ]; then
1537 __get_cword4 "$@";
1538 else
1539 __get_cword3;
1540 fi
1541}
1542_getent ()
1543{
1544 local cur prev;
1545 COMPREPLY=();
1546 cur=`_get_cword`;
1547 prev=${COMP_WORDS[COMP_CWORD-1]};
1548 case $prev in
1549 passwd)
1550 COMPREPLY=($( compgen -u "$cur" ));
1551 return 0
1552 ;;
1553 group)
1554 COMPREPLY=($( compgen -g "$cur" ));
1555 return 0
1556 ;;
1557 services)
1558 COMPREPLY=($( compgen -s "$cur" ));
1559 return 0
1560 ;;
1561 hosts)
1562 COMPREPLY=($( compgen -A hostname "$cur" ));
1563 return 0
1564 ;;
1565 protocols | networks | ahosts | ahostsv4 | ahostsv6 | rpc)
1566 COMPREPLY=($( getent "$prev" | sed -ne 's|^\('"$cur"'[^[:space:]]*\).*|\1|p' ));
1567 return 0
1568 ;;
1569 aliases | shadow)
1570 COMPREPLY=($( getent "$prev" | sed -ne 's|^\('"$cur"'[^:]*\).*|\1|p' ));
1571 return 0
1572 ;;
1573 esac;
1574 if [ $COMP_CWORD -eq 1 ]; then
1575 COMPREPLY=($( compgen -W 'passwd group hosts services protocols \
1576 networks ahosts ahostsv4 ahostsv6 aliases ethers netgroup rpc \
1577 shadow' -- "$cur" ));
1578 fi
1579}
1580_gids ()
1581{
1582 if type getent &>/dev/null; then
1583 COMPREPLY=($( getent group | awk -F: '{if ($3 ~ /^'"$cur"'/) print $3}' ));
1584 else
1585 if type perl &>/dev/null; then
1586 COMPREPLY=($( compgen -W '$( perl -e '"'"'while (($gid) = (getgrent)[2]) { print $gid . "\n" }'"'"' )' -- "$cur" ));
1587 else
1588 COMPREPLY=($( awk 'BEGIN {FS=":"} {if ($3 ~ /^'"$cur"'/) print $3}' /etc/group ));
1589 fi;
1590 fi
1591}
1592_gpasswd ()
1593{
1594 local cur prev;
1595 COMPREPLY=();
1596 cur=`_get_cword`;
1597 prev=${COMP_WORDS[COMP_CWORD-1]};
1598 case "$prev" in
1599 -a | -d | -A | -M)
1600 COMPREPLY=($( compgen -u -- "$cur" ));
1601 return 0
1602 ;;
1603 esac;
1604 if [[ "$cur" == -* ]]; then
1605 COMPREPLY=($( compgen -W '-a -d -r -R -A -M' -- "$cur" ));
1606 return 0;
1607 fi;
1608 [ -n "$bash205" ] && COMPREPLY=($( compgen -g -- "$cur" ))
1609}
1610_gpg ()
1611{
1612 local cur prev;
1613 COMPREPLY=();
1614 cur=`_get_cword`;
1615 prev=${COMP_WORDS[COMP_CWORD-1]};
1616 case "$prev" in
1617 -@(s|-sign|-clearsign|-decrypt-files|-load-extension))
1618 _filedir;
1619 return 0
1620 ;;
1621 --@(export|@(?(l|nr|nrl)sign|edit)-key))
1622 COMPREPLY=($( compgen -W "$( gpg --list-keys 2>/dev/null | sed -ne 's@^pub.*/\([^ ]*\).*$@\1@p;s@^.*\(<\([^>]*\)>\).*$@\2@p')" -- "$cur" ));
1623 return 0
1624 ;;
1625 -@(r|-recipient))
1626 COMPREPLY=($( compgen -W "$( gpg --list-keys 2>/dev/null | sed -ne 's@^.*<\([^>]*\)>.*$@\1@p')" -- "$cur" ));
1627 if [ -e ~/.gnupg/gpg.conf ]; then
1628 COMPREPLY=("${COMPREPLY[@]}" $( compgen -W "$( sed -ne 's@^[ \t]*group[ \t][ \t]*\([^=]*\).*$@\1@p' ~/.gnupg/gpg.conf )" -- "$cur"));
1629 fi;
1630 return 0
1631 ;;
1632 esac;
1633 if [[ "$cur" == -* ]]; then
1634 COMPREPLY=($( compgen -W '-s -b -e -f -c -d -a -r -u -Z -o -v\
1635 -q -n -N $(gpg --dump-options)' -- "$cur" ));
1636 fi
1637}
1638_gpg2 ()
1639{
1640 local cur prev;
1641 COMPREPLY=();
1642 cur=`_get_cword`;
1643 prev=${COMP_WORDS[COMP_CWORD-1]};
1644 case "$prev" in
1645 --homedir)
1646 _filedir -d;
1647 return 0
1648 ;;
1649 -@(s|-sign|-clearsign|-options|-decrypt))
1650 _filedir;
1651 return 0
1652 ;;
1653 --@(export|@(?(l|nr|nrl)sign|edit)-key))
1654 COMPREPLY=($( compgen -W "$( gpg2 --list-keys 2>/dev/null | sed -ne 's@^pub.*/\([^ ]*\).*$@\1@p;s@^.*\(<\([^>]*\)>\).*$@\2@p')" -- "$cur" ));
1655 return 0
1656 ;;
1657 -@(r|-recipient))
1658 COMPREPLY=($( compgen -W "$( gpg2 --list-keys 2>/dev/null | sed -ne 's@^.*<\([^>]*\)>.*$@\1@p')" -- "$cur" ));
1659 if [ -e ~/.gnupg/gpg.conf ]; then
1660 COMPREPLY=("${COMPREPLY[@]}" $( compgen -W "$( sed -ne 's@^[ \t]*group[ \t][ \t]*\([^=]*\).*$@\1@p' ~/.gnupg/gpg.conf)" -- "$cur"));
1661 fi;
1662 return 0
1663 ;;
1664 esac;
1665 if [[ "$cur" == -* ]]; then
1666 COMPREPLY=($( compgen -W '-s -b -e -c -d -k -K -a -r -u -z -o -v \
1667 -n -N -i -h -R -t $(gpg2 --dump-options)' -- "$cur" ));
1668 fi
1669}
1670_groupadd ()
1671{
1672 local cur prev split=false;
1673 COMPREPLY=();
1674 cur=`_get_cword`;
1675 prev=${COMP_WORDS[COMP_CWORD-1]};
1676 _split_longopt && split=true;
1677 case "$prev" in
1678 -g | --gid | -K | --key | -p | --password)
1679 return 0
1680 ;;
1681 esac;
1682 $split && return 0;
1683 if [[ "$cur" == -* ]]; then
1684 COMPREPLY=($( compgen -W '-f --force -g --gid -h --help \
1685 -K --key -o --non-unique -p --password -r --system' -- "$cur" ));
1686 return 0;
1687 fi
1688}
1689_groupmems ()
1690{
1691 local cur prev;
1692 COMPREPLY=();
1693 cur=`_get_cword`;
1694 prev=${COMP_WORDS[COMP_CWORD-1]};
1695 case "$prev" in
1696 -a | -d)
1697 COMPREPLY=($( compgen -u -- "$cur" ));
1698 return 0
1699 ;;
1700 -g)
1701 [ -n "$bash205" ] && COMPREPLY=($( compgen -g -- "$cur" ));
1702 return 0
1703 ;;
1704 esac;
1705 if [[ "$cur" == -* ]]; then
1706 COMPREPLY=($( compgen -W '-a -d -p -g -l' -- "$cur" ));
1707 return 0;
1708 fi
1709}
1710_groupmod ()
1711{
1712 local cur prev split=false;
1713 COMPREPLY=();
1714 cur=`_get_cword`;
1715 prev=${COMP_WORDS[COMP_CWORD-1]};
1716 _split_longopt && split=true;
1717 case "$prev" in
1718 -g | --gid | -h | --help | -n | --new-name | -p | --password)
1719 return 0
1720 ;;
1721 esac;
1722 $split && return 0;
1723 if [[ "$cur" == -* ]]; then
1724 COMPREPLY=($( compgen -W '-g --gid -h --help -n --new-name \
1725 -o --non-unique -p --password' -- "$cur" ));
1726 return 0;
1727 fi;
1728 [ -n "$bash205" ] && COMPREPLY=($( compgen -g -- "$cur" ))
1729}
1730_grpck ()
1731{
1732 local cur;
1733 COMPREPLY=();
1734 cur=`_get_cword`;
1735 if [[ "$cur" == -* ]]; then
1736 COMPREPLY=($( compgen -W '-r -s' -- "$cur" ));
1737 return 0;
1738 fi;
1739 _filedir
1740}
1741_gzip ()
1742{
1743 local cur prev xspec helpopts;
1744 COMPREPLY=();
1745 cur=`_get_cword`;
1746 prev=${COMP_WORDS[COMP_CWORD-1]};
1747 helpopts=`_parse_help gzip`;
1748 if [[ "$cur" == -* ]]; then
1749 COMPREPLY=($( compgen -W "$helpopts -2 -3 -4 -5 -6 -7 -8" -- "$cur" ));
1750 return 0;
1751 fi;
1752 local IFS='
1753';
1754 xspec="*.?(t)gz";
1755 if [[ "$prev" == --* ]]; then
1756 [[ "$prev" == --decompress || "$prev" == --list || "$prev" == --test ]] && xspec="!"$xspec;
1757 [[ "$prev" == --force ]] && xspec=;
1758 else
1759 if [[ "$prev" == -* ]]; then
1760 [[ "$prev" == -*[dlt]* ]] && xspec="!"$xspec;
1761 [[ "$prev" == -*f* ]] && xspec=;
1762 else
1763 if [ "$prev" = '>' -o "$prev" = '>>' ]; then
1764 xspec=;
1765 else
1766 if [ "$prev" = '<' ]; then
1767 xspec=;
1768 fi;
1769 fi;
1770 fi;
1771 fi;
1772 _expand || return 0;
1773 COMPREPLY=($( compgen -f -X "$xspec" -- "$cur" ) $( compgen -d -- "$cur" ))
1774}
1775_hciattach ()
1776{
1777 local cur;
1778 COMPREPLY=();
1779 cur=`_get_cword`;
1780 if [[ "$cur" == -* ]]; then
1781 COMPREPLY=($( compgen -W '-n -p -t -b -s -l' -- "$cur" ));
1782 else
1783 _count_args;
1784 case $args in
1785 1)
1786 COMPREPLY=($( command ls /dev/tty* ));
1787 COMPREPLY=($( compgen -W '${COMPREPLY[@]} \
1788 ${COMPREPLY[@]#/dev/}' -- "$cur" ))
1789 ;;
1790 2)
1791 COMPREPLY=($( compgen -W 'any ericsson digi \
1792 xircom csr bboxes swave bcsp 0x0105 \
1793 0x080a 0x0160 0x0002' -- "$cur" ))
1794 ;;
1795 3)
1796 COMPREPLY=($( compgen -W '9600 19200 38400 \
1797 57600 115200 230400 460800 921600' -- "$cur" ))
1798 ;;
1799 4)
1800 COMPREPLY=($( compgen -W 'flow noflow' -- "$cur" ))
1801 ;;
1802 5)
1803 _bluetooth_adresses
1804 ;;
1805 esac;
1806 fi
1807}
1808_hciconfig ()
1809{
1810 local cur;
1811 COMPREPLY=();
1812 cur=`_get_cword`;
1813 _get_command;
1814 if [ -z $command ]; then
1815 if [[ "$cur" == -* ]]; then
1816 COMPREPLY=($( compgen -W '-h --help -a --all' -- "$cur" ));
1817 else
1818 COMPREPLY=($( compgen -W 'up down reset rstat auth \
1819 noauth encrypt noencrypt secmgr nosecmgr \
1820 piscan noscan iscan pscan ptype name class \
1821 voice iac inqmode inqdata inqtype inqparams \
1822 pageparms pageto afhmode aclmtu scomtu putkey \
1823 delkey commands features version revision lm' -- "$cur" ));
1824 fi;
1825 else
1826 case $command in
1827 @(putkey|delkey))
1828 _count_args;
1829 if [ $args -eq 2 ]; then
1830 _bluetooth_adresses;
1831 fi
1832 ;;
1833 lm)
1834 _count_args;
1835 if [ $args -eq 2 ]; then
1836 COMPREPLY=($( compgen -W 'MASTER \
1837 SLAVE NONE ACCEPT' -- "$cur" ));
1838 fi
1839 ;;
1840 ptype)
1841 _count_args;
1842 if [ $args -eq 2 ]; then
1843 _bluetooth_packet_types;
1844 fi
1845 ;;
1846 esac;
1847 fi
1848}
1849_hcitool ()
1850{
1851 local cur prev split=false;
1852 COMPREPLY=();
1853 cur=`_get_cword`;
1854 prev=${COMP_WORDS[COMP_CWORD-1]};
1855 _split_longopt && split=true;
1856 case $prev in
1857 -i)
1858 _bluetooth_devices;
1859 return 0
1860 ;;
1861 --role)
1862 COMPREPLY=($( compgen -W 'm s' -- "$cur" ));
1863 return 0
1864 ;;
1865 --pkt-type)
1866 _bluetooth_packet_types;
1867 return 0
1868 ;;
1869 esac;
1870 $split && return 0;
1871 _get_command;
1872 if [ -z $command ]; then
1873 if [[ "$cur" == -* ]]; then
1874 COMPREPLY=($( compgen -W '-h -i' -- "$cur" ));
1875 else
1876 COMPREPLY=($( compgen -W 'dev inq scan name info \
1877 spinq epinq cmd con cc dc sr cpt rssi lq tpl \
1878 afh lst auth enc key clkoff clock' -- "$cur" ));
1879 fi;
1880 else
1881 case $command in
1882 @(name|info|dc|rssi|lq|afh|auth|key|clkoff|lst))
1883 _count_args;
1884 if [ $args -eq 2 ]; then
1885 _bluetooth_adresses;
1886 fi
1887 ;;
1888 cc)
1889 if [[ "$cur" == -* ]]; then
1890 COMPREPLY=($( compgen -W '--role --pkt-type' -- "$cur" ));
1891 else
1892 _count_args;
1893 if [ $args -eq 2 ]; then
1894 _bluetooth_adresses;
1895 fi;
1896 fi
1897 ;;
1898 sr)
1899 _count_args;
1900 if [ $args -eq 2 ]; then
1901 _bluetooth_adresses;
1902 else
1903 COMPREPLY=($( compgen -W 'master slave' -- "$cur" ));
1904 fi
1905 ;;
1906 cpt)
1907 _count_args;
1908 if [ $args -eq 2 ]; then
1909 _bluetooth_adresses;
1910 else
1911 _bluetooth_packet_types;
1912 fi
1913 ;;
1914 @(tpl|enc|clock))
1915 _count_args;
1916 if [ $args -eq 2 ]; then
1917 _bluetooth_adresses;
1918 else
1919 COMPREPLY=($( compgen -W '0 1' -- "$cur" ));
1920 fi
1921 ;;
1922 esac;
1923 fi
1924}
1925_heimdal_encodings ()
1926{
1927 COMPREPLY=($( compgen -W 'des-cbc-mcrc des-cbc-md4 des-cbc-md5 \
1928 des3-cbc-sha1 arcfour-hmac-md5 aes128-cts-hmac-sha1-96 \
1929 aes256-cts-hmac-sha1-96' -- "$cur" ))
1930}
1931_heimdal_principals ()
1932{
1933 COMPREPLY=($( compgen -W "$( kadmin -l dump 2>/dev/null | awk '{print $1}' )" -- "$cur" ))
1934}
1935_heimdal_realms ()
1936{
1937 COMPREPLY=($( compgen -W "( kadmin -l dump 2>/dev/null | awk '{print $1}' | awk -F @ '{print $2}' )" -- "$cur" ))
1938}
1939_hid2hci ()
1940{
1941 local cur;
1942 COMPREPLY=();
1943 cur=`_get_cword`;
1944 if [[ "$cur" == -* ]]; then
1945 COMPREPLY=($( compgen -W '-h --help -q --quiet -0 --tohci -1 \
1946 --tohid' -- "$cur" ));
1947 fi
1948}
1949_iconv ()
1950{
1951 local cur prev;
1952 COMPREPLY=();
1953 cur=`_get_cword`;
1954 prev=${COMP_WORDS[COMP_CWORD-1]};
1955 case "$prev" in
1956 -@(f|t|-@(from|to)-code))
1957 COMPREPLY=($( compgen -W '$( iconv --list | sed -e "s@//@@;" )' -- "$cur" ));
1958 return 0
1959 ;;
1960 esac;
1961 if [[ "$cur" = -* ]]; then
1962 COMPREPLY=($( compgen -W '--from-code -f --to-code -t --list
1963 --output -o --verbose' -- "$cur" ));
1964 return 0;
1965 fi
1966}
1967_id ()
1968{
1969 local cur;
1970 COMPREPLY=();
1971 cur=`_get_cword`;
1972 if [[ "$cur" == -* ]]; then
1973 COMPREPLY=($( compgen -W '-a -g --group -G --groups -n --name\
1974 -r --real -u --user --help --version' -- "$cur" ));
1975 else
1976 COMPREPLY=($( compgen -u "$cur" ));
1977 fi
1978}
1979_identify ()
1980{
1981 local cur;
1982 COMPREPLY=();
1983 cur=`_get_cword`;
1984 _ImageMagick;
1985 if [[ "$cur" == -* ]]; then
1986 COMPREPLY=($( compgen -W '-alpha -antialias -authenticate \
1987 -channel -colorspace -crop -debug -define -density \
1988 -depth -extract -format -fuzz -gamma -help -interlace \
1989 -interpolate -limit -list -log -monitor -ping -quiet \
1990 -regard-warnings -respect-parenthesis \
1991 -sampling-factor -seed -set -size -strip -units \
1992 -verbose -version -virtual-pixel' -- "$cur" ));
1993 else
1994 if [[ "$cur" == +* ]]; then
1995 COMPREPLY=($( compgen -W '+debug' -- "$cur" ));
1996 else
1997 _filedir;
1998 fi;
1999 fi
2000}
2001_import ()
2002{
2003 local cur;
2004 COMPREPLY=();
2005 cur=`_get_cword`;
2006 _ImageMagick;
2007 if [[ "$cur" == -* ]]; then
2008 COMPREPLY=($( compgen -W '-adjoin -annotate -border -channel \
2009 -colors -colorspace -comment -compress -crop -debug \
2010 -define -delay -density -depth -descend -display \
2011 -dispose -dither -encipher -encoding -endian -filter \
2012 -format -frame -geometry -gravity -help -identify \
2013 -interlace -interpolate -label -limit -list -log \
2014 -monitor -monochrome -negate -page -pause -pointsize \
2015 -quality -quantize -quiet -regard-warnings -repage \
2016 -resize -respect-parenthesis -rotate -sampling-factor \
2017 -scene -screen -seed -set -silent -snaps -strip \
2018 -thumbnail -transparent -transparent-color -treedepth \
2019 -trim -type -verbose -version -virtual-pixel \
2020 -window' -- "$cur" ));
2021 else
2022 if [[ "$cur" == +* ]]; then
2023 COMPREPLY=($( compgen -W '+debug' -- "$cur" ));
2024 else
2025 _filedir;
2026 fi;
2027 fi
2028}
2029_info ()
2030{
2031 local cur i infopath;
2032 COMPREPLY=();
2033 cur=`_get_cword`;
2034 _expand || return 0;
2035 if [[ "$cur" == */* ]]; then
2036 _filedir;
2037 return 0;
2038 fi;
2039 infopath='/usr/share/info';
2040 if [ "${INFOPATH: -1:1}" == ':' ]; then
2041 infopath=${INFOPATH}${infopath};
2042 else
2043 if [ ${INFOPATH:+set} ]; then
2044 infopath=$INFOPATH;
2045 fi;
2046 fi;
2047 infopath=$infopath:;
2048 if [ -n "$cur" ]; then
2049 infopath="${infopath//://$cur* }";
2050 else
2051 infopath="${infopath//:// }";
2052 fi;
2053 COMPREPLY=($( eval command ls "$infopath" 2>/dev/null ));
2054 COMPREPLY=(${COMPREPLY[@]##*/?(:)});
2055 for ((i=0 ; i < ${#COMPREPLY[@]} ; ++i ))
2056 do
2057 if [ "${COMPREPLY[$i]}" == 'dir' ]; then
2058 unset COMPREPLY[$i];
2059 fi;
2060 done;
2061 COMPREPLY=(${COMPREPLY[@]%.@(gz|bz2|xz|lzma)});
2062 COMPREPLY=($( compgen -W '${COMPREPLY[@]%.*}' -- "${cur//\\\\/}" ));
2063 return 0
2064}
2065_insmod ()
2066{
2067 local cur prev modpath;
2068 COMPREPLY=();
2069 cur=`_get_cword`;
2070 prev=${COMP_WORDS[COMP_CWORD-1]};
2071 if [ $1 = "modprobe" ] && [ "${COMP_WORDS[1]}" = "-r" ]; then
2072 _installed_modules "$cur";
2073 return 0;
2074 fi;
2075 if [[ "$cur" == */* ]]; then
2076 _filedir '@(?(k)o?(.gz))';
2077 return 0;
2078 fi;
2079 if [ $COMP_CWORD -gt 1 ] && [[ "${COMP_WORDS[COMP_CWORD-1]}" != -* ]]; then
2080 COMPREPLY=($( /sbin/modinfo -p ${COMP_WORDS[1]} 2>/dev/null | awk '{if ($1 ~ /^parm:/ && $2 ~ /^'"$cur"'/) { print $2 } \
2081 else if ($1 !~ /:/ && $1 ~ /^'"$cur"'/) { print $1 }}' ));
2082 else
2083 _modules $(uname -r);
2084 fi;
2085 return 0
2086}
2087_installed_groups ()
2088{
2089 local installed_groups;
2090 installed_groups=$( find /var/lib/pacman/local -name desc -exec sed -ne '/%GROUPS%/,/^$/{//d; p}' {} \; | sort -u );
2091 COMPREPLY=($( compgen -W "$( for i in $installed_groups; do echo ${i%-*-*}; done )" -- $cur ))
2092}
2093_installed_modules ()
2094{
2095 COMPREPLY=($( compgen -W "$( PATH="$PATH:/sbin" lsmod | awk '{if (NR != 1) print $1}' )" -- $1 ))
2096}
2097_installed_pkgs ()
2098{
2099 local installed_pkgs;
2100 installed_pkgs=$( ls /var/lib/pacman/local/ );
2101 COMPREPLY=($( compgen -W "$( for i in $installed_pkgs; do echo ${i%-*-*}; done )" -- $cur ))
2102}
2103_instring ()
2104{
2105 str="${1}";
2106 shift 1;
2107 for c in "${@}";
2108 do
2109 if [ $(expr index "${str}" "${c}") -gt 0 ]; then
2110 return 0;
2111 fi;
2112 done;
2113 return 1
2114}
2115_iptables ()
2116{
2117 local cur prev table chain;
2118 COMPREPLY=();
2119 cur=`_get_cword`;
2120 prev=${COMP_WORDS[COMP_CWORD-1]};
2121 chain='s/^Chain \([^ ]\+\).*$/\1/p';
2122 if [[ $COMP_LINE == *-t\ *filter* ]]; then
2123 table="-t filter";
2124 else
2125 if [[ $COMP_LINE == *-t\ *nat* ]]; then
2126 table="-t nat";
2127 else
2128 if [[ $COMP_LINE == *-t\ *mangle* ]]; then
2129 table="-t mangle";
2130 fi;
2131 fi;
2132 fi;
2133 _split_longopt;
2134 case "$prev" in
2135 -*[AIDRPFXLZ])
2136 COMPREPLY=($( compgen -W '`iptables $table -nL | \
2137 sed -ne "s/^Chain \([^ ]\+\).*$/\1/p"`' -- "$cur" ))
2138 ;;
2139 -*t)
2140 COMPREPLY=($( compgen -W 'nat filter mangle' -- "$cur" ))
2141 ;;
2142 -j)
2143 if [ "$table" = "-t filter" -o "$table" = "" ]; then
2144 COMPREPLY=($( compgen -W 'ACCEPT DROP LOG ULOG REJECT \
2145 `iptables $table -nL | sed -ne "$chain" \
2146 -e "s/INPUT|OUTPUT|FORWARD|PREROUTING|POSTROUTING//"`' -- "$cur" ));
2147 else
2148 if [ "$table" = "-t nat" ]; then
2149 COMPREPLY=($( compgen -W 'ACCEPT DROP LOG ULOG REJECT \
2150 MIRROR SNAT DNAT MASQUERADE `iptables $table -nL | \
2151 sed -ne "$chain" -e "s/OUTPUT|PREROUTING|POSTROUTING//"`' -- "$cur" ));
2152 else
2153 if [ "$table" = "-t mangle" ]; then
2154 COMPREPLY=($( compgen -W 'ACCEPT DROP LOG ULOG REJECT \
2155 MARK TOS `iptables $table -nL | sed -ne "$chain" \
2156 -e "s/INPUT|OUTPUT|FORWARD|PREROUTING|POSTROUTING//"`' -- "$cur" ));
2157 fi;
2158 fi;
2159 fi
2160 ;;
2161 *)
2162 if [[ "$cur" == -* ]]; then
2163 COMPREPLY=($( compgen -W '-i -o -s -d -p -f -m --append \
2164 --delete --insert --replace --list --flush --zero --new \
2165 --delete-chain --policy --rename-chain --proto --source \
2166 --destination --in-interface --jump --match --numeric \
2167 --out-interface --table --verbose --line-numbers --exact \
2168 --fragment --modprobe --set-counters --version' -- "$cur"));
2169 fi
2170 ;;
2171 esac
2172}
2173_isql ()
2174{
2175 local cur;
2176 cur=`_get_cword`;
2177 [ -f "$ODBCINI" ] && COMPREPLY=($( grep \\["$cur" "$ODBCINI" | tr -d \\[\\] ))
2178}
2179_iwconfig ()
2180{
2181 local cur prev;
2182 COMPREPLY=();
2183 cur=`_get_cword`;
2184 prev=${COMP_WORDS[COMP_CWORD-1]};
2185 case $prev in
2186 mode)
2187 COMPREPLY=($( compgen -W 'managed ad-hoc master \
2188 repeater secondary monitor' -- "$cur" ));
2189 return 0
2190 ;;
2191 essid)
2192 COMPREPLY=($( compgen -W 'on off any' -- "$cur" ));
2193 if [ -n "${COMP_IWLIST_SCAN:-}" ]; then
2194 COMPREPLY=("${COMPREPLY[@]}" $( compgen -W "$( iwlist ${COMP_WORDS[1]} scan | awk -F '\"' '/ESSID/ {print $2}' )" -- "$cur" ));
2195 fi;
2196 return 0
2197 ;;
2198 nwid)
2199 COMPREPLY=($( compgen -W 'on off' -- "$cur" ));
2200 return 0
2201 ;;
2202 channel)
2203 COMPREPLY=($( compgen -W "$( iwlist ${COMP_WORDS[1]} channel | awk '/^[[:space:]]*Channel/ {print $2}' )" -- "$cur" ));
2204 return 0
2205 ;;
2206 freq)
2207 COMPREPLY=($( compgen -W "$( iwlist ${COMP_WORDS[1]} channel | awk '/^[[:space:]]*Channel/ {print $4\"G\"}')" -- "$cur" ));
2208 return 0
2209 ;;
2210 ap)
2211 COMPREPLY=($( compgen -W 'on off any' -- "$cur" ));
2212 if [ -n "${COMP_IWLIST_SCAN:-}" ]; then
2213 COMPREPLY=("${COMPREPLY[@]}" $( compgen -W "$( iwlist ${COMP_WORDS[1]} scan | awk -F ': ' '/Address/ {print $2}' )" -- "$cur" ));
2214 fi;
2215 return 0
2216 ;;
2217 rate)
2218 COMPREPLY=($( compgen -W 'auto fixed' -- "$cur" ));
2219 COMPREPLY=("${COMPREPLY[@]}" $( compgen -W "$( iwlist ${COMP_WORDS[1]} rate | awk '/^[[:space:]]*[0-9]/ {print $1\"M\"}' )" -- "$cur" ));
2220 return 0
2221 ;;
2222 rts | frag)
2223 COMPREPLY=($( compgen -W 'auto fixed off' -- "$cur" ));
2224 return 0
2225 ;;
2226 key | enc)
2227 COMPREPLY=($( compgen -W 'off on open restricted' -- "$cur" ));
2228 return 0
2229 ;;
2230 power)
2231 COMPREPLY=($( compgen -W 'period timeout off on' -- "$cur" ));
2232 return 0
2233 ;;
2234 txpower)
2235 COMPREPLY=($( compgen -W 'off on auto' -- "$cur" ));
2236 return 0
2237 ;;
2238 retry)
2239 COMPREPLY=($( compgen -W 'limit lifetime' -- "$cur" ));
2240 return 0
2241 ;;
2242 esac;
2243 if [ $COMP_CWORD -eq 1 ]; then
2244 if [[ "$cur" == -* ]]; then
2245 COMPREPLY=($( compgen -W '--help --version' -- "$cur" ));
2246 else
2247 _available_interfaces -w;
2248 fi;
2249 else
2250 COMPREPLY=($( compgen -W 'essid nwid mode freq channel sens mode \
2251 ap nick rate rts frag enc key power txpower commit' -- "$cur" ));
2252 fi
2253}
2254_iwlist ()
2255{
2256 local cur prev;
2257 COMPREPLY=();
2258 cur=`_get_cword`;
2259 prev=${COMP_WORDS[COMP_CWORD-1]};
2260 if [ $COMP_CWORD -eq 1 ]; then
2261 if [[ "$cur" == -* ]]; then
2262 COMPREPLY=($( compgen -W '--help --version' -- "$cur" ));
2263 else
2264 _available_interfaces -w;
2265 fi;
2266 else
2267 COMPREPLY=($( compgen -W 'scan scanning freq frequency \
2268 channel rate bit bitrate key enc encryption power \
2269 txpower retry ap accesspoint peers event' -- "$cur" ));
2270 fi
2271}
2272_iwpriv ()
2273{
2274 local cur prev;
2275 COMPREPLY=();
2276 cur=`_get_cword`;
2277 prev=${COMP_WORDS[COMP_CWORD-1]};
2278 case "$prev" in
2279 roam)
2280 COMPREPLY=($( compgen -W 'on off' -- "$cur" ));
2281 return 0
2282 ;;
2283 port)
2284 COMPREPLY=($( compgen -W 'ad-hoc managed' -- "$cur" ));
2285 return 0
2286 ;;
2287 esac;
2288 if [ $COMP_CWORD -eq 1 ]; then
2289 if [[ "$cur" == -* ]]; then
2290 COMPREPLY=($( compgen -W '--help --version' -- "$cur" ));
2291 else
2292 _available_interfaces -w;
2293 fi;
2294 else
2295 COMPREPLY=($( compgen -W '--all roam port' -- "$cur" ));
2296 fi
2297}
2298_iwspy ()
2299{
2300 local cur;
2301 COMPREPLY=();
2302 cur=`_get_cword`;
2303 if [ $COMP_CWORD -eq 1 ]; then
2304 if [[ "$cur" == -* ]]; then
2305 COMPREPLY=($( compgen -W '--help --version' -- "$cur" ));
2306 else
2307 _available_interfaces -w;
2308 fi;
2309 else
2310 COMPREPLY=($( compgen -W 'setthr getthr off' -- "$cur" ));
2311 fi
2312}
2313_kernel_versions ()
2314{
2315 COMPREPLY=($( compgen -W '$( command ls /lib/modules )' -- "$cur" ))
2316}
2317_kill ()
2318{
2319 local cur;
2320 COMPREPLY=();
2321 cur=`_get_cword`;
2322 if [ $COMP_CWORD -eq 1 ] && [[ "$cur" == -* ]]; then
2323 _signals;
2324 else
2325 _pids;
2326 fi
2327}
2328_killall ()
2329{
2330 local cur;
2331 COMPREPLY=();
2332 cur=`_get_cword`;
2333 if [ $COMP_CWORD -eq 1 ] && [[ "$cur" == -* ]]; then
2334 _signals;
2335 else
2336 _pnames;
2337 fi;
2338 return 0
2339}
2340_known_hosts ()
2341{
2342 local options;
2343 COMPREPLY=();
2344 [ "$1" = -a ] || [ "$2" = -a ] && options=-a;
2345 [ "$1" = -c ] || [ "$2" = -c ] && options="$options -c";
2346 _known_hosts_real $options "$(_get_cword)"
2347}
2348_known_hosts_real ()
2349{
2350 local configfile flag prefix;
2351 local cur curd awkcur user suffix aliases global_kh user_kh hosts i host;
2352 local -a kh khd config;
2353 local OPTIND=1;
2354 while getopts "acF:p:" flag "$@"; do
2355 case $flag in
2356 a)
2357 aliases='yes'
2358 ;;
2359 c)
2360 suffix=':'
2361 ;;
2362 F)
2363 configfile=$OPTARG
2364 ;;
2365 p)
2366 prefix=$OPTARG
2367 ;;
2368 esac;
2369 done;
2370 [ $# -lt $OPTIND ] && echo "error: $FUNCNAME: missing mandatory argument CWORD";
2371 cur=${!OPTIND};
2372 let "OPTIND += 1";
2373 [ $# -ge $OPTIND ] && echo "error: $FUNCNAME("$@"): unprocessed arguments:" $(while [ $# -ge $OPTIND ]; do echo ${!OPTIND}; shift; done);
2374 [[ $cur == *@* ]] && user=${cur%@*}@ && cur=${cur#*@};
2375 kh=();
2376 if [ -n "$configfile" ]; then
2377 [ -r "$configfile" ] && config=("${config[@]}" "$configfile");
2378 else
2379 [ -r /etc/ssh/ssh_config ] && config=("${config[@]}" "/etc/ssh/ssh_config");
2380 [ -r "${HOME}/.ssh/config" ] && config=("${config[@]}" "${HOME}/.ssh/config");
2381 [ -r "${HOME}/.ssh2/config" ] && config=("${config[@]}" "${HOME}/.ssh2/config");
2382 fi;
2383 if [ ${#config[@]} -gt 0 ]; then
2384 local OIFS=$IFS IFS='
2385';
2386 global_kh=($( 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[@]}" ));
2387 for ((i=0; i < ${#global_kh[@]}; i++ ))
2388 do
2389 global_kh[i]=$(echo "${global_kh[i]//\"/}");
2390 done;
2391 user_kh=($( 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[@]}" ));
2392 for ((i=0; i < ${#user_kh[@]}; i++ ))
2393 do
2394 user_kh[i]=$(echo "${user_kh[i]//\"/}");
2395 done;
2396 IFS=$OIFS;
2397 fi;
2398 [ -r "$global_kh" ] && kh=("${kh[@]}" "${global_kh[@]}");
2399 if [ -z "$configfile" ]; then
2400 [ -r /etc/ssh/ssh_known_hosts ] && kh=("${kh[@]}" /etc/ssh/ssh_known_hosts);
2401 [ -r /etc/ssh/ssh_known_hosts2 ] && kh=("${kh[@]}" /etc/ssh/ssh_known_hosts2);
2402 [ -r /etc/known_hosts ] && kh=("${kh[@]}" /etc/known_hosts);
2403 [ -r /etc/known_hosts2 ] && kh=("${kh[@]}" /etc/known_hosts2);
2404 [ -d /etc/ssh2/knownhosts ] && khd=("${khd[@]}" /etc/ssh2/knownhosts/*pub);
2405 fi;
2406 [ -r "$user_kh" ] && kh=("${kh[@]}" "${user_kh[@]}");
2407 if [ -z "$configfile" ]; then
2408 [ -r ~/.ssh/known_hosts ] && kh=("${kh[@]}" ~/.ssh/known_hosts);
2409 [ -r ~/.ssh/known_hosts2 ] && kh=("${kh[@]}" ~/.ssh/known_hosts2);
2410 [ -d ~/.ssh2/hostkeys ] && khd=("${khd[@]}" ~/.ssh2/hostkeys/*pub);
2411 fi;
2412 if [ ${#kh[@]} -gt 0 -o ${#khd[@]} -gt 0 -o -n "$configfile" ]; then
2413 awkcur=${cur//\//\\\/};
2414 awkcur=${awkcur//\./\\\.};
2415 curd=$awkcur;
2416 if [[ "$awkcur" == [0-9]*.* ]]; then
2417 awkcur="^$awkcur.*";
2418 else
2419 if [[ "$awkcur" == [0-9]* ]]; then
2420 awkcur="^$awkcur.*\.";
2421 else
2422 if [ -z "$awkcur" ]; then
2423 awkcur="[a-z.]";
2424 else
2425 awkcur="^$awkcur";
2426 fi;
2427 fi;
2428 fi;
2429 if [ ${#kh[@]} -gt 0 ]; then
2430 COMPREPLY=($( awk 'BEGIN {FS=","}
2431 /^\s*[^|\#]/ {for (i=1; i<=2; ++i) { \
2432 gsub(" .*$", "", $i); \
2433 gsub("[\\[\\]]", "", $i); \
2434 gsub(":[0-9]+$", "", $i); \
2435 if ($i ~ /'"$awkcur"'/) {print $i} \
2436 }}' "${kh[@]}" 2>/dev/null ));
2437 fi;
2438 if [ ${#khd[@]} -gt 0 ]; then
2439 for i in "${khd[@]}";
2440 do
2441 if [[ "$i" == *key_22_$awkcurd*.pub ]] && [ -r "$i" ]; then
2442 host=${i/#*key_22_/};
2443 host=${host/%.pub/};
2444 COMPREPLY=("${COMPREPLY[@]}" $host);
2445 fi;
2446 done;
2447 fi;
2448 if [ ${#config[@]} -gt 0 ] && [ -n "$aliases" ]; then
2449 local host_aliases=$( sed -ne 's/^[ \t]*[Hh][Oo][Ss][Tt]\([Nn][Aa][Mm][Ee]\)\?['"$'\t '"']\+\([^#*?]*\)\(#.*\)\?$/\2/p' "${config[@]}" );
2450 hosts=$( compgen -W "$host_aliases" -- "$cur" );
2451 COMPREPLY=("${COMPREPLY[@]}" $hosts);
2452 fi;
2453 if type avahi-browse &>/dev/null; then
2454 if [ -n "$(pidof avahi-daemon)" ]; then
2455 COMPREPLY=("${COMPREPLY[@]}" $(
2456 compgen -W "$( avahi-browse -cpr _workstation._tcp | grep ^= | cut -d\; -f7 | sort -u )" -- "$cur" ));
2457 fi;
2458 fi;
2459 for ((i=0; i < ${#COMPREPLY[@]}; i++ ))
2460 do
2461 COMPREPLY[i]=$prefix$user${COMPREPLY[i]}$suffix;
2462 done;
2463 fi;
2464 if [ -n "${COMP_KNOWN_HOSTS_WITH_HOSTFILE-1}" ]; then
2465 COMPREPLY=("${COMPREPLY[@]}" $( compgen -A hostname -P "$prefix$user" -S "$suffix" -- "$cur" ));
2466 fi;
2467 return 0
2468}
2469_ktutil ()
2470{
2471 local cur prev command options split=false;
2472 COMPREPLY=();
2473 cur=`_get_cword`;
2474 prev=${COMP_WORDS[COMP_CWORD-1]};
2475 _split_longopt && split=true;
2476 case $prev in
2477 -p | --principal)
2478 _heimdal_principals;
2479 return 0
2480 ;;
2481 -e | --enctype)
2482 _heimdal_encodings;
2483 return 0
2484 ;;
2485 -a | --admin-server)
2486 _known_hosts_real "$cur";
2487 return 0
2488 ;;
2489 -r | --realm)
2490 _heimdal_realms;
2491 return 0
2492 ;;
2493 -@(s|k|-@(srv|key)tab))
2494 _filedir;
2495 return 0
2496 ;;
2497 esac;
2498 $split && return 0;
2499 commands='add change copy get list remove rename purge srvconvert \
2500 srv2keytab srvcreate key2srvtab';
2501 for ((i=1; i < COMP_CWORD; i++ ))
2502 do
2503 case ${COMP_WORDS[i]} in
2504 -@(k|-keytab))
2505 i=$(($i+1))
2506 ;;
2507 -*)
2508
2509 ;;
2510 *)
2511 command=${COMP_WORDS[i]};
2512 break
2513 ;;
2514 esac;
2515 done;
2516 if [[ "$cur" == -* ]]; then
2517 case $command in
2518 add)
2519 options='-p --principal -V -e --enctype -w --password -r \
2520 --random -s --no-salt -h --hex'
2521 ;;
2522 change)
2523 options='-r --realm -a --admin-server -s --server-port'
2524 ;;
2525 get)
2526 options='-p --principal -e --enctype -r --realm -a \
2527 --admin-server -s server --server-port'
2528 ;;
2529 list)
2530 options='--keys --timestamp'
2531 ;;
2532 remove)
2533 options='-p --principal -V --kvno -e --enctype'
2534 ;;
2535 purge)
2536 options='--age'
2537 ;;
2538 @(srv2keytab|key2srvtab))
2539 options='-s --srvtab'
2540 ;;
2541 *)
2542 options='-k --keytab -v --verbose --version -v --help'
2543 ;;
2544 esac;
2545 COMPREPLY=($( compgen -W "$options" -- "$cur" ));
2546 else
2547 case $command in
2548 copy)
2549 _filedir
2550 ;;
2551 get)
2552 _heimdal_principals
2553 ;;
2554 rename)
2555 _heimdal_principals
2556 ;;
2557 *)
2558 COMPREPLY=($( compgen -W "$commands" -- "$cur" ))
2559 ;;
2560 esac;
2561 fi
2562}
2563_l2ping ()
2564{
2565 local cur prev;
2566 COMPREPLY=();
2567 cur=`_get_cword`;
2568 prev=${COMP_WORDS[COMP_CWORD-1]};
2569 case $prev in
2570 -i)
2571 _bluetooth_devices;
2572 return 0
2573 ;;
2574 esac;
2575 if [[ "$cur" == -* ]]; then
2576 COMPREPLY=($( compgen -W '-i -s -c -t -f -r' -- "$cur" ));
2577 else
2578 _bluetooth_adresses;
2579 fi
2580}
2581_lastlog ()
2582{
2583 local cur prev split=false;
2584 COMPREPLY=();
2585 cur=`_get_cword`;
2586 prev=${COMP_WORDS[COMP_CWORD-1]};
2587 _split_longopt && split=true;
2588 case "$prev" in
2589 -b | --before | -h | --help | -t | --time)
2590 return 0
2591 ;;
2592 -u | --user)
2593 COMPREPLY=($( compgen -u -- "$cur" ));
2594 return 0
2595 ;;
2596 esac;
2597 $split && return 0;
2598 if [[ "$cur" == -* ]]; then
2599 COMPREPLY=($( compgen -W '-b --before -h --help -t --time \
2600 -u --user' -- "$cur" ));
2601 return 0;
2602 fi
2603}
2604_logicalvolumes ()
2605{
2606 COMPREPLY=($(compgen -W "$( lvscan 2>/dev/null | sed -n -e "s|^.*'\(.*\)'.*$|\1|p" )" -- "$cur" ))
2607}
2608_longopt ()
2609{
2610 local cur prev;
2611 cur=`_get_cword`;
2612 prev=${COMP_WORDS[COMP_CWORD-1]};
2613 if _split_longopt; then
2614 case "$prev" in
2615 *[Dd][Ii][Rr]*)
2616 _filedir -d
2617 ;;
2618 *[Ff][Ii][Ll][Ee]*)
2619 _filedir
2620 ;;
2621 esac;
2622 return 0;
2623 fi;
2624 if [[ "$cur" == -* ]]; then
2625 COMPREPLY=($( compgen -W "$( $1 --help 2>&1 | sed -e '/--/!d' -e 's/.*\(--[-A-Za-z0-9]\+\).*/\1/' |sort -u )" -- "$cur" ));
2626 else
2627 if [[ "$1" == rmdir ]]; then
2628 _filedir -d;
2629 else
2630 _filedir;
2631 fi;
2632 fi
2633}
2634_look ()
2635{
2636 local cur;
2637 COMPREPLY=();
2638 cur=`_get_cword`;
2639 if [ $COMP_CWORD = 1 ]; then
2640 COMPREPLY=($( compgen -W '$(look "$cur" 2>/dev/null)' ));
2641 fi
2642}
2643_lvchange ()
2644{
2645 local cur prev;
2646 COMPREPLY=();
2647 cur=`_get_cword`;
2648 prev=${COMP_WORDS[COMP_CWORD-1]};
2649 case "$prev" in
2650 -@(a|A|C|M|-available|-autobackup|-continguous|-persistent))
2651 COMPREPLY=($( compgen -W 'y n' -- "$cur" ));
2652 return 0
2653 ;;
2654 -@(p|-permission))
2655 COMPREPLY=($( compgen -W 'r rw' -- "$cur" ));
2656 return 0
2657 ;;
2658 esac;
2659 if [[ "$cur" == -* ]]; then
2660 COMPREPLY=($( compgen -W '-A --autobackup -a --available \
2661 --addtag --alloc -C --contiguous -d --debug --deltag \
2662 -f --force -h --help --ignorelockingfailure -M \
2663 --persistent --major major --minor minor -P --partial \
2664 -p --permission -r --readahead --refresh -t --test \
2665 -v --verbose --version' -- "$cur" ));
2666 else
2667 _logicalvolumes;
2668 fi
2669}
2670_lvcreate ()
2671{
2672 local cur prev;
2673 COMPREPLY=();
2674 cur=`_get_cword`;
2675 prev=${COMP_WORDS[COMP_CWORD-1]};
2676 case "$prev" in
2677 -@(A|C|M|Z|-autobackup|-continguous|-persistent|-zero))
2678 COMPREPLY=($( compgen -W 'y n' -- "$cur" ));
2679 return 0
2680 ;;
2681 -@(L|-size))
2682 _sizes;
2683 return 0
2684 ;;
2685 -@(p|-permission))
2686 COMPREPLY=($( compgen -W 'r rw' -- "$cur" ));
2687 return 0
2688 ;;
2689 -@(n|-name))
2690 _logicalvolumes;
2691 return 0
2692 ;;
2693 esac;
2694 if [[ "$cur" == -* ]]; then
2695 COMPREPLY=($( compgen -W '-A --autobackup --addtag --alloc \
2696 -C --contiguous -d --debug -h -? --help -i --stripes \
2697 -I --stripesize -l --extents -L --size -M --persistent \
2698 --major --minor -n --name -p --permission -r \
2699 --readahead -t --test --type -v --verbose -Z --zero \
2700 --version' -- "$cur" ));
2701 else
2702 _args;
2703 if [ $args -eq 0 ]; then
2704 _volumegroups;
2705 else
2706 _physicalvolumes;
2707 fi;
2708 fi
2709}
2710_lvdisplay ()
2711{
2712 local cur prev;
2713 COMPREPLY=();
2714 cur=`_get_cword`;
2715 prev=${COMP_WORDS[COMP_CWORD-1]};
2716 case "$prev" in
2717 --units)
2718 _units;
2719 return 0
2720 ;;
2721 esac;
2722 if [[ "$cur" == -* ]]; then
2723 COMPREPLY=($( compgen -W '-c --colon -C --columns --units \
2724 -P --partial -m --maps -v --verbose -d --debug -h \
2725 --help --version' -- "$cur" ));
2726 else
2727 _logicalvolumes;
2728 fi
2729}
2730_lvextend ()
2731{
2732 local cur prev;
2733 COMPREPLY=();
2734 cur=`_get_cword`;
2735 prev=${COMP_WORDS[COMP_CWORD-1]};
2736 case "$prev" in
2737 -@(A|-autobackup))
2738 COMPREPLY=($( compgen -W 'y n' -- "$cur" ));
2739 return 0
2740 ;;
2741 -@(L|-size))
2742 _sizes;
2743 return 0
2744 ;;
2745 esac;
2746 if [[ "$cur" == -* ]]; then
2747 COMPREPLY=($( compgen -W '-A --autobackup --alloc -d \
2748 --debug -h --help -i --stripes -I --stripesize \
2749 -l --extents -L --size -n --nofsck -r --resizefs \
2750 -t --test --type -v --verbose --version' -- "$cur" ));
2751 else
2752 _args;
2753 if [ $args -eq 0 ]; then
2754 _logicalvolumes;
2755 else
2756 _physicalvolumes;
2757 fi;
2758 fi
2759}
2760_lvm ()
2761{
2762 local prev;
2763 COMPREPLY=();
2764 cur=`_get_cword`;
2765 if [ $COMP_CWORD -eq 1 ]; then
2766 COMPREPLY=($( compgen -W 'dumpconfig help lvchange \
2767 lvcreate lvdisplay lvextend lvmchange \
2768 lvmdiskscan lvmsadc lvmsar lvreduce \
2769 lvremove lvrename lvresize lvs lvscan \
2770 pvchange pvcreate pvdata pvdisplay pvmove \
2771 pvremove pvresize pvs pvscan vgcfgbackup \
2772 vgcfgrestore vgchange vgck vgconvert \
2773 vgcreate vgdisplay vgexport vgextend \
2774 vgimport vgmerge vgmknodes vgreduce \
2775 vgremove vgrename vgs vgscan vgsplit \
2776 version' -- "$cur" ));
2777 else
2778 case ${COMP_WORDS[1]} in
2779 pvchange)
2780 _pvchange
2781 ;;
2782 pvcreate)
2783 _pvcreate
2784 ;;
2785 pvdisplay)
2786 _pvdisplay
2787 ;;
2788 pvmove)
2789 _pvmove
2790 ;;
2791 pvremove)
2792 _pvremove
2793 ;;
2794 pvresize)
2795 _pvresize
2796 ;;
2797 pvs)
2798 _pvs
2799 ;;
2800 pvscan)
2801 _pvscan
2802 ;;
2803 vgcfgbackup)
2804 _vgcfgbackup
2805 ;;
2806 vgcfgrestore)
2807 _vgcfgrestore
2808 ;;
2809 vgchange)
2810 _vgchange
2811 ;;
2812 vgck)
2813 _vgck
2814 ;;
2815 vgconvert)
2816 _vgconvert
2817 ;;
2818 vgcreate)
2819 _vgcreate
2820 ;;
2821 vgdisplay)
2822 _vgdisplay
2823 ;;
2824 vgexport)
2825 _vgexport
2826 ;;
2827 vgextend)
2828 _vgextend
2829 ;;
2830 vgimport)
2831 _vgimport
2832 ;;
2833 vgmerge)
2834 _vgmerge
2835 ;;
2836 vgmknodes)
2837 _vgmknodes
2838 ;;
2839 vgreduce)
2840 _vgreduce
2841 ;;
2842 vgremove)
2843 _vgremove
2844 ;;
2845 vgrename)
2846 _vgrename
2847 ;;
2848 vgs)
2849 _vgs
2850 ;;
2851 vgscan)
2852 _vgscan
2853 ;;
2854 vgsplit)
2855 _vgsplit
2856 ;;
2857 lvchange)
2858 _lvchange
2859 ;;
2860 lvcreate)
2861 _lvcreate
2862 ;;
2863 lvdisplay)
2864 _lvdisplay
2865 ;;
2866 lvextend)
2867 _lvextend
2868 ;;
2869 lvreduce)
2870 _lvreduce
2871 ;;
2872 lvremove)
2873 _lvremove
2874 ;;
2875 lvrename)
2876 _lvrename
2877 ;;
2878 lvresize)
2879 _lvresize
2880 ;;
2881 lvs)
2882 _lvs
2883 ;;
2884 lvscan)
2885 _lvscan
2886 ;;
2887 esac;
2888 fi
2889}
2890_lvmdiskscan ()
2891{
2892 local cur;
2893 COMPREPLY=();
2894 cur=`_get_cword`;
2895 if [[ "$cur" == -* ]]; then
2896 COMPREPLY=($( compgen -W '-d --debug -h -? --help -l \
2897 --lvmpartition -v --verbose --version' -- "$cur" ));
2898 fi
2899}
2900_lvreduce ()
2901{
2902 local cur prev;
2903 COMPREPLY=();
2904 cur=`_get_cword`;
2905 prev=${COMP_WORDS[COMP_CWORD-1]};
2906 case "$prev" in
2907 -@(A|-autobackup))
2908 COMPREPLY=($( compgen -W 'y n' -- "$cur" ));
2909 return 0
2910 ;;
2911 -@(L|-size))
2912 _sizes;
2913 return 0
2914 ;;
2915 esac;
2916 if [[ "$cur" == -* ]]; then
2917 COMPREPLY=($( compgen -W '-A --autobackup -d \
2918 --debug -f --force -h --help -l --extents \
2919 -L --size -n --nofsck -r --resizefs -t --test \
2920 -v --verbose --version' -- "$cur" ));
2921 else
2922 _logicalvolumes;
2923 fi
2924}
2925_lvremove ()
2926{
2927 local cur prev;
2928 COMPREPLY=();
2929 cur=`_get_cword`;
2930 prev=${COMP_WORDS[COMP_CWORD-1]};
2931 case "$prev" in
2932 -@(A|-autobackup))
2933 COMPREPLY=($( compgen -W 'y n' -- "$cur" ));
2934 return 0
2935 ;;
2936 esac;
2937 if [[ "$cur" == -* ]]; then
2938 COMPREPLY=($( compgen -W '-A --autobackup -d --debug -f \
2939 --force -h -? --help -t --test -v --verbose \
2940 --version' -- "$cur" ));
2941 else
2942 _logicalvolumes;
2943 fi
2944}
2945_lvrename ()
2946{
2947 local cur prev;
2948 COMPREPLY=();
2949 cur=`_get_cword`;
2950 prev=${COMP_WORDS[COMP_CWORD-1]};
2951 case "$prev" in
2952 -@(A|-autobackup))
2953 COMPREPLY=($( compgen -W 'y n' -- "$cur" ));
2954 return 0
2955 ;;
2956 esac;
2957 if [[ "$cur" == -* ]]; then
2958 COMPREPLY=($( compgen -W '-A --autobackup -d --debug -h \
2959 -? --help -t --test -v --verbose --version' -- "$cur" ));
2960 else
2961 _logicalvolumes;
2962 fi
2963}
2964_lvresize ()
2965{
2966 local cur prev;
2967 COMPREPLY=();
2968 cur=`_get_cword`;
2969 prev=${COMP_WORDS[COMP_CWORD-1]};
2970 case "$prev" in
2971 -@(A|-autobackup))
2972 COMPREPLY=($( compgen -W 'y n' -- "$cur" ));
2973 return 0
2974 ;;
2975 -@(L|-size))
2976 _sizes;
2977 return 0
2978 ;;
2979 esac;
2980 if [[ "$cur" == -* ]]; then
2981 COMPREPLY=($( compgen -W '-A --autobackup --alloc -d \
2982 --debug -h --help -i --stripes -I --stripesize \
2983 -l --extents -L --size -n --nofsck -r --resizefs \
2984 -t --test --type -v --verbose --version' -- "$cur" ));
2985 else
2986 _args;
2987 if [ $args -eq 0 ]; then
2988 _logicalvolumes;
2989 else
2990 _physicalvolumes;
2991 fi;
2992 fi
2993}
2994_lvs ()
2995{
2996 local cur prev;
2997 COMPREPLY=();
2998 cur=`_get_cword`;
2999 prev=${COMP_WORDS[COMP_CWORD-1]};
3000 case "$prev" in
3001 -@(o|O|-options|-sort))
3002 COMPREPLY=($( compgen -W 'lv_uuid lv_name lv_attr lv_minor \
3003 lv_size seg_count origin snap_percent segtype stripes \
3004 stripesize chunksize seg_start seg_size' -- "$cur" ));
3005 return 0
3006 ;;
3007 --units)
3008 _units;
3009 return 0
3010 ;;
3011 esac;
3012 if [[ "$cur" == -* ]]; then
3013 COMPREPLY=($( compgen -W '--aligned -d --debug -h --help \
3014 --ignorelockingfailure --noheadings --nosuffix -o --options -O \
3015 --sort -P --partial --segments --separator --unbuffered --units \
3016 -v --verbose --version' -- "$cur" ));
3017 else
3018 _logicalvolumes;
3019 fi
3020}
3021_lvscan ()
3022{
3023 local cur;
3024 COMPREPLY=();
3025 cur=`_get_cword`;
3026 if [[ "$cur" == -* ]]; then
3027 COMPREPLY=($( compgen -W '-b --blockdevice -d --debug \
3028 -h -? --help --ignorelockingfailure -P \
3029 --partial -v --verbose --version' -- "$cur" ));
3030 fi
3031}
3032_lzma ()
3033{
3034 local cur prev xspec;
3035 COMPREPLY=();
3036 cur=`_get_cword`;
3037 prev=${COMP_WORDS[COMP_CWORD-1]};
3038 if [[ "$cur" == -* ]]; then
3039 COMPREPLY=($( compgen -W '-c -d -f -h -k -L -q -s \
3040 -v -V -z -1 -2 -3 -4 -5 -6 -7 -8 -9 \
3041 --help --decompress --compress --keep --force \
3042 --test --stdout --quiet --verbose --license \
3043 --version --small --fast --best --text' -- "$cur" ));
3044 return 0;
3045 fi;
3046 local IFS='
3047';
3048 xspec="*.lzma";
3049 if [[ "$prev" == --* ]]; then
3050 [[ "$prev" == --decompress || "$prev" == --list || "$prev" == --test ]] && xspec="!"$xspec;
3051 [[ "$prev" == --compress ]] && xspec=;
3052 else
3053 if [[ "$prev" == -* ]]; then
3054 [[ "$prev" == -*[dt]* ]] && xspec="!"$xspec;
3055 [[ "$prev" == -*z* ]] && xspec=;
3056 fi;
3057 fi;
3058 _expand || return 0;
3059 COMPREPLY=($( compgen -f -X "$xspec" -- "$cur" ) $( compgen -d -- "$cur" ))
3060}
3061_lzop ()
3062{
3063 local cur prev xspec;
3064 COMPREPLY=();
3065 cur=`_get_cword`;
3066 prev=${COMP_WORDS[COMP_CWORD-1]};
3067 if [[ "$cur" == -* ]]; then
3068 COMPREPLY=($( compgen -W '-d -x -l -t -h -I -V -L -1 -2 -3 \
3069 -4 -5 -6 -7 -8 -9 -q -v -c -f -F -n -N -P -k -U -o \
3070 -S --fast --best --decompress --uncompress --extract \
3071 --test --list --ls --info --sysinfo --license --help \
3072 --version --stdout --to-stdout --output --path \
3073 --force --no-checksum --no-name --name --no-mode \
3074 --no-time --suffix --keep --unlink --delete --crc32 \
3075 --no-warn --ignore-warn --quiet --silent --verbose \
3076 --no-stdin --filter --checksum --no-color --mono \
3077 --color' -- "$cur" ));
3078 return 0;
3079 fi;
3080 case "$prev" in
3081 -o | --output)
3082 _filedir;
3083 return 0
3084 ;;
3085 --path)
3086 _filedir -d;
3087 return 0
3088 ;;
3089 -S | --suffix)
3090 return 0
3091 ;;
3092 esac;
3093 xspec="*.?(t)lzo";
3094 case "$prev" in
3095 --@(@(de|un)compress|extract|list|ls|info|test))
3096 xspec="!"$xspec
3097 ;;
3098 --force)
3099 xspec=
3100 ;;
3101 --*)
3102
3103 ;;
3104 -*f* | '<' | '>')
3105 xspec=
3106 ;;
3107 -*[dltx]*)
3108 xspec="!"$xspec
3109 ;;
3110 esac;
3111 _expand || return 0;
3112 local IFS='
3113';
3114 COMPREPLY=($( compgen -f -X "$xspec" -- "$cur" ) $( compgen -d -- "$cur" ))
3115}
3116_makepkg ()
3117{
3118 local cur prev;
3119 COMPREPLY=();
3120 cur=${COMP_WORDS[COMP_CWORD]};
3121 prev=${COMP_WORDS[COMP_CWORD-1]};
3122 case "$prev" in
3123 -p)
3124 _filedir;
3125 return 0
3126 ;;
3127 --help | --cleancache)
3128 COMPREPLY='';
3129 return 0
3130 ;;
3131 esac;
3132 if [[ "$cur" == -* ]]; then
3133 COMPREPLY=($( compgen -W '\
3134 -A --ignorearch \
3135 -b --builddeps \
3136 -c --clean \
3137 -C --cleancache \
3138 -d --nodeps \
3139 -e --noextract \
3140 -f --force \
3141 -g --geninteg \
3142 -h --help \
3143 -i --install \
3144 -L --log \
3145 -m --nocolor \
3146 -o --nobuild \
3147 -p \
3148 -r --rmdeps \
3149 -s --syncdeps \
3150 --asroot \
3151 --source \
3152 --noconfirm \
3153 --noprogressbar' -- $cur ));
3154 fi;
3155 rem_selected
3156}
3157_man ()
3158{
3159 local cur i prev sect manpath manext mansect uname;
3160 manext="@([0-9lnp]|[0-9][px]|man|3pm)?(.@(gz|bz2|lzma))";
3161 mansect="@([0-9lnp]|[0-9][px]|3pm)";
3162 COMPREPLY=();
3163 cur=`_get_cword`;
3164 prev=${COMP_WORDS[COMP_CWORD-1]};
3165 if [[ "$prev" == -l ]]; then
3166 _filedir $manext;
3167 return 0;
3168 fi;
3169 _expand || return 0;
3170 if [[ "$cur" == */* ]]; then
3171 _filedir $manext;
3172 return 0;
3173 fi;
3174 uname=$( uname -s );
3175 if [[ $uname == @(Linux|GNU|GNU/*|FreeBSD|Cygwin|CYGWIN_*) ]]; then
3176 manpath=$( manpath 2>/dev/null || command man --path );
3177 else
3178 manpath=$MANPATH;
3179 fi;
3180 if [ -z "$manpath" ]; then
3181 COMPREPLY=($( compgen -c -- "$cur" ));
3182 return 0;
3183 fi;
3184 [[ "$prev" == $mansect ]] && sect=$prev || sect='*';
3185 manpath=$manpath:;
3186 if [ -n "$cur" ]; then
3187 manpath="${manpath//://*man$sect/$cur* } ${manpath//://*cat$sect/$cur* }";
3188 else
3189 manpath="${manpath//://*man$sect/ } ${manpath//://*cat$sect/ }";
3190 fi;
3191 COMPREPLY=($( eval command ls "$manpath" 2>/dev/null ));
3192 COMPREPLY=(${COMPREPLY[@]##*/?(:)});
3193 COMPREPLY=(${COMPREPLY[@]%.@(gz|bz2|lzma)});
3194 COMPREPLY=($( compgen -W '${COMPREPLY[@]%.*}' -- "${cur//\\\\/}" ));
3195 if [[ "$prev" != $mansect ]]; then
3196 local start=${#COMPREPLY[@]};
3197 _filedir $manext;
3198 for ((i=$start; i < ${#COMPREPLY[@]}; i++ ))
3199 do
3200 [[ ${COMPREPLY[i]} == */* ]] || COMPREPLY[i]=./${COMPREPLY[i]};
3201 done;
3202 fi;
3203 return 0
3204}
3205_mdadm ()
3206{
3207 local cur prev mode options;
3208 COMPREPLY=();
3209 cur=`_get_cword`;
3210 prev=${COMP_WORDS[COMP_CWORD-1]};
3211 case $prev in
3212 -@(c|b))
3213 _filedir;
3214 return 0
3215 ;;
3216 -l)
3217 _mdadm_raid_level;
3218 return 0
3219 ;;
3220 -p)
3221 _mdadm_raid_layout;
3222 return 0
3223 ;;
3224 -a)
3225 _mdadm_auto_flag;
3226 return 0
3227 ;;
3228 -U)
3229 _mdadm_update_flag;
3230 return 0
3231 ;;
3232 esac;
3233 if [[ "$cur" == *=* ]]; then
3234 prev=${cur/=*/};
3235 cur=${cur/*=/};
3236 case "$prev" in
3237 --@(config|bitmap|backup-file))
3238 _filedir;
3239 return 0
3240 ;;
3241 --level)
3242 _mdadm_raid_level;
3243 return 0
3244 ;;
3245 --@(layout|parity))
3246 _mdadm_raid_layout;
3247 return 0
3248 ;;
3249 --auto)
3250 _mdadm_auto_flag;
3251 return 0
3252 ;;
3253 --update)
3254 _mdadm_update_flag;
3255 return 0
3256 ;;
3257 esac;
3258 fi;
3259 options='-h --help --help-options -V --version -v --verbose -q --quiet -b \
3260 --brief -f --force -c --config= -s --scan -e --metadata= --homehost=';
3261 if [[ "$cur" == -* ]]; then
3262 if [[ $COMP_CWORD -eq 1 ]]; then
3263 COMPREPLY=($( compgen -W "$options -A --assemble -B --build -C --create -F --follow --monitor -G --grow" -- "$cur" ));
3264 else
3265 case ${COMP_WORDS[COMP_CWORD-1]} in
3266 -@(A|-assemble))
3267 COMPREPLY=($( compgen -W "$options -u --uuid= -m --super-minor= -N --name= -f --force -R --run --no-degraded -a --auto -b --bitmap= --backup-file= -U --update= --auto-update-homehost" -- "$cur" ))
3268 ;;
3269 -@(B|C|G|-build|-create|-grow))
3270 COMPREPLY=($( compgen -W "$options -n --raid-devices= -x --spare-devices= -z --size= -c --chunk= --rounding= -l --level= -p --layout= --parity= -b --bitmap= --bitmap-chunk= -W --write-mostly --write-behind= --assume-clean --backup-file= -N --name= -R --run -f --force -a --auto" -- "$cur" ))
3271 ;;
3272 -@(F|-follow|-monitor))
3273 COMPREPLY=($( compgen -W "$options -m --mail -p --program --alert -y --syslog -d --delay -f --daemonise -i --pid-file -1 --oneshot -t --test" -- "$cur" ))
3274 ;;
3275 @(/dev/*|--add|--fail|--remove))
3276 COMPREPLY=($( compgen -W "$options -a --add --re-add -r --remove -f --fail --set-faulty" -- "$cur" ))
3277 ;;
3278 *)
3279 COMPREPLY=($( compgen -W "$options -Q --query -D --detail -E --examine --sparc2.2 -X --examine-bitmap -R --run -S --stop -o --readonly -w --readwrite --zero-superblock -t --test" -- "$cur" ))
3280 ;;
3281 esac;
3282 fi;
3283 else
3284 cur=${cur:=/dev/};
3285 _filedir;
3286 fi
3287}
3288_mdadm_auto_flag ()
3289{
3290 COMPREPLY=($( compgen -W 'no yes md mdp part p' -- "$cur" ))
3291}
3292_mdadm_raid_layout ()
3293{
3294 local level;
3295 for ((i=1; i < COMP_CWORD; i++ ))
3296 do
3297 if [[ "${COMP_WORDS[i]}" == -@(l|-level) ]]; then
3298 level=${COMP_WORDS[i+1]};
3299 break;
3300 fi;
3301 done;
3302 case $level in
3303 raid5)
3304 COMPREPLY=($( compgen -W 'left-asymmetric left-symmetric \
3305 right-asymmetric right-symmetric la ra ls rs' -- "$cur" ))
3306 ;;
3307 raid10)
3308 COMPREPLY=($( compgen -W 'n o p' -- "$cur" ))
3309 ;;
3310 faulty)
3311 COMPREPLY=($( compgen -W 'write-transient wt read-transient rt \
3312 write-persistent wp read-persistent rp write-all read-fixable \
3313 rf clear flush none' -- $cur ))
3314 ;;
3315 esac
3316}
3317_mdadm_raid_level ()
3318{
3319 local mode;
3320 for ((i=1; i < COMP_CWORD; i++ ))
3321 do
3322 case ${COMP_WORDS[i]} in
3323 -@(C|-create))
3324 mode=create;
3325 break
3326 ;;
3327 -@(B|-build))
3328 mode=build;
3329 break
3330 ;;
3331 esac;
3332 done;
3333 case $mode in
3334 create)
3335 COMPREPLY=($( compgen -W 'linear raid0 0 stripe raid1 1 mirror \
3336 raid4 4 raid5 5 raid6 6 raid10 10 multipath mp faulty' -- "$cur" ))
3337 ;;
3338 build)
3339 COMPREPLY=($( compgen -W 'linear stripe raid0 0 raid1 multipath \
3340 mp faulty' -- "$cur" ))
3341 ;;
3342 esac
3343}
3344_mdadm_update_flag ()
3345{
3346 COMPREPLY=($( compgen -W 'sparc2.2 summaries uuid name homehost resync \
3347 byteorder super-minor' -- "$cur" ))
3348}
3349_mii_tool ()
3350{
3351 local cur prev split=false;
3352 COMPREPLY=();
3353 cur=`_get_cword`;
3354 prev=${COMP_WORDS[COMP_CWORD-1]};
3355 _split_longopt && split=true;
3356 case $prev in
3357 -F | --force)
3358 COMPREPLY=($( compgen -W '100baseTx-FD 100baseTx-HD \
3359 10baseT-FD 10baseT-HD' -- "$cur" ));
3360 return 0
3361 ;;
3362 -A | --advertise)
3363 COMPREPLY=($( compgen -W '100baseT4 100baseTx-FD 100baseTx-HD \
3364 10baseT-FD 10baseT-HD' -- "$cur" ));
3365 return 0
3366 ;;
3367 esac;
3368 $split && return 0;
3369 if [[ "$cur" == -* ]]; then
3370 COMPREPLY=($( compgen -W '-v --verbose -V --version -R \
3371 --reset -r --restart -w --watch -l --log -A \
3372 --advertise -F --force' -- "$cur" ));
3373 else
3374 _available_interfaces -a;
3375 fi
3376}
3377_mkisofs ()
3378{
3379 local cur prev;
3380 COMPREPLY=();
3381 cur=`_get_cword`;
3382 prev=${COMP_WORDS[COMP_CWORD-1]};
3383 case "$prev" in
3384 -@(o|abstract|biblio|check-session|copyright|log-file|root-info|prep-boot|*-list))
3385 _filedir;
3386 return 0
3387 ;;
3388 -*-charset)
3389 COMPREPLY=($( compgen -W '$( mkisofs -input-charset \
3390 help 2>&1 | tail -n +3 )' -- "$cur" ));
3391 return 0
3392 ;;
3393 -uid)
3394 _uids;
3395 return 0
3396 ;;
3397 -gid)
3398 _gids;
3399 return 0
3400 ;;
3401 esac;
3402 if [[ "$cur" == -* ]]; then
3403 COMPREPLY=($( compgen -W '-abstract -A -allow-lowercase \
3404 -allow-multidot -biblio -cache-inodes \
3405 -no-cache-inodes -b -eltorito-alt-boot -B -G \
3406 -hard-disk-boot -no-emul-boot -no-boot \
3407 -boot-load-seg -boot-load-size \
3408 -boot-info-table -C -c -check-oldname \
3409 -check-session -copyright -d -D -dir-mode \
3410 -dvd-video -f -file-mode -gid -gui \
3411 -graft-points -hide -hide-list -hidden \
3412 -hidden-list -hide-joliet -hide-joliet-list \
3413 -hide-joliet-trans-tbl -hide-rr-moved \
3414 -input-charset -output-charset -iso-level -J \
3415 -joliet-long -jcharset -l -L -log-file -m \
3416 -exclude-list -max-iso9660-filenames -M -N \
3417 -new-dir-mode -nobak -no-bak -force-rr -no-rr \
3418 -no-split-symlink-components \
3419 -no-split-symlink-fields -o -pad -no-pad \
3420 -path-list -P -p -print-size -quiet -R -r \
3421 -relaxed-filenames -sort -split-output \
3422 -stream-media-size -stream-file-name -sysid -T\
3423 -table-name -ucs-level -udf -uid \
3424 -use-fileversion -U -no-iso-translate -V \
3425 -volset -volset-size -volset-seqno -v -x -z \
3426 -hfs -apple -map -magic -hfs-creator \
3427 -hfs-type -probe -no-desktop -mac-name \
3428 -boot-hfs-file -part -auto -cluster-size \
3429 -hide-hfs -hide-hfs-list -hfs-volid \
3430 -icon-position -root-info -prep-boot \
3431 -input-hfs-charset -output-hfs-charset \
3432 -hfs-unlock -hfs-bless -hfs-parms --cap \
3433 --netatalk --double --ethershare --ushare \
3434 --exchange --sgi --xinet --macbin --single \
3435 --dave --sfm --osx-double --osx-hfs' -- "$cur" ));
3436 else
3437 _filedir;
3438 fi
3439}
3440_modules ()
3441{
3442 local modpath;
3443 modpath=/lib/modules/$1;
3444 COMPREPLY=($( command ls -R $modpath | sed -ne 's/^\('"$cur"'.*\)\.k\?o\(\|.gz\)$/\1/p'))
3445}
3446_mogrify ()
3447{
3448 local cur;
3449 COMPREPLY=();
3450 cur=`_get_cword`;
3451 _ImageMagick;
3452 if [[ "$cur" == -* ]]; then
3453 COMPREPLY=($( compgen -W '-adaptive-blur -adaptive-resize \
3454 -adaptive-sharpen -adjoin -affine -alpha -annotate \
3455 -antialias -attenuate -authenticate -auto-orient \
3456 -background -bias -black-point-compensation \
3457 -black-threshold -blue-primary -blur -border \
3458 -bordercolor -caption -channel -charcoal -chop -clip \
3459 -clip-mask -clip-path -clut -colorize -colors \
3460 -colorspace -comment -compose -compress -contrast \
3461 -contrast-stretch -convolve -cycle -debug -decipher \
3462 -define -delay -density -depth -despeckle -display \
3463 -dispose -distort -dither -draw -edge -emboss \
3464 -encipher -encoding -endian -enhance -equalize \
3465 -evaluate -extent -extract -family -fill -filter \
3466 -flip -floodfill -flop -font -format -frame -fuzz \
3467 -gamma -gaussian-blur -geometry -gravity \
3468 -green-primary -help -identify -implode -intent \
3469 -interlace -interpolate -label -lat -layers -level \
3470 -limit -linear-stretch -liquid-rescale -list -log \
3471 -loop -mask -mattecolor -median -modulate -monitor \
3472 -monochrome -motion-blur -negate -noise -normalize \
3473 -opaque -ordered-dither -orient -page -paint -path \
3474 -ping -pointsize -polaroid -posterize -preview -print \
3475 -profile -quality -quantize -quiet -radial-blur \
3476 -raise -random-threshold -recolor -red-primary \
3477 -regard-warnings -region -render -repage -resample \
3478 -resize -roll -rotate -sample -sampling-factor -scale \
3479 -scene -seed -segment -sepia-tone -set -shade -shadow \
3480 -sharpen -shave -shear -sigmoidal-contrast -size \
3481 -sketch -solarize -splice -spread -stretch -strip \
3482 -stroke -strokewidth -style -swirl -taint -texture \
3483 -threshold -thumbnail -tile -tile-offset -tint \
3484 -transform -transparent -transparent-color -transpose \
3485 -transverse -treedepth -trim -type -undercolor \
3486 -unique-colors -units -unsharp -verbose -version \
3487 -view -vignette -virtual-pixel -wave -weight \
3488 -white-point -white-threshold' -- "$cur" ));
3489 else
3490 if [[ "$cur" == +* ]]; then
3491 COMPREPLY=($( compgen -W '+compress +contrast +debug +dither \
3492 +endian +gamma +label +map +mask +matte +negate +page \
3493 +raise' -- "$cur" ));
3494 else
3495 _filedir;
3496 fi;
3497 fi
3498}
3499_montage ()
3500{
3501 local cur;
3502 COMPREPLY=();
3503 cur=`_get_cword`;
3504 _ImageMagick;
3505 if [[ "$cur" == -* ]]; then
3506 COMPREPLY=($( compgen -W '-adjoin -affine -alpha \
3507 -authenticate -background -blue-primary -blur -border \
3508 -bordercolor -borderwidth -caption -channel -clone \
3509 -coalesce -colors -colorspace -comment -compose \
3510 -compress -crop -debug -define -density -depth \
3511 -display -dispose -dither -draw -encoding -endian \
3512 -extract -fill -filter -flatten -flip -flop -font \
3513 -format -frame -gamma -geometry -gravity \
3514 -green-primary -help -identify -interlace \
3515 -interpolate -label -limit -list -log -mattecolor \
3516 -mode -monitor -monochrome -origin -page -pointsize \
3517 -polaroid -profile -quality -quantize -quiet \
3518 -red-primary -regard-warnings -repage -resize \
3519 -respect-parenthesis -rotate -sampling-factor -scenes \
3520 -seed -set -shadow -size -strip -stroke -texture \
3521 -thumbnail -tile -title -transform -transparent \
3522 -transparent-color -treedepth -trim -type -units \
3523 -verbose -version -virtual-pixel \
3524 -white-point' -- "$cur" ));
3525 else
3526 if [[ "$cur" == +* ]]; then
3527 COMPREPLY=($( compgen -W '+adjoin +compress +debug +dither \
3528 +endian +gamma +label +matte +page' -- "$cur" ));
3529 else
3530 _filedir;
3531 fi;
3532 fi
3533}
3534_mount ()
3535{
3536 local cur i sm host prev;
3537 COMPREPLY=();
3538 cur=`_get_cword`;
3539 [[ "$cur" == \\ ]] && cur="/";
3540 prev=${COMP_WORDS[COMP_CWORD-1]};
3541 for i in {,/usr}/{,s}bin/showmount;
3542 do
3543 [ -x $i ] && sm=$i && break;
3544 done;
3545 if [ -n "$sm" ] && [[ "$cur" == *:* ]]; then
3546 COMPREPLY=($( $sm -e ${cur%%:*} | sed 1d | grep ^${cur#*:} | awk '{print $1}' ));
3547 else
3548 if [[ "$cur" == //* ]]; then
3549 host=${cur#//};
3550 host=${host%%/*};
3551 if [ -n "$host" ]; then
3552 COMPREPLY=($( compgen -W "$( echo $( smbclient -d 0 -NL $host 2>/dev/null|
3553 sed -ne '/^['"$'\t '"']*Sharename/,/^$/p' |
3554 sed -ne '3,$s|^[^A-Za-z]*\([^'"$'\t '"']*\).*$|//'$host'/\1|p' ) )" -- "$cur" ));
3555 fi;
3556 else
3557 if [ -r /etc/vfstab ]; then
3558 COMPREPLY=($( compgen -W "$( awk '! /^[ \t]*#/ {if ($3 ~ /\//) print $3}' /etc/vfstab )" -- "$cur" ));
3559 else
3560 if [ ! -e /etc/fstab ]; then
3561 COMPREPLY=($( compgen -W "$( mount | awk '! /^[ \t]*#/ {if ($3 ~ /\//) print $3}' )" -- "$cur" ));
3562 else
3563 if [ $prev = -L ]; then
3564 COMPREPLY=($( compgen -W '$(sed -ne "s/^[[:space:]]*LABEL=\([^[:space:]]*\).*/\1/p" /etc/fstab )' -- "$cur" ));
3565 else
3566 if [ $prev = -U ]; then
3567 COMPREPLY=($( compgen -W '$(sed -ne "s/^[[:space:]]*UUID=\([^[:space:]]*\).*/\1/p" /etc/fstab )' -- "$cur" ));
3568 else
3569 COMPREPLY=($( compgen -W "$( awk '! /^[ \t]*#/ {if ($2 ~ /\//) print $2}' /etc/fstab )" -- "$cur" ));
3570 fi;
3571 fi;
3572 fi;
3573 fi;
3574 fi;
3575 fi;
3576 return 0
3577}
3578_mplayer ()
3579{
3580 local cmd cur prev skinsdir IFS='
3581' i j k=0;
3582 COMPREPLY=();
3583 cmd=${COMP_WORDS[0]};
3584 cur=`_get_cword`;
3585 prev=${COMP_WORDS[COMP_CWORD-1]};
3586 case "$prev" in
3587 -@([av][cfo]|[av]fm|vop|fstype|demuxer|o[av]c|of|profile))
3588 _mplayer_options_list $cmd $prev;
3589 return 0
3590 ;;
3591 -audiofile)
3592 _filedir '@(mp3|MP3|mpg|MPG|ogg|OGG|w?(a)v|W?(A)V|mid|MID|flac|FLAC|mka|MKA|ape|APE)';
3593 return 0
3594 ;;
3595 -font)
3596 _filedir '@(desc|ttf)';
3597 return 0
3598 ;;
3599 -sub)
3600 _filedir '@(srt|SRT|sub|SUB|txt|TXT|utf|UTF|rar|RAR|mpsub|smi|js|ssa|SSA|ass|ASS)';
3601 return 0
3602 ;;
3603 -vobsub)
3604 _filedir '@(idx|IDX|ifo|IFO|sub|SUB)';
3605 IFS='
3606';
3607 COMPREPLY=($( for i in "${COMPREPLY[@]}"; do
3608 if [ -f $i -a -r $i ]; then
3609 echo ${i%.*}
3610 else
3611 echo $i
3612 fi
3613 done ));
3614 IFS='
3615';
3616 return 0
3617 ;;
3618 -ifo)
3619 _filedir '@(ifo|IFO)';
3620 return 0
3621 ;;
3622 -cuefile)
3623 _filedir '@(bin|BIN|cue|CUE)';
3624 return 0
3625 ;;
3626 -skin)
3627 if [ -n "$MPLAYER_SKINS_DIR" ]; then
3628 skinsdir=$MPLAYER_SKINS_DIR;
3629 else
3630 skinsdir=/usr/share/mplayer/Skin;
3631 fi;
3632 IFS='
3633';
3634 for i in ~/.mplayer/Skin $skinsdir;
3635 do
3636 if [ -d $i -a -r $i ]; then
3637 for j in $( compgen -d $i/$cur );
3638 do
3639 COMPREPLY[$k]=${j#$i/};
3640 k=$((++k));
3641 done;
3642 fi;
3643 done;
3644 IFS='
3645';
3646 return 0
3647 ;;
3648 -@(mixer|@(cdrom|dvd)-device|dvdauth|fb|zrdev))
3649 cur=${cur:=/dev/};
3650 _filedir;
3651 return 0
3652 ;;
3653 -@(edl?(out)|lircconf|menu-cfg|playlist|csslib|dumpfile) | -@(subfile|vobsub|aofile|fbmodeconfig|include|o|dvdkey) | -passlogfile)
3654 _filedir;
3655 return 0
3656 ;;
3657 -@(auto@(q|sync)|loop|menu-root|speed|sstep|aid|alang) | -@(?(@(audio|sub)-)demuxer|bandwidth|cache|chapter) | -@(dvd?(angle)|fps|frames|mc|passwd|user|sb|srate|ss|vcd) | -@(vi?(d|vo)|ffactor|sid|slang|spu@(align|aa|gauss)) | -@(vobsubid|delay|bpp|brightness|contrast|dfbopts|display) | -@(fbmode|geometry|guiwid|hue|icelayer|screen[wh]|wid) | -@(monitor@(aspect|-@(dotclock|[hv]freq))|panscan|saturation) | -@(xineramascreen|zr@(crop|norm|quality|[xy]doff|[vh]dec)) | -@(aspect|pp|x|y|xy|z|stereo|audio-@(density|delay|preload)) | -@(endpos|osdlevel|ffourcc|sws|channels|skiplimit|format) | -@(ofps|aa@(driver|@(osd|sub)color)|vobsubout?(i@(ndex|d))) | -sub@(-bg-@(alpha|color)|cp|delay|fps|pos|align|width) | -sub@(font-@(blur|outline|autoscale|encoding|@(osd|text)-scale)))
3658 return 0
3659 ;;
3660 -lavdopts)
3661 COMPREPLY=($( compgen -W 'ec er= bug= idct= gray' -- "$cur" ));
3662 return 0
3663 ;;
3664 -lavcopts)
3665 COMPREPLY=($( compgen -W 'vcodec= vqmin= vqscale= vqmax= mbqmin= \
3666 mbqmax= vqdiff= vmax_b_frames= vme= vhq v4mv keyint= \
3667 vb_strategy= vpass= aspect= vbitrate= vratetol= vrc_maxrate= \
3668 vrc_minrate= vrc_buf_size= vb_qfactor= vi_qfactor= vb_qoffset= \
3669 vi_qoffset= vqblur= vqcomp= vrc_eq= vrc_override= \
3670 vrc_init_cplx= vqsquish= vlelim= vcelim= vstrict= vdpart \
3671 vpsize= gray vfdct= idct= lumi_mask= dark_mask= tcplx_mask= \
3672 scplx_mask= naq ildct format= pred qpel precmp= cmp= subcmp= \
3673 predia= dia= trell last_pred= preme= subq= psnr mpeg_quant aic \
3674 umv' -- "$cur" ));
3675 return 0
3676 ;;
3677 -ssf)
3678 COMPREPLY=($( compgen -W 'lgb= cgb= ls= cs= chs= cvs=' -- "$cur" ));
3679 return 0
3680 ;;
3681 -jpeg)
3682 COMPREPLY=($( compgen -W 'noprogressive progressive nobaseline \
3683 baseline optimize= smooth= quality= outdir=' -- "$cur" ));
3684 return 0
3685 ;;
3686 -xvidopts)
3687 COMPREPLY=($( compgen -W 'dr2 nodr2' -- "$cur" ));
3688 return 0
3689 ;;
3690 -xvidencopts)
3691 COMPREPLY=($( compgen -W 'pass= bitrate= fixed_quant= me_quality= \
3692 4mv rc_reaction_delay_factor= rc_averaging_period= rc_buffer= \
3693 quant_range= min_key_interval= max_key_interval= mpeg_quant \
3694 mod_quant lumi_mask hintedme hintfile debug keyframe_boost= \
3695 kfthreshold= kfreduction=' -- "$cur" ));
3696 return 0
3697 ;;
3698 -divx4opts)
3699 COMPREPLY=($( compgen -W 'br= key= deinterlace q= min_quant= \
3700 max_quant= rc_period= rc_reaction_period= crispness= \
3701 rc_reaction_ratio= pass= vbrpass= help' -- "$cur" ));
3702 return 0
3703 ;;
3704 -info)
3705 COMPREPLY=($( compgen -W 'name= artist= genre= subject= \
3706 copyright= srcform= comment= help' -- "$cur" ));
3707 return 0
3708 ;;
3709 -lameopts)
3710 COMPREPLY=($( compgen -W 'vbr= abr cbr br= q= aq= ratio= vol= \
3711 mode= padding= fast preset= help' -- "$cur" ));
3712 return 0
3713 ;;
3714 -rawaudio)
3715 COMPREPLY=($( compgen -W 'on channels= rate= samplesize= format=' -- "$cur" ));
3716 return 0
3717 ;;
3718 -rawvideo)
3719 COMPREPLY=($( compgen -W 'on fps= sqcif qcif cif 4cif pal ntsc w= \
3720 h= y420 yv12 yuy2 y8 format= size=' -- "$cur" ));
3721 return 0
3722 ;;
3723 -aop)
3724 COMPREPLY=($( compgen -W 'list= delay= format= fout= volume= mul= \
3725 softclip' -- "$cur" ));
3726 return 0
3727 ;;
3728 -dxr2)
3729 COMPREPLY=($( compgen -W 'ar-mode= iec958-encoded iec958-decoded \
3730 mute ucode= 75ire bw color interlaced macrovision= norm= \
3731 square-pixel ccir601-pixel cr-left= cr-right= cr-top= cr-bot= \
3732 ck-rmin= ck-gmin= ck-bmin= ck-rmax= ck-gmax= ck-bmax= ck-r= \
3733 ck-g= ck-b= ignore-cache= ol-osd= olh-cor= olw-cor= olx-cor= \
3734 oly-cor= overlay overlay-ratio= update-cache' -- "$cur" ));
3735 return 0
3736 ;;
3737 -tv)
3738 COMPREPLY=($( compgen -W 'on noaudio driver= device= input= freq= \
3739 outfmt= width= height= buffersize= norm= channel= chanlist= \
3740 audiorate= forceaudio alsa amode= forcechan= adevice= audioid= \
3741 volume= bass= treble= balance= fps= channels= immediatemode=' -- "$cur" ));
3742 return 0
3743 ;;
3744 -mf)
3745 COMPREPLY=($( compgen -W 'on w= h= fps= type=' -- "$cur" ));
3746 return 0
3747 ;;
3748 -cdda)
3749 COMPREPLY=($( compgen -W 'speed= paranoia= generic-dev= \
3750 sector-size= overlap= toc-bias toc-offset= skip noskip' \
3751 -- "$cur" ));
3752 return 0
3753 ;;
3754 -input)
3755 COMPREPLY=($( compgen -W 'conf= ar-delay ar-rate keylist cmdlist \
3756 js-dev file' -- "$cur" ));
3757 return 0
3758 ;;
3759 -af)
3760 COMPREPLY=($( compgen -W 'resample resample= channels channels= \
3761 format format= volume volume= delay delay= pan pan= sub sub= \
3762 surround surround=' -- "$cur" ));
3763 return 0
3764 ;;
3765 -af-adv)
3766 COMPREPLY=($( compgen -W 'force= list=' -- "$cur" ));
3767 return 0
3768 ;;
3769 esac;
3770 case "$cur" in
3771 -*)
3772 COMPREPLY=($( compgen -W '$( $cmd -list-options 2>/dev/null | \
3773 sed -ne '1,/^[[:space:]]*Name/d' \
3774 -e "s/^[[:space:]]*/-/" -e "s/[[:space:]:].*//" \
3775 -e "/^-\(Total\|.*\*\)\?$/!p" )' -- "$cur" ))
3776 ;;
3777 *)
3778 _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|fl[iv]|FL[IV]|viv|VIV|rm?(j)|RM?(J)|ra?(m)|RA?(M)|yuv|YUV|mov|MOV|qt|QT|mp[234]|MP[234]|m4[av]|M4[AV]|og[gmavx]|OG[GMAVX]|w?(a)v|W?(A)V|dump|DUMP|mk[av]|MK[AV]|m4a|M4A|aac|AAC|m[24]v|M[24]V|dv|DV|rmvb|RMVB|mid|MID|ts|TS|3g[p2]|mpc|MPC|flac|FLAC|vro|VRO|divx|DIVX|aif?(f)|AIF?(F)|m2ts|M2TS|vdr|VDR|xvid|XVID|ape|APE)'
3779 ;;
3780 esac;
3781 return 0
3782}
3783_mplayer_options_list ()
3784{
3785 cur=${cur%\\};
3786 COMPREPLY=($( compgen -W "$( $1 $2 help 2>/dev/null | sed -e '1,/^Available/d' | awk '{print $1}' | sed -e 's/:$//' -e 's/^'${2#-}'$//' -e 's/<.*//' )" -- "$cur" ))
3787}
3788_mysqladmin ()
3789{
3790 local cur prev;
3791 COMPREPLY=();
3792 cur=`_get_cword`;
3793 prev=${COMP_WORDS[COMP_CWORD-1]};
3794 case "$prev" in
3795 -u)
3796 COMPREPLY=($( compgen -u -- "$cur" ));
3797 return 0
3798 ;;
3799 *)
3800
3801 ;;
3802 esac;
3803 COMPREPLY=($( compgen -W '-# -f -? -C -h -p -P -i -r -E -s -S -t -u \
3804 -v -V -w' -- "$cur" ));
3805 COMPREPLY=("${COMPREPLY[@]}" $( compgen -W 'create drop extended-status flush-hosts flush-logs \
3806 flush-status flush-tables flush-threads flush-privileges kill \
3807 password ping processlist reload refresh shutdown status variables \
3808 version' -- "$cur" ))
3809}
3810_netcfg ()
3811{
3812 local cur prev opts lopts cmds prfls;
3813 COMPREPLY=();
3814 cur="${COMP_WORDS[COMP_CWORD]}";
3815 prev="${COMP_WORDS[COMP_CWORD-1]}";
3816 opts="-c -d -a -i -h -v";
3817 lopts="--help --version";
3818 cmds="check-iface down all-down iface-down all-resume all-suspend";
3819 prfls="`find /etc/network.d -maxdepth 1 -not -type d -printf '%f\n'`";
3820 case "${cur}" in
3821 --*)
3822 COMPREPLY=($( compgen -W "${lopts}" -- $cur ));
3823 return 0
3824 ;;
3825 -*)
3826 COMPREPLY=($( compgen -W "${opts} ${lopts}" -- $cur ));
3827 return 0
3828 ;;
3829 *)
3830 if [ $COMP_CWORD -eq 1 ]; then
3831 COMPREPLY=($( compgen -W "${opts} ${lopts} ${cmds} ${prfls}" -- $cur ));
3832 fi
3833 ;;
3834 esac;
3835 case "${prev}" in
3836 -c | check-iface | -i | iface-down)
3837 _connected_intfs;
3838 return 0
3839 ;;
3840 -d | down)
3841 _connected_prfls;
3842 return 0
3843 ;;
3844 *)
3845
3846 ;;
3847 esac;
3848 return 0
3849}
3850_newgrp ()
3851{
3852 COMPREPLY=();
3853 if [[ "`_get_cword`" == "-" ]]; then
3854 COMPREPLY=(-);
3855 fi
3856}
3857_newusers ()
3858{
3859 local cur prev split=false;
3860 COMPREPLY=();
3861 cur=`_get_cword`;
3862 prev=${COMP_WORDS[COMP_CWORD-1]};
3863 _split_longopt && split=true;
3864 case "$prev" in
3865 -c | --crypt)
3866 COMPREPLY=($( compgen -W 'DES MD5 NONE SHA256 SHA512' -- "$cur" ));
3867 return 0
3868 ;;
3869 -s | --sha-rounds)
3870 return 0
3871 ;;
3872 esac;
3873 $split && return 0;
3874 if [[ "$cur" == -* ]]; then
3875 COMPREPLY=($( compgen -W '-c --crypt-method --r --system \
3876 -s --sha-rounds' -- "$cur" ));
3877 return 0;
3878 fi;
3879 _filedir
3880}
3881_openssl ()
3882{
3883 local cur prev commands command options formats;
3884 COMPREPLY=();
3885 cur=`_get_cword`;
3886 commands='asn1parse ca ciphers crl crl2pkcs7 dgst dh dhparam dsa \
3887 dsaparam ec ecparam enc engine errstr gendh gendsa genrsa \
3888 nseq ocsp passwd pkcs12 pkcs7 pkcs8 prime rand req rsa \
3889 rsautl s_client s_server s_time sess_id smime speed spkac \
3890 verify version x509 md2 md4 md5 rmd160 sha sha1 aes-128-cbc \
3891 aes-128-ecb aes-192-cbc aes-192-ecb aes-256-cbc aes-256-ecb \
3892 base64 bf bf-cbc bf-cfb bf-ecb bf-ofb camellia-128-cbc \
3893 camellia-128-ecb camellia-192-cbc camellia-192-ecb \
3894 camellia-256-cbc camellia-256-ecb cast cast-cbc cast5-cbc \
3895 cast5-cfb cast5-ecb cast5-ofb des des-cbc des-cfb des-ecb \
3896 des-ede des-ede-cbc des-ede-cfb des-ede-ofb des-ede3 \
3897 des-ede3-cbc des-ede3-cfb des-ede3-ofb des-ofb des3 desx rc2 \
3898 rc2-40-cbc rc2-64-cbc rc2-cbc rc2-cfb rc2-ecb rc2-ofb rc4 \
3899 rc4-40';
3900 if [ $COMP_CWORD -eq 1 ]; then
3901 COMPREPLY=($( compgen -W "$commands" -- "$cur" ));
3902 else
3903 command=${COMP_WORDS[1]};
3904 prev=${COMP_WORDS[COMP_CWORD-1]};
3905 case $prev in
3906 -@(CA|CAfile|CAkey|CAserial|cert|certfile|config|content|dcert|dkey|dhparam|extfile|in|inkey|kfile|key|keyout|out|oid|prvrify|rand|recip|revoke|sess_in|sess_out|spkac|sign|signkey|signer|signature|ss_cert|untrusted|verify))
3907 _filedir;
3908 return 0
3909 ;;
3910 -@(outdir|CApath))
3911 _filedir -d;
3912 return 0
3913 ;;
3914 -@(name|crlexts|extensions))
3915 _openssl_sections;
3916 return 0
3917 ;;
3918 -@(in|out|key|cert|CA|CAkey|dkey|dcert)form)
3919 formats='DER PEM';
3920 case $command in
3921 x509)
3922 formats="$formats NET"
3923 ;;
3924 smime)
3925 formats="$formats SMIME"
3926 ;;
3927 esac;
3928 COMPREPLY=($( compgen -W "$formats" -- "$cur" ));
3929 return 0
3930 ;;
3931 -connect)
3932 _known_hosts_real "$cur";
3933 return 0
3934 ;;
3935 -starttls)
3936 COMPREPLY=($( compgen -W 'smtp pop3 imap ftp' -- "$cur" ));
3937 return 0
3938 ;;
3939 -cipher)
3940 COMPREPLY=($( compgen -W "$(openssl ciphers | tr ':' '\n')" -- "$cur" ));
3941 return 0
3942 ;;
3943 esac;
3944 if [[ "$cur" == -* ]]; then
3945 case $command in
3946 asn1parse)
3947 options='-inform -in -out -noout -offset -length -i -oid \
3948 -strparse'
3949 ;;
3950 ca)
3951 options='-verbose -config -name -gencrl -revoke \
3952 -crl_reason -crl_hold -crl_compromise \
3953 -crl_CA_compromise -crldays -crlhours -crlexts \
3954 -startdate -enddate -days -md -policy -keyfile -key \
3955 -passin -cert -selfsig -in -out -notext -outdir \
3956 -infiles -spkac -ss_cert -preserveDN -noemailDN \
3957 -batch -msie_hack -extensions -extfile -engine \
3958 -subj -utf8 -multivalue-rdn'
3959 ;;
3960 ciphers)
3961 options='-v -ssl2 -ssl3 -tls1'
3962 ;;
3963 crl)
3964 options='-inform -outform -text -in -out -noout -hash \
3965 -issuer -lastupdate -nextupdate -CAfile -CApath'
3966 ;;
3967 crl2pkcs7)
3968 options='-inform -outform -in -out -print_certs'
3969 ;;
3970 dgst)
3971 options='-md5 -md4 -md2 -sha1 -sha -mdc2 -ripemd160 -dss1 \
3972 -c -d -hex -binary -out -sign -verify -prverify \
3973 -signature'
3974 ;;
3975 dsa)
3976 options='-inform -outform -in -passin -out -passout -des \
3977 -des3 -idea -text -noout -modulus -pubin -pubout'
3978 ;;
3979 dsaparam)
3980 options='-inform -outform -in -out -noout -text -C -rand \
3981 -genkey'
3982 ;;
3983 enc)
3984 options='-ciphername -in -out -pass -e -d -a -A -k -kfile \
3985 -S -K -iv -p -P -bufsize -debug'
3986 ;;
3987 dhparam)
3988 options='-inform -outform -in -out -dsaparam -noout -text \
3989 -C -2 -5 -rand'
3990 ;;
3991 gendsa)
3992 options='-out -des -des3 -idea -rand'
3993 ;;
3994 genrsa)
3995 options='-out -passout -des -des3 -idea -f4 -3 -rand'
3996 ;;
3997 pkcs7)
3998 options='-inform -outform -in -out -print_certs -text \
3999 -noout'
4000 ;;
4001 rand)
4002 options='-out -rand -base64'
4003 ;;
4004 req)
4005 options='-inform -outform -in -passin -out -passout -text \
4006 -noout -verify -modulus -new -rand -newkey -newkey \
4007 -nodes -key -keyform -keyout -md5 -sha1 -md2 -mdc2 \
4008 -config -x509 -days -asn1-kludge -newhdr -extensions \
4009 -reqexts section'
4010 ;;
4011 rsa)
4012 options='-inform -outform -in -passin -out -passout \
4013 -sgckey -des -des3 -idea -text -noout -modulus -check \
4014 -pubin -pubout -engine'
4015 ;;
4016 rsautl)
4017 options='-in -out -inkey -pubin -certin -sign -verify \
4018 -encrypt -decrypt -pkcs -ssl -raw -hexdump -asn1parse'
4019 ;;
4020 s_client)
4021 options='-connect -verify -cert -certform -key -keyform \
4022 -pass -CApath -CAfile -reconnect -pause -showcerts \
4023 -debug -msg -nbio_test -state -nbio -crlf -ign_eof \
4024 -quiet -ssl2 -ssl3 -tls1 -no_ssl2 -no_ssl3 -no_tls1 \
4025 -bugs -cipher -starttls -engine -tlsextdebug \
4026 -no_ticket -sess_out -sess_in -rand'
4027 ;;
4028 s_server)
4029 options='-accept -context -verify -Verify -crl_check \
4030 -crl_check_all -cert -certform -key -keyform -pass \
4031 -dcert -dcertform -dkey -dkeyform -dpass -dhparam \
4032 -nbio -nbio_test -crlf -debug -msg -state -CApath \
4033 -CAfile -nocert -cipher -quiet -no_tmp_rsa -ssl2 \
4034 -ssl3 -tls1 -no_ssl2 -no_ssl3 -no_tls1 -no_dhe \
4035 -bugs -hack -www -WWW -HTTP -engine -tlsextdebug \
4036 -no_ticket -id_prefix -rand'
4037 ;;
4038 s_time)
4039 options='-connect -www -cert -key -CApath -CAfile -reuse \
4040 -new -verify -nbio -time -ssl2 -ssl3 -bugs -cipher'
4041 ;;
4042 sess_id)
4043 options='-inform -outform -in -out -text -noout -context \
4044 ID'
4045 ;;
4046 smime)
4047 options='-encrypt -decrypt -sign -verify -pk7out -des \
4048 -des3 -rc2-40 -rc2-64 -rc2-128 -aes128 -aes192 -aes256 \
4049 -in -certfile -signer -recip -inform -passin -inkey \
4050 -out -outform -content -to -from -subject -text -rand'
4051 ;;
4052 speed)
4053 options='-engine'
4054 ;;
4055 verify)
4056 options='-CApath -CAfile -purpose -untrusted -help \
4057 -issuer_checks -verbose -certificates'
4058 ;;
4059 x509)
4060 options='-inform -outform -keyform -CAform -CAkeyform -in \
4061 -out -serial -hash -subject-hash -issuer_hash -subject \
4062 -issuer -nameopt -email -startdate -enddate -purpose \
4063 -dates -modulus -fingerprint -alias -noout -trustout \
4064 -clrtrust -clrreject -addtrust -addreject -setalias \
4065 -days -set_serial -signkey -x509toreq -req -CA -CAkey \
4066 -CAcreateserial -CAserial -text -C -md2 -md5 -sha1 \
4067 -mdc2 -clrext -extfile -extensions -engine'
4068 ;;
4069 @(md5|md4|md2|sha1|sha|mdc2|ripemd160))
4070 options='-c -d'
4071 ;;
4072 esac;
4073 COMPREPLY=($( compgen -W "$options" -- "$cur" ));
4074 else
4075 if [[ "$command" == speed ]]; then
4076 COMPREPLY=($( compgen -W 'md2 mdc2 md5 hmac sha1 rmd160 \
4077 idea-cbc rc2-cbc rc5-cbc bf-cbc des-cbc des-ede3 rc4 \
4078 rsa512 rsa1024 rsa2048 rsa4096 dsa512 dsa1024 dsa2048 idea \
4079 rc2 des rsa blowfish' -- "$cur" ));
4080 else
4081 _filedir;
4082 fi;
4083 fi;
4084 fi
4085}
4086_openssl_sections ()
4087{
4088 local config f;
4089 for ((i=2; i < COMP_CWORD; i++ ))
4090 do
4091 if [[ "${COMP_WORDS[i]}" == -config ]]; then
4092 config=${COMP_WORDS[i+1]};
4093 break;
4094 fi;
4095 done;
4096 if [ -z "$config" ]; then
4097 for f in /etc/ssl/openssl.cnf /etc/pki/tls/openssl.cnf /usr/share/ssl/openssl.cnf;
4098 do
4099 [ -f $f ] && config=$f && break;
4100 done;
4101 fi;
4102 [ ! -f "$config" ] && return 0;
4103 COMPREPLY=($( compgen -W "$( awk '/\[.*\]/ {print $2}' $config )" -- "$cur" ))
4104}
4105_pacman ()
4106{
4107 local a arg toparse op mod cur;
4108 COMPREPLY=();
4109 for ((i=1; i < ${#COMP_WORDS[@]}-1; i++ ))
4110 do
4111 a=${COMP_WORDS[i]};
4112 arg="${a:0:2}";
4113 toparse="${a:2}";
4114 case "${arg}" in
4115 -@(U|R|S|Q|h|V))
4116 op="${arg/-}";
4117 mod="${mod}${a:2}"
4118 ;;
4119 --)
4120 arg="${a:2}";
4121 case "${arg}" in
4122 remove)
4123 op="R"
4124 ;;
4125 upgrade)
4126 op="U"
4127 ;;
4128 query)
4129 op="Q"
4130 ;;
4131 sync)
4132 op="S"
4133 ;;
4134 help)
4135 op="h"
4136 ;;
4137 version)
4138 op="V"
4139 ;;
4140 verbose)
4141 mod="${mod}v"
4142 ;;
4143 root)
4144 mod="${mod}r"
4145 ;;
4146 dbpath)
4147 mod="${mod}b"
4148 ;;
4149 nodeps)
4150 mod="${mod}d"
4151 ;;
4152 force)
4153 mod="${mod}f"
4154 ;;
4155 groups)
4156 mod="${mod}g"
4157 ;;
4158 info)
4159 mod="${mod}i"
4160 ;;
4161 list)
4162 mod="${mod}l"
4163 ;;
4164 print-uris)
4165 mod="${mod}p"
4166 ;;
4167 search)
4168 mod="${mod}s"
4169 ;;
4170 sysupgrade)
4171 mod="${mod}u"
4172 ;;
4173 upgrades)
4174 mod="${mod}u"
4175 ;;
4176 downloadonly)
4177 mod="${mod}w"
4178 ;;
4179 refresh)
4180 mod="${mod}y"
4181 ;;
4182 changelog)
4183 mod="${mod}c"
4184 ;;
4185 deps)
4186 mod="${mod}d"
4187 ;;
4188 explicit)
4189 mod="${mod}e"
4190 ;;
4191 unrequired)
4192 mod="${mod}t"
4193 ;;
4194 foreign)
4195 mod="${mod}m"
4196 ;;
4197 owns)
4198 mod="${mod}o"
4199 ;;
4200 file)
4201 mod="${mod}p"
4202 ;;
4203 search)
4204 mod="${mod}s"
4205 ;;
4206 upgrades)
4207 mod="${mod}u"
4208 ;;
4209 cascade)
4210 mod="${mod}c"
4211 ;;
4212 check)
4213 mod="${mod}k"
4214 ;;
4215 dbonly)
4216 mod="${mod}k"
4217 ;;
4218 nosave)
4219 mod="${mod}n"
4220 ;;
4221 recursive)
4222 mod="${mod}s"
4223 ;;
4224 unneeded)
4225 mod="${mod}u"
4226 ;;
4227 esac
4228 ;;
4229 *)
4230 toparse="${a}"
4231 ;;
4232 esac;
4233 arglen=$(( ${#toparse}-1 ));
4234 for c in $(seq 0 "${arglen}");
4235 do
4236 arg=${toparse:$c:1};
4237 [ "${arg}" != "-" ] && mod="${mod}${arg}";
4238 done;
4239 done;
4240 cur=${COMP_WORDS[COMP_CWORD]};
4241 if [ $COMP_CWORD -eq 1 ] && [[ "$cur" == -* ]]; then
4242 COMPREPLY=($( compgen -W '\
4243 -h --help \
4244 -Q --query \
4245 -R --remove \
4246 -S --sync \
4247 -U --upgrade \
4248 -V --version \
4249 ' -- $cur ));
4250 rem_selected;
4251 return 0;
4252 fi;
4253 if [[ "$cur" == -* ]]; then
4254 case "${op}" in
4255 U)
4256 COMPREPLY=($( compgen -W '\
4257 --asdeps \
4258 --asexplicit \
4259 -d --nodeps \
4260 -f --force \
4261 -h --help \
4262 --config \
4263 --logfile \
4264 --noconfirm \
4265 --noprogressbar \
4266 --noscriptlet \
4267 -v --verbose \
4268 -r --root \
4269 -b --dbpath \
4270 --cachedir \
4271 ' -- $cur ));
4272 return 0
4273 ;;
4274 R)
4275 COMPREPLY=($( compgen -W '\
4276 -c --cascade \
4277 -d --nodeps \
4278 -h --help \
4279 -k --dbonly \
4280 -n --nosave \
4281 -s --recursive \
4282 -u --unneeded \
4283 --config \
4284 --logfile \
4285 --noconfirm \
4286 --noprogressbar \
4287 --noscriptlet \
4288 -v --verbose \
4289 -r --root \
4290 -b --dbpath \
4291 --cachedir \
4292 ' -- $cur ));
4293 return 0
4294 ;;
4295 S)
4296 COMPREPLY=($( compgen -W '\
4297 --asdeps \
4298 --asexplicit \
4299 -c --clean \
4300 -d --nodeps \
4301 -f --force \
4302 -g --groups \
4303 -h --help \
4304 -i --info \
4305 -l --list \
4306 -p --print-uris \
4307 -s --search \
4308 -u --sysupgrade \
4309 -w --downloadonly \
4310 -y --refresh \
4311 --needed \
4312 --ignore \
4313 --ignoregroup \
4314 --config \
4315 --logfile \
4316 --noconfirm \
4317 --noprogressbar \
4318 --noscriptlet \
4319 -v --verbose \
4320 -r --root \
4321 -b --dbpath \
4322 --cachedir \
4323 ' -- $cur ));
4324 return 0
4325 ;;
4326 Q)
4327 COMPREPLY=($( compgen -W '\
4328 -c --changelog \
4329 -d --deps \
4330 -e --explicit \
4331 -g --groups \
4332 -h --help \
4333 -i --info \
4334 -k --check \
4335 -l --list \
4336 -m --foreign \
4337 -o --owns \
4338 -p --file \
4339 -s --search \
4340 -t --unrequired \
4341 -u --upgrades \
4342 --config \
4343 --logfile \
4344 --noconfirm \
4345 --noprogressbar \
4346 --noscriptlet \
4347 -v --verbose \
4348 -r --root \
4349 -b --dbpath \
4350 --cachedir \
4351 ' -- $cur ));
4352 return 0
4353 ;;
4354 esac;
4355 rem_selected;
4356 else
4357 case "${op}" in
4358 U)
4359 COMPREPLY=($( compgen -d -- "$cur" ) $( compgen -f -X '!*.pkg.tar.*' -- "$cur" ));
4360 return 0
4361 ;;
4362 h | V)
4363 COMPREPLY='';
4364 return 0
4365 ;;
4366 Q)
4367 if _instring $mod g; then
4368 _installed_groups;
4369 else
4370 if _instring $mod o; then
4371 COMPREPLY=($( compgen -d -- "$cur" ) $( compgen -f -- "$cur" ));
4372 else
4373 if _instring $mod p; then
4374 COMPREPLY=($( compgen -d -- "$cur" ) $( compgen -f -X '!*.pkg.tar.*' -- "$cur" ));
4375 else
4376 if _instring $mod u; then
4377 COMPREPLY='';
4378 return 0;
4379 else
4380 _installed_pkgs;
4381 fi;
4382 fi;
4383 fi;
4384 fi;
4385 return 0
4386 ;;
4387 R)
4388 _installed_pkgs;
4389 return 0
4390 ;;
4391 S)
4392 if _instring $mod l; then
4393 _available_repos;
4394 else
4395 _available_pkgs;
4396 fi;
4397 return 0
4398 ;;
4399 esac;
4400 fi;
4401 rem_selected
4402}
4403_parse_help ()
4404{
4405 local cmd;
4406 cmd=$1;
4407 $cmd --help | grep -- "^[[:space:]]*-" | tr "," " " | awk '{print $1; if ($2 ~ /-.*/) { print $2 } }' | sed -e "s:=.*::g"
4408}
4409_passwd ()
4410{
4411 local cur prev;
4412 COMPREPLY=();
4413 cur=`_get_cword`;
4414 prev=${COMP_WORDS[COMP_CWORD-1]};
4415 case "$prev" in
4416 -n | -x | -w | -i | -\? | --help | --usage)
4417 return 0
4418 ;;
4419 esac;
4420 if [[ "$cur" == -* ]]; then
4421 COMPREPLY=($( compgen -W '-k -l --stdin -u -d -n -x -w -i -S \
4422 -? --help --usage' -- "$cur" ));
4423 return 0;
4424 fi;
4425 COMPREPLY=($( compgen -u -- "$cur" ))
4426}
4427_pci_ids ()
4428{
4429 COMPREPLY=(${COMPREPLY[@]:-} $( compgen -W "$( PATH="$PATH:/sbin" lspci -n | awk '{print $3}')" -- "$cur" ))
4430}
4431_perl ()
4432{
4433 local cur prev prefix temp;
4434 local optPrefix optSuffix;
4435 COMPREPLY=();
4436 cur=`_get_cword`;
4437 prev=${COMP_WORDS[COMP_CWORD-1]};
4438 prefix="";
4439 if [[ "$cur" == -?* ]]; then
4440 temp=$cur;
4441 prev=${temp:0:2};
4442 cur=${temp:2};
4443 optPrefix=-P$prev;
4444 optSuffix=-S/;
4445 prefix=$prev;
4446 fi;
4447 case "$prev" in
4448 -I | -x)
4449 local IFS='
4450';
4451 COMPREPLY=($( compgen -d $optPrefix $optSuffix -- "$cur" ));
4452 return 0
4453 ;;
4454 -m | -M)
4455 _perlmodules;
4456 return 0
4457 ;;
4458 esac;
4459 if [[ "$cur" == -* ]]; then
4460 COMPREPLY=($( compgen -W '-C -s -T -u -U -W -X -h -v -V -c -w -d \
4461 -D -p -n -a -F -l -0 -I -m -M -P -S -x -i -e ' -- "$cur" ));
4462 else
4463 _filedir;
4464 fi
4465}
4466_perldoc ()
4467{
4468 local cur prev prefix temp;
4469 COMPREPLY=();
4470 cur=`_get_cword`;
4471 prev=${COMP_WORDS[COMP_CWORD-1]};
4472 prefix="";
4473 if [[ "$cur" == -?* ]]; then
4474 temp=$cur;
4475 prev=${temp:0:2};
4476 cur=${temp:2};
4477 prefix=$prev;
4478 fi;
4479 case $prev in
4480 -f)
4481 COMPREPLY=($( compgen -W 'chomp chop chr crypt hex index lc \
4482 lcfirst length oct ord pack q qq reverse rindex sprintf \
4483 substr tr uc ucfirst y m pos quotemeta s split study qr abs \
4484 atan2 cos exp hex int log oct rand sin sqrt srand pop push \
4485 shift splice unshift grep join map qw reverse sort unpack \
4486 delete each exists keys values binmode close closedir \
4487 dbmclose dbmopen die eof fileno flock format getc print \
4488 printf read readdir rewinddir seek seekdir select syscall \
4489 sysread sysseek syswrite tell telldir truncate warn write \
4490 pack read syscall sysread syswrite unpack vec -X chdir chmod \
4491 chown chroot fcntl glob ioctl link lstat mkdir open opendir \
4492 readlink rename rmdir stat symlink umask unlink utime caller \
4493 continue do dump eval exit goto last next redo return \
4494 sub wantarray caller import local my our package use defined \
4495 formline reset scalar undef \
4496 alarm exec fork getpgrp getppid getpriority kill pipe qx \
4497 setpgrp setpriority sleep system times wait waitpid \
4498 import no package require use bless dbmclose dbmopen package \
4499 ref tie tied untie use accept bind connect getpeername \
4500 getsockname getsockopt listen recv send setsockopt shutdown \
4501 socket socketpair msgctl msgget msgrcv msgsnd semctl semget \
4502 semop shmctl shmget shmread shmwrite endgrent endhostent \
4503 endnetent endpwent getgrent getgrgid getgrnam getlogin \
4504 getpwent getpwnam getpwuid setgrent setpwent endprotoent \
4505 endservent gethostbyaddr gethostbyname gethostent \
4506 getnetbyaddr getnetbyname getnetent getprotobyname \
4507 getprotobynumber getprotoent getservbyname getservbyport \
4508 getservent sethostent setnetent setprotoent setservent \
4509 gmtime localtime time times' -- "$cur" ));
4510 return 0
4511 ;;
4512 esac;
4513 if [[ "$cur" == -* ]]; then
4514 COMPREPLY=($( compgen -W '-h -v -t -u -m -l -F -X -f -q' -- "$cur" ));
4515 else
4516 if [[ "$cur" != */* ]]; then
4517 _perlmodules;
4518 COMPREPLY=("${COMPREPLY[@]}" $( compgen -W '$( PAGER=/bin/cat man perl | \
4519 sed -ne "/perl.*Perl overview/,/perlwin32/p" | \
4520 awk "\$NF=2 { print \$1}" | grep perl )' -- "$cur" ));
4521 fi;
4522 fi
4523}
4524_perlmodules ()
4525{
4526 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" ))
4527}
4528_pgids ()
4529{
4530 COMPREPLY=($( compgen -W '$( command ps axo pgid= )' -- "$cur" ))
4531}
4532_pgrep ()
4533{
4534 local cur;
4535 COMPREPLY=();
4536 cur=`_get_cword`;
4537 _pnames;
4538 return 0
4539}
4540_physicalvolumes ()
4541{
4542 COMPREPLY=($(compgen -W "$( pvscan 2>/dev/null | sed -n -e 's|^.*PV \(.*\) VG.*$|\1|p' )" -- "$cur" ))
4543}
4544_pids ()
4545{
4546 COMPREPLY=($( compgen -W '$( command ps axo pid= )' -- "$cur" ))
4547}
4548_pnames ()
4549{
4550 COMPREPLY=($( compgen -W '$( command ps axo command= | \
4551 sed -e "s/ .*//; s:.*/::; s/:$//;" \
4552 -e "s/^[[(-]//; s/[])]$//" \
4553 -e "s/^<defunct>$//")' -- "$cur" ))
4554}
4555_pvchange ()
4556{
4557 local cur prev;
4558 COMPREPLY=();
4559 cur=`_get_cword`;
4560 prev=${COMP_WORDS[COMP_CWORD-1]};
4561 case "$prev" in
4562 -@(A|x|-autobackup|--allocatable))
4563 COMPREPLY=($( compgen -W 'y n' -- "$cur" ));
4564 return 0
4565 ;;
4566 esac;
4567 if [[ "$cur" == -* ]]; then
4568 COMPREPLY=($( compgen -W '-a --all -A --autobackup \
4569 -d --debug -h --help -t --test -u --uuid -x \
4570 --allocatable -v --verbose --addtag --deltag \
4571 --version' -- "$cur" ));
4572 else
4573 _physicalvolumes;
4574 fi
4575}
4576_pvcreate ()
4577{
4578 local cur prev;
4579 COMPREPLY=();
4580 cur=`_get_cword`;
4581 prev=${COMP_WORDS[COMP_CWORD-1]};
4582 case "$prev" in
4583 --restorefile)
4584 _filedir;
4585 return 0
4586 ;;
4587 -@(M|-metadatatype))
4588 COMPREPLY=($( compgen -W '1 2' -- "$cur" ));
4589 return 0
4590 ;;
4591 --metadatacopies)
4592 COMPREPLY=($( compgen -W '0 1 2' -- "$cur" ));
4593 return 0
4594 ;;
4595 --@(metadatasize|setphysicalvolumesize))
4596 _sizes;
4597 return 0
4598 ;;
4599 esac;
4600 if [[ "$cur" == -* ]]; then
4601 COMPREPLY=($( compgen -W '--restorefile -d --debug -f \
4602 --force -h -? --help --labelsector -M --metadatatype \
4603 --metadatacopies --metadatasize \
4604 --setphysicalvolumesize -t --test -u --uuid uuid -v \
4605 --verbose -y --yes --version' -- "$cur" ));
4606 else
4607 _physicalvolumes;
4608 fi
4609}
4610_pvdisplay ()
4611{
4612 local cur prev;
4613 COMPREPLY=();
4614 cur=`_get_cword`;
4615 prev=${COMP_WORDS[COMP_CWORD-1]};
4616 case "$prev" in
4617 --units)
4618 _units;
4619 return 0
4620 ;;
4621 esac;
4622 if [[ "$cur" == -* ]]; then
4623 COMPREPLY=($( compgen -W '-c --colon -C --columns --units \
4624 -v --verbose -d --debug -h --help --version' -- "$cur" ));
4625 else
4626 _physicalvolumes;
4627 fi
4628}
4629_pvmove ()
4630{
4631 local cur prev;
4632 COMPREPLY=();
4633 cur=`_get_cword`;
4634 prev=${COMP_WORDS[COMP_CWORD-1]};
4635 case "$prev" in
4636 -@(A|-autobackup))
4637 COMPREPLY=($( compgen -W 'y n' -- "$cur" ));
4638 return 0
4639 ;;
4640 -@(n|-name))
4641 _logicalvolumes;
4642 return 0
4643 ;;
4644 esac;
4645 if [[ "$cur" == -* ]]; then
4646 COMPREPLY=($( compgen -W '--abort -A --autobackup \
4647 -b --background -d --debug -f --force -h -? \
4648 --help -i --interval -t --test -v --verbose \
4649 --version -n --name' -- "$cur" ));
4650 else
4651 _physicalvolumes;
4652 fi
4653}
4654_pvremove ()
4655{
4656 local cur;
4657 COMPREPLY=();
4658 cur=`_get_cword`;
4659 if [[ "$cur" == -* ]]; then
4660 COMPREPLY=($( compgen -W '-d --debug -f --force -h -? \
4661 --help -y --yes -t --test -v --verbose \
4662 --version' -- "$cur" ));
4663 else
4664 _physicalvolumes;
4665 fi
4666}
4667_pvs ()
4668{
4669 local cur prev;
4670 COMPREPLY=();
4671 cur=`_get_cword`;
4672 prev=${COMP_WORDS[COMP_CWORD-1]};
4673 case "$prev" in
4674 -@(o|O|-options|-sort))
4675 COMPREPLY=($( compgen -W 'pv_fmt pv_uuid \
4676 pv_size pv_free pv_used pv_name \
4677 pv_attr pv_pe_count \
4678 pv_pe_alloc_count' -- "$cur" ));
4679 return 0
4680 ;;
4681 --units)
4682 _units;
4683 return 0
4684 ;;
4685 esac;
4686 if [[ "$cur" == -* ]]; then
4687 COMPREPLY=($( compgen -W '--aligned -a --all -d --debug \
4688 -h -? --help --ignorelockingfailure --noheadings \
4689 --nosuffix -o --options -O --sort \
4690 --separator --unbuffered --units \
4691 -v --verbose --version' -- "$cur" ));
4692 else
4693 _physicalvolumes;
4694 fi
4695}
4696_pvscan ()
4697{
4698 local cur;
4699 COMPREPLY=();
4700 cur=`_get_cword`;
4701 if [[ "$cur" == -* ]]; then
4702 COMPREPLY=($( compgen -W '-d --debug -e \
4703 --exported -n --novolumegroup -h -? \
4704 --help --ignorelockingfailure -P \
4705 --partial -s --short -u --uuid -v \
4706 --verbose --version' -- "$cur" ));
4707 fi
4708}
4709_pwck ()
4710{
4711 local cur;
4712 COMPREPLY=();
4713 cur=`_get_cword`;
4714 if [[ "$cur" == -* ]]; then
4715 COMPREPLY=($( compgen -W '-q -r -s' -- "$cur" ));
4716 return 0;
4717 fi;
4718 _filedir
4719}
4720_python ()
4721{
4722 local prev cur i;
4723 COMPREPLY=();
4724 cur=`_get_cword`;
4725 prev=${COMP_WORDS[COMP_CWORD-1]##*/};
4726 case "$prev" in
4727 -Q)
4728 COMPREPLY=($( compgen -W "old new warn warnall" -- "$cur" ));
4729 return 0
4730 ;;
4731 -W)
4732 COMPREPLY=($( compgen -W "ignore default all module once error" -- "$cur" ));
4733 return 0
4734 ;;
4735 -c)
4736 _filedir '@(py|pyc|pyo)';
4737 return 0
4738 ;;
4739 !(python|-?))
4740 [[ ${COMP_WORDS[COMP_CWORD-2]} != -@(Q|W) ]] && _filedir
4741 ;;
4742 esac;
4743 for ((i=0; i < ${#COMP_WORDS[@]}-1; i++ ))
4744 do
4745 if [[ ${COMP_WORDS[i]} == -c ]]; then
4746 _filedir;
4747 fi;
4748 done;
4749 if [[ "$cur" != -* ]]; then
4750 _filedir '@(py|pyc|pyo)';
4751 else
4752 COMPREPLY=($( compgen -W "- -d -E -h -i -O -Q -S -t -u -U -v -V -W -x -c" -- "$cur" ));
4753 fi;
4754 return 0
4755}
4756_qdbus ()
4757{
4758 local cur compstr;
4759 COMPREPLY=();
4760 cur=`_get_cword`;
4761 if [ -z "$cur" ]; then
4762 compstr=${COMP_WORDS[*]};
4763 else
4764 compstr=$( command echo ${COMP_WORDS[*]} | sed "s/ ${cur/\//\\/}$//" );
4765 fi;
4766 COMPREPLY=($( compgen -W '$( command $compstr | sed s/\(.*\)// )' -- "$cur" ))
4767}
4768_rdesktop ()
4769{
4770 local cur prev;
4771 COMPREPLY=();
4772 cur=`_get_cword`;
4773 prev=${COMP_WORDS[COMP_CWORD-1]};
4774 case $prev in
4775 -k)
4776 COMPREPLY=($( command ls /usr/share/rdesktop/keymaps 2>/dev/null | egrep -v '(common|modifiers)' ));
4777 COMPREPLY=(${COMPREPLY[@]:-} $( command ls $HOME/.rdesktop/keymaps 2>/dev/null ));
4778 COMPREPLY=(${COMPREPLY[@]:-} $( command ls ./keymaps 2>/dev/null ));
4779 COMPREPLY=($( compgen -W '${COMPREPLY[@]}' -- "$cur" ));
4780 return 0
4781 ;;
4782 -a)
4783 COMPREPLY=($( compgen -W '8 15 16 24' -- "$cur" ));
4784 return 0
4785 ;;
4786 -x)
4787 COMPREPLY=($( compgen -W 'b broadband m modem l lan' -- $cur ));
4788 return 0
4789 ;;
4790 -r)
4791 COMPREPLY=($( compgen -W 'comport: disk: lptport: \
4792 printer: sound: lspci scard' -- "$cur" ));
4793 return 0
4794 ;;
4795 esac;
4796 if [[ "$cur" == -* ]]; then
4797 COMPREPLY=($( compgen -W '-u -d -s -c -p -n -k -g -f -b -L \
4798 -A -B -e -E -m -C -D -K -S -T -N -X -a -z -x -P -r \
4799 -0 -4 -5' -- "$cur" ));
4800 else
4801 _known_hosts_real "$cur";
4802 fi
4803}
4804_realcommand ()
4805{
4806 type -P "$1" > /dev/null && {
4807 if type -p realpath > /dev/null; then
4808 realpath "$(type -P "$1")";
4809 else
4810 if type -p readlink > /dev/null; then
4811 readlink -f "$(type -P "$1")";
4812 else
4813 type -P "$1";
4814 fi;
4815 fi
4816 }
4817}
4818_renice ()
4819{
4820 local command cur curopt i;
4821 COMPREPLY=();
4822 cur=`_get_cword`;
4823 command=$1;
4824 i=0;
4825 while [ $i -le $COMP_CWORD -a ${#COMPREPLY[@]} -eq 0 ]; do
4826 curopt=${COMP_WORDS[COMP_CWORD-$i]};
4827 case "$curopt" in
4828 -u)
4829 COMPREPLY=($( compgen -u -- "$cur" ))
4830 ;;
4831 -g)
4832 _pgids
4833 ;;
4834 -p | $command)
4835 _pids
4836 ;;
4837 esac;
4838 i=$(( ++i ));
4839 done
4840}
4841_rfcomm ()
4842{
4843 local cur prev;
4844 COMPREPLY=();
4845 cur=`_get_cword`;
4846 prev=${COMP_WORDS[COMP_CWORD-1]};
4847 case $prev in
4848 -@(f|-config))
4849 _filedir;
4850 return 0
4851 ;;
4852 -i)
4853 _bluetooth_devices;
4854 _bluetooth_adresses;
4855 return 0
4856 ;;
4857 esac;
4858 _get_command;
4859 if [ -z $command ]; then
4860 if [[ "$cur" == -* ]]; then
4861 COMPREPLY=($( compgen -W '-h --help -a -r --raw -f \
4862 --config -i -A --auth -E --encrypt -S --secure \
4863 -M --master' -- "$cur" ));
4864 else
4865 COMPREPLY=($( compgen -W 'show connect listen watch \
4866 bind release' -- "$cur" ));
4867 fi;
4868 else
4869 _count_args;
4870 if [ $args -eq 2 ]; then
4871 _bluetooth_devices;
4872 else
4873 case $command in
4874 @(connect|bind))
4875 if [ $args -eq 3 ]; then
4876 _bluetooth_adresses;
4877 fi
4878 ;;
4879 esac;
4880 fi;
4881 fi
4882}
4883_rl_enabled ()
4884{
4885 [[ "$( bind -v )" = *$1+([[:space:]])on* ]]
4886}
4887_rmmod ()
4888{
4889 local cur;
4890 COMPREPLY=();
4891 cur=`_get_cword`;
4892 _installed_modules "$cur";
4893 return 0
4894}
4895_root_command ()
4896{
4897 PATH=$PATH:/sbin:/usr/sbin:/usr/local/sbin _command $1 $2 $3
4898}
4899_route ()
4900{
4901 local cur prev;
4902 COMPREPLY=();
4903 cur=`_get_cword`;
4904 prev=${COMP_WORDS[COMP_CWORD-1]};
4905 if [ "$prev" = dev ]; then
4906 COMPREPLY=($( ifconfig -a | sed -ne 's|^\('$cur'[^ ]*\).*$|\1|p' ));
4907 return 0;
4908 fi;
4909 COMPREPLY=($( compgen -W 'add del -host -net netmask metric mss \
4910 window irtt reject mod dyn reinstate dev \
4911 default gw' -- "$cur" ));
4912 COMPREPLY=($( echo " ${COMP_WORDS[@]}" | (while read -d ' ' i; do
4913 [ "$i" == "" ] && continue
4914 # flatten array with spaces on either side,
4915 # otherwise we cannot grep on word
4916 # boundaries of first and last word
4917 COMPREPLY=" ${COMPREPLY[@]} "
4918 # remove word from list of completions
4919 COMPREPLY=( ${COMPREPLY/ $i / } )
4920 done
4921 echo "${COMPREPLY[@]}")
4922 ));
4923 return 0
4924}
4925_rrdtool ()
4926{
4927 cur=`_get_cword`;
4928 COMPREPLY=($( compgen -W 'create update updatev graph dump restore last \
4929 lastupdate first info fetch tune resize xport' -- "$cur" ))
4930}
4931_samba_debuglevel ()
4932{
4933 COMPREPLY=($( compgen -W '0 1 2 3 4 5 6 7 8 9 10' -- "$cur" ))
4934}
4935_samba_domains ()
4936{
4937 if [ -n "${COMP_SAMBA_SCAN:-}" ]; then
4938 COMPREPLY=($( compgen -W '$( smbtree -N -D )' -- "$cur" ));
4939 fi
4940}
4941_samba_hosts ()
4942{
4943 if [ -n "${COMP_SAMBA_SCAN:-}" ]; then
4944 COMPREPLY=($( compgen -W "$( smbtree -N -S | sed -ne 's/^[[:space:]]*\\\\*\([^[:space:]]*\).*/\1/p' )" -- $cur ));
4945 fi
4946}
4947_samba_resolve_order ()
4948{
4949 COMPREPLY=($( compgen -W 'lmhosts host wins bcast' -- "$cur" ))
4950}
4951_scp ()
4952{
4953 local configfile cur userhost path prefix;
4954 COMPREPLY=();
4955 cur=`_get_cword ":"`;
4956 _expand || return 0;
4957 if [[ "$cur" == *:* ]]; then
4958 local IFS='
4959';
4960 cur=${cur/\\:/:};
4961 userhost=${cur%%?(\\):*};
4962 path=${cur#*:};
4963 path=${path//\\\\\\\\ / };
4964 if [ -z "$path" ]; then
4965 path=$(ssh -o 'Batchmode yes' $userhost pwd 2>/dev/null);
4966 fi;
4967 COMPREPLY=($( ssh -o 'Batchmode yes' $userhost command ls -aF1d "$path*" 2>/dev/null | sed -e "s/[][(){}<>\",:;^&\!$=?\`|\\ ']/\\\\\\\\\\\\&/g" -e 's/[*@|=]$//g' -e 's/[^\/]$/& /g' ));
4968 return 0;
4969 fi;
4970 if [[ "$cur" = -F* ]]; then
4971 cur=${cur#-F};
4972 prefix=-F;
4973 else
4974 set -- "${COMP_WORDS[@]}";
4975 while [ $# -gt 0 ]; do
4976 if [ "${1:0:2}" = -F ]; then
4977 if [ ${#1} -gt 2 ]; then
4978 configfile="$(dequote "${1:2}")";
4979 else
4980 shift;
4981 [ "$1" ] && configfile="$(dequote "$1")";
4982 fi;
4983 break;
4984 fi;
4985 shift;
4986 done;
4987 [[ "$cur" == */* ]] || _known_hosts_real -c -a -F "$configfile" "$cur";
4988 fi;
4989 local IFS='
4990';
4991 COMPREPLY=("${COMPREPLY[@]}" $( command ls -aF1d $cur* 2>/dev/null | sed -e "s/[][(){}<>\",:;^&\!$=?\`|\\ ']/\\\\&/g" -e 's/[*@|=]$//g' -e 's/[^\/]$/& /g' -e "s/^/$prefix/"));
4992 return 0
4993}
4994_sdptool ()
4995{
4996 local cur prev split=false;
4997 COMPREPLY=();
4998 cur=`_get_cword`;
4999 prev=${COMP_WORDS[COMP_CWORD-1]};
5000 _split_longopt && split=true;
5001 case $prev in
5002 --bdaddr)
5003 _bluetooth_adresses;
5004 return 0
5005 ;;
5006 esac;
5007 $split && return 0;
5008 _get_command;
5009 if [ -z $command ]; then
5010 if [[ "$cur" == -* ]]; then
5011 COMPREPLY=($( compgen -W '--help' -- "$cur" ));
5012 else
5013 COMPREPLY=($( compgen -W 'search browse records add \
5014 del get setattr setseq' -- "$cur" ));
5015 fi;
5016 else
5017 case $command in
5018 search)
5019 if [[ "$cur" == -* ]]; then
5020 COMPREPLY=($( compgen -W '--bdaddr \
5021 --tree --raw --xml' -- "$cur" ));
5022 else
5023 _bluetooth_services;
5024 fi
5025 ;;
5026 @(browse|records))
5027 if [[ "$cur" == -* ]]; then
5028 COMPREPLY=($( compgen -W '--tree --raw --xml' -- "$cur" ));
5029 else
5030 _bluetooth_adresses;
5031 fi
5032 ;;
5033 add)
5034 if [[ "$cur" == -* ]]; then
5035 COMPREPLY=($( compgen -W '--handle --channel' -- "$cur" ));
5036 else
5037 _bluetooth_services;
5038 fi
5039 ;;
5040 get)
5041 if [[ "$cur" == -* ]]; then
5042 COMPREPLY=($( compgen -W '--bdaddr \
5043 --tree --raw --xml' -- "$cur" ));
5044 fi
5045 ;;
5046 esac;
5047 fi
5048}
5049_services ()
5050{
5051 local sysvdir famdir;
5052 [ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d || sysvdir=/etc/init.d;
5053 famdir=/etc/xinetd.d;
5054 COMPREPLY=($( builtin echo $sysvdir/!(*.rpm@(orig|new|save)|*~|functions)));
5055 if [ -d $famdir ]; then
5056 COMPREPLY=("${COMPREPLY[@]}" $( builtin echo $famdir/!(*.rpm@(orig|new|save)|*~)));
5057 fi;
5058 COMPREPLY=($( compgen -W '${COMPREPLY[@]#@($sysvdir|$famdir)/}' -- "$cur" ))
5059}
5060_sftp ()
5061{
5062 local cur prev configfile;
5063 COMPREPLY=();
5064 cur=`_get_cword`;
5065 prev=${COMP_WORDS[COMP_CWORD-1]};
5066 case "$prev" in
5067 -@(b|F|P))
5068 _filedir;
5069 return 0
5070 ;;
5071 -o)
5072 _ssh_options;
5073 return 0
5074 ;;
5075 esac;
5076 if [[ "$cur" == -F* ]]; then
5077 cur=${cur#-F};
5078 _filedir;
5079 COMPREPLY=("${COMPREPLY[@]/#/-F}");
5080 cur=-F$cur;
5081 else
5082 if [[ "$cur" == -* ]]; then
5083 COMPREPLY=($( compgen -W '-1 -C -v -B -b -F -o -P -R -S -s' -- "$cur" ));
5084 else
5085 set -- "${COMP_WORDS[@]}";
5086 while [ $# -gt 0 ]; do
5087 if [ "${1:0:2}" = -F ]; then
5088 if [ ${#1} -gt 2 ]; then
5089 configfile="$(dequote "${1:2}")";
5090 else
5091 shift;
5092 [ "$1" ] && configfile="$(dequote "$1")";
5093 fi;
5094 break;
5095 fi;
5096 shift;
5097 done;
5098 _known_hosts_real -a -F "$configfile" "$cur";
5099 fi;
5100 fi;
5101 return 0
5102}
5103_shells ()
5104{
5105 COMPREPLY=("${COMPREPLY[@]}" $( compgen -W '$( grep "^[[:space:]]*/" \
5106 /etc/shells 2>/dev/null )' -- "$cur" ))
5107}
5108_signals ()
5109{
5110 local i;
5111 COMPREPLY=($( compgen -A signal SIG${cur#-} ));
5112 for ((i=0; i < ${#COMPREPLY[@]}; i++ ))
5113 do
5114 COMPREPLY[i]=-${COMPREPLY[i]#SIG};
5115 done
5116}
5117_sizes ()
5118{
5119 COMPREPLY=($( compgen -W 'k K m M g G t T' -- "$cur" ))
5120}
5121_smbcacls ()
5122{
5123 local cur prev split=false;
5124 COMPREPLY=();
5125 cur=`_get_cword`;
5126 prev=${COMP_WORDS[COMP_CWORD-1]};
5127 _split_longopt && split=true;
5128 case $prev in
5129 -s)
5130 _filedir;
5131 return 0
5132 ;;
5133 -l | --log-basename)
5134 _filedir -d;
5135 return 0
5136 ;;
5137 -d | --debuglevel)
5138 _samba_debuglevel;
5139 return 0
5140 ;;
5141 esac;
5142 $split && return 0;
5143 if [[ "$cur" == -* ]]; then
5144 COMPREPLY=($( compgen -W '-a -M -D -S -U -C -G --numeric -t \
5145 -h --help -V -s -d --debuglevel -l --log-basename' -- "$cur" ));
5146 fi
5147}
5148_smbclient ()
5149{
5150 local cur prev split=false;
5151 COMPREPLY=();
5152 cur=`_get_cword`;
5153 prev=${COMP_WORDS[COMP_CWORD-1]};
5154 _split_longopt && split=true;
5155 case $prev in
5156 -R)
5157 _samba_resolve_order;
5158 return 0
5159 ;;
5160 -t)
5161 COMPREPLY=($( compgen -W 'SJIS EUC JIS7 JIS8 JUNET HEX CAP' -- "$cur" ));
5162 return 0
5163 ;;
5164 -s | -A | --authentication-file)
5165 _filedir;
5166 return 0
5167 ;;
5168 -l | --log-basename | -D)
5169 _filedir -d;
5170 return 0
5171 ;;
5172 -O)
5173 COMPREPLY=($( compgen -W 'SO_KEEPALIVE SO_REUSEADDR \
5174 SO_BROADCAST TCP_NODELAY IPTOS_LOWDELAY \
5175 IPTOS_THROUGHPUT SO_SNDBUF SO_RCVBUF \
5176 SO_SNDLOWAT SO_RCVLOWAT' -- "$cur" ));
5177 return 0
5178 ;;
5179 -T)
5180 COMPREPLY=($( compgen -W 'c x I X F b g q r N a' -- "$cur" ));
5181 return 0
5182 ;;
5183 -W | --workgroup)
5184 _samba_domains;
5185 return 0
5186 ;;
5187 -d | --debuglevel)
5188 _samba_debuglevel;
5189 return 0
5190 ;;
5191 -p | --port | -M | -I | -b | -U | --user | -n | -i | -T | -c)
5192 return 0
5193 ;;
5194 -\? | --help | -V | --version)
5195 return 0
5196 ;;
5197 esac;
5198 $split && return 0;
5199 if [[ "$cur" == -* ]]; then
5200 COMPREPLY=($( compgen -W '-b -d -L -U -I -M -m -A -N -i -O \
5201 -p -R -s -k -P -c -D -W -l -E --debuglevel \
5202 --log-basename --workgroup' -- "$cur" ));
5203 fi
5204}
5205_smbcquotas ()
5206{
5207 local cur prev split=false;
5208 COMPREPLY=();
5209 cur=`_get_cword`;
5210 prev=${COMP_WORDS[COMP_CWORD-1]};
5211 _split_longopt && split=true;
5212 case $prev in
5213 -s | -A | --authentication-file)
5214 _filedir;
5215 return 0
5216 ;;
5217 -l | --log-basename)
5218 _filedir -d;
5219 return 0
5220 ;;
5221 -d | --debuglevel)
5222 _samba_debuglevel;
5223 return 0
5224 ;;
5225 esac;
5226 $split && return 0;
5227 if [[ "$cur" == -* ]]; then
5228 COMPREPLY=($( compgen -W '-u -L -F -S -n -t -v -h --help -V \
5229 -s -d --debuglevel -l --log-basename -N -k -A \
5230 --authentication-file -U --user' -- "$cur" ));
5231 fi
5232}
5233_smbget ()
5234{
5235 local cur prev split=false;
5236 COMPREPLY=();
5237 cur=`_get_cword`;
5238 prev=${COMP_WORDS[COMP_CWORD-1]};
5239 _split_longopt && split=true;
5240 case $prev in
5241 -@(o|f|-outputfile|-rcfile))
5242 _filedir;
5243 return 0
5244 ;;
5245 -d | --debuglevel)
5246 _samba_debuglevel;
5247 return 0
5248 ;;
5249 esac;
5250 $split && return 0;
5251 if [[ "$cur" == -* ]]; then
5252 COMPREPLY=($( compgen -W '-a --guest -r --resume -R --recursive -u \
5253 --username -p --password -w --workgroup -n --nonprompt -d \
5254 --debuglevel -D --dots -P --keep-permissions -o --outputfile -f \
5255 --rcfile -q --quiet -v --verbose -b --blocksize -? --help --usage' -- "$cur" ));
5256 fi
5257}
5258_smbpasswd ()
5259{
5260 local cur prev;
5261 COMPREPLY=();
5262 cur=`_get_cword`;
5263 prev=${COMP_WORDS[COMP_CWORD-1]};
5264 case $prev in
5265 -r)
5266 _samba_hosts;
5267 return 0
5268 ;;
5269 -R)
5270 _samba_resolve_order;
5271 return 0
5272 ;;
5273 -c)
5274 _filedir;
5275 return 0
5276 ;;
5277 -D)
5278 _samba_debuglevel;
5279 return 0
5280 ;;
5281 esac;
5282 if [[ "$cur" == -* ]]; then
5283 COMPREPLY=($( compgen -W '-a -c -x -d -e -D -n -r -R -m -U -h \
5284 -s -w -W -i -L' -- "$cur" ));
5285 fi
5286}
5287_smbtar ()
5288{
5289 local cur prev;
5290 COMPREPLY=();
5291 cur=`_get_cword`;
5292 prev=${COMP_WORDS[COMP_CWORD-1]};
5293 case $prev in
5294 -@(r|t))
5295 _filedir tar;
5296 return 0
5297 ;;
5298 -s)
5299 _samba_hosts;
5300 return 0
5301 ;;
5302 -l)
5303 _samba_debuglevel;
5304 return 0
5305 ;;
5306 esac;
5307 if [[ "$cur" == -* ]]; then
5308 COMPREPLY=($( compgen -W '-r -i -a -v -s -p -x -X -N -b -d -l -u -t' -- "$cur" ));
5309 fi
5310}
5311_smbtree ()
5312{
5313 local cur prev split=false;
5314 COMPREPLY=();
5315 cur=`_get_cword`;
5316 prev=${COMP_WORDS[COMP_CWORD-1]};
5317 _split_longopt && split=true;
5318 case $prev in
5319 -s | -A | --authentication-file)
5320 _filedir;
5321 return 0
5322 ;;
5323 -l | --log-basename)
5324 _filedir -d;
5325 return 0
5326 ;;
5327 -d | --debuglevel)
5328 _samba_debuglevel;
5329 return 0
5330 ;;
5331 esac;
5332 $split && return 0;
5333 if [[ "$cur" == -* ]]; then
5334 COMPREPLY=($( compgen -W '-b -D -S -V -s -d --debuglevel -l \
5335 --log-basename -N -k -A --authentication-file -U --user\
5336 -h --help' -- "$cur" ));
5337 fi
5338}
5339_split_longopt ()
5340{
5341 if [[ "$cur" == --?*=* ]]; then
5342 prev="${cur%%?(\\)=*}";
5343 cur="${cur#*=}";
5344 return 0;
5345 fi;
5346 return 1
5347}
5348_ssh ()
5349{
5350 local cur prev configfile;
5351 local -a config;
5352 COMPREPLY=();
5353 cur=`_get_cword`;
5354 prev=${COMP_WORDS[COMP_CWORD-1]};
5355 case "$prev" in
5356 -@(F|i|S))
5357 _filedir;
5358 return 0
5359 ;;
5360 -c)
5361 COMPREPLY=($( compgen -W '3des-cbc aes128-cbc \
5362 aes192-cbc aes256-cbc aes128-ctr aes192-ctr \
5363 aes256-ctr arcfour128 arcfour256 arcfour \
5364 blowfish-cbc cast128-cbc' -- "$cur" ));
5365 return 0
5366 ;;
5367 -c)
5368 COMPREPLY=($( compgen -W 'hmac-md5 hmac-sha1 \
5369 umac-64@openssh.com hmac-ripemd160 \
5370 hmac-sha1-96 hmac-md5-96' -- "$cur" ));
5371 return 0
5372 ;;
5373 -l)
5374 COMPREPLY=($( compgen -u -- "$cur" ));
5375 return 0
5376 ;;
5377 -o)
5378 _ssh_options;
5379 return 0
5380 ;;
5381 -w)
5382 _available_interfaces;
5383 return 0
5384 ;;
5385 -b)
5386 COMPREPLY=($( compgen -W "$(/sbin/ifconfig | awk '/adr:/ {print $2}' | awk -F: '{print $2}' )" -- "$cur" ));
5387 return 0
5388 ;;
5389 esac;
5390 if [[ "$cur" == -F* ]]; then
5391 cur=${cur#-F};
5392 _filedir;
5393 COMPREPLY=("${COMPREPLY[@]/#/-F}");
5394 cur=-F$cur;
5395 else
5396 if [[ "$cur" == -* ]]; then
5397 COMPREPLY=($( compgen -W '-1 -2 -4 -6 -A -a -C -f -g -K -k -M \
5398 -N -n -q -s -T -t -V -v -X -v -Y -y -b -b -c -D -e -F \
5399 -i -L -l -m -O -o -p -R -S -w' -- "$cur" ));
5400 else
5401 set -- "${COMP_WORDS[@]}";
5402 while [ $# -gt 0 ]; do
5403 if [ "${1:0:2}" = -F ]; then
5404 if [ ${#1} -gt 2 ]; then
5405 configfile="$(dequote "${1:2}")";
5406 else
5407 shift;
5408 [ "$1" ] && configfile="$(dequote "$1")";
5409 fi;
5410 break;
5411 fi;
5412 shift;
5413 done;
5414 _known_hosts_real -a -F "$configfile" "$cur";
5415 if [ $COMP_CWORD -ne 1 ]; then
5416 COMPREPLY=("${COMPREPLY[@]}" $( compgen -c -- "$cur" ));
5417 fi;
5418 fi;
5419 fi;
5420 return 0
5421}
5422_ssh_copy_id ()
5423{
5424 local cur prev;
5425 COMPREPLY=();
5426 cur=`_get_cword`;
5427 prev=${COMP_WORDS[COMP_CWORD-1]};
5428 case "$prev" in
5429 -i)
5430 _filedir;
5431 return 0
5432 ;;
5433 esac;
5434 if [[ "$cur" == -* ]]; then
5435 COMPREPLY=($( compgen -W '-i' -- "$cur" ));
5436 else
5437 _known_hosts_real -a "$cur";
5438 fi;
5439 return 0
5440}
5441_ssh_options ()
5442{
5443 COMPREPLY=($( compgen -W 'AddressFamily BatchMode BindAddress \
5444 ChallengeResponseAuthentication CheckHostIP Cipher Ciphers \
5445 ClearAllForwardings Compression CompressionLevel \
5446 ConnectionAttempts ConnectTimeout ControlMaster ControlPath \
5447 DynamicForward EscapeChar ExitOnForwardFailure ForwardAgent \
5448 ForwardX11 ForwardX11Trusted GatewayPorts GlobalKnownHostsFile \
5449 GSSAPIAuthentication GSSAPIDelegateCredentials HashKnownHosts \
5450 Host HostbasedAuthentication HostKeyAlgorithms HostKeyAlias \
5451 HostName IdentityFile IdentitiesOnly KbdInteractiveDevices \
5452 LocalCommand LocalForward LogLevel MACs \
5453 NoHostAuthenticationForLocalhost NumberOfPasswordPrompts \
5454 PasswordAuthentication PermitLocalCommand Port \
5455 PreferredAuthentications Protocol ProxyCommand \
5456 PubkeyAuthentication RekeyLimit RemoteForward \
5457 RhostsRSAAuthentication RSAAuthentication SendEnv \
5458 ServerAliveInterval ServerAliveCountMax SmartcardDevice \
5459 StrictHostKeyChecking TCPKeepAlive Tunnel TunnelDevice \
5460 UsePrivilegedPort User UserKnownHostsFile VerifyHostKeyDNS \
5461 VisualHostKey XAuthLocation' -- "$cur" ))
5462}
5463_stream ()
5464{
5465 local cur;
5466 COMPREPLY=();
5467 cur=`_get_cword`;
5468 _ImageMagick;
5469 if [[ "$cur" == -* ]]; then
5470 COMPREPLY=($( compgen -W '-authenticate -channel -colorspace \
5471 -compress -debug -define -density -depth -extract \
5472 -help -identify -interlace -interpolate -limit -list \
5473 -log -map -monitor -quantize -quiet -regard-warnings \
5474 -respect-parenthesis -sampling-factor -seed -set \
5475 -size -storage-type -transparent-color -verbose \
5476 -version -virtual-pixel' -- "$cur" ));
5477 else
5478 if [[ "$cur" == +* ]]; then
5479 COMPREPLY=($( compgen -W '+debug' -- "$cur" ));
5480 else
5481 _filedir;
5482 fi;
5483 fi
5484}
5485_svn ()
5486{
5487 local cur cmds cmdOpts pOpts mOpts rOpts qOpts nOpts optsParam opt;
5488 COMPREPLY=();
5489 cur=${COMP_WORDS[COMP_CWORD]};
5490 cmds='add blame annotate praise cat changelist cl checkout co cleanup';
5491 cmds="$cmds commit ci copy cp delete remove rm diff export help import";
5492 cmds="$cmds info list ls lock log merge mergeinfo mkdir move mv rename";
5493 cmds="$cmds propdel pdel propedit pedit propget pget proplist plist";
5494 cmds="$cmds propset pset resolve resolved revert status switch unlock";
5495 cmds="$cmds update";
5496 local helpOpts='--help -h';
5497 local specOpts="--version $helpOpts";
5498 optsParam="-r|--revision|--username|--password|--targets";
5499 optsParam="$optsParam|-x|--extensions|-m|--message|-F|--file";
5500 optsParam="$optsParam|--encoding|--diff-cmd|--diff3-cmd|--editor-cmd";
5501 optsParam="$optsParam|--old|--new|--config-dir|--config-option";
5502 optsParam="$optsParam|--native-eol|-l|--limit|-c|--change";
5503 optsParam="$optsParam|--depth|--set-depth|--with-revprop";
5504 optsParam="$optsParam|--changelist|--accept|--show-revs";
5505 local svnProps revProps allProps psCmds propCmds;
5506 svnProps="svn:keywords svn:executable svn:needs-lock svn:externals
5507 svn:ignore svn:eol-style svn:mime-type $SVN_BASH_FILE_PROPS";
5508 revProps="svn:author svn:log svn:date $SVN_BASH_REV_PROPS";
5509 allProps=($svnProps $revProps);
5510 psCmds='propset|pset|ps';
5511 propCmds="$psCmds|propget|pget|pg|propedit|pedit|pe|propdel|pdel|pd";
5512 local cmd= isPropCmd= isPsCmd= isHelpCmd= nExpectArgs= isCur= i=0;
5513 local prev= help= prop= val= isRevProp= last='none' nargs=0 stat=;
5514 local options= hasRevPropOpt= hasRevisionOpt= hasRelocateOpt=;
5515 local acceptOpt= URL= hasReintegrateOpt=;
5516 for opt in "${COMP_WORDS[@]}";
5517 do
5518 [[ -n $isCur ]] && stat=$last;
5519 isCur=;
5520 [[ $i -eq $COMP_CWORD ]] && isCur=1;
5521 let i++;
5522 [ $last = 'none' ] && {
5523 last='first';
5524 continue
5525 };
5526 if [[ $prev == @($optsParam) ]]; then
5527 [[ $prev = '--accept' ]] && acceptOpt=$opt;
5528 prev='';
5529 last='skip';
5530 continue;
5531 fi;
5532 if [[ $prev == @(<|>|>>|[12]>|[12]>>) ]]; then
5533 prev='';
5534 last='skip';
5535 continue;
5536 fi;
5537 prev=$opt;
5538 if [[ ! -n $cmd && -n $opt && ( $opt != -* || $opt == @(${specOpts// /|}) ) ]]; then
5539 cmd=$opt;
5540 [[ $cmd == @($propCmds) ]] && isPropCmd=1;
5541 [[ $cmd == @($psCmds) ]] && isPsCmd=1;
5542 [[ $cmd == @(${helpOpts// /|}) ]] && cmd='help';
5543 [[ $cmd = 'help' ]] && isHelpCmd=1;
5544 if [[ -n $isHelpCmd && -n $cmd && $cmd != 'help' && ! -n $help ]]; then
5545 help=$cmd;
5546 cmd='help';
5547 fi;
5548 last='cmd';
5549 continue;
5550 fi;
5551 if [[ -n $isHelpCmd && ! -n $help && -n $opt && $opt != -* ]]; then
5552 help=$opt;
5553 last='help';
5554 continue;
5555 fi;
5556 if [[ -n $isPropCmd && ! -n $prop && -n $opt && $opt != -* ]]; then
5557 prop=$opt;
5558 [[ $prop == @(${revProps// /|}) ]] && isRevProp=1;
5559 last='prop';
5560 continue;
5561 fi;
5562 if [[ -n $isPsCmd && -n $prop && ! -n $val && $opt != -* ]]; then
5563 val=$opt;
5564 last='val';
5565 continue;
5566 fi;
5567 if [[ $last != 'onlyarg' ]]; then
5568 case $opt in
5569 -r | --revision | --revision=*)
5570 hasRevisionOpt=1
5571 ;;
5572 --revprop)
5573 hasRevPropOpt=1;
5574 allProps=($revProps);
5575 nExpectArgs=1
5576 ;;
5577 -h | --help)
5578 isHelpCmd=1
5579 ;;
5580 -F | --file)
5581 val='-F'
5582 ;;
5583 --relocate)
5584 hasRelocateOpt=1
5585 ;;
5586 --reintegrate)
5587 hasReintegrateOpt=1
5588 ;;
5589 esac;
5590 if [[ $opt = '--' && ! -n $isCur ]]; then
5591 last='onlyarg';
5592 continue;
5593 fi;
5594 if [[ $opt == -* ]]; then
5595 [[ ! -n $isCur ]] && options="$options $opt ";
5596 last='opt';
5597 continue;
5598 fi;
5599 else
5600 let nargs++;
5601 continue;
5602 fi;
5603 if [[ $cmd = 'merge' && ! -n $URL ]]; then
5604 URL=$opt;
5605 fi;
5606 last='arg';
5607 let nargs++;
5608 done;
5609 [[ -n $stat ]] || stat=$last;
5610 if [[ ! -n $cmd || $stat = 'cmd' ]]; then
5611 COMPREPLY=($( compgen -W "$cmds $specOpts" -- $cur ));
5612 return 0;
5613 fi;
5614 if [[ $stat = 'help' || ( -n $isHelpCmd && ! -n $help ) ]]; then
5615 COMPREPLY=($( compgen -W "$cmds" -- $cur ));
5616 return 0;
5617 fi;
5618 if [[ $cmd = 'merge' || $cmd = 'mergeinfo' ]]; then
5619 local here=$(_svn_info URL);
5620 if [[ ! -n $URL && $stat = 'arg' ]]; then
5621 if [[ "$here" == */branches/* ]]; then
5622 COMPREPLY=($(compgen -W ${here/\/branches\/*/\/trunk} -- $cur ));
5623 return 0;
5624 else
5625 if [[ "$here" == */trunk* ]]; then
5626 COMPREPLY=($(compgen -W ${here/\/trunk*/\/branches\/} -- $cur ));
5627 return 0;
5628 else
5629 COMPREPLY=($(compgen -W $(_svn_info Root) -- $cur ));
5630 return 0;
5631 fi;
5632 fi;
5633 else
5634 if [[ $URL == */branches/* && $here == */trunk* && ! -n $hasReintegrateOpt && $cur = '' && $stat = 'arg' ]]; then
5635 COMPREPLY=($(compgen -W '--reintegrate' -- $cur ));
5636 return 0;
5637 fi;
5638 fi;
5639 fi;
5640 if [[ $stat = 'skip' ]]; then
5641 local previous=${COMP_WORDS[COMP_CWORD-1]};
5642 local values= dirs= beep= exes=;
5643 [[ $previous = '--config-dir' ]] && dirs=1;
5644 [[ $previous = --*-cmd ]] && exes=1;
5645 [[ $previous = '--native-eol' ]] && values='LF CR CRLF';
5646 [[ $previous = '--limit' ]] && values='0 1 2 3 4 5 6 7 8 9';
5647 [[ $previous = '--revision' || $previous = '-r' ]] && values='HEAD BASE PREV COMMITTED 0 {';
5648 [[ $previous = '--encoding' ]] && values="latin1 utf8 $SVN_BASH_ENCODINGS";
5649 [[ $previous = '--extensions' || $previous = '-x' ]] && values="--unified --ignore-space-change --ignore-all-space --ignore-eol-style";
5650 [[ $previous = '--depth' ]] && values='empty files immediates infinity';
5651 [[ $previous = '--set-depth' ]] && values='empty exclude files immediates infinity';
5652 [[ $previous = '--accept' ]] && {
5653 if [[ $cmd = 'resolve' ]]; then
5654 values='base working mine-full theirs-full';
5655 else
5656 values='postpone base mine-full theirs-full edit launch';
5657 fi
5658 };
5659 [[ $previous = '--show-revs' ]] && values='merged eligible';
5660 if [[ $previous = '--username' ]]; then
5661 values="$SVN_BASH_USERNAME";
5662 if [[ $SVN_BASH_COMPL_EXT == *username* ]]; then
5663 local file=;
5664 for file in ~/.subversion/auth/svn.simple/*;
5665 do
5666 if [ -r $file ]; then
5667 values="$values $(_svn_read_hashfile username < $file)";
5668 fi;
5669 done;
5670 fi;
5671 [[ ! -n "$values" ]] && beep=1;
5672 fi;
5673 [[ $previous = '--password' ]] && beep=1;
5674 [[ -n $values ]] && COMPREPLY=($( compgen -W "$values" -- $cur ));
5675 [[ -n $dirs ]] && COMPREPLY=($( compgen -o dirnames -- $cur ));
5676 [[ -n $exes ]] && COMPREPLY=($( compgen -c -- $cur ));
5677 [[ -n $beep ]] && {
5678 echo -en "\a";
5679 COMPREPLY=('')
5680 };
5681 return 0;
5682 fi;
5683 if [[ -n $isPropCmd && ( ! -n $prop || $stat = 'prop' ) && $cur != -* ]]; then
5684 local choices=;
5685 if [[ $cur == *:* ]]; then
5686 local prefix=${cur%:*} suffix=${cur#*:} c=;
5687 for c in ${allProps[@]};
5688 do
5689 [[ $c == $prefix:* ]] && choices="$choices ${c#*:}";
5690 done;
5691 cur=$suffix;
5692 else
5693 COMPREPLY=($( compgen -W "${allProps[*]}" -- $cur ));
5694 [ ${#COMPREPLY[@]} -eq 1 ] && return 0;
5695 local seen= n=0 last= c=;
5696 for c in ${allProps[@]%:*};
5697 do
5698 if [[ $c == $cur* && ( ! -n $seen || $c != @($seen) ) ]]; then
5699 let n++;
5700 last=$c;
5701 choices="$choices $c:";
5702 if [[ -n $seen ]]; then
5703 seen="$seen|$c*";
5704 else
5705 seen="$c*";
5706 fi;
5707 fi;
5708 done;
5709 [[ $n -eq 1 ]] && choices="$last:1 $last:2";
5710 fi;
5711 COMPREPLY=($( compgen -W "$choices" -- $cur ));
5712 return 0;
5713 fi;
5714 if [[ -n $isRevProp && ! -n $hasRevPropOpt ]]; then
5715 COMPREPLY=($( compgen -W '--revprop' -- $cur ));
5716 return 0;
5717 fi;
5718 if [[ -n $isRevProp && -n $hasRevPropOpt && ! -n $hasRevisionOpt ]]; then
5719 COMPREPLY=($( compgen -W '--revision' -- $cur ));
5720 return 0;
5721 fi;
5722 if [[ -n $isPsCmd && -n $prop && ( ! -n $val || $stat = 'val' ) ]]; then
5723 local values="\' --file";
5724 case $prop in
5725 svn:keywords)
5726 values="Id Rev URL Date Author Header \' $SVN_BASH_KEYWORDS"
5727 ;;
5728 svn:executable | svn:needs-lock)
5729 values='\\*'
5730 ;;
5731 svn:eol-style)
5732 values='native LF CR CRLF'
5733 ;;
5734 svn:mime-type)
5735 values="text/ text/plain text/html text/xml text/rtf
5736 image/ image/png image/gif image/jpeg image/tiff
5737 audio/ audio/midi audio/mpeg
5738 video/ video/mpeg video/mp4
5739 application/ application/octet-stream
5740 $SVN_BASH_MIME_TYPE"
5741 ;;
5742 esac;
5743 COMPREPLY=($( compgen -W "$values" -- $cur ));
5744 [[ -n ${COMPREPLY} ]] && return 0;
5745 fi;
5746 if [[ $cmd = 'resolve' && ! -n $acceptOpt ]]; then
5747 COMPREPLY=($( compgen -W '--accept' -- $cur ));
5748 return 0;
5749 fi;
5750 case $cmd in
5751 merge)
5752 nExpectArgs=3
5753 ;;
5754 mergeinfo)
5755 nExpectArgs=1
5756 ;;
5757 copy | cp | move | mv | rename | ren | export | import)
5758 nExpectArgs=2
5759 ;;
5760 switch | sw)
5761 [[ ! -n $hasRelocateOpt ]] && nExpectArgs=2
5762 ;;
5763 help | h)
5764 nExpectArgs=0
5765 ;;
5766 --version)
5767 nExpectArgs=0
5768 ;;
5769 esac;
5770 if [[ -n $nExpectArgs && $nargs -gt $nExpectArgs ]]; then
5771 echo -en "\a";
5772 COMPREPLY=('');
5773 return 0;
5774 fi;
5775 if [[ $cur != -* || $stat = 'onlyarg' ]]; then
5776 if [[ $SVN_BASH_COMPL_EXT == *svnstatus* ]]; then
5777 local status='svn status --non-interactive';
5778 [[ $SVN_BASH_COMPL_EXT == *recurse* ]] || status="$status --non-recursive";
5779 [[ $SVN_BASH_COMPL_EXT == *externals* ]] || status="$status --ignore-externals";
5780 local cs= files=;
5781 [[ -n $cur ]] && cs=$cur*;
5782 case $cmd in
5783 st*)
5784 files=$cur*
5785 ;;
5786 ci | commit | revert | di*)
5787 files=$($status $cs| _svn_grcut '@([MADR!]*| M*|_M*)')
5788 ;;
5789 add)
5790 files=$($status $cs| _svn_grcut '\?*')
5791 ;;
5792 unlock)
5793 files=$($status $cs| _svn_grcut '@(??L*|?????[KOTB]*)')
5794 ;;
5795 resolve*)
5796 files=$($status $cs| _svn_grcut '@(?C*|C*)')
5797 ;;
5798 praise | blame | ann*)
5799 files=$( _svn_lls all $cur* )
5800 ;;
5801 p*)
5802 if [[ $cmd == @($propCmds) && $prop == @(svn:ignore|svn:externals) ]]; then
5803 files=$( _svn_lls dir . $cur* );
5804 else
5805 files="$( _svn_lls all $cur* )
5806 $($status $cs | _svn_grcut 'A*' )";
5807 fi
5808 ;;
5809 info)
5810 files="$( _svn_lls all $cur* )
5811 $($status $cs | _svn_grcut 'A*' )"
5812 ;;
5813 remove | rm | del* | move | mv | rename)
5814 files=$( _svn_lls all $cur* )
5815 ;;
5816 mkdir)
5817 files=$( _svn_lls dir $cur* )
5818 ;;
5819 log | lock | up* | cl* | switch)
5820 files=$( _svn_lls all $cur* )
5821 ;;
5822 merge)
5823 files=$( _svn_lls all $cur* )
5824 ;;
5825 ls | list)
5826 files=$( _svn_lls all $cur* )
5827 ;;
5828 *)
5829 local fallback=1
5830 ;;
5831 esac;
5832 if [[ $SVN_BASH_COMPL_EXT != *recurse* ]]; then
5833 files="$files $( _svn_lls dir $cur* )";
5834 fi;
5835 if [[ -n $files ]]; then
5836 COMPREPLY=($( compgen -W "$files" -- $cur ));
5837 [[ -n "${COMPREPLY[*]}" ]] || COMPREPLY=('');
5838 else
5839 if [[ ! -n $fallback ]]; then
5840 echo -en "\a";
5841 COMPREPLY=('');
5842 fi;
5843 fi;
5844 fi;
5845 return 0;
5846 fi;
5847 pOpts="--username --password --no-auth-cache --non-interactive";
5848 mOpts="-m --message -F --file --encoding --force-log --with-revprop";
5849 rOpts="-r --revision";
5850 qOpts="-q --quiet";
5851 nOpts="-N --non-recursive --depth";
5852 gOpts="-g --use-merge-history";
5853 cmdOpts=;
5854 case $cmd in
5855 --version)
5856 cmdOpts="$qOpts"
5857 ;;
5858 add)
5859 cmdOpts="--auto-props --no-auto-props --force --targets --no-ignore --parents $nOpts $qOpts $pOpts"
5860 ;;
5861 blame | annotate | ann | praise)
5862 cmdOpts="$rOpts $pOpts -v --verbose --incremental --xml -x --extensions --force $gOpts"
5863 ;;
5864 cat)
5865 cmdOpts="$rOpts $pOpts"
5866 ;;
5867 changelist | cl)
5868 cmdOpts="--targets $pOpts $qOpts --changelist -R --recursive --depth --remove"
5869 ;;
5870 checkout | co)
5871 cmdOpts="$rOpts $qOpts $nOpts $pOpts --ignore-externals --force --accept"
5872 ;;
5873 cleanup)
5874 cmdOpts="--diff3-cmd $pOpts"
5875 ;;
5876 commit | ci)
5877 cmdOpts="$mOpts $qOpts $nOpts --targets --editor-cmd $pOpts --no-unlock --changelist --keep-changelists"
5878 ;;
5879 copy | cp)
5880 cmdOpts="$mOpts $rOpts $qOpts --editor-cmd $pOpts --parents"
5881 ;;
5882 delete | del | remove | rm)
5883 cmdOpts="--force $mOpts $qOpts --targets --editor-cmd $pOpts --keep-local"
5884 ;;
5885 diff | di)
5886 cmdOpts="$rOpts -x --extensions --diff-cmd --no-diff-deleted $nOpts $pOpts --force --old --new --notice-ancestry -c --change --summarize --changelist --xml"
5887 ;;
5888 export)
5889 cmdOpts="$rOpts $qOpts $pOpts $nOpts --force --native-eol --ignore-externals"
5890 ;;
5891 help | h | \?)
5892 cmdOpts=
5893 ;;
5894 import)
5895 cmdOpts="--auto-props --no-auto-props $mOpts $qOpts $nOpts --no-ignore --editor-cmd $pOpts --force"
5896 ;;
5897 info)
5898 cmdOpts="$pOpts $rOpts --targets -R --recursive --depth --incremental --xml --changelist"
5899 ;;
5900 list | ls)
5901 cmdOpts="$rOpts -v --verbose -R --recursive $pOpts --incremental --xml --depth"
5902 ;;
5903 lock)
5904 cmdOpts="-m --message -F --file --encoding --force-log --targets --force $pOpts"
5905 ;;
5906 log)
5907 cmdOpts="$rOpts -v --verbose --targets $pOpts --stop-on-copy --incremental --xml $qOpts -l --limit -c --change $gOpts --with-all-revprops --with-revprop"
5908 ;;
5909 merge)
5910 cmdOpts="$rOpts $nOpts $qOpts --force --dry-run --diff3-cmd $pOpts --ignore-ancestry -c --change -x --extensions --record-only --accept --reintegrate"
5911 ;;
5912 mergeinfo)
5913 cmdOpts="$rOpts $pOpts --show-revs"
5914 ;;
5915 mkdir)
5916 cmdOpts="$mOpts $qOpts --editor-cmd $pOpts --parents"
5917 ;;
5918 move | mv | rename | ren)
5919 cmdOpts="$mOpts $rOpts $qOpts --force --editor-cmd $pOpts --parents"
5920 ;;
5921 propdel | pdel | pd)
5922 cmdOpts="$qOpts -R --recursive $rOpts $pOpts --changelist --depth";
5923 [[ -n $isRevProp || ! -n $prop ]] && cmdOpts="$cmdOpts --revprop"
5924 ;;
5925 propedit | pedit | pe)
5926 cmdOpts="--editor-cmd $pOpts $mOpts --force";
5927 [[ -n $isRevProp || ! -n $prop ]] && cmdOpts="$cmdOpts --revprop $rOpts"
5928 ;;
5929 propget | pget | pg)
5930 cmdOpts="-v --verbose -R --recursive $rOpts --strict $pOpts --changelist --depth --xml";
5931 [[ -n $isRevProp || ! -n $prop ]] && cmdOpts="$cmdOpts --revprop"
5932 ;;
5933 proplist | plist | pl)
5934 cmdOpts="-v --verbose -R --recursive $rOpts --revprop $qOpts $pOpts --changelist --depth --xml"
5935 ;;
5936 propset | pset | ps)
5937 cmdOpts="$qOpts --targets -R --recursive --encoding $pOpts --force --changelist --depth";
5938 [[ -n $isRevProp || ! -n $prop ]] && cmdOpts="$cmdOpts --revprop $rOpts";
5939 [[ -n $val ]] || cmdOpts="$cmdOpts -F --file"
5940 ;;
5941 resolve)
5942 cmdOpts="--targets -R --recursive $qOpts $pOpts --accept --depth"
5943 ;;
5944 resolved)
5945 cmdOpts="--targets -R --recursive $qOpts $pOpts --depth"
5946 ;;
5947 revert)
5948 cmdOpts="--targets -R --recursive $qOpts --changelist --depth $pOpts"
5949 ;;
5950 status | stat | st)
5951 cmdOpts="-u --show-updates -v --verbose $nOpts $qOpts $pOpts --no-ignore --ignore-externals --incremental --xml --changelist"
5952 ;;
5953 switch | sw)
5954 cmdOpts="--relocate $rOpts $nOpts $qOpts $pOpts --diff3-cmd --force --accept --ignore-externals --set-depth"
5955 ;;
5956 unlock)
5957 cmdOpts="--targets --force $pOpts"
5958 ;;
5959 update | up)
5960 cmdOpts="$rOpts $nOpts $qOpts $pOpts --diff3-cmd --ignore-externals --force --accept --changelist --editor-cmd --set-depth"
5961 ;;
5962 *)
5963
5964 ;;
5965 esac;
5966 [[ "$cmd" != "--version" ]] && cmdOpts="$cmdOpts $helpOpts";
5967 cmdOpts="$cmdOpts --config-dir --config-option";
5968 if [[ $acceptOpt == @(edit|launch) ]]; then
5969 cmdOpts=${cmdOpts/ --non-interactive / };
5970 fi;
5971 for opt in $options;
5972 do
5973 local optBase;
5974 case $opt in
5975 --*)
5976 optBase=${opt/=*/}
5977 ;;
5978 -*)
5979 optBase=${opt:0:2}
5980 ;;
5981 esac;
5982 cmdOpts=" $cmdOpts ";
5983 cmdOpts=${cmdOpts/ ${optBase} / };
5984 case $optBase in
5985 -v)
5986 cmdOpts=${cmdOpts/ --verbose / }
5987 ;;
5988 --verbose)
5989 cmdOpts=${cmdOpts/ -v / }
5990 ;;
5991 -N)
5992 cmdOpts=${cmdOpts/ --non-recursive / }
5993 ;;
5994 --non-recursive)
5995 cmdOpts=${cmdOpts/ -N / }
5996 ;;
5997 -R)
5998 cmdOpts=${cmdOpts/ --recursive / }
5999 ;;
6000 --recursive)
6001 cmdOpts=${cmdOpts/ -R / }
6002 ;;
6003 -x)
6004 cmdOpts=${cmdOpts/ --extensions / }
6005 ;;
6006 --extensions)
6007 cmdOpts=${cmdOpts/ -x / }
6008 ;;
6009 -q)
6010 cmdOpts=${cmdOpts/ --quiet / }
6011 ;;
6012 --quiet)
6013 cmdOpts=${cmdOpts/ -q / }
6014 ;;
6015 -h)
6016 cmdOpts=${cmdOpts/ --help / }
6017 ;;
6018 --help)
6019 cmdOpts=${cmdOpts/ -h / }
6020 ;;
6021 -l)
6022 cmdOpts=${cmdOpts/ --limit / }
6023 ;;
6024 --limit)
6025 cmdOpts=${cmdOpts/ -l / }
6026 ;;
6027 -r)
6028 cmdOpts=${cmdOpts/ --revision / }
6029 ;;
6030 --revision)
6031 cmdOpts=${cmdOpts/ -r / }
6032 ;;
6033 -c)
6034 cmdOpts=${cmdOpts/ --change / }
6035 ;;
6036 --change)
6037 cmdOpts=${cmdOpts/ -c / }
6038 ;;
6039 --auto-props)
6040 cmdOpts=${cmdOpts/ --no-auto-props / }
6041 ;;
6042 --no-auto-props)
6043 cmdOpts=${cmdOpts/ --auto-props / }
6044 ;;
6045 -g)
6046 cmdOpts=${cmdOpts/ --use-merge-history / }
6047 ;;
6048 --use-merge-history)
6049 cmdOpts=${cmdOpts/ -g / }
6050 ;;
6051 -m | --message | -F | --file)
6052 cmdOpts=${cmdOpts/ --message / };
6053 cmdOpts=${cmdOpts/ -m / };
6054 cmdOpts=${cmdOpts/ --file / };
6055 cmdOpts=${cmdOpts/ -F / }
6056 ;;
6057 esac;
6058 if [ $isHelpCmd ]; then
6059 cmdOpts=${cmdOpts/ -h / };
6060 cmdOpts=${cmdOpts/ --help / };
6061 fi;
6062 done;
6063 COMPREPLY=($( compgen -W "$cmdOpts" -- $cur ));
6064 return 0
6065}
6066_svn_grcut ()
6067{
6068 local re=$1 line= old_IFS;
6069 old_IFS="$IFS";
6070 IFS='
6071';
6072 while read -r line; do
6073 [[ ! -n $re || $line == $re ]] && echo "${line/????????/}";
6074 done;
6075 IFS="$old_IFS"
6076}
6077_svn_info ()
6078{
6079 local what=$1 line=;
6080 LANG=C LC_MESSAGES=C svn info --non-interactive 2> /dev/null | while read line; do
6081 [[ $line == *"$what: "* ]] && echo ${line#*: };
6082 done
6083}
6084_svn_lls ()
6085{
6086 local opt=$1 f=;
6087 shift;
6088 for f in "$@";
6089 do
6090 if [[ $opt == @(dir|all) && -d "$f" ]]; then
6091 echo "$f/";
6092 else
6093 if [[ $opt == @(file|all) ]]; then
6094 local dn= fn="$f";
6095 [[ "$f" == */* ]] && dn=${f%\/*}/ fn=${f##*\/};
6096 [ -f "${dn}.svn/text-base/${fn}.svn-base" ] && echo "$f";
6097 fi;
6098 fi;
6099 done
6100}
6101_svn_read_hashfile ()
6102{
6103 local tkey=$1 key= val=;
6104 while true; do
6105 read tag len;
6106 [ $tag = 'END' ] && break;
6107 [ $tag != 'K' ] && {
6108 return
6109 };
6110 read -r -n $len key;
6111 read;
6112 read tag len;
6113 [ $tag != 'V' ] && {
6114 return
6115 };
6116 read -r -n $len val;
6117 read;
6118 if [[ $key = $tkey ]]; then
6119 echo "$val";
6120 return;
6121 fi;
6122 done
6123}
6124_svnadmin ()
6125{
6126 local cur cmds cmdOpts optsParam opt helpCmds optBase i;
6127 COMPREPLY=();
6128 cur=${COMP_WORDS[COMP_CWORD]};
6129 cmds='crashtest create deltify dump help hotcopy list-dblogs \
6130 list-unused-dblogs load lslocks lstxns pack recover rmlocks \
6131 rmtxns setlog setrevprop setuuid upgrade verify --version';
6132 if [[ $COMP_CWORD -eq 1 ]]; then
6133 COMPREPLY=($( compgen -W "$cmds" -- $cur ));
6134 return 0;
6135 fi;
6136 optsParam="-r|--revision|--parent-dir|--fs-type";
6137 helpCmds='help|--help|h|\?';
6138 if [[ ${COMP_WORDS[1]} != @($helpCmds) ]] && [[ "$cur" != -* ]] || [[ ${COMP_WORDS[COMP_CWORD-1]} == @($optsParam) ]]; then
6139 return 0;
6140 fi;
6141 cmdOpts=;
6142 case ${COMP_WORDS[1]} in
6143 create)
6144 cmdOpts="--bdb-txn-nosync --bdb-log-keep --config-dir --fs-type --pre-1.4-compatible --pre-1.5-compatible"
6145 ;;
6146 deltify)
6147 cmdOpts="-r --revision -q --quiet"
6148 ;;
6149 dump)
6150 cmdOpts="-r --revision --incremental -q --quiet --deltas"
6151 ;;
6152 help | h | \?)
6153 cmdOpts="$cmds"
6154 ;;
6155 hotcopy)
6156 cmdOpts="--clean-logs"
6157 ;;
6158 load)
6159 cmdOpts="--ignore-uuid --force-uuid --parent-dir -q --quiet --use-pre-commit-hook --use-post-commit-hook"
6160 ;;
6161 recover)
6162 cmdOpts="--wait"
6163 ;;
6164 rmtxns)
6165 cmdOpts="-q --quiet"
6166 ;;
6167 setlog)
6168 cmdOpts="-r --revision --bypass-hooks"
6169 ;;
6170 setrevprop)
6171 cmdOpts="-r --revision --use-pre-revprop-change-hook --use-post-revprop-change-hook"
6172 ;;
6173 verify)
6174 cmdOpts="-r --revision -q --quiet"
6175 ;;
6176 *)
6177
6178 ;;
6179 esac;
6180 cmdOpts="$cmdOpts --help -h";
6181 for ((i=2; i<=$COMP_CWORD-1; ++i ))
6182 do
6183 opt=${COMP_WORDS[$i]};
6184 case $opt in
6185 --*)
6186 optBase=${opt/=*/}
6187 ;;
6188 -*)
6189 optBase=${opt:0:2}
6190 ;;
6191 esac;
6192 cmdOpts=" $cmdOpts ";
6193 cmdOpts=${cmdOpts/ ${optBase} / };
6194 case $optBase in
6195 -q)
6196 cmdOpts=${cmdOpts/ --quiet / }
6197 ;;
6198 --quiet)
6199 cmdOpts=${cmdOpts/ -q / }
6200 ;;
6201 -h)
6202 cmdOpts=${cmdOpts/ --help / }
6203 ;;
6204 --help)
6205 cmdOpts=${cmdOpts/ -h / }
6206 ;;
6207 -r)
6208 cmdOpts=${cmdOpts/ --revision / }
6209 ;;
6210 --revision)
6211 cmdOpts=${cmdOpts/ -r / }
6212 ;;
6213 esac;
6214 if [[ $opt == @($optsParam) ]]; then
6215 ((++i));
6216 fi;
6217 done;
6218 COMPREPLY=($( compgen -W "$cmdOpts" -- $cur ));
6219 return 0
6220}
6221_svndumpfilter ()
6222{
6223 local cur cmds cmdOpts optsParam opt helpCmds optBase i;
6224 COMPREPLY=();
6225 cur=${COMP_WORDS[COMP_CWORD]};
6226 cmds='exclude help include --version';
6227 if [[ $COMP_CWORD -eq 1 ]]; then
6228 COMPREPLY=($( compgen -W "$cmds" -- $cur ));
6229 return 0;
6230 fi;
6231 optsParam="--targets";
6232 helpCmds='help|--help|h|\?';
6233 if [[ ${COMP_WORDS[1]} != @($helpCmds) ]] && [[ "$cur" != -* ]] || [[ ${COMP_WORDS[COMP_CWORD-1]} == @($optsParam) ]]; then
6234 return 0;
6235 fi;
6236 cmdOpts=;
6237 case ${COMP_WORDS[1]} in
6238 exclude | include)
6239 cmdOpts="--drop-empty-revs --renumber-revs
6240 --skip-missing-merge-sources --targets
6241 --preserve-revprops --quiet"
6242 ;;
6243 help | h | \?)
6244 cmdOpts="$cmds"
6245 ;;
6246 *)
6247
6248 ;;
6249 esac;
6250 cmdOpts="$cmdOpts --help -h";
6251 for ((i=2; i<=$COMP_CWORD-1; ++i ))
6252 do
6253 opt=${COMP_WORDS[$i]};
6254 case $opt in
6255 --*)
6256 optBase=${opt/=*/}
6257 ;;
6258 -*)
6259 optBase=${opt:0:2}
6260 ;;
6261 esac;
6262 cmdOpts=" $cmdOpts ";
6263 cmdOpts=${cmdOpts/ ${optBase} / };
6264 case $optBase in
6265 -h)
6266 cmdOpts=${cmdOpts/ --help / }
6267 ;;
6268 --help)
6269 cmdOpts=${cmdOpts/ -h / }
6270 ;;
6271 esac;
6272 if [[ $opt == @($optsParam) ]]; then
6273 ((++i));
6274 fi;
6275 done;
6276 COMPREPLY=($( compgen -W "$cmdOpts" -- $cur ));
6277 return 0
6278}
6279_svnlook ()
6280{
6281 local cur cmds cmdOpts optsParam opt helpCmds optBase i;
6282 COMPREPLY=();
6283 cur=${COMP_WORDS[COMP_CWORD]};
6284 cmds='author cat changed date diff dirs-changed help history info \
6285 lock log propget proplist tree uuid youngest --version';
6286 if [[ $COMP_CWORD -eq 1 ]]; then
6287 COMPREPLY=($( compgen -W "$cmds" -- $cur ));
6288 return 0;
6289 fi;
6290 optsParam="-r|--revision|-t|--transaction|-l|--limit|-x|--extensions";
6291 helpCmds='help|--help|h|\?';
6292 if [[ ${COMP_WORDS[1]} != @($helpCmds) ]] && [[ "$cur" != -* ]] || [[ ${COMP_WORDS[COMP_CWORD-1]} == @($optsParam) ]]; then
6293 return 0;
6294 fi;
6295 cmdOpts=;
6296 case ${COMP_WORDS[1]} in
6297 author)
6298 cmdOpts="-r --revision -t --transaction"
6299 ;;
6300 cat)
6301 cmdOpts="-r --revision -t --transaction"
6302 ;;
6303 changed)
6304 cmdOpts="-r --revision -t --transaction --copy-info"
6305 ;;
6306 date)
6307 cmdOpts="-r --revision -t --transaction"
6308 ;;
6309 diff)
6310 cmdOpts="-r --revision -t --transaction --diff-copy-from --no-diff-added --no-diff-deleted -x --extensions"
6311 ;;
6312 dirs-changed)
6313 cmdOpts="-r --revision -t --transaction"
6314 ;;
6315 help | h | \?)
6316 cmdOpts="$cmds"
6317 ;;
6318 history)
6319 cmdOpts="-r --revision -l --limit --show-ids"
6320 ;;
6321 info)
6322 cmdOpts="-r --revision -t --transaction"
6323 ;;
6324 lock)
6325 cmdOpts=
6326 ;;
6327 log)
6328 cmdOpts="-r --revision -t --transaction"
6329 ;;
6330 propget | pget | pg)
6331 cmdOpts="-r --revision -t --transaction --revprop"
6332 ;;
6333 proplist | plist | pl)
6334 cmdOpts="-r --revision -t --transaction --revprop -v --verbose --xml"
6335 ;;
6336 tree)
6337 cmdOpts="-r --revision -t --transaction --full-paths -N --non-recursive --show-ids"
6338 ;;
6339 uuid)
6340 cmdOpts=
6341 ;;
6342 youngest)
6343 cmdOpts=
6344 ;;
6345 *)
6346
6347 ;;
6348 esac;
6349 cmdOpts="$cmdOpts --help -h";
6350 for ((i=2; i<=$COMP_CWORD-1; ++i ))
6351 do
6352 opt=${COMP_WORDS[$i]};
6353 case $opt in
6354 --*)
6355 optBase=${opt/=*/}
6356 ;;
6357 -*)
6358 optBase=${opt:0:2}
6359 ;;
6360 esac;
6361 cmdOpts=" $cmdOpts ";
6362 cmdOpts=${cmdOpts/ ${optBase} / };
6363 case $optBase in
6364 -N)
6365 cmdOpts=${cmdOpts/ --non-recursive / }
6366 ;;
6367 --non-recursive)
6368 cmdOpts=${cmdOpts/ -N / }
6369 ;;
6370 -h)
6371 cmdOpts=${cmdOpts/ --help / }
6372 ;;
6373 --help)
6374 cmdOpts=${cmdOpts/ -h / }
6375 ;;
6376 -l)
6377 cmdOpts=${cmdOpts/ --limit / }
6378 ;;
6379 --limit)
6380 cmdOpts=${cmdOpts/ -l / }
6381 ;;
6382 -r)
6383 cmdOpts=${cmdOpts/ --revision / }
6384 ;;
6385 --revision)
6386 cmdOpts=${cmdOpts/ -r / }
6387 ;;
6388 -t)
6389 cmdOpts=${cmdOpts/ --transaction / }
6390 ;;
6391 --transaction)
6392 cmdOpts=${cmdOpts/ -t / }
6393 ;;
6394 -v)
6395 cmdOpts=${cmdOpts/ --verbose / }
6396 ;;
6397 --verbose)
6398 cmdOpts=${cmdOpts/ -v / }
6399 ;;
6400 -x)
6401 cmdOpts=${cmdOpts/ --extensions / }
6402 ;;
6403 --extensions)
6404 cmdOpts=${cmdOpts/ -x / }
6405 ;;
6406 esac;
6407 if [[ $opt == @($optsParam) ]]; then
6408 ((++i));
6409 fi;
6410 done;
6411 COMPREPLY=($( compgen -W "$cmdOpts" -- $cur ));
6412 return 0
6413}
6414_svnsync ()
6415{
6416 local cur cmds cmdOpts optsParam opt helpCmds optBase i;
6417 COMPREPLY=();
6418 cur=${COMP_WORDS[COMP_CWORD]};
6419 cmds='copy-revprops help info initialize synchronize --version';
6420 if [[ $COMP_CWORD -eq 1 ]]; then
6421 COMPREPLY=($( compgen -W "$cmds" -- $cur ));
6422 return 0;
6423 fi;
6424 optsParam="--config-dir|--config-option|--source-username|--source-password";
6425 optsParam="$optsParam|--sync-username|--sync-password";
6426 helpCmds='help|--help|h|\?';
6427 if [[ ${COMP_WORDS[1]} != @($helpCmds) ]] && [[ "$cur" != -* ]] || [[ ${COMP_WORDS[COMP_CWORD-1]} == @($optsParam) ]]; then
6428 return 0;
6429 fi;
6430 cmdOpts=;
6431 case ${COMP_WORDS[1]} in
6432 copy-revprops | initialize | init | synchronize | sync)
6433 cmdOpts="--non-interactive --no-auth-cache --trust-server-cert --source-username --source-password --sync-username --sync-password --config-dir --config-option -q --quiet"
6434 ;;
6435 help | h | \?)
6436 cmdOpts="$cmds"
6437 ;;
6438 info)
6439 cmdOpts="--non-interactive --no-auth-cache --trust-server-cert --source-username --source-password --sync-username --sync-password --config-dir --config-option"
6440 ;;
6441 *)
6442
6443 ;;
6444 esac;
6445 cmdOpts="$cmdOpts --help -h";
6446 for ((i=2; i<=$COMP_CWORD-1; ++i ))
6447 do
6448 opt=${COMP_WORDS[$i]};
6449 case $opt in
6450 --*)
6451 optBase=${opt/=*/}
6452 ;;
6453 -*)
6454 optBase=${opt:0:2}
6455 ;;
6456 esac;
6457 cmdOpts=" $cmdOpts ";
6458 cmdOpts=${cmdOpts/ ${optBase} / };
6459 case $optBase in
6460 -h)
6461 cmdOpts=${cmdOpts/ --help / }
6462 ;;
6463 --help)
6464 cmdOpts=${cmdOpts/ -h / }
6465 ;;
6466 -q)
6467 cmdOpts=${cmdOpts/ --quiet / }
6468 ;;
6469 --quiet)
6470 cmdOpts=${cmdOpts/ -q / }
6471 ;;
6472 esac;
6473 if [[ $opt == @($optsParam) ]]; then
6474 ((++i));
6475 fi;
6476 done;
6477 COMPREPLY=($( compgen -W "$cmdOpts" -- $cur ));
6478 return 0
6479}
6480_sysctl ()
6481{
6482 local cur;
6483 COMPREPLY=();
6484 cur=`_get_cword`;
6485 COMPREPLY=($( compgen -W "$(sysctl -N -a 2>/dev/null)" -- "$cur" ));
6486 return 0
6487}
6488_tar ()
6489{
6490 local cur ext regex tar untar;
6491 COMPREPLY=();
6492 cur=`_get_cword`;
6493 if [ $COMP_CWORD -eq 1 ]; then
6494 COMPREPLY=($( compgen -W 'c t x u r d A' -- "$cur" ));
6495 return 0;
6496 fi;
6497 case "${COMP_WORDS[1]}" in
6498 ?(-)[cr]*f)
6499 _filedir;
6500 return 0
6501 ;;
6502 +([^IZzJjy])f)
6503 ext='t@(ar?(.@(Z|gz|bz?(2)|lz?(ma)))|gz|bz?(2)|lz?(ma))';
6504 regex='t\(ar\(\.\(Z\|gz\|bz2\?\|lzma\|xz\)\)\?\|gz\|bz2\?\|lzma\|xz\)'
6505 ;;
6506 *[Zz]*f)
6507 ext='t?(ar.)@(gz|Z)';
6508 regex='t\(ar\.\)\?\(gz\|Z\)'
6509 ;;
6510 *[Ijy]*f)
6511 ext='t?(ar.)bz?(2)';
6512 regex='t\(ar\.\)\?bz2\?'
6513 ;;
6514 *[J]*f)
6515 ext='t?(ar.)@(lz?(ma)|xz)';
6516 regex='t\(ar\.\)\?\(lzma\|xz\)\?'
6517 ;;
6518 *)
6519 _filedir;
6520 return 0
6521 ;;
6522 esac;
6523 if [[ "$COMP_LINE" == *$ext' ' ]]; then
6524 tar=$( echo "$COMP_LINE" | sed -e 's/^.* \([^ ]*'$regex'\) .*$/\1/' );
6525 untar=t${COMP_WORDS[1]//[^Izjyf]/};
6526 COMPREPLY=($( compgen -W "$( echo $( tar $untar $tar 2>/dev/null ) )" -- "$cur" ));
6527 return 0;
6528 fi;
6529 _filedir "$ext";
6530 return 0
6531}
6532_uids ()
6533{
6534 if type getent &>/dev/null; then
6535 COMPREPLY=($( compgen -W '$( getent passwd | cut -d: -f3 )' -- "$cur" ));
6536 else
6537 if type perl &>/dev/null; then
6538 COMPREPLY=($( compgen -W '$( perl -e '"'"'while (($uid) = (getpwent)[2]) { print $uid . "\n" }'"'"' )' -- "$cur" ));
6539 else
6540 COMPREPLY=($( compgen -W '$( cut -d: -f3 /etc/passwd )' -- "$cur" ));
6541 fi;
6542 fi
6543}
6544_umount ()
6545{
6546 local cur IFS='
6547';
6548 COMPREPLY=();
6549 cur=`_get_cword`;
6550 COMPREPLY=($( compgen -W '$( mount | cut -d" " -f 3 )' -- "$cur" ));
6551 return 0
6552}
6553_units ()
6554{
6555 COMPREPLY=($( compgen -W 'h s b k m g t H K M G T' -- "$cur" ))
6556}
6557_unrar ()
6558{
6559 local cur;
6560 COMPREPLY=();
6561 cur=`_get_cword`;
6562 case "$cur" in
6563 -*)
6564 COMPREPLY=($( compgen -W '-ad -ap -av- -c- -cfg- -cl -cu \
6565 -dh -ep -f -idp -ierr -inul -kb -o+ -o- -ow -p -p- -r -ta \
6566 -tb -tn -to -u -v -ver -vp -x -x@ -y' -- "$cur" ))
6567 ;;
6568 *)
6569 if [ $COMP_CWORD -eq 1 ]; then
6570 COMPREPLY=($( compgen -W 'e l lb lt p t v vb vt x' -- "$cur" ));
6571 else
6572 _filedir '@(rar|RAR)';
6573 fi
6574 ;;
6575 esac;
6576 return 0
6577}
6578_usb_ids ()
6579{
6580 COMPREPLY=(${COMPREPLY[@]:-} $( compgen -W "$( PATH="$PATH:/sbin" lsusb | awk '{print $6}' )" -- "$cur" ))
6581}
6582_user_at_host ()
6583{
6584 local cur;
6585 COMPREPLY=();
6586 cur=`_get_cword`;
6587 if [[ $cur == *@* ]]; then
6588 _known_hosts_real "$cur";
6589 else
6590 COMPREPLY=($( compgen -u -- "$cur" ));
6591 fi;
6592 return 0
6593}
6594_useradd ()
6595{
6596 local cur prev split=false;
6597 COMPREPLY=();
6598 cur=`_get_cword`;
6599 prev=${COMP_WORDS[COMP_CWORD-1]};
6600 _split_longopt && split=true;
6601 case "$prev" in
6602 -c | --comment | -h | --help | -e | --expiredate | -f | --inactive | -k | --key | -p | --password | -u | --uid | -Z | --selinux-user)
6603 return 0
6604 ;;
6605 -b | --base-dir | -d | --home | -k | --skel)
6606 _filedir -d;
6607 return 0
6608 ;;
6609 -g | --gid)
6610 _gids;
6611 [ -n "$bash205" ] && COMPREPLY=("${COMPREPLY[@]}" $( compgen -g ));
6612 COMPREPLY=($( compgen -W '${COMPREPLY[@]}' -- "$cur" ));
6613 return 0
6614 ;;
6615 -G | --groups)
6616 [ -n "$bash205" ] && COMPREPLY=($( compgen -g -- "$cur" ));
6617 return 0
6618 ;;
6619 -s | --shell)
6620 _shells;
6621 return 0
6622 ;;
6623 esac;
6624 $split && return 0;
6625 if [[ "$cur" == -* ]]; then
6626 COMPREPLY=($( compgen -W '-b --base-dir -c --comment -d --home\
6627 -D --defaults -e --expiredate -f --inactive -g --gid \
6628 -G --groups -h --help -k --skel -K --key -l -M \
6629 -m --create-home -N --no-user-group -o --non-unique \
6630 -p --password -r --system -s --shell -u --uid \
6631 -U --user-group -Z --selinux-user' -- "$cur" ));
6632 return 0;
6633 fi
6634}
6635_userdel ()
6636{
6637 local cur;
6638 COMPREPLY=();
6639 cur=`_get_cword`;
6640 if [[ "$cur" == -* ]]; then
6641 COMPREPLY=($( compgen -W '-f --force -h --help -r --remove' -- "$cur" ));
6642 return 0;
6643 fi;
6644 COMPREPLY=($( compgen -u -- "$cur" ))
6645}
6646_usergroup ()
6647{
6648 local IFS='
6649';
6650 cur=${cur//\\\\ / };
6651 if [[ $cur = *@(\\:|.)* ]] && [ -n "$bash205" ]; then
6652 user=${cur%%*([^:.])};
6653 COMPREPLY=($(compgen -P ${user/\\\\} -g -- ${cur##*[.:]}));
6654 else
6655 if [[ $cur = *:* ]] && [ -n "$bash205" ]; then
6656 COMPREPLY=($( compgen -g -- ${cur##*[.:]} ));
6657 else
6658 COMPREPLY=($( compgen -S : -u -- "$cur" ));
6659 fi;
6660 fi
6661}
6662_usermod ()
6663{
6664 local cur prev split=false;
6665 COMPREPLY=();
6666 cur=`_get_cword`;
6667 prev=${COMP_WORDS[COMP_CWORD-1]};
6668 _split_longopt && split=true;
6669 case "$prev" in
6670 -c | --comment | -d | --home | -e | --expiredate | -f | --inactive | -h | --help | -l | --login | -p | --password | -u | --uid | -Z | --selinux-user)
6671 return 0
6672 ;;
6673 -g | --gid)
6674 _gids;
6675 [ -n "$bash205" ] && COMPREPLY=("${COMPREPLY[@]}" $( compgen -g ));
6676 COMPREPLY=($( compgen -W '${COMPREPLY[@]}' -- "$cur" ));
6677 return 0
6678 ;;
6679 -G | --groups)
6680 [ -n "$bash205" ] && COMPREPLY=($( compgen -g -- "$cur" ));
6681 return 0
6682 ;;
6683 -s | --shell)
6684 _shells;
6685 return 0
6686 ;;
6687 esac;
6688 $split && return 0;
6689 if [[ "$cur" == -* ]]; then
6690 COMPREPLY=($( compgen -W '-a --append -c --comment -d --home \
6691 -e --expiredate -f --inactive -g --gid -G --groups \
6692 -h --help -l --login -L --lock -o --non-unique \
6693 -p --password -s --shell -u --uid -U --unlock \
6694 -Z --selinux-user' -- "$cur" ));
6695 return 0;
6696 fi;
6697 COMPREPLY=($( compgen -u -- "$cur" ))
6698}
6699_vgcfgbackup ()
6700{
6701 local cur prev;
6702 COMPREPLY=();
6703 cur=`_get_cword`;
6704 prev=${COMP_WORDS[COMP_CWORD-1]};
6705 case "$prev" in
6706 -@(f|-file))
6707 _filedir;
6708 return 0
6709 ;;
6710 esac;
6711 if [[ "$cur" == -* ]]; then
6712 COMPREPLY=($( compgen -W '-d --debug -f --file -h --help \
6713 --ignorelockingfailure -P --partial -v --verbose \
6714 --version' -- "$cur" ));
6715 else
6716 _volumegroups;
6717 fi
6718}
6719_vgcfgrestore ()
6720{
6721 local cur prev;
6722 COMPREPLY=();
6723 cur=`_get_cword`;
6724 prev=${COMP_WORDS[COMP_CWORD-1]};
6725 case "$prev" in
6726 -@(f|-file))
6727 _filedir;
6728 return 0
6729 ;;
6730 -@(M|-metadatatype))
6731 COMPREPLY=($( compgen -W '1 2' -- "$cur" ));
6732 return 0
6733 ;;
6734 -@(n|-name))
6735 _volumegroups;
6736 return 0
6737 ;;
6738 esac;
6739 if [[ "$cur" == -* ]]; then
6740 COMPREPLY=($( compgen -W '-d --debug -f --file -l --list \
6741 -h --help -M --Metadatatype -n --name -t --test \
6742 -v --verbose --version' -- "$cur" ));
6743 else
6744 _volumegroups;
6745 fi
6746}
6747_vgchange ()
6748{
6749 local cur prev;
6750 COMPREPLY=();
6751 cur=`_get_cword`;
6752 prev=${COMP_WORDS[COMP_CWORD-1]};
6753 case "$prev" in
6754 -@(a|A|x|-available|-autobackup|-resizeable))
6755 COMPREPLY=($( compgen -W 'y n' -- "$cur" ));
6756 return 0
6757 ;;
6758 esac;
6759 if [[ "$cur" == -* ]]; then
6760 COMPREPLY=($( compgen -W '-A --autobackup --alloc -P \
6761 --partial -d --debug -h --help --ignorelockingfailure \
6762 -t --test -u --uuid -v --verbose --version -a \
6763 --available -x --resizeable -l --logicalvolume \
6764 --addtag --deltag' -- "$cur" ));
6765 else
6766 _volumegroups;
6767 fi
6768}
6769_vgck ()
6770{
6771 local cur prev;
6772 COMPREPLY=();
6773 cur=`_get_cword`;
6774 if [[ "$cur" == -* ]]; then
6775 COMPREPLY=($( compgen -W '-d --debug -h \
6776 -? --help -v --verbose --version' -- "$cur" ));
6777 else
6778 _volumegroups;
6779 fi
6780}
6781_vgconvert ()
6782{
6783 local cur prev;
6784 COMPREPLY=();
6785 cur=`_get_cword`;
6786 prev=${COMP_WORDS[COMP_CWORD-1]};
6787 case "$prev" in
6788 -@(M|-metadatatype))
6789 COMPREPLY=($( compgen -W '1 2' -- "$cur" ));
6790 return 0
6791 ;;
6792 --metadatacopies)
6793 COMPREPLY=($( compgen -W '0 1 2' -- "$cur" ));
6794 return 0
6795 ;;
6796 --metadatasize)
6797 _sizes;
6798 return 0
6799 ;;
6800 esac;
6801 if [[ "$cur" == -* ]]; then
6802 COMPREPLY=($( compgen -W '-d --debug -h --help --labelsector \
6803 -M --metadatatype --metadatacopies --metadatasize \
6804 -t --test -v --verbose --version' -- "$cur" ));
6805 else
6806 _volumegroups;
6807 fi
6808}
6809_vgcreate ()
6810{
6811 local cur prev;
6812 COMPREPLY=();
6813 cur=`_get_cword`;
6814 prev=${COMP_WORDS[COMP_CWORD-1]};
6815 case "$prev" in
6816 -@(A|-autobackup))
6817 COMPREPLY=($( compgen -W 'y n' -- "$cur" ));
6818 return 0
6819 ;;
6820 -@(M|-metadatatype))
6821 COMPREPLY=($( compgen -W '1 2' -- "$cur" ));
6822 return 0
6823 ;;
6824 -@(s|-physicalextentsize))
6825 _sizes;
6826 return 0
6827 ;;
6828 esac;
6829 if [[ "$cur" == -* ]]; then
6830 COMPREPLY=($( compgen -W '-A --autobackup --addtag --alloc -d \
6831 --debug -h --help -l --maxlogicalvolumes -M --metadatatype -p \
6832 --maxphysicalvolumes -s --physicalextentsize -t --test -v \
6833 --verbose --version' -- "$cur" ));
6834 else
6835 _args;
6836 if [ $args -eq 0 ]; then
6837 _volumegroups;
6838 else
6839 _physicalvolumes;
6840 fi;
6841 fi
6842}
6843_vgdisplay ()
6844{
6845 local cur prev;
6846 COMPREPLY=();
6847 cur=`_get_cword`;
6848 prev=${COMP_WORDS[COMP_CWORD-1]};
6849 case "$prev" in
6850 --units)
6851 _units;
6852 return 0
6853 ;;
6854 esac;
6855 if [[ "$cur" == -* ]]; then
6856 COMPREPLY=($( compgen -W '-c --colon -C --columns --units \
6857 -P --partial -A --activevolumegroups -v --verbose \
6858 -d --debug -h --help --version' -- "$cur" ));
6859 else
6860 _volumegroups;
6861 fi
6862}
6863_vgextend ()
6864{
6865 local cur prev;
6866 COMPREPLY=();
6867 cur=`_get_cword`;
6868 prev=${COMP_WORDS[COMP_CWORD-1]};
6869 case "$prev" in
6870 -@(A|-autobackup))
6871 COMPREPLY=($( compgen -W 'y n' -- "$cur" ));
6872 return 0
6873 ;;
6874 -@(L|-size))
6875 _sizes;
6876 return 0
6877 ;;
6878 esac;
6879 if [[ "$cur" == -* ]]; then
6880 COMPREPLY=($( compgen -W '-A --autobackup -d --debug -h \
6881 -? --help -t --test -v --verbose --version' -- "$cur" ));
6882 else
6883 _args;
6884 if [ $args -eq 0 ]; then
6885 _volumegroups;
6886 else
6887 _physicalvolumes;
6888 fi;
6889 fi
6890}
6891_vgmerge ()
6892{
6893 local cur prev;
6894 COMPREPLY=();
6895 cur=`_get_cword`;
6896 prev=${COMP_WORDS[COMP_CWORD-1]};
6897 case "$prev" in
6898 -@(A|-autobackup))
6899 COMPREPLY=($( compgen -W 'y n' -- "$cur" ));
6900 return 0
6901 ;;
6902 esac;
6903 if [[ "$cur" == -* ]]; then
6904 COMPREPLY=($( compgen -W '-A --autobackup -d --debug -h --help -l \
6905 --list -t --test -v --verbose --version' -- "$cur" ));
6906 else
6907 _volumegroups;
6908 fi
6909}
6910_vgmknodes ()
6911{
6912 local cur;
6913 COMPREPLY=();
6914 cur=`_get_cword`;
6915 if [[ "$cur" == -* ]]; then
6916 COMPREPLY=($( compgen -W '-d --debug -h --help -v --verbose \
6917 --version' -- "$cur" ));
6918 else
6919 _volumegroups;
6920 fi
6921}
6922_vgport ()
6923{
6924 local cur prev;
6925 COMPREPLY=();
6926 cur=`_get_cword`;
6927 if [[ "$cur" == -* ]]; then
6928 COMPREPLY=($( compgen -W '-a --all -d --debug -h \
6929 -? --help -v --verbose --version' -- "$cur" ));
6930 else
6931 _volumegroups;
6932 fi
6933}
6934_vgreduce ()
6935{
6936 local cur prev;
6937 COMPREPLY=();
6938 cur=`_get_cword`;
6939 prev=${COMP_WORDS[COMP_CWORD-1]};
6940 case "$prev" in
6941 -@(A|-autobackup))
6942 COMPREPLY=($( compgen -W 'y n' -- "$cur" ));
6943 return 0
6944 ;;
6945 esac;
6946 if [[ "$cur" == -* ]]; then
6947 COMPREPLY=($( compgen -W '-a --all -A --autobackup -d \
6948 --debug -h --help --removemissing -t --test -v \
6949 --verbose --version' -- "$cur" ));
6950 else
6951 _args;
6952 if [ $args -eq 0 ]; then
6953 _volumegroups;
6954 else
6955 _physicalvolumes;
6956 fi;
6957 fi
6958}
6959_vgremove ()
6960{
6961 local cur;
6962 COMPREPLY=();
6963 cur=`_get_cword`;
6964 if [[ "$cur" == -* ]]; then
6965 COMPREPLY=($( compgen -W '-d --debug -h --help -t --test \
6966 -v --verbose --version' -- "$cur" ));
6967 else
6968 _volumegroups;
6969 fi
6970}
6971_vgrename ()
6972{
6973 local cur prev;
6974 COMPREPLY=();
6975 cur=`_get_cword`;
6976 prev=${COMP_WORDS[COMP_CWORD-1]};
6977 case "$prev" in
6978 -@(A|-autobackup))
6979 COMPREPLY=($( compgen -W 'y n' -- "$cur" ));
6980 return 0
6981 ;;
6982 esac;
6983 if [[ "$cur" == -* ]]; then
6984 COMPREPLY=($( compgen -W '-A --autobackup -d --debug -h \
6985 -? --help -t --test -v --verbose --version' -- "$cur" ));
6986 else
6987 _volumegroups;
6988 fi
6989}
6990_vgs ()
6991{
6992 local cur prev;
6993 COMPREPLY=();
6994 cur=`_get_cword`;
6995 prev=${COMP_WORDS[COMP_CWORD-1]};
6996 case "$prev" in
6997 -@(o|O|-options|-sort))
6998 COMPREPLY=($( compgen -W 'vg_fmt vg_uuid vg_name \
6999 vg_attr vg_size vg_free vg_sysid \
7000 vg_extent_size vg_extent_count vg_free_count \
7001 max_lv max_pv pv_count lv_count snap_count \
7002 vg_seqno' -- "$cur" ));
7003 return 0
7004 ;;
7005 --units)
7006 _units;
7007 return 0
7008 ;;
7009 esac;
7010 if [[ "$cur" == -* ]]; then
7011 COMPREPLY=($( compgen -W '--aligned -d --debug \
7012 -h --help --ignorelockingfailure --noheadings \
7013 --nosuffix -o --options -O --sort -P --partial \
7014 --separator --unbuffered --units \
7015 -v --verbose --version' -- "$cur" ));
7016 else
7017 _volumegroups;
7018 fi
7019}
7020_vgscan ()
7021{
7022 local cur;
7023 COMPREPLY=();
7024 cur=`_get_cword`;
7025 if [[ "$cur" == -* ]]; then
7026 COMPREPLY=($( compgen -W '-d --debug -h --help \
7027 --ignorelockingfailure --mknodes -P \
7028 --partial -v --verbose --version' -- "$cur" ));
7029 fi
7030}
7031_vgsplit ()
7032{
7033 local cur prev;
7034 COMPREPLY=();
7035 cur=`_get_cword`;
7036 prev=${COMP_WORDS[COMP_CWORD-1]};
7037 case "$prev" in
7038 -@(A|-autobackup))
7039 COMPREPLY=($( compgen -W 'y n' -- "$cur" ));
7040 return 0
7041 ;;
7042 -@(M|-metadatatype))
7043 COMPREPLY=($( compgen -W '1 2' -- "$cur" ));
7044 return 0
7045 ;;
7046 esac;
7047 if [[ "$cur" == -* ]]; then
7048 COMPREPLY=($( compgen -W '-A --autobackup -d --debug \
7049 -h --help -l --list -M --metadatatype -t --test \
7050 -v --verbose --version' -- "$cur" ));
7051 else
7052 _args;
7053 if [ $args -eq 0 -o $args -eq 1 ]; then
7054 _volumegroups;
7055 else
7056 _physicalvolumes;
7057 fi;
7058 fi
7059}
7060_vipw ()
7061{
7062 local cur prev;
7063 COMPREPLY=();
7064 cur=`_get_cword`;
7065 prev=${COMP_WORDS[COMP_CWORD-1]};
7066 case "$prev" in
7067 -h | --help)
7068 return 0
7069 ;;
7070 esac;
7071 if [[ "$cur" == -* ]]; then
7072 COMPREPLY=($( compgen -W '-g --group -h --help -p --passwd \
7073 -q --quiet -s --shadow' -- "$cur" ));
7074 return 0;
7075 fi
7076}
7077_volumegroups ()
7078{
7079 COMPREPLY=($(compgen -W "$( vgscan 2>/dev/null | sed -n -e 's|.*Found.*"\(.*\)".*$|\1|p' )" -- "$cur" ))
7080}
7081_xhost ()
7082{
7083 local cur=`_get_cword`;
7084 case "$cur" in
7085 +*)
7086 _known_hosts_real -p+ "${cur:1}"
7087 ;;
7088 -*)
7089 _known_hosts_real -p- "${cur:1}"
7090 ;;
7091 *)
7092 _known_hosts_real "$cur"
7093 ;;
7094 esac;
7095 return 0
7096}
7097_xmllint ()
7098{
7099 local cur prev;
7100 COMPREPLY=();
7101 cur=`_get_cword`;
7102 prev=${COMP_WORDS[COMP_CWORD-1]};
7103 case "$prev" in
7104 -o | --output)
7105 _filedir;
7106 return 0
7107 ;;
7108 --path | --dtdvalidfpi | --maxmem | --encode | --pattern)
7109 return 0
7110 ;;
7111 --dtdvalid)
7112 _filedir dtd;
7113 return 0
7114 ;;
7115 --relaxng)
7116 _filedir rng;
7117 return 0
7118 ;;
7119 --schema)
7120 _filedir xsd;
7121 return 0
7122 ;;
7123 --schematron)
7124 _filedir sch;
7125 return 0
7126 ;;
7127 esac;
7128 if [[ "$cur" == -* ]]; then
7129 COMPREPLY=($( compgen -W '$( xmllint --help 2>&1 | \
7130 sed -ne "s/^[[:space:]]*\(--[^[:space:]:]*\).*/\1/p" ) \
7131 -o' -- "$cur" ));
7132 return 0;
7133 fi;
7134 _filedir '@(*ml|htm|svg)'
7135}
7136_xmlwf ()
7137{
7138 local cur prev;
7139 COMPREPLY=();
7140 cur=`_get_cword`;
7141 prev=${COMP_WORDS[COMP_CWORD-1]};
7142 case "$prev" in
7143 -d)
7144 _filedir -d;
7145 return 0
7146 ;;
7147 -e)
7148 COMPREPLY=($( compgen -W 'US-ASCII UTF-8 UTF-16 \
7149 ISO-8859-1' -- "$cur" ));
7150 return 0
7151 ;;
7152 esac;
7153 if [[ "$cur" == -* ]]; then
7154 COMPREPLY=($( compgen -W '-c -d -e -m -n -p -r -s -t -v -w \
7155 -x' -- "$cur" ));
7156 return 0;
7157 fi;
7158 _filedir '@(*ml|htm|svg)'
7159}
7160_xrandr ()
7161{
7162 local cur prev output modes;
7163 COMPREPLY=();
7164 cur=`_get_cword`;
7165 prev=${COMP_WORDS[COMP_CWORD-1]};
7166 case "$prev" in
7167 --output)
7168 local outputs=$(xrandr|grep 'connected'|awk '{print $1}');
7169 COMPREPLY=($(compgen -W "$outputs" -- "$cur"));
7170 return 0
7171 ;;
7172 --mode)
7173 for ((i = 1; i < COMP_CWORD; i++ ))
7174 do
7175 if [[ "${COMP_WORDS[i]}" == "--output" ]]; then
7176 output=${COMP_WORDS[i+1]};
7177 break;
7178 fi;
7179 done;
7180 modes=$(xrandr|sed -e "1,/$output/ d" -e "/connected/,$ d"|awk '{print $1}');
7181 COMPREPLY=($( compgen -W "$modes" -- "$cur"));
7182 return 0
7183 ;;
7184 esac;
7185 case "$cur" in
7186 *)
7187 COMPREPLY=($(compgen -W '-d -display -help -o \
7188 --orientation -q --query -s --size\
7189 -r --rate -v --version -x -y --screen \
7190 --verbose --dryrun --prop --fb \
7191 --fbmm --dpi --output --auto --mode \
7192 --preferred --pos --reflect --rotate \
7193 --left-of --right-of --above --below \
7194 --same-as --set --off --crtc --newmode \
7195 --rmmode --addmode --delmode' -- "$cur"));
7196 return 0
7197 ;;
7198 esac;
7199 return 0
7200}
7201_xz ()
7202{
7203 COMPREPLY=();
7204 local cur=`_get_cword`;
7205 local prev=${COMP_WORDS[COMP_CWORD-1]};
7206 if [[ "$cur" == -* ]]; then
7207 COMPREPLY=($( compgen -W '-z --compress -d --decompress \
7208 -t --test -l --list -k --keep -f --force -c --stdout \
7209 -S --suffix --files --files0 -F --format -C --check \
7210 -0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -M --memory --lzma1 \
7211 --lzma2 --x86 --powerpc --ia64 --arm --armthumb \
7212 --sparc --delta -q --quiet -v --verbose -h --help \
7213 -H --long-help -V --version' -- "$cur" ));
7214 return 0;
7215 fi;
7216 local split=false;
7217 _split_longopt && split=true;
7218 local xspec="*.@(xz|lzma)";
7219 case "$prev" in
7220 -@(!(-*)[dlt]*|-decompress|-list|-test))
7221 xspec="!"$xspec
7222 ;;
7223 --files | --files0)
7224 _filedir;
7225 return 0
7226 ;;
7227 -C | --check)
7228 COMPREPLY=($( compgen -W 'crc32 crc64 sha256' -- "$cur" ));
7229 return 0
7230 ;;
7231 -F | --format)
7232 COMPREPLY=($( compgen -W 'auto xz lzma raw' -- "$cur" ));
7233 return 0
7234 ;;
7235 -M | --memory | -S | --suffix | --delta | --lzma1 | --lzma2)
7236 return 0
7237 ;;
7238 -h | --help | -H | --long-help | -V | --version)
7239 return 0
7240 ;;
7241 esac;
7242 $split && return 0;
7243 _expand || return 0;
7244 local IFS='
7245';
7246 COMPREPLY=($( compgen -f -X "$xspec" -- "$cur" ) $( compgen -d -- "$cur" ))
7247}
7248_xzdec ()
7249{
7250 COMPREPLY=();
7251 local cur=`_get_cword`;
7252 local prev=${COMP_WORDS[COMP_CWORD-1]};
7253 if [[ "$cur" == -* ]]; then
7254 COMPREPLY=($( compgen -W '-M --memory -h --help -V --version' -- "$cur" ));
7255 return 0;
7256 fi;
7257 local split=false;
7258 _split_longopt && split=true;
7259 case "$prev" in
7260 -M | --memory)
7261 return 0
7262 ;;
7263 -h | --help | -V | --version)
7264 return 0
7265 ;;
7266 esac;
7267 $split && return 0;
7268 _filedir xz
7269}
7270dequote ()
7271{
7272 eval echo "$1" 2> /dev/null
7273}
7274quote ()
7275{
7276 echo \'${1//\'/\'\\\'\'}\'
7277}
7278quote_readline ()
7279{
7280 if [ -n "$bash4" ]; then
7281 echo "${1}";
7282 return;
7283 fi;
7284 local t="${1//\\/\\\\}";
7285 echo \'${t//\'/\'\\\'\'}\'
7286}
7287rem_selected ()
7288{
7289 COMPREPLY=($(echo "${COMP_WORDS[@]}" | (while read -d ' ' i; do
7290 [ "${i}" == "" ] && continue
7291 # flatten array with spaces on either side,
7292 # otherwise we cannot grep on word boundaries of
7293 # first and last word
7294 COMPREPLY=" ${COMPREPLY[@]} "
7295 # remove word from list of completions
7296 COMPREPLY=(${COMPREPLY/ ${i%% *} / })
7297 done
7298 echo ${COMPREPLY[@]})));
7299 return 0
7300}