API tools faq
paste
Guest User

Untitled

a guest
May 23rd, 2017
624
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 230.97 KB | None | 0 0
raw download clone embed print report
  1. BASH=/bin/bash
  2. BASHOPTS=checkwinsize:cmdhist:expand_aliases:extglob:extquote:force_fignore:histappend:interactive_comments:login_shell:progcomp:promptvars:sourcepath
  3. BASH_ALIASES=()
  4. BASH_ARGC=()
  5. BASH_ARGV=()
  6. BASH_CMDS=()
  7. BASH_COMPLETION=/etc/bash_completion
  8. BASH_COMPLETION_COMPAT_DIR=/etc/bash_completion.d
  9. BASH_COMPLETION_DIR=/etc/bash_completion.d
  10. BASH_LINENO=()
  11. BASH_SOURCE=()
  12. BASH_VERSINFO=([0]="4" [1]="1" [2]="5" [3]="2" [4]="release" [5]="i686-pc-linux-gnu")
  13. BASH_VERSION='4.1.5(2)-release'
  14. COLUMNS=80
  15. DIRSTACK=()
  16. EUID=1000
  17. GROUPS=()
  18. G_BROKEN_FILENAMES=1
  19. HISTCONTROL=ignoreboth
  20. HISTFILE=/home/mgtd/.bash_history
  21. HISTFILESIZE=1000
  22. HISTSIZE=1000
  23. HOME=/home/mgtd
  24. HOSTNAME=chakrabox
  25. HOSTTYPE=i686
  26. HUSHLOGIN=FALSE
  27. IFS=$' \t\n'
  28. INPUTRC=/etc/inputrc
  29. LANG=de_DE.utf8
  30. LESS=-R
  31. LINES=25
  32. LOGNAME=mgtd
  33. MACHTYPE=i686-pc-linux-gnu
  34. MAIL=/var/spool/mail/mgtd
  35. MAILCHECK=60
  36. MOZ_PLUGIN_PATH=/usr/lib/mozilla/plugins
  37. OPTERR=1
  38. OPTIND=1
  39. OSTYPE=linux-gnu
  40. PATH=/bin:/usr/bin:/sbin:/usr/sbin:/usr/bin/perlbin/site:/usr/bin/perlbin/vendor:/usr/bin/perlbin/core
  41. PIPESTATUS=([0]="1")
  42. PKG_CONFIG_PATH=/usr/lib/pkgconfig
  43. PPID=3631
  44. PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\$ '
  45. PS2='> '
  46. PS3='> '
  47. PS4='+ '
  48. PWD=/home/mgtd
  49. SHELL=/bin/bash
  50. SHELLOPTS=braceexpand:emacs:hashall:histexpand:history:interactive-comments:monitor
  51. SHLVL=1
  52. TERM=linux
  53. UID=1000
  54. USER=mgtd
  55. XDG_CACHE_HOME=/home/mgtd/.cache
  56. XDG_CONFIG_DIRS=/etc/xdg
  57. XDG_CONFIG_HOME=/home/mgtd/.config
  58. XDG_DATA_DIRS=/usr/share:/usr/local/share
  59. XDG_DATA_HOME=/home/mgtd/.local/share
  60. _=']'
  61. bash205='4.1.5(2)-release'
  62. bash205b='4.1.5(2)-release'
  63. bash3='4.1.5(2)-release'
  64. bash4='4.1.5(2)-release'
  65. shell=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. }
  7270. dequote ()
  7271. {
  7272. eval echo "$1" 2> /dev/null
  7273. }
  7274. quote ()
  7275. {
  7276. echo \'${1//\'/\'\\\'\'}\'
  7277. }
  7278. quote_readline ()
  7279. {
  7280. if [ -n "$bash4" ]; then
  7281. echo "${1}";
  7282. return;
  7283. fi;
  7284. local t="${1//\\/\\\\}";
  7285. echo \'${t//\'/\'\\\'\'}\'
  7286. }
  7287. rem_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. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!