API tools faq
paste
Guest User

Untitled

a guest
Feb 8th, 2011
586
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 288.53 KB | None | 0 0
raw download clone embed print report
  1. 1,2d0
  2. < # bash_completion - programmable completion functions for bash 3.x
  3. < # (backwards compatible with bash 2.05b)
  4. 4c2
  5. < # $Id: bash_completion,v 1.872 2006/03/01 16:20:18 ianmacd Exp $
  6. ---
  7. > # bash_completion - programmable completion functions for bash 3.2+
  8. 6c4,6
  9. < # Copyright (C) Ian Macdonald <[email protected]>
  10. ---
  11. > # Copyright © 2006-2008, Ian Macdonald <[email protected]>
  12. > # © 2009-2010, Bash Completion Maintainers
  13. > # <[email protected]>
  14. 24c24
  15. < # http://www.caliban.org/bash/index.shtml#completion
  16. ---
  17. > # http://bash-completion.alioth.debian.org/
  18. 26c26
  19. < # RELEASE: 20060301
  20. ---
  21. > # RELEASE: 1.1
  22. 28c28,38
  23. < [ -n "${BASH_COMPLETION_DEBUG:-}" ] && set -v || set +v
  24. ---
  25. > if [[ $- == *v* ]]; then
  26. > BASH_COMPLETION_ORIGINAL_V_VALUE="-v"
  27. > else
  28. > BASH_COMPLETION_ORIGINAL_V_VALUE="+v"
  29. > fi
  30. >
  31. > if [[ -n $BASH_COMPLETION_DEBUG ]]; then
  32. > set -v
  33. > else
  34. > set +v
  35. > fi
  36. 34c44,45
  37. < readonly BASH_COMPLETION BASH_COMPLETION_DIR
  38. ---
  39. > [ -n "$BASH_COMPLETION_COMPAT_DIR" ] || BASH_COMPLETION_COMPAT_DIR=/etc/bash_completion.d
  40. > readonly BASH_COMPLETION BASH_COMPLETION_DIR BASH_COMPLETION_COMPAT_DIR
  41. 41d51
  42. < RELEASE=$( uname -r )
  43. 43,62c53,56
  44. < # features supported by bash 2.05 and higher
  45. < if [ ${BASH_VERSINFO[0]} -eq 2 ] && [[ ${BASH_VERSINFO[1]} > 04 ]] ||
  46. < [ ${BASH_VERSINFO[0]} -gt 2 ]; then
  47. < declare -r bash205=$BASH_VERSION 2>/dev/null || :
  48. < default="-o default"
  49. < dirnames="-o dirnames"
  50. < filenames="-o filenames"
  51. < fi
  52. < # features supported by bash 2.05b and higher
  53. < if [ ${BASH_VERSINFO[0]} -eq 2 ] && [[ ${BASH_VERSINFO[1]} = "05b" ]] ||
  54. < [ ${BASH_VERSINFO[0]} -gt 2 ]; then
  55. < declare -r bash205b=$BASH_VERSION 2>/dev/null || :
  56. < nospace="-o nospace"
  57. < fi
  58. < # features supported by bash 3.0 and higher
  59. < if [ ${BASH_VERSINFO[0]} -gt 2 ]; then
  60. < declare -r bash3=$BASH_VERSION 2>/dev/null || :
  61. < bashdefault="-o bashdefault"
  62. < plusdirs="-o plusdirs"
  63. < fi
  64. ---
  65. > case ${UNAME} in
  66. > Linux|GNU|GNU/*) USERLAND=GNU ;;
  67. > *) USERLAND=${UNAME} ;;
  68. > esac
  69. 77,78c71,73
  70. < complete -f -X '!*.?(t)bz?(2)' bunzip2 bzcat bzcmp bzdiff bzegrep bzfgrep bzgrep
  71. < complete -f -X '!*.@(zip|ZIP|jar|JAR|exe|EXE|pk3|war|wsz|ear|zargo|xpi|sxw|ott)' unzip zipinfo
  72. ---
  73. > # bzcmp, bzdiff, bz*grep, bzless, bzmore intentionally not here, see Debian: #455510
  74. > complete -f -X '!*.?(t)bz?(2)' bunzip2 bzcat pbunzip2 pbzcat
  75. > complete -f -X '!*.@(zip|ZIP|[ejw]ar|[EJW]AR|exe|EXE|pk3|wsz|zargo|xpi|sxw|o[tx]t|od[fgpst]|epub)' unzip zipinfo
  76. 80c75,76
  77. < complete -f -X '!*.@(Z|gz|tgz|Gz|dz)' gunzip zcmp zdiff zcat zegrep zfgrep zgrep zless zmore
  78. ---
  79. > # zcmp, zdiff, z*grep, zless, zmore intentionally not here, see Debian: #455510
  80. > complete -f -X '!*.@(Z|[gGd]z|t[ag]z)' gunzip zcat unpigz
  81. 82c78,81
  82. < complete -f -X '!*.@(gif|jp?(e)g|miff|tif?(f)|pn[gm]|p[bgp]m|bmp|xpm|ico|xwd|tga|pcx|GIF|JP?(E)G|MIFF|TIF?(F)|PN[GM]|P[BGP]M|BMP|XPM|ICO|XWD|TGA|PCX)' ee display
  83. ---
  84. > # lzcmp, lzdiff intentionally not here, see Debian: #455510
  85. > complete -f -X '!*.lzma' lzcat lzegrep lzfgrep lzgrep lzless lzmore unlzma
  86. > complete -f -X '!*.@(xz|lzma)' unxz xzcat
  87. > complete -f -X '!*.@(gif|jp?(e)g|miff|tif?(f)|pn[gm]|p[bgp]m|bmp|xpm|ico|xwd|tga|pcx|GIF|JP?(E)G|MIFF|TIF?(F)|PN[GM]|P[BGP]M|BMP|XPM|ICO|XWD|TGA|PCX)' ee
  88. 86c85
  89. < complete -f -X '!*.@(dvi|DVI)?(.@(gz|bz2))' kdvi
  90. ---
  91. > complete -f -X '!*.@(dvi|DVI)?(.@(gz|Z|bz2))' kdvi
  92. 90,91c89,91
  93. < complete -f -X '!*.@(@(?(e)ps|?(E)PS|pdf|PDF)?(.gz|.GZ)|cb(r|z)|CB(R|Z)|djv?(u)|DJV?(U)||dvi|DVI|gif|jp?(e)g|miff|tif?(f)|pn[gm]|p[bgp]m|bmp|xpm|ico|xwd|tga|pcx|GIF|JP?(E)G|MIFF|TIF?(F)|PN[GM]|P[BGP]M|BMP|XPM|ICO|XWD|TGA|PCX)' evince
  94. < complete -f -X '!*.@(?(e)ps|?(E)PS)' ps2pdf
  95. ---
  96. > complete -f -X '!*.@(@(?(e)ps|?(E)PS|pdf|PDF|dvi|DVI)?(.gz|.GZ|.bz2|.BZ2)|cb[rz]|CB[RZ]|djv?(u)|DJV?(U)|dvi|DVI|gif|jp?(e)g|miff|tif?(f)|pn[gm]|p[bgp]m|bmp|xpm|ico|xwd|tga|pcx|GIF|JP?(E)G|MIFF|TIF?(F)|PN[GM]|P[BGP]M|BMP|XPM|ICO|XWD|TGA|PCX|fdf|FDF)' evince
  97. > complete -f -X '!*.@(okular|@(?(e|x)ps|?(E|X)PS|pdf|PDF|dvi|DVI|cb[rz]|CB[RZ]|djv?(u)|DJV?(U)|dvi|DVI|gif|jp?(e)g|miff|tif?(f)|pn[gm]|p[bgp]m|bmp|xpm|ico|xwd|tga|pcx|GIF|JP?(E)G|MIFF|TIF?(F)|PN[GM]|P[BGP]M|BMP|XPM|ICO|XWD|TGA|PCX|epub|EPUB|odt|ODT|fb|FB|mobi|MOBI|g3|G3|chm|CHM|fdf|FDF)?(.?(gz|GZ|bz2|BZ2)))' okular
  98. > complete -f -X '!*.@(?(e)ps|?(E)PS|pdf|PDF)' ps2pdf ps2pdf12 ps2pdf13 ps2pdf14 ps2pdfwr
  99. 93c93
  100. < complete -f -X '!*.@(?(la)tex|?(LA)TEX|texi|TEXI|dtx|DTX|ins|INS)' tex latex slitex jadetex pdfjadetex pdftex pdflatex texi2dvi
  101. ---
  102. > complete -f -X '!*.@(?(la)tex|?(LA)TEX|texi|TEXI|dtx|DTX|ins|INS|ltx|LTX)' tex latex slitex jadetex pdfjadetex pdftex pdflatex texi2dvi
  103. 95c95
  104. < complete -f -X '!*.@(mp?(e)g|MP?(E)G|wma|avi|AVI|asf|vob|VOB|bin|dat|divx|DIVX|vcd|ps|pes|fli|flv|FLV|viv|rm|ram|yuv|mov|MOV|qt|QT|wmv|mp3|MP3|m4p|M4P|m4v|M4V|ogg|OGG|ogm|OGM|mp4|MP4|wav|WAV|asx|ASX|mng|MNG|srt)' xine aaxine fbxine kaffeine
  105. ---
  106. > complete -f -X '!*@(.@(mp?(e)g|MP?(E)G|wma|avi|AVI|asf|vob|VOB|bin|dat|divx|DIVX|vcd|ps|pes|fli|flv|FLV|fxm|FXM|viv|rm|ram|yuv|mov|MOV|qt|QT|wmv|mp[234]|MP[234]|m4[pv]|M4[PV]|mkv|MKV|og[gmv]|OG[GMV]|t[ps]|T[PS]|wav|WAV|flac|FLAC|asx|ASX|mng|MNG|srt|m[eo]d|M[EO]D|s[3t]m|S[3T]M|it|IT|xm|XM)|+([0-9]).@(vdr|VDR))' xine aaxine fbxine kaffeine dragon
  107. 102,106c102,106
  108. < complete -f -X '!*.@(mid?(i)|MID?(I))' playmidi
  109. < complete -f -X '!*.@(mid?(i)|MID?(I)|rmi|RMI|rcp|RCP|[gr]36|[GR]36|g18|G18|mod|MOD|xm|XM|it|IT|x3m|X3M)' timidity
  110. < complete -f -X '*.@(o|so|so.!(conf)|a|rpm|gif|GIF|jp?(e)g|JP?(E)G|mp3|MP3|mp?(e)g|MPG|avi|AVI|asf|ASF|ogg|OGG|class|CLASS)' vi vim gvim rvim view rview rgvim rgview gview
  111. < complete -f -X '*.@(o|so|so.!(conf)|a|rpm|gif|GIF|jp?(e)g|JP?(E)G|mp3|MP3|mp?(e)g|MPG|avi|AVI|asf|ASF|ogg|OGG|class|CLASS)' emacs
  112. < complete -f -X '!*.@(exe|EXE|com|COM|scr|SCR|exe.so)' wine
  113. ---
  114. > complete -f -X '!*.@(mid?(i)|MID?(I)|cmf|CMF)' playmidi
  115. > complete -f -X '!*.@(mid?(i)|MID?(I)|rmi|RMI|rcp|RCP|[gr]36|[GR]36|g18|G18|mod|MOD|xm|XM|it|IT|x3m|X3M|s[3t]m|S[3T]M|kar|KAR)' timidity
  116. > complete -f -X '!*.@(m[eo]d|M[EO]D|s[3t]m|S[3T]M|xm|XM|it|IT)' modplugplay modplug123
  117. > complete -f -X '*.@(o|so|so.!(conf)|a|rpm|gif|GIF|jp?(e)g|JP?(E)G|mp3|MP3|mp?(e)g|MPG|avi|AVI|asf|ASF|ogg|OGG|class|CLASS)' vi vim gvim rvim view rview rgvim rgview gview emacs xemacs sxemacs kate kwrite
  118. > complete -f -X '!*.@([eE][xX][eE]?(.[sS][oO])|[cC][oO][mM]|[sS][cC][rR])' wine
  119. 108,111c108,112
  120. < complete -f -X '!*.@(?([xX]|[sS])[hH][tT][mM]?([lL]))' netscape mozilla lynx opera galeon curl dillo elinks amaya
  121. < complete -f -X '!*.@(sxw|stw|sxg|sgl|doc|dot|rtf|txt|htm|html|odt|ott|odm)' oowriter
  122. < complete -f -X '!*.@(sxi|sti|pps|ppt|pot|odp|otp)' ooimpress
  123. < complete -f -X '!*.@(sxc|stc|xls|xlw|xlt|csv|ods|ots)' oocalc
  124. ---
  125. > # konqueror not here on purpose, it's more than a web/html browser
  126. > complete -f -X '!*.@(?([xX]|[sS])[hH][tT][mM]?([lL]))' netscape mozilla lynx opera galeon dillo elinks amaya firefox mozilla-firefox iceweasel google-chrome chromium-browser epiphany
  127. > complete -f -X '!*.@(sxw|stw|sxg|sgl|doc?([mx])|dot?([mx])|rtf|txt|htm|html|odt|ott|odm)' oowriter
  128. > complete -f -X '!*.@(sxi|sti|pps?(x)|ppt?([mx])|pot?([mx])|odp|otp)' ooimpress
  129. > complete -f -X '!*.@(sxc|stc|xls?([bmx])|xlw|xlt?([mx])|[ct]sv|ods|ots)' oocalc
  130. 115a117,125
  131. > complete -f -X '!*.s@(qlite?(3)|?(3)db)' sqlite3
  132. > complete -f -X '!*.aux' bibtex
  133. > complete -f -X '!*.po' poedit gtranslator kbabel lokalize
  134. > complete -f -X '!*.@([Pp][Rr][Gg]|[Cc][Ll][Pp])' harbour gharbour hbpp
  135. > complete -f -X '!*.[Hh][Rr][Bb]' hbrun
  136. > complete -f -X '!*.ly' lilypond ly2dvi
  137. > complete -f -X '!*.@(dif?(f)|?(d)patch)?(.@([gx]z|bz2|lzma))' cdiff
  138. > complete -f -X '!*.@(dif?(f)|?(d)patch)' kompare
  139. > complete -f -X '!*.lyx' lyx
  140. 121,124c131
  141. < complete -u su usermod userdel passwd chage write chfn groups slay w sux
  142. <
  143. < # group commands see only groups
  144. < [ -n "$bash205" ] && complete -g groupmod groupdel newgrp 2>/dev/null
  145. ---
  146. > complete -u su passwd write chfn groups slay w sux
  147. 127c134
  148. < complete -A stopped -P '%' bg
  149. ---
  150. > complete -A stopped -P '"%' -S '"' bg
  151. 130c137
  152. < complete -j -P '%' fg jobs disown
  153. ---
  154. > complete -j -P '"%' -S '"' fg jobs disown
  155. 163,165c170,174
  156. < unset -v have
  157. < PATH=$PATH:/sbin:/usr/sbin:/usr/local/sbin type $1 &>/dev/null &&
  158. < have="yes"
  159. ---
  160. > unset -v have
  161. > # Completions for system administrator commands are installed as well in
  162. > # case completion is attempted via `sudo command ...'.
  163. > PATH=$PATH:/sbin:/usr/sbin:/usr/local/sbin type $1 &>/dev/null &&
  164. > have="yes"
  165. 168,171d176
  166. < # use GNU sed if we have it, since its extensions are still used in our code
  167. < #
  168. < [ $UNAME != Linux ] && have gsed && alias sed=gsed
  169. <
  170. 175c180
  171. < _rl_enabled()
  172. ---
  173. > _rl_enabled()
  174. 180c185,373
  175. < # Get the word to complete
  176. ---
  177. > # This function shell-quotes the argument
  178. > quote()
  179. > {
  180. > echo \'${1//\'/\'\\\'\'}\' #'# Help vim syntax highlighting
  181. > }
  182. >
  183. > # @see _quote_readline_by_ref()
  184. > quote_readline()
  185. > {
  186. > local quoted
  187. > _quote_readline_by_ref "$1" ret
  188. > printf %s "$ret"
  189. > } # quote_readline()
  190. >
  191. >
  192. > # This function shell-dequotes the argument
  193. > dequote()
  194. > {
  195. > eval echo "$1" 2> /dev/null
  196. > }
  197. >
  198. >
  199. > # Assign variable one scope above the caller
  200. > # Usage: local "$1" && _upvar $1 "value(s)"
  201. > # Param: $1 Variable name to assign value to
  202. > # Param: $* Value(s) to assign. If multiple values, an array is
  203. > # assigned, otherwise a single value is assigned.
  204. > # NOTE: For assigning multiple variables, use '_upvars'. Do NOT
  205. > # use multiple '_upvar' calls, since one '_upvar' call might
  206. > # reassign a variable to be used by another '_upvar' call.
  207. > # See: http://fvue.nl/wiki/Bash:_Passing_variables_by_reference
  208. > _upvar() {
  209. > if unset -v "$1"; then # Unset & validate varname
  210. > if (( $# == 2 )); then
  211. > eval $1=\"\$2\" # Return single value
  212. > else
  213. > eval $1=\(\"\${@:2}\"\) # Return array
  214. > fi
  215. > fi
  216. > }
  217. >
  218. >
  219. > # Assign variables one scope above the caller
  220. > # Usage: local varname [varname ...] &&
  221. > # _upvars [-v varname value] | [-aN varname [value ...]] ...
  222. > # Available OPTIONS:
  223. > # -aN Assign next N values to varname as array
  224. > # -v Assign single value to varname
  225. > # Return: 1 if error occurs
  226. > # See: http://fvue.nl/wiki/Bash:_Passing_variables_by_reference
  227. > _upvars() {
  228. > if ! (( $# )); then
  229. > echo "${FUNCNAME[0]}: usage: ${FUNCNAME[0]} [-v varname"\
  230. > "value] | [-aN varname [value ...]] ..." 1>&2
  231. > return 2
  232. > fi
  233. > while (( $# )); do
  234. > case $1 in
  235. > -a*)
  236. > # Error checking
  237. > [[ ${1#-a} ]] || { echo "bash: ${FUNCNAME[0]}: \`$1': missing"\
  238. > "number specifier" 1>&2; return 1; }
  239. > printf %d "${1#-a}" &> /dev/null || { echo "bash:"\
  240. > "${FUNCNAME[0]}: \`$1': invalid number specifier" 1>&2
  241. > return 1; }
  242. > # Assign array of -aN elements
  243. > [[ "$2" ]] && unset -v "$2" && eval $2=\(\"\${@:3:${1#-a}}\"\) &&
  244. > shift $((${1#-a} + 2)) || { echo "bash: ${FUNCNAME[0]}:"\
  245. > "\`$1${2+ }$2': missing argument(s)" 1>&2; return 1; }
  246. > ;;
  247. > -v)
  248. > # Assign single value
  249. > [[ "$2" ]] && unset -v "$2" && eval $2=\"\$3\" &&
  250. > shift 3 || { echo "bash: ${FUNCNAME[0]}: $1: missing"\
  251. > "argument(s)" 1>&2; return 1; }
  252. > ;;
  253. > *)
  254. > echo "bash: ${FUNCNAME[0]}: $1: invalid option" 1>&2
  255. > return 1 ;;
  256. > esac
  257. > done
  258. > }
  259. >
  260. >
  261. > # Reassemble command line words, excluding specified characters from the
  262. > # list of word completion separators (COMP_WORDBREAKS).
  263. > # @param $1 chars Characters out of $COMP_WORDBREAKS which should
  264. > # NOT be considered word breaks. This is useful for things like scp where
  265. > # we want to return host:path and not only path, so we would pass the
  266. > # colon (:) as $1 here.
  267. > # @param $2 words Name of variable to return words to
  268. > # @param $3 cword Name of variable to return cword to
  269. > #
  270. > __reassemble_comp_words_by_ref() {
  271. > local exclude i j ref
  272. > # Exclude word separator characters?
  273. > if [[ $1 ]]; then
  274. > # Yes, exclude word separator characters;
  275. > # Exclude only those characters, which were really included
  276. > exclude="${1//[^$COMP_WORDBREAKS]}"
  277. > fi
  278. >
  279. > # Default to cword unchanged
  280. > eval $3=$COMP_CWORD
  281. > # Are characters excluded which were former included?
  282. > if [[ $exclude ]]; then
  283. > # Yes, list of word completion separators has shrunk;
  284. > # Re-assemble words to complete
  285. > for (( i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do
  286. > # Is current word not word 0 (the command itself) and is word not
  287. > # empty and is word made up of just word separator characters to be
  288. > # excluded?
  289. > while [[ $i -gt 0 && ${COMP_WORDS[$i]} &&
  290. > ${COMP_WORDS[$i]//[^$exclude]} == ${COMP_WORDS[$i]}
  291. > ]]; do
  292. > [ $j -ge 2 ] && ((j--))
  293. > # Append word separator to current word
  294. > ref="$2[$j]"
  295. > eval $2[$j]=\${!ref}\${COMP_WORDS[i]}
  296. > # Indicate new cword
  297. > [ $i = $COMP_CWORD ] && eval $3=$j
  298. > # Indicate next word if available, else end *both* while and for loop
  299. > (( $i < ${#COMP_WORDS[@]} - 1)) && ((i++)) || break 2
  300. > done
  301. > # Append word to current word
  302. > ref="$2[$j]"
  303. > eval $2[$j]=\${!ref}\${COMP_WORDS[i]}
  304. > # Indicate new cword
  305. > [ $i = $COMP_CWORD ] && [[ ${COMP_WORDS[i]} ]] && eval $3=$j
  306. > done
  307. > else
  308. > # No, list of word completions separators hasn't changed;
  309. > eval $2=\( \"\${COMP_WORDS[@]}\" \)
  310. > fi
  311. > } # __reassemble_comp_words_by_ref()
  312. >
  313. >
  314. > # @param $1 exclude Characters out of $COMP_WORDBREAKS which should NOT be
  315. > # considered word breaks. This is useful for things like scp where
  316. > # we want to return host:path and not only path, so we would pass the
  317. > # colon (:) as $1 in this case. Bash-3 doesn't do word splitting, so this
  318. > # ensures we get the same word on both bash-3 and bash-4.
  319. > # @param $2 words Name of variable to return words to
  320. > # @param $3 cword Name of variable to return cword to
  321. > # @param $4 cur Name of variable to return current word to complete to
  322. > # @see ___get_cword_at_cursor_by_ref()
  323. > __get_cword_at_cursor_by_ref() {
  324. > local cword words=()
  325. > __reassemble_comp_words_by_ref "$1" words cword
  326. >
  327. > local i cur2
  328. > local cur="$COMP_LINE"
  329. > local index="$COMP_POINT"
  330. > for (( i = 0; i <= cword; ++i )); do
  331. > while [[
  332. > # Current word fits in $cur?
  333. > "${#cur}" -ge ${#words[i]} &&
  334. > # $cur doesn't match cword?
  335. > "${cur:0:${#words[i]}}" != "${words[i]}"
  336. > ]]; do
  337. > # Strip first character
  338. > cur="${cur:1}"
  339. > # Decrease cursor position
  340. > ((index--))
  341. > done
  342. >
  343. > # Does found word matches cword?
  344. > if [[ "$i" -lt "$cword" ]]; then
  345. > # No, cword lies further;
  346. > local old_size="${#cur}"
  347. > cur="${cur#${words[i]}}"
  348. > local new_size="${#cur}"
  349. > index=$(( index - old_size + new_size ))
  350. > fi
  351. > done
  352. >
  353. > if [[ "${words[cword]:0:${#cur}}" != "$cur" ]]; then
  354. > # We messed up. At least return the whole word so things keep working
  355. > cur2=${words[cword]}
  356. > else
  357. > cur2=${cur:0:$index}
  358. > fi
  359. >
  360. > local "$2" "$3" "$4" &&
  361. > _upvars -a${#words[@]} $2 "${words[@]}" -v $3 "$cword" -v $4 "$cur2"
  362. > }
  363. >
  364. >
  365. > # Get the word to complete and optional previous words.
  366. 185,189c378,457
  367. < # it will complete just "foo", not "foobar", which is what the user wants.)
  368. < #
  369. < # Accepts an optional parameter indicating which characters out of
  370. < # $COMP_WORDBREAKS should NOT be considered word breaks. This is useful
  371. < # for things like scp where we want to return host:path and not only path.
  372. ---
  373. > # Also one is able to cross over possible wordbreak characters.
  374. > # Usage: _get_comp_words_by_ref [OPTIONS] [VARNAMES]
  375. > # Available VARNAMES:
  376. > # cur Return cur via $cur
  377. > # prev Return prev via $prev
  378. > # words Return words via $words
  379. > # cword Return cword via $cword
  380. > #
  381. > # Available OPTIONS:
  382. > # -n EXCLUDE Characters out of $COMP_WORDBREAKS which should NOT be
  383. > # considered word breaks. This is useful for things like scp
  384. > # where we want to return host:path and not only path, so we
  385. > # would pass the colon (:) as -n option in this case. Bash-3
  386. > # doesn't do word splitting, so this ensures we get the same
  387. > # word on both bash-3 and bash-4.
  388. > # -c VARNAME Return cur via $VARNAME
  389. > # -p VARNAME Return prev via $VARNAME
  390. > # -w VARNAME Return words via $VARNAME
  391. > # -i VARNAME Return cword via $VARNAME
  392. > #
  393. > # Example usage:
  394. > #
  395. > # $ _get_comp_words_by_ref -n : cur prev
  396. > #
  397. > _get_comp_words_by_ref()
  398. > {
  399. > local exclude flag i OPTIND=1
  400. > local cur cword words=()
  401. > local upargs=() upvars=() vcur vcword vprev vwords
  402. >
  403. > while getopts "c:i:n:p:w:" flag "$@"; do
  404. > case $flag in
  405. > c) vcur=$OPTARG ;;
  406. > i) vcword=$OPTARG ;;
  407. > n) exclude=$OPTARG ;;
  408. > p) vprev=$OPTARG ;;
  409. > w) vwords=$OPTARG ;;
  410. > esac
  411. > done
  412. > while [[ $# -ge $OPTIND ]]; do
  413. > case ${!OPTIND} in
  414. > cur) vcur=cur ;;
  415. > prev) vprev=prev ;;
  416. > cword) vcword=cword ;;
  417. > words) vwords=words ;;
  418. > *) echo "bash: $FUNCNAME(): \`${!OPTIND}': unknown argument" \
  419. > 1>&2; return 1
  420. > esac
  421. > let "OPTIND += 1"
  422. > done
  423. >
  424. > __get_cword_at_cursor_by_ref "$exclude" words cword cur
  425. >
  426. > [[ $vcur ]] && { upvars+=("$vcur" ); upargs+=(-v $vcur "$cur" ); }
  427. > [[ $vcword ]] && { upvars+=("$vcword"); upargs+=(-v $vcword "$cword"); }
  428. > [[ $vprev ]] && { upvars+=("$vprev" ); upargs+=(-v $vprev
  429. > "${words[cword - 1]}"); }
  430. > [[ $vwords ]] && { upvars+=("$vwords"); upargs+=(-a${#words[@]} $vwords
  431. > "${words[@]}"); }
  432. >
  433. > (( ${#upvars[@]} )) && local "${upvars[@]}" && _upvars "${upargs[@]}"
  434. > }
  435. >
  436. >
  437. > # Get the word to complete.
  438. > # This is nicer than ${COMP_WORDS[$COMP_CWORD]}, since it handles cases
  439. > # where the user is completing in the middle of a word.
  440. > # (For example, if the line is "ls foobar",
  441. > # and the cursor is here --------> ^
  442. > # @param $1 string Characters out of $COMP_WORDBREAKS which should NOT be
  443. > # considered word breaks. This is useful for things like scp where
  444. > # we want to return host:path and not only path, so we would pass the
  445. > # colon (:) as $1 in this case. Bash-3 doesn't do word splitting, so this
  446. > # ensures we get the same word on both bash-3 and bash-4.
  447. > # @param $2 integer Index number of word to return, negatively offset to the
  448. > # current word (default is 0, previous is 1), respecting the exclusions
  449. > # given at $1. For example, `_get_cword "=:" 1' returns the word left of
  450. > # the current word, respecting the exclusions "=:".
  451. > # @deprecated Use `_get_comp_words_by_ref cur' instead
  452. > # @see _get_comp_words_by_ref()
  453. 192,210c460,504
  454. < local i
  455. < local WORDBREAKS=${COMP_WORDBREAKS}
  456. < if [ -n $1 ]; then
  457. < for (( i=0; i<${#1}; ++i )); do
  458. < local char=${1:$i:1}
  459. < WORDBREAKS=${WORDBREAKS//$char/}
  460. < done
  461. < fi
  462. < local cur=${COMP_LINE:0:$COMP_POINT}
  463. < local tmp="${cur}"
  464. < local word_start=`expr "$tmp" : '.*['"${WORDBREAKS}"']'`
  465. < while [ "$word_start" -ge 2 ]; do
  466. < local char=${cur:$(( $word_start - 2 )):1}
  467. < if [ "$char" != "\\" ]; then
  468. < break
  469. < fi
  470. < tmp=${COMP_LINE:0:$(( $word_start - 2 ))}
  471. < word_start=`expr "$tmp" : '.*['"${WORDBREAKS}"']'`
  472. < done
  473. ---
  474. > local LC_CTYPE=C
  475. > local cword words
  476. > __reassemble_comp_words_by_ref "$1" words cword
  477. >
  478. > # return previous word offset by $2
  479. > if [[ ${2//[^0-9]/} ]]; then
  480. > printf "%s" "${words[cword-$2]}"
  481. > elif [[ "${#words[cword]}" -eq 0 ]] || [[ "$COMP_POINT" == "${#COMP_LINE}" ]]; then
  482. > printf "%s" "${words[cword]}"
  483. > else
  484. > local i
  485. > local cur="$COMP_LINE"
  486. > local index="$COMP_POINT"
  487. > for (( i = 0; i <= cword; ++i )); do
  488. > while [[
  489. > # Current word fits in $cur?
  490. > "${#cur}" -ge ${#words[i]} &&
  491. > # $cur doesn't match cword?
  492. > "${cur:0:${#words[i]}}" != "${words[i]}"
  493. > ]]; do
  494. > # Strip first character
  495. > cur="${cur:1}"
  496. > # Decrease cursor position
  497. > ((index--))
  498. > done
  499. >
  500. > # Does found word matches cword?
  501. > if [[ "$i" -lt "$cword" ]]; then
  502. > # No, cword lies further;
  503. > local old_size="${#cur}"
  504. > cur="${cur#${words[i]}}"
  505. > local new_size="${#cur}"
  506. > index=$(( index - old_size + new_size ))
  507. > fi
  508. > done
  509. >
  510. > if [[ "${words[cword]:0:${#cur}}" != "$cur" ]]; then
  511. > # We messed up! At least return the whole word so things
  512. > # keep working
  513. > printf "%s" "${words[cword]}"
  514. > else
  515. > printf "%s" "${cur:0:$index}"
  516. > fi
  517. > fi
  518. > } # _get_cword()
  519. 213,214c507,518
  520. < cur=${cur:$word_start}
  521. < echo $cur
  522. ---
  523. > # Get word previous to the current word.
  524. > # This is a good alternative to `prev=${COMP_WORDS[COMP_CWORD-1]}' because bash4
  525. > # will properly return the previous word with respect to any given exclusions to
  526. > # COMP_WORDBREAKS.
  527. > # @deprecated Use `_get_comp_words_by_ref cur prev' instead
  528. > # @see _get_comp_words_by_ref()
  529. > #
  530. > _get_pword()
  531. > {
  532. > if [ $COMP_CWORD -ge 1 ]; then
  533. > _get_cword "${@:-}" 1;
  534. > fi
  535. 217a522,595
  536. > # If the word-to-complete contains a colon (:), left-trim COMPREPLY items with
  537. > # word-to-complete.
  538. > # On bash-3, and bash-4 with a colon in COMP_WORDBREAKS, words containing
  539. > # colons are always completed as entire words if the word to complete contains
  540. > # a colon. This function fixes this, by removing the colon-containing-prefix
  541. > # from COMPREPLY items.
  542. > # The preferred solution is to remove the colon (:) from COMP_WORDBREAKS in
  543. > # your .bashrc:
  544. > #
  545. > # # Remove colon (:) from list of word completion separators
  546. > # COMP_WORDBREAKS=${COMP_WORDBREAKS//:}
  547. > #
  548. > # See also: Bash FAQ - E13) Why does filename completion misbehave if a colon
  549. > # appears in the filename? - http://tiswww.case.edu/php/chet/bash/FAQ
  550. > # @param $1 current word to complete (cur)
  551. > # @modifies global array $COMPREPLY
  552. > #
  553. > __ltrim_colon_completions() {
  554. > # If word-to-complete contains a colon,
  555. > # and bash-version < 4,
  556. > # or bash-version >= 4 and COMP_WORDBREAKS contains a colon
  557. > if [[
  558. > "$1" == *:* && (
  559. > ${BASH_VERSINFO[0]} -lt 4 ||
  560. > (${BASH_VERSINFO[0]} -ge 4 && "$COMP_WORDBREAKS" == *:*)
  561. > )
  562. > ]]; then
  563. > # Remove colon-word prefix from COMPREPLY items
  564. > local colon_word=${1%${1##*:}}
  565. > local i=${#COMPREPLY[*]}
  566. > while [ $((--i)) -ge 0 ]; do
  567. > COMPREPLY[$i]=${COMPREPLY[$i]#"$colon_word"}
  568. > done
  569. > fi
  570. > } # __ltrim_colon_completions()
  571. >
  572. >
  573. > # This function quotes the argument in a way so that readline dequoting
  574. > # results in the original argument. This is necessary for at least
  575. > # `compgen' which requires its arguments quoted/escaped:
  576. > #
  577. > # $ ls "a'b/"
  578. > # c
  579. > # $ compgen -f "a'b/" # Wrong, doesn't return output
  580. > # $ compgen -f "a\'b/" # Good (bash-4)
  581. > # a\'b/c
  582. > # $ compgen -f "a\\\\\'b/" # Good (bash-3)
  583. > # a\'b/c
  584. > #
  585. > # See also: http://lists.gnu.org/archive/html/bug-bash/2009-03/msg00155.html
  586. > # @param $1 Argument to quote
  587. > # @param $2 Name of variable to return result to
  588. > _quote_readline_by_ref()
  589. > {
  590. > if [[ ${1:0:1} == "'" ]]; then
  591. > # Quote word, leaving out first character
  592. > printf -v $2 %q "${1:1}"
  593. > if [[ ${BASH_VERSINFO[0]} -le 3 ]]; then
  594. > # Double-quote word on bash-3
  595. > printf -v $2 %q ${!2}
  596. > fi
  597. > elif [[ ${BASH_VERSINFO[0]} -le 3 && ${1:0:1} == '"' ]]; then
  598. > printf -v $2 %q "${1:1}"
  599. > else
  600. > printf -v $2 %q "$1"
  601. > fi
  602. >
  603. > # If result becomes quoted like this: $'string', re-evaluate in order to
  604. > # drop the additional quoting. See also: http://www.mail-archive.com/
  605. > # [email protected]/msg01942.html
  606. > [[ ${!2:0:1} == '$' ]] && eval $2=${!2}
  607. > } # _quote_readline_by_ref()
  608. >
  609. >
  610. 220,221c598,599
  611. < # If passed -d, it completes only on directories. If passed anything else,
  612. < # it's assumed to be a file glob to complete on.
  613. ---
  614. > # @param $1 If `-d', complete only on directories. Otherwise filter/pick only
  615. > # completions with `.$1' as file extension.
  616. 225c603,688
  617. < local IFS=$'\t\n' xspec #glob
  618. ---
  619. > local i IFS=$'\t\n' xspec
  620. >
  621. > __expand_tilde_by_ref cur
  622. >
  623. > local -a toks
  624. > local quoted tmp
  625. >
  626. > _quote_readline_by_ref "$cur" quoted
  627. > toks=( ${toks[@]-} $(
  628. > compgen -d -- "$quoted" | {
  629. > while read -r tmp; do
  630. > # TODO: I have removed a "[ -n $tmp ] &&" before 'printf ..',
  631. > # and everything works again. If this bug suddenly
  632. > # appears again (i.e. "cd /b<TAB>" becomes "cd /"),
  633. > # remember to check for other similar conditionals (here
  634. > # and _filedir_xspec()). --David
  635. > printf '%s\n' $tmp
  636. > done
  637. > }
  638. > ))
  639. >
  640. > # On bash-3, special characters need to be escaped extra. This is
  641. > # unless the first character is a single quote ('). If the single
  642. > # quote appears further down the string, bash default completion also
  643. > # fails, e.g.:
  644. > #
  645. > # $ ls 'a&b/'
  646. > # f
  647. > # $ foo 'a&b/<TAB> # Becomes: foo 'a&b/f'
  648. > # $ foo a'&b/<TAB> # Nothing happens
  649. > #
  650. > if [[ "$1" != -d ]]; then
  651. > xspec=${1:+"!*.$1"}
  652. > if [[ ${cur:0:1} == "'" && ${BASH_VERSINFO[0]} -ge 4 ]]; then
  653. > toks=( ${toks[@]-} $(
  654. > eval compgen -f -X \"\$xspec\" -- $quoted
  655. > ) )
  656. > else
  657. > toks=( ${toks[@]-} $(
  658. > compgen -f -X "$xspec" -- $quoted
  659. > ) )
  660. > fi
  661. > if [ ${#toks[@]} -ne 0 ]; then
  662. > # If `compopt' is available, set `-o filenames'
  663. > compopt &>/dev/null && compopt -o filenames ||
  664. > # No, `compopt' isn't available;
  665. > # Is `-o filenames' set?
  666. > [[ (
  667. > ${COMP_WORDS[0]} &&
  668. > "$(complete -p ${COMP_WORDS[0]})" == *"-o filenames"*
  669. > ) ]] || {
  670. > # No, `-o filenames' isn't set;
  671. > # Emulate `-o filenames'
  672. > # NOTE: A side-effect of emulating `-o filenames' is that
  673. > # backslash escape characters are visible within the list
  674. > # of presented completions, e.g. the completions look
  675. > # like:
  676. > #
  677. > # $ foo a<TAB>
  678. > # a\ b/ a\$b/
  679. > #
  680. > # whereas with `-o filenames' active the completions look
  681. > # like:
  682. > #
  683. > # $ ls a<TAB>
  684. > # a b/ a$b/
  685. > #
  686. > for ((i=0; i < ${#toks[@]}; i++)); do
  687. > # If directory exists, append slash (/)
  688. > if [[ ${cur:0:1} != "'" ]]; then
  689. > [[ -d ${toks[i]} ]] && toks[i]="${toks[i]}"/
  690. > if [[ ${cur:0:1} == '"' ]]; then
  691. > toks[i]=${toks[i]//\\/\\\\}
  692. > toks[i]=${toks[i]//\"/\\\"}
  693. > toks[i]=${toks[i]//\$/\\\$}
  694. > else
  695. > toks[i]=$(printf %q ${toks[i]})
  696. > fi
  697. > fi
  698. > done
  699. > }
  700. > fi
  701. > fi
  702. >
  703. > COMPREPLY=( "${COMPREPLY[@]}" "${toks[@]}" )
  704. > } # _filedir()
  705. 227d689
  706. < _expand || return 0
  707. 229,230c691,703
  708. < #glob=$(set +o|grep noglob) # save glob setting.
  709. < #set -f # disable pathname expansion (globbing)
  710. ---
  711. > # This function splits $cur=--foo=bar into $prev=--foo, $cur=bar, making it
  712. > # easier to support both "--foo bar" and "--foo=bar" style completions.
  713. > # Returns 0 if current option was split, 1 otherwise.
  714. > #
  715. > _split_longopt()
  716. > {
  717. > if [[ "$cur" == --?*=* ]]; then
  718. > # Cut also backslash before '=' in case it ended up there
  719. > # for some reason.
  720. > prev="${cur%%?(\\)=*}"
  721. > cur="${cur#*=}"
  722. > return 0
  723. > fi
  724. 232,241c705,714
  725. < if [ "${1:-}" = -d ]; then
  726. < COMPREPLY=( ${COMPREPLY[@]:-} $( compgen -d -- $cur ) )
  727. < #eval "$glob" # restore glob setting.
  728. < return 0
  729. < fi
  730. <
  731. < xspec=${1:+"!*.$1"} # set only if glob passed in as $1
  732. < COMPREPLY=( ${COMPREPLY[@]:-} $( compgen -f -X "$xspec" -- "$cur" ) \
  733. < $( compgen -d -- "$cur" ) )
  734. < #eval "$glob" # restore glob setting.
  735. ---
  736. > return 1
  737. > }
  738. >
  739. > # This function tries to parse the output of $command --help
  740. > #
  741. > _parse_help() {
  742. > local cmd
  743. > cmd=$1
  744. > $cmd --help 2>&1 | command grep -- "^[[:space:]]*-" | tr "," " " | \
  745. > awk '{print $1; if ($2 ~ /-.*/) { print $2 } }' | sed -e "s:=.*::g"
  746. 248c721,738
  747. < local i
  748. ---
  749. > local i
  750. >
  751. > # standard signal completion is rather braindead, so we need
  752. > # to hack around to get what we want here, which is to
  753. > # complete on a dash, followed by the signal name minus
  754. > # the SIG prefix
  755. > COMPREPLY=( $( compgen -A signal SIG${cur#-} ))
  756. > for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
  757. > COMPREPLY[i]=-${COMPREPLY[i]#SIG}
  758. > done
  759. > }
  760. >
  761. > # This function completes on known mac addresses
  762. > #
  763. > _mac_addresses()
  764. > {
  765. > local re='\([A-Fa-f0-9]\{2\}:\)\{5\}[A-Fa-f0-9]\{2\}'
  766. > local PATH="$PATH:/sbin:/usr/sbin"
  767. 250,257c740,750
  768. < # standard signal completion is rather braindead, so we need
  769. < # to hack around to get what we want here, which is to
  770. < # complete on a dash, followed by the signal name minus
  771. < # the SIG prefix
  772. < COMPREPLY=( $( compgen -A signal SIG${cur#-} ))
  773. < for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
  774. < COMPREPLY[i]=-${COMPREPLY[i]#SIG}
  775. < done
  776. ---
  777. > # Local interfaces (Linux only?)
  778. > COMPREPLY=( "${COMPREPLY[@]}" $( ifconfig -a 2>/dev/null | sed -ne \
  779. > "s/.*[[:space:]]HWaddr[[:space:]]\{1,\}\($re\)[[:space:]]*$/\1/p" ) )
  780. >
  781. > # ARP cache
  782. > COMPREPLY=( "${COMPREPLY[@]}" $( arp -an 2>/dev/null | sed -ne \
  783. > "s/.*[[:space:]]\($re\)[[:space:]].*/\1/p" -ne \
  784. > "s/.*[[:space:]]\($re\)[[:space:]]*$/\1/p" ) )
  785. >
  786. > COMPREPLY=( $( compgen -W '${COMPREPLY[@]}' -- "$cur" ) )
  787. > __ltrim_colon_completions "$cur"
  788. 264,283c757,783
  789. < if [ -f /etc/debian_version ]; then
  790. < # Debian system
  791. < COMPREPLY=( $( sed -ne 's|^iface \([^ ]\+\).*$|\1|p' \
  792. < /etc/network/interfaces ) )
  793. < elif [ -f /etc/SuSE-release ]; then
  794. < # SuSE system
  795. < COMPREPLY=( $( command ls \
  796. < /etc/sysconfig/network/ifcfg-* | \
  797. < sed -ne 's|.*ifcfg-\('$cur'.*\)|\1|p' ) )
  798. < elif [ -f /etc/pld-release ]; then
  799. < # PLD Linux
  800. < COMPREPLY=( $( command ls -B \
  801. < /etc/sysconfig/interfaces | \
  802. < sed -ne 's|.*ifcfg-\('$cur'.*\)|\1|p' ) )
  803. < else
  804. < # Assume Red Hat
  805. < COMPREPLY=( $( command ls \
  806. < /etc/sysconfig/network-scripts/ifcfg-* | \
  807. < sed -ne 's|.*ifcfg-\('$cur'.*\)|\1|p' ) )
  808. < fi
  809. ---
  810. > if [ -f /etc/debian_version ]; then
  811. > # Debian system
  812. > COMPREPLY=( $( compgen -W "$( sed -ne 's|^iface \([^ ]\{1,\}\).*$|\1|p'\
  813. > /etc/network/interfaces )" -- "$cur" ) )
  814. > elif [ -f /etc/SuSE-release ]; then
  815. > # SuSE system
  816. > COMPREPLY=( $( compgen -W "$( printf '%s\n' \
  817. > /etc/sysconfig/network/ifcfg-* | \
  818. > sed -ne 's|.*ifcfg-\(.*\)|\1|p' )" -- "$cur" ) )
  819. > elif [ -f /etc/pld-release ]; then
  820. > # PLD Linux
  821. > COMPREPLY=( $( compgen -W "$( command ls -B \
  822. > /etc/sysconfig/interfaces | \
  823. > sed -ne 's|.*ifcfg-\(.*\)|\1|p' )" -- "$cur" ) )
  824. > else
  825. > # Assume Red Hat
  826. > COMPREPLY=( $( compgen -W "$( printf '%s\n' \
  827. > /etc/sysconfig/network-scripts/ifcfg-* | \
  828. > sed -ne 's|.*ifcfg-\(.*\)|\1|p' )" -- "$cur" ) )
  829. > fi
  830. > }
  831. >
  832. > # This function completes on available kernels
  833. > #
  834. > _kernel_versions()
  835. > {
  836. > COMPREPLY=( $( compgen -W '$( command ls /lib/modules )' -- "$cur" ) )
  837. 292c792
  838. < local cmd
  839. ---
  840. > local cmd
  841. 294,300c794,800
  842. < if [ "${1:-}" = -w ]; then
  843. < cmd="iwconfig"
  844. < elif [ "${1:-}" = -a ]; then
  845. < cmd="ifconfig"
  846. < else
  847. < cmd="ifconfig -a"
  848. < fi
  849. ---
  850. > if [ "${1:-}" = -w ]; then
  851. > cmd="iwconfig"
  852. > elif [ "${1:-}" = -a ]; then
  853. > cmd="ifconfig"
  854. > else
  855. > cmd="ifconfig -a"
  856. > fi
  857. 302,303c802,804
  858. < COMPREPLY=( $( eval $cmd 2>/dev/null | \
  859. < sed -ne 's|^\('$cur'[^[:space:][:punct:]]\{1,\}\).*$|\1|p') )
  860. ---
  861. > COMPREPLY=( $( eval PATH="$PATH:/sbin" $cmd 2>/dev/null | \
  862. > awk '/^[^ \t]/ { print $1 }' ) )
  863. > COMPREPLY=( $( compgen -W '${COMPREPLY[@]/%[[:punct:]]/}' -- "$cur" ) )
  864. 305a807,846
  865. >
  866. > # Expand variable starting with tilde (~)
  867. > # Only the first portion of the variable from the tilde up to the first slash
  868. > # (~../) is expanded. The remainder of the variable, containing for example
  869. > # a dollar sign variable ($) or asterisk (*) is not expanded.
  870. > # Example usage:
  871. > #
  872. > # $ v="~"; __expand_tilde_by_ref v; echo "$v"
  873. > #
  874. > # Example output:
  875. > #
  876. > # v output
  877. > # -------- ----------------
  878. > # ~ /home/user
  879. > # ~foo/bar /home/foo/bar
  880. > # ~foo/$HOME /home/foo/$HOME
  881. > # ~foo/a b /home/foo/a b
  882. > # ~foo/* /home/foo/*
  883. > #
  884. > # @param $1 Name of variable (not the value of the variable) to expand
  885. > __expand_tilde_by_ref() {
  886. > # Does $1 start with tilde (~)?
  887. > if [ "${!1:0:1}" = "~" ]; then
  888. > # Does $1 contain slash (/)?
  889. > if [ "${!1}" != "${!1//\/}" ]; then
  890. > # Yes, $1 contains slash;
  891. > # 1: Remove * including and after first slash (/), i.e. "~a/b"
  892. > # becomes "~a". Double quotes allow eval.
  893. > # 2: Remove * before the first slash (/), i.e. "~a/b"
  894. > # becomes "b". Single quotes prevent eval.
  895. > # +-----1----+ +---2----+
  896. > eval $1="${!1/%\/*}"/'${!1#*/}'
  897. > else
  898. > # No, $1 doesn't contain slash
  899. > eval $1="${!1}"
  900. > fi
  901. > fi
  902. > } # __expand_tilde_by_ref()
  903. >
  904. >
  905. 310c851,852
  906. < [ "$cur" != "${cur%\\}" ] && cur="$cur\\"
  907. ---
  908. > # FIXME: Why was this here?
  909. > #[ "$cur" != "${cur%\\}" ] && cur="$cur\\"
  910. 312,320c854,865
  911. < # expand ~username type directory specifications
  912. < if [[ "$cur" == \~*/* ]]; then
  913. < eval cur=$cur
  914. <
  915. < elif [[ "$cur" == \~* ]]; then
  916. < cur=${cur#\~}
  917. < COMPREPLY=( $( compgen -P '~' -u $cur ) )
  918. < return ${#COMPREPLY[@]}
  919. < fi
  920. ---
  921. > # Expand ~username type directory specifications. We want to expand
  922. > # ~foo/... to /home/foo/... to avoid problems when $cur starting with
  923. > # a tilde is fed to commands and ending up quoted instead of expanded.
  924. >
  925. > if [[ "$cur" == \~*/* ]]; then
  926. > eval cur=$cur
  927. > elif [[ "$cur" == \~* ]]; then
  928. > cur=${cur#\~}
  929. > COMPREPLY=( $( compgen -P '~' -u "$cur" ) )
  930. > [ ${#COMPREPLY[@]} -eq 1 ] && eval COMPREPLY[0]=${COMPREPLY[0]}
  931. > return ${#COMPREPLY[@]}
  932. > fi
  933. 325c870
  934. < [ $UNAME = SunOS -o $UNAME = AIX ] &&
  935. ---
  936. > [[ $UNAME == SunOS || $UNAME == AIX ]] &&
  937. 328c873
  938. < COMPREPLY=( $( compgen -W '$( command ps -efo pid | sed 1d )' -- $cur ))
  939. ---
  940. > COMPREPLY=( $( compgen -W '$( command ps -efo pid | sed 1d )' -- "$cur" ))
  941. 332c877
  942. < COMPREPLY=( $( compgen -W '$( command ps axo pid | sed 1d )' -- $cur ) )
  943. ---
  944. > COMPREPLY=( $( compgen -W '$( command ps axo pid= )' -- "$cur" ) )
  945. 337c882
  946. < [ $UNAME = SunOS -o $UNAME = AIX ] &&
  947. ---
  948. > [[ $UNAME == SunOS || $UNAME == AIX ]] &&
  949. 340c885
  950. < COMPREPLY=( $( compgen -W '$( command ps -efo pgid | sed 1d )' -- $cur ))
  951. ---
  952. > COMPREPLY=( $( compgen -W '$( command ps -efo pgid | sed 1d )' -- "$cur" ))
  953. 344c889,912
  954. < COMPREPLY=( $( compgen -W '$( command ps axo pgid | sed 1d )' -- $cur ))
  955. ---
  956. > COMPREPLY=( $( compgen -W '$( command ps axo pgid= )' -- "$cur" ))
  957. > }
  958. >
  959. > # This function completes on process names.
  960. > # AIX and SunOS prefer X/Open, all else should be BSD.
  961. > [[ $UNAME == SunOS || $UNAME == AIX ]] &&
  962. > _pnames()
  963. > {
  964. > COMPREPLY=( $( compgen -X '<defunct>' -W '$( command ps -efo comm | \
  965. > sed -e 1d -e "s:.*/::" -e "s/^-//" | sort -u )' -- "$cur" ) )
  966. > } ||
  967. > _pnames()
  968. > {
  969. > # FIXME: completes "[kblockd/0]" to "0". Previously it was completed
  970. > # to "kblockd" which isn't correct either. "kblockd/0" would be
  971. > # arguably most correct, but killall from psmisc 22 treats arguments
  972. > # containing "/" specially unless -r is given so that wouldn't quite
  973. > # work either. Perhaps it'd be best to not complete these to anything
  974. > # for now.
  975. > # Not using "ps axo comm" because under some Linux kernels, it
  976. > # truncates command names (see e.g. http://bugs.debian.org/497540#19)
  977. > COMPREPLY=( $( compgen -X '<defunct>' -W '$( command ps axo command= | \
  978. > sed -e "s/ .*//" -e "s:.*/::" -e "s/:$//" -e "s/^[[(-]//" \
  979. > -e "s/[])]$//" | sort -u )' -- "$cur" ) )
  980. 351,360c919,926
  981. < if type getent &>/dev/null; then
  982. < COMPREPLY=( $( getent passwd | \
  983. < awk -F: '{if ($3 ~ /^'$cur'/) print $3}' ) )
  984. < elif type perl &>/dev/null; then
  985. < COMPREPLY=( $( compgen -W '$( perl -e '"'"'while (($uid) = (getpwent)[2]) { print $uid . "\n" }'"'"' )' -- $cur ) )
  986. < else
  987. < # make do with /etc/passwd
  988. < COMPREPLY=( $( awk 'BEGIN {FS=":"} {if ($3 ~ /^'$cur'/) print $3}'\
  989. < /etc/passwd ) )
  990. < fi
  991. ---
  992. > if type getent &>/dev/null; then
  993. > COMPREPLY=( $( compgen -W '$( getent passwd | cut -d: -f3 )' -- "$cur" ) )
  994. > elif type perl &>/dev/null; then
  995. > COMPREPLY=( $( compgen -W '$( perl -e '"'"'while (($uid) = (getpwent)[2]) { print $uid . "\n" }'"'"' )' -- "$cur" ) )
  996. > else
  997. > # make do with /etc/passwd
  998. > COMPREPLY=( $( compgen -W '$( cut -d: -f3 /etc/passwd )' -- "$cur" ) )
  999. > fi
  1000. 367,376c933,941
  1001. < if type getent &>/dev/null; then
  1002. < COMPREPLY=( $( getent group | \
  1003. < awk -F: '{if ($3 ~ /^'$cur'/) print $3}' ) )
  1004. < elif type perl &>/dev/null; then
  1005. < COMPREPLY=( $( compgen -W '$( perl -e '"'"'while (($gid) = (getgrent)[2]) { print $gid . "\n" }'"'"' )' -- $cur ) )
  1006. < else
  1007. < # make do with /etc/group
  1008. < COMPREPLY=( $( awk 'BEGIN {FS=":"} {if ($3 ~ /^'$cur'/) print $3}'\
  1009. < /etc/group ) )
  1010. < fi
  1011. ---
  1012. > if type getent &>/dev/null; then
  1013. > COMPREPLY=( $( compgen -W '$( getent group | cut -d: -f3 )' \
  1014. > -- "$cur" ) )
  1015. > elif type perl &>/dev/null; then
  1016. > COMPREPLY=( $( compgen -W '$( perl -e '"'"'while (($gid) = (getgrent)[2]) { print $gid . "\n" }'"'"' )' -- "$cur" ) )
  1017. > else
  1018. > # make do with /etc/group
  1019. > COMPREPLY=( $( compgen -W '$( cut -d: -f3 /etc/group )' -- "$cur" ) )
  1020. > fi
  1021. 383,390c948,957
  1022. < local sysvdir famdir
  1023. < [ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d || sysvdir=/etc/init.d
  1024. < famdir=/etc/xinetd.d
  1025. < COMPREPLY=( $( builtin echo $sysvdir/!(*.rpmsave|*.rpmorig|*~|functions)) )
  1026. <
  1027. < if [ -d $famdir ]; then
  1028. < COMPREPLY=( ${COMPREPLY[@]} $( builtin echo $famdir/!(*.rpmsave|*.rpmorig|*~)) )
  1029. < fi
  1030. ---
  1031. > local sysvdir famdir
  1032. > [ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d || sysvdir=/etc/init.d
  1033. > famdir=/etc/xinetd.d
  1034. > COMPREPLY=( $( printf '%s\n' \
  1035. > $sysvdir/!(*.rpm@(orig|new|save)|*~|functions) ) )
  1036. >
  1037. > if [ -d $famdir ]; then
  1038. > COMPREPLY=( "${COMPREPLY[@]}" $( printf '%s\n' \
  1039. > $famdir/!(*.rpm@(orig|new|save)|*~) ) )
  1040. > fi
  1041. 392c959
  1042. < COMPREPLY=( $( compgen -W '${COMPREPLY[@]#@($sysvdir|$famdir)/}' -- $cur ) )
  1043. ---
  1044. > COMPREPLY=( $( compgen -W '${COMPREPLY[@]#@($sysvdir|$famdir)/}' -- "$cur" ) )
  1045. 395c962
  1046. < # This function complete on modules
  1047. ---
  1048. > # This function completes on modules
  1049. 399,402c966,969
  1050. < local modpath
  1051. < modpath=/lib/modules/$1
  1052. < COMPREPLY=( $( command ls -R $modpath | \
  1053. < sed -ne 's/^\('$cur'.*\)\.k\?o\(\|.gz\)$/\1/p') )
  1054. ---
  1055. > local modpath
  1056. > modpath=/lib/modules/$1
  1057. > COMPREPLY=( $( compgen -W "$( command ls -R $modpath | \
  1058. > sed -ne 's/^\(.*\)\.k\{0,1\}o\(\.gz\)\{0,1\}$/\1/p' )" -- "$cur" ) )
  1059. 405c972
  1060. < # this function complete on user:group format
  1061. ---
  1062. > # This function completes on installed modules
  1063. 407c974
  1064. < _usergroup()
  1065. ---
  1066. > _installed_modules()
  1067. 409,418c976,977
  1068. < local IFS=$'\n'
  1069. < cur=${cur//\\\\ / }
  1070. < if [[ $cur = *@(\\:|.)* ]] && [ -n "$bash205" ]; then
  1071. < user=${cur%%*([^:.])}
  1072. < COMPREPLY=( $(compgen -P ${user/\\\\} -g -- ${cur##*[.:]}) )
  1073. < elif [[ $cur = *:* ]] && [ -n "$bash205" ]; then
  1074. < COMPREPLY=( $( compgen -g -- ${cur##*[.:]} ) )
  1075. < else
  1076. < COMPREPLY=( $( compgen -S : -u -- $cur ) )
  1077. < fi
  1078. ---
  1079. > COMPREPLY=( $( compgen -W "$( PATH="$PATH:/sbin" lsmod | \
  1080. > awk '{if (NR != 1) print $1}' )" -- "$1" ) )
  1081. 421c980
  1082. < # this function count the number of mandatory args
  1083. ---
  1084. > # This function completes on user or user:group format; as for chown and cpio.
  1085. 423c982,986
  1086. < _count_args()
  1087. ---
  1088. > # The : must be added manually; it will only complete usernames initially.
  1089. > # The legacy user.group format is not supported.
  1090. > #
  1091. > # It assumes compopt -o filenames; but doesn't touch it.
  1092. > _usergroup()
  1093. 425,558c988,1012
  1094. < args=1
  1095. < for (( i=1; i < COMP_CWORD; i++ )); do
  1096. < if [[ "${COMP_WORDS[i]}" != -* ]]; then
  1097. < args=$(($args+1))
  1098. < fi
  1099. < done
  1100. < }
  1101. <
  1102. < # start of section containing completion functions for bash built-ins
  1103. <
  1104. < # bash alias completion
  1105. < #
  1106. < _alias()
  1107. < {
  1108. < local cur
  1109. <
  1110. < COMPREPLY=()
  1111. < cur=${COMP_WORDS[$COMP_CWORD]}
  1112. <
  1113. < case "$COMP_LINE" in
  1114. < *[^=])
  1115. < COMPREPLY=( $( compgen -A alias -S '=' -- $cur ) )
  1116. < ;;
  1117. < *=)
  1118. < COMPREPLY=( "$( alias ${cur%=} 2>/dev/null | \
  1119. < sed -e 's|^alias '$cur'\(.*\)$|\1|' )" )
  1120. < ;;
  1121. < esac
  1122. < }
  1123. < complete -F _alias $nospace alias
  1124. <
  1125. < # bash export completion
  1126. < #
  1127. < _export()
  1128. < {
  1129. < local cur
  1130. <
  1131. < COMPREPLY=()
  1132. < cur=${COMP_WORDS[$COMP_CWORD]}
  1133. <
  1134. < case "$COMP_LINE" in
  1135. < *=\$*)
  1136. < COMPREPLY=( $( compgen -v -P '$' -- ${cur#*=\$} ) )
  1137. < ;;
  1138. < *[^=])
  1139. < COMPREPLY=( $( compgen -v -S '=' -- $cur ) )
  1140. < ;;
  1141. < *=)
  1142. < COMPREPLY=( "$( eval echo -n \"$`echo ${cur%=}`\" |
  1143. < ( echo -n \'
  1144. < sed -e 's/'\''/'\''\\\'\'''\''/g'
  1145. < echo -n \' ) )" )
  1146. < ;;
  1147. < esac
  1148. < }
  1149. < complete -F _export $default $nospace export
  1150. <
  1151. < # bash shell function completion
  1152. < #
  1153. < _function()
  1154. < {
  1155. < local cur prev
  1156. <
  1157. < COMPREPLY=()
  1158. < cur=`_get_cword`
  1159. < prev=${COMP_WORDS[COMP_CWORD-1]}
  1160. <
  1161. < if [[ $1 == @(declare|typeset) ]]; then
  1162. < if [ "$prev" = -f ]; then
  1163. < COMPREPLY=( $( compgen -A function -- $cur ) )
  1164. < elif [[ "$cur" == -* ]]; then
  1165. < COMPREPLY=( $( compgen -W '-a -f -F -i -r -x -p' -- \
  1166. < $cur ) )
  1167. < fi
  1168. < elif [ $COMP_CWORD -eq 1 ]; then
  1169. < COMPREPLY=( $( compgen -A function -- $cur ) )
  1170. < else
  1171. < COMPREPLY=( "() $( type -- ${COMP_WORDS[1]} | sed -e 1,2d )" )
  1172. < fi
  1173. < }
  1174. < complete -F _function function declare typeset
  1175. <
  1176. < # bash complete completion
  1177. < #
  1178. < _complete()
  1179. < {
  1180. < local cur prev options
  1181. <
  1182. < COMPREPLY=()
  1183. < cur=`_get_cword`
  1184. < prev=${COMP_WORDS[COMP_CWORD-1]}
  1185. <
  1186. < case $prev in
  1187. < -o)
  1188. < options="default dirnames filenames"
  1189. < [ -n "$bash205b" ] && options="$options nospace"
  1190. < [ -n "$bash3" ] && options="$options bashdefault plusdirs"
  1191. < COMPREPLY=( $( compgen -W "$options" -- $cur ) )
  1192. < return 0
  1193. < ;;
  1194. <
  1195. < -A)
  1196. < COMPREPLY=( $( compgen -W 'alias arrayvar binding \
  1197. < builtin command directory disabled enabled \
  1198. < export file function group helptopic hostname \
  1199. < job keyword running service setopt shopt \
  1200. < signal stopped user variable' -- $cur ) )
  1201. < return 0
  1202. < ;;
  1203. <
  1204. < -C)
  1205. < COMPREPLY=( $( compgen -A command -- $cur ) )
  1206. < return 0
  1207. < ;;
  1208. < -F)
  1209. < COMPREPLY=( $( compgen -A function -- $cur ) )
  1210. < return 0
  1211. < ;;
  1212. < -@(p|r))
  1213. < COMPREPLY=( $( complete -p | sed -e 's|.* ||' | \
  1214. < grep "^$cur" ) )
  1215. < return 0
  1216. < ;;
  1217. <
  1218. < esac
  1219. <
  1220. < if [[ "$cur" == -* ]]; then
  1221. < # relevant options completion
  1222. < options="-a -b -c -d -e -f -g -j -k -s -v -u -A -G -W -P -S -X -F -C"
  1223. < [ -n "$bash205" ] && options="$options -o"
  1224. < COMPREPLY=( $( compgen -W "$options" -- $cur ) )
  1225. < else
  1226. < COMPREPLY=( $( compgen -A command -- $cur ) )
  1227. < fi
  1228. ---
  1229. > local IFS=$'\n'
  1230. > if [[ $cur = *\\\\* || $cur = *:*:* ]]; then
  1231. > # Give up early on if something seems horribly wrong.
  1232. > return
  1233. > elif [[ $cur = *\\:* ]]; then
  1234. > # Completing group after 'user\:gr<TAB>'.
  1235. > # Reply with a list of groups prefixed with 'user:', readline will
  1236. > # escape to the colon.
  1237. > local prefix
  1238. > prefix=${cur%%*([^:])}
  1239. > prefix=${prefix//\\}
  1240. > COMPREPLY=( $( compgen -P "$prefix" -g -- "${cur#*[:]}" ) )
  1241. > elif [[ $cur = *:* ]]; then
  1242. > # Completing group after 'user:gr<TAB>'.
  1243. > # Reply with a list of unprefixed groups since readline with split on :
  1244. > # and only replace the 'gr' part
  1245. > COMPREPLY=( $( compgen -g -- "${cur#*:}" ) )
  1246. > else
  1247. > # Completing a partial 'usernam<TAB>'.
  1248. > #
  1249. > # Don't suffix with a : because readline will escape it and add a
  1250. > # slash. It's better to complete into 'chown username ' than 'chown
  1251. > # username\:'.
  1252. > COMPREPLY=( $( compgen -u -- "$cur" ) )
  1253. > fi
  1254. 560,562d1013
  1255. < complete -F _complete complete
  1256. <
  1257. < # start of section containing completion functions for external programs
  1258. 564,2428c1015,1022
  1259. < # a little help for FreeBSD ports users
  1260. < [ $UNAME = FreeBSD ] && complete -W 'index search fetch fetch-list \
  1261. < extract patch configure build install reinstall \
  1262. < deinstall clean clean-depends kernel buildworld' make
  1263. <
  1264. < # This completes on a list of all available service scripts for the
  1265. < # 'service' command and/or the SysV init.d directory, followed by
  1266. < # that script's available commands
  1267. < #
  1268. < { have service || [ -d /etc/init.d/ ]; } &&
  1269. < _service()
  1270. < {
  1271. < local cur sysvdir
  1272. <
  1273. < COMPREPLY=()
  1274. < prev=${COMP_WORDS[COMP_CWORD-1]}
  1275. < cur=`_get_cword`
  1276. <
  1277. < # don't complete for things like killall, ssh and mysql if it's
  1278. < # the standalone command, rather than the init script
  1279. < [[ ${COMP_WORDS[0]} != @(*init.d/!(functions|~)|service) ]] && return 0
  1280. <
  1281. < # don't complete past 2nd token
  1282. < [ $COMP_CWORD -gt 2 ] && return 0
  1283. <
  1284. < [ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d \
  1285. < || sysvdir=/etc/init.d
  1286. <
  1287. < if [[ $COMP_CWORD -eq 1 ]] && [[ $prev == "service" ]]; then
  1288. < _services
  1289. < else
  1290. < COMPREPLY=( $( compgen -W '`sed -ne "y/|/ /; \
  1291. < s/^.*Usage.*{\(.*\)}.*$/\1/p" \
  1292. < $sysvdir/${prev##*/} 2>/dev/null`' -- $cur ) )
  1293. < fi
  1294. <
  1295. < return 0
  1296. < } &&
  1297. < complete -F _service service
  1298. < [ -d /etc/init.d/ ] && complete -F _service $default \
  1299. < $(for i in /etc/init.d/*; do echo ${i##*/}; done)
  1300. <
  1301. < # chown(1) completion
  1302. < #
  1303. < _chown()
  1304. < {
  1305. < local cur
  1306. < cur=`_get_cword`
  1307. <
  1308. < # options completion
  1309. < if [[ "$cur" == -* ]]; then
  1310. < COMPREPLY=( $( compgen -W '-c -h -f -R -v --changes \
  1311. < --dereference --no-dereference --from= --silent --quiet \
  1312. < --reference= --recursive --verbose --help --version' -- $cur ) )
  1313. < else
  1314. < _count_args
  1315. <
  1316. < case $args in
  1317. < 1)
  1318. < _usergroup
  1319. < ;;
  1320. < *)
  1321. < _filedir
  1322. < ;;
  1323. < esac
  1324. < fi
  1325. < }
  1326. < complete -F _chown $filenames chown
  1327. <
  1328. < # chgrp(1) completion
  1329. < #
  1330. < _chgrp()
  1331. < {
  1332. < local cur prev
  1333. <
  1334. < COMPREPLY=()
  1335. < cur=`_get_cword`
  1336. < cur=${cur//\\\\/}
  1337. < prev=${COMP_WORDS[COMP_CWORD-1]}
  1338. <
  1339. < # options completion
  1340. < if [[ "$cur" == -* ]]; then
  1341. < COMPREPLY=( $( compgen -W '-c -h -f -R -v --changes \
  1342. < --dereference --no-dereference --silent --quiet \
  1343. < --reference= --recursive --verbose --help --version' -- $cur ) )
  1344. < return 0
  1345. < fi
  1346. <
  1347. < # first parameter on line or first since an option?
  1348. < if [ $COMP_CWORD -eq 1 ] && [[ "$cur" != -* ]] || \
  1349. < [[ "$prev" == -* ]] && [ -n "$bash205" ]; then
  1350. < local IFS=$'\n'
  1351. < COMPREPLY=( $( compgen -g $cur 2>/dev/null ) )
  1352. < else
  1353. < _filedir || return 0
  1354. < fi
  1355. <
  1356. < return 0
  1357. < }
  1358. < complete -F _chgrp $filenames chgrp
  1359. <
  1360. < # umount(8) completion. This relies on the mount point being the third
  1361. < # space-delimited field in the output of mount(8)
  1362. < #
  1363. < _umount()
  1364. < {
  1365. < local cur
  1366. <
  1367. < COMPREPLY=()
  1368. < cur=`_get_cword`
  1369. <
  1370. < OLDIFS="$IFS"
  1371. < IFS="\n"
  1372. < COMPREPLY=( $( compgen -W '$( mount | cut -d" " -f 3 )' -- $cur ) )
  1373. < IFS="$OLDIFS"
  1374. <
  1375. < return 0
  1376. < }
  1377. < complete -F _umount $dirnames umount
  1378. <
  1379. < # mount(8) completion. This will pull a list of possible mounts out of
  1380. < # /etc/{,v}fstab, unless the word being completed contains a ':', which
  1381. < # would indicate the specification of an NFS server. In that case, we
  1382. < # query the server for a list of all available exports and complete on
  1383. < # that instead.
  1384. < #
  1385. < _mount()
  1386. < { local cur i sm host
  1387. <
  1388. < COMPREPLY=()
  1389. < cur=`_get_cword`
  1390. < [[ "$cur" == \\ ]] && cur="/"
  1391. <
  1392. < for i in {,/usr}/{,s}bin/showmount; do [ -x $i ] && sm=$i && break; done
  1393. <
  1394. < if [ -n "$sm" ] && [[ "$cur" == *:* ]]; then
  1395. < COMPREPLY=( $( $sm -e ${cur%%:*} | sed 1d | \
  1396. < grep ^${cur#*:} | awk '{print $1}' ) )
  1397. < elif [[ "$cur" == //* ]]; then
  1398. < host=${cur#//}
  1399. < host=${host%%/*}
  1400. < if [ -n "$host" ]; then
  1401. < COMPREPLY=( $( compgen -W "$( echo $( smbclient -d 0 -NL $host 2>/dev/null|
  1402. < sed -ne '/^['"$'\t '"']*Sharename/,/^$/p' |
  1403. < sed -ne '3,$s|^[^A-Za-z]*\([^'"$'\t '"']*\).*$|//'$host'/\1|p' ) )" -- "$cur" ) )
  1404. < fi
  1405. < elif [ -r /etc/vfstab ]; then
  1406. < # Solaris
  1407. < COMPREPLY=( $( awk '! /^[ \t]*#/ {if ($3 ~ /\//) print $3}' \
  1408. < /etc/vfstab | grep "^$cur" ) )
  1409. < elif [ ! -e /etc/fstab ]; then
  1410. < # probably Cygwin
  1411. < COMPREPLY=( $( mount | awk '! /^[ \t]*#/ {if ($3 ~ /\//) print $3}' \
  1412. < | grep "^$cur" ) )
  1413. < else
  1414. < # probably Linux
  1415. < COMPREPLY=( $( awk '! /^[ \t]*#/ {if ($2 ~ /\//) print $2}' \
  1416. < /etc/fstab | grep "^$cur" ) )
  1417. < fi
  1418. <
  1419. < return 0
  1420. < }
  1421. < complete -F _mount $default $filenames mount
  1422. <
  1423. < # Linux rmmod(8) completion. This completes on a list of all currently
  1424. < # installed kernel modules.
  1425. < #
  1426. < have rmmod && {
  1427. < _rmmod()
  1428. < {
  1429. < local cur
  1430. <
  1431. < COMPREPLY=()
  1432. < cur=`_get_cword`
  1433. <
  1434. < COMPREPLY=( $( /sbin/lsmod | \
  1435. < awk '{if (NR != 1 && $1 ~ /^'$cur'/) print $1}' 2>/dev/null ))
  1436. < return 0
  1437. < }
  1438. < complete -F _rmmod rmmod
  1439. <
  1440. < # Linux insmod(8), modprobe(8) and modinfo(8) completion. This completes on a
  1441. < # list of all available modules for the version of the kernel currently
  1442. < # running.
  1443. < #
  1444. < _insmod()
  1445. < {
  1446. < local cur prev modpath
  1447. <
  1448. < COMPREPLY=()
  1449. < cur=`_get_cword`
  1450. < prev=${COMP_WORDS[COMP_CWORD-1]}
  1451. <
  1452. < # behave like lsmod for modprobe -r
  1453. < if [ $1 = "modprobe" ] &&
  1454. < [ "${COMP_WORDS[1]}" = "-r" ]; then
  1455. < COMPREPLY=( $( /sbin/lsmod | \
  1456. < awk '{if (NR != 1 && $1 ~ /^'$cur'/) print $1}' ) )
  1457. < return 0
  1458. < fi
  1459. <
  1460. < # do filename completion if we're giving a path to a module
  1461. < if [[ "$cur" == */* ]]; then
  1462. < _filedir '@(?(k)o?(.gz))'
  1463. < return 0
  1464. < fi
  1465. <
  1466. < if [ $COMP_CWORD -gt 1 ] &&
  1467. < [[ "${COMP_WORDS[COMP_CWORD-1]}" != -* ]]; then
  1468. < # do module parameter completion
  1469. < COMPREPLY=( $( /sbin/modinfo -p ${COMP_WORDS[1]} 2>/dev/null | \
  1470. < awk '{if ($1 ~ /^parm:/ && $2 ~ /^'$cur'/) { print $2 } \
  1471. < else if ($1 !~ /:/ && $1 ~ /^'$cur'/) { print $1 }}' ) )
  1472. < else
  1473. < _modules $(uname -r)
  1474. < fi
  1475. <
  1476. < return 0
  1477. < }
  1478. < complete -F _insmod $filenames insmod modprobe modinfo
  1479. < }
  1480. <
  1481. < # man(1) completion
  1482. < #
  1483. < [ $UNAME = GNU -o $UNAME = Linux -o $UNAME = Darwin \
  1484. < -o $UNAME = FreeBSD -o $UNAME = SunOS -o $UNAME = Cygwin \
  1485. < -o $UNAME = OpenBSD ] &&
  1486. < _man()
  1487. < {
  1488. < local cur prev sect manpath UNAME
  1489. <
  1490. < COMPREPLY=()
  1491. < cur=`_get_cword`
  1492. < prev=${COMP_WORDS[COMP_CWORD-1]}
  1493. <
  1494. < _expand || return 0
  1495. <
  1496. < # default completion if parameter contains /
  1497. < if [[ "$cur" == */* ]]; then
  1498. < _filedir
  1499. < return 0
  1500. < fi
  1501. <
  1502. < UNAME=$( uname -s )
  1503. < # strip OS type and version under Cygwin
  1504. < UNAME=${UNAME/CYGWIN_*/Cygwin}
  1505. < if [ $UNAME = GNU -o $UNAME = Linux -o $UNAME = FreeBSD \
  1506. < -o $UNAME = Cygwin ]; then
  1507. < manpath=$( manpath 2>/dev/null || command man --path )
  1508. < else
  1509. < manpath=$MANPATH
  1510. < fi
  1511. <
  1512. < if [ -z "$manpath" ]; then
  1513. < COMPREPLY=( $( compgen -c -- $cur ) )
  1514. < return 0
  1515. < fi
  1516. <
  1517. < # determine manual section to search
  1518. < [[ "$prev" == [0-9ln] ]] && sect=$prev || sect='*'
  1519. <
  1520. < manpath=$manpath:
  1521. < if [ -n "$cur" ]; then
  1522. < manpath="${manpath//://*man$sect/$cur* } ${manpath//://*cat$sect/$cur* }"
  1523. < else
  1524. < manpath="${manpath//://*man$sect/ } ${manpath//://*cat$sect/ }"
  1525. < fi
  1526. <
  1527. < # redirect stderr for when path doesn't exist
  1528. < COMPREPLY=( $( eval command ls "$manpath" 2>/dev/null ) )
  1529. < # weed out directory path names and paths to man pages
  1530. < COMPREPLY=( ${COMPREPLY[@]##*/?(:)} )
  1531. < # strip suffix from man pages
  1532. < COMPREPLY=( ${COMPREPLY[@]%.@(gz|bz2)} )
  1533. < COMPREPLY=( $( compgen -W '${COMPREPLY[@]%.*}' -- "${cur//\\\\/}" ) )
  1534. <
  1535. < [[ "$prev" != [0-9ln] ]] && _filedir '[0-9ln]'
  1536. <
  1537. < return 0
  1538. < }
  1539. < [ $UNAME = GNU -o $UNAME = Linux -o $UNAME = Darwin \
  1540. < -o $UNAME = FreeBSD -o $UNAME = SunOS -o $UNAME = Cygwin \
  1541. < -o $UNAME = OpenBSD ] && \
  1542. < complete -F _man $filenames man apropos whatis
  1543. <
  1544. < # renice(8) completion
  1545. < #
  1546. < _renice()
  1547. < {
  1548. < local command cur curopt i
  1549. <
  1550. < COMPREPLY=()
  1551. < cur=`_get_cword`
  1552. < command=$1
  1553. <
  1554. < i=0
  1555. < # walk back through command line and find last option
  1556. < while [ $i -le $COMP_CWORD -a ${#COMPREPLY[@]} -eq 0 ]; do
  1557. < curopt=${COMP_WORDS[COMP_CWORD-$i]}
  1558. < case "$curopt" in
  1559. < -u)
  1560. < COMPREPLY=( $( compgen -u -- $cur ) )
  1561. < ;;
  1562. < -g)
  1563. < _pgids
  1564. < ;;
  1565. < -p|$command)
  1566. < _pids
  1567. < ;;
  1568. < esac
  1569. < i=$(( ++i ))
  1570. < done
  1571. < }
  1572. < complete -F _renice renice
  1573. <
  1574. < # kill(1) completion
  1575. < #
  1576. < _kill()
  1577. < {
  1578. < local cur
  1579. <
  1580. < COMPREPLY=()
  1581. < cur=`_get_cword`
  1582. <
  1583. < if [ $COMP_CWORD -eq 1 ] && [[ "$cur" == -* ]]; then
  1584. < # return list of available signals
  1585. < _signals
  1586. < else
  1587. < # return list of available PIDs
  1588. < _pids
  1589. < fi
  1590. < }
  1591. < complete -F _kill kill
  1592. <
  1593. < # Linux and FreeBSD killall(1) completion.
  1594. < #
  1595. < [ $UNAME = Linux -o $UNAME = FreeBSD ] &&
  1596. < _killall()
  1597. < {
  1598. < local cur
  1599. <
  1600. < COMPREPLY=()
  1601. < cur=`_get_cword`
  1602. <
  1603. < if [ $COMP_CWORD -eq 1 ] && [[ "$cur" == -* ]]; then
  1604. < _signals
  1605. < else
  1606. < COMPREPLY=( $( compgen -W '$( command ps axo command | \
  1607. < sed -ne "1d; s/^\[\?\([^-][^] ]*\).*$/\1/p" | \
  1608. < sed -e "s/.*\///" )' -- $cur ) )
  1609. < fi
  1610. <
  1611. < return 0
  1612. < }
  1613. < [ $UNAME = Linux -o $UNAME = FreeBSD ] && complete -F _killall killall pkill
  1614. <
  1615. < # Linux and FreeBSD pgrep(1) completion.
  1616. < #
  1617. < [ $UNAME = Linux -o $UNAME = FreeBSD ] &&
  1618. < _pgrep()
  1619. < {
  1620. < local cur
  1621. <
  1622. < COMPREPLY=()
  1623. < cur=`_get_cword`
  1624. <
  1625. < COMPREPLY=( $( compgen -W '$( command ps axo command | \
  1626. < sed -ne "1d; s/^\[\?\([^-][^] ]*\).*$/\1/p" | \
  1627. < sed -e "s/.*\///" )' -- $cur ) )
  1628. <
  1629. < return 0
  1630. < }
  1631. < [ $UNAME = Linux -o $UNAME = FreeBSD ] && complete -F _pgrep pgrep
  1632. < # Linux pidof(8) completion.
  1633. < [ $UNAME = Linux ] && complete -F _pgrep pidof
  1634. <
  1635. < # GNU find(1) completion. This makes heavy use of ksh style extended
  1636. < # globs and contains Linux specific code for completing the parameter
  1637. < # to the -fstype option.
  1638. < #
  1639. < _find()
  1640. < {
  1641. < local cur prev i exprfound onlyonce
  1642. <
  1643. < COMPREPLY=()
  1644. < cur=`_get_cword`
  1645. < prev=${COMP_WORDS[COMP_CWORD-1]}
  1646. <
  1647. < case "$prev" in
  1648. < -@(max|min)depth)
  1649. < COMPREPLY=( $( compgen -W '0 1 2 3 4 5 6 7 8 9' -- $cur ) )
  1650. < return 0
  1651. < ;;
  1652. < -?(a|c)newer|-fls|-fprint?(0|f)|-?(i)?(l)name|-?(i)wholename)
  1653. < _filedir
  1654. < return 0
  1655. < ;;
  1656. < -fstype)
  1657. < # this is highly non-portable
  1658. < [ -e /proc/filesystems ] &&
  1659. < COMPREPLY=( $( cut -d$'\t' -f 2 /proc/filesystems | \
  1660. < grep "^$cur" ) )
  1661. < return 0
  1662. < ;;
  1663. < -gid)
  1664. < _gids
  1665. < return 0
  1666. < ;;
  1667. < -group)
  1668. < if [ -n "$bash205" ]; then
  1669. < COMPREPLY=( $( compgen -g -- $cur 2>/dev/null) )
  1670. < fi
  1671. < return 0
  1672. < ;;
  1673. < -?(x)type)
  1674. < COMPREPLY=( $( compgen -W 'b c d p f l s' -- $cur ) )
  1675. < return 0
  1676. < ;;
  1677. < -uid)
  1678. < _uids
  1679. < return 0
  1680. < ;;
  1681. < -user)
  1682. < COMPREPLY=( $( compgen -u -- $cur ) )
  1683. < return 0
  1684. < ;;
  1685. < -exec|-ok)
  1686. < COMP_WORDS=(COMP_WORDS[0] $cur)
  1687. < COMP_CWORD=1
  1688. < _command
  1689. < return 0
  1690. < ;;
  1691. < -[acm]min|-[acm]time|-?(i)?(l)name|-inum|-?(i)path|-?(i)regex| \
  1692. < -links|-perm|-size|-used|-printf)
  1693. < # do nothing, just wait for a parameter to be given
  1694. < return 0
  1695. < ;;
  1696. < esac
  1697. <
  1698. < _expand || return 0
  1699. <
  1700. < # set exprfound to 1 if there is already an expression present
  1701. < for i in ${COMP_WORDS[@]}; do
  1702. < [[ "$i" = [-\(\),\!]* ]] && exprfound=1 && break
  1703. < done
  1704. <
  1705. < # handle case where first parameter is not a dash option
  1706. < if [ "$exprfound" != 1 ] && [[ "$cur" != [-\(\),\!]* ]]; then
  1707. < _filedir -d
  1708. < return 0
  1709. < fi
  1710. <
  1711. < # complete using basic options
  1712. < COMPREPLY=( $( compgen -W '-daystart -depth -follow -help -maxdepth \
  1713. < -mindepth -mount -noleaf -version -xdev -amin -anewer \
  1714. < -atime -cmin -cnewer -ctime -empty -false -fstype \
  1715. < -gid -group -ilname -iname -inum -ipath -iregex \
  1716. < -wholename \
  1717. < -links -lname -mmin -mtime -name -newer -nouser \
  1718. < -nogroup -perm -regex -size -true -type -uid -used \
  1719. < -user -xtype -exec -fls -fprint -fprint0 -fprintf -ok \
  1720. < -print -print0 -printf -prune -ls' -- $cur ) )
  1721. <
  1722. < # this removes any options from the list of completions that have
  1723. < # already been specified somewhere on the command line, as long as
  1724. < # these options can only be used once (in a word, "options", in
  1725. < # opposition to "tests" and "actions", as in the find(1) manpage).
  1726. < onlyonce=' -daystart -depth -follow -help -maxdepth -mindepth -mount \
  1727. < -noleaf -version -xdev '
  1728. < COMPREPLY=( $( echo "${COMP_WORDS[@]}" | \
  1729. < (while read -d ' ' i; do
  1730. < [ "$i" == "" ] ||
  1731. < [ "${onlyonce/ ${i%% *} / }" == "$onlyonce" ] &&
  1732. < continue
  1733. < # flatten array with spaces on either side,
  1734. < # otherwise we cannot grep on word boundaries of
  1735. < # first and last word
  1736. < COMPREPLY=" ${COMPREPLY[@]} "
  1737. < # remove word from list of completions
  1738. < COMPREPLY=( ${COMPREPLY/ ${i%% *} / } )
  1739. < done
  1740. < echo ${COMPREPLY[@]})
  1741. < ) )
  1742. <
  1743. < _filedir
  1744. <
  1745. < return 0
  1746. < }
  1747. < complete -F _find $filenames find
  1748. <
  1749. < # Linux iwconfig(8) completion
  1750. < #
  1751. < [ $UNAME = Linux ] && have iwconfig &&
  1752. < _iwconfig()
  1753. < {
  1754. < local cur prev
  1755. <
  1756. < COMPREPLY=()
  1757. < cur=`_get_cword`
  1758. < prev=${COMP_WORDS[COMP_CWORD-1]}
  1759. <
  1760. < case $prev in
  1761. < mode)
  1762. < COMPREPLY=( $( compgen -W 'managed ad-hoc master \
  1763. < repeater secondary monitor' -- $cur ) )
  1764. < return 0
  1765. < ;;
  1766. < essid)
  1767. < COMPREPLY=( $( compgen -W 'on off any' -- $cur ) )
  1768. < if [ -n "${COMP_IWLIST_SCAN:-}" ]; then
  1769. < COMPREPLY=( ${COMPREPLY[@]:-} \
  1770. < $( iwlist ${COMP_WORDS[1]} scan | \
  1771. < awk -F '"' '/ESSID/ {print $2}' | \
  1772. < grep "^$cur" ))
  1773. < fi
  1774. < return 0
  1775. < ;;
  1776. < nwid)
  1777. < COMPREPLY=( $( compgen -W 'on off' -- $cur ) )
  1778. < return 0
  1779. < ;;
  1780. < channel)
  1781. < COMPREPLY=( $( iwlist ${COMP_WORDS[1]} channel | \
  1782. < awk '/^[[:space:]]*Channel/ {print $2}' | \
  1783. < grep "^$cur" ) )
  1784. < return 0
  1785. < ;;
  1786. <
  1787. < freq)
  1788. < COMPREPLY=( $( iwlist ${COMP_WORDS[1]} channel | \
  1789. < awk '/^[[:space:]]*Channel/ {print $4"G"}' | \
  1790. < grep "^$cur" ) )
  1791. < return 0
  1792. < ;;
  1793. < ap)
  1794. < COMPREPLY=( $( compgen -W 'on off any' -- $cur ) )
  1795. < if [ -n "${COMP_IWLIST_SCAN:-}" ]; then
  1796. < COMPREPLY=( ${COMPREPLY[@]:-} \
  1797. < $( iwlist ${COMP_WORDS[1]} scan | \
  1798. < awk -F ': ' '/Address/ {print $2}' | \
  1799. < grep "^$cur" ) )
  1800. < fi
  1801. < return 0
  1802. < ;;
  1803. < rate)
  1804. < COMPREPLY=( $( compgen -W 'auto fixed' -- $cur ) )
  1805. < COMPREPLY=( ${COMPREPLY[@]:-} \
  1806. < $( iwlist ${COMP_WORDS[1]} rate | \
  1807. < awk '/^[[:space:]]*[0-9]/ {print $1"M"}' | \
  1808. < grep "^$cur" ) )
  1809. < return 0
  1810. < ;;
  1811. < rts)
  1812. < COMPREPLY=( $( compgen -W 'auto fixed off' -- $cur ) )
  1813. < return 0
  1814. < ;;
  1815. < frag)
  1816. < COMPREPLY=( $( compgen -W 'auto fixed off' -- $cur ) )
  1817. < return 0
  1818. < ;;
  1819. < key)
  1820. < COMPREPLY=( $( compgen -W 'off on open restricted' -- $cur ) )
  1821. < return 0
  1822. < ;;
  1823. < enc)
  1824. < COMPREPLY=( $( compgen -W 'off on open restricted' -- $cur ) )
  1825. < return 0
  1826. < ;;
  1827. < power)
  1828. < COMPREPLY=( $( compgen -W 'period timeout off on' -- $cur ) )
  1829. < return 0
  1830. < ;;
  1831. < txpower)
  1832. < COMPREPLY=( $( compgen -W 'off on auto' -- $cur ) )
  1833. < return 0
  1834. < ;;
  1835. < retry)
  1836. < COMPREPLY=( $( compgen -W 'limit lifetime' -- $cur ) )
  1837. < return 0
  1838. < ;;
  1839. < esac
  1840. <
  1841. < if [ $COMP_CWORD -eq 1 ]; then
  1842. < if [[ "$cur" == -* ]]; then
  1843. < COMPREPLY=( $( compgen -W '--help --version' -- $cur ) )
  1844. < else
  1845. < _available_interfaces -w
  1846. < fi
  1847. < else
  1848. < COMPREPLY=( $( compgen -W 'essid nwid mode freq channel sens mode \
  1849. < ap nick rate rts frag enc key power txpower commit' -- $cur ) )
  1850. < fi
  1851. <
  1852. < } &&
  1853. < complete -F _iwconfig iwconfig
  1854. <
  1855. < # Linux iwlist(8) completion
  1856. < #
  1857. < [ $UNAME = Linux ] && have iwlist &&
  1858. < _iwlist()
  1859. < {
  1860. < local cur prev
  1861. <
  1862. < COMPREPLY=()
  1863. < cur=`_get_cword`
  1864. < prev=${COMP_WORDS[COMP_CWORD-1]}
  1865. <
  1866. < if [ $COMP_CWORD -eq 1 ]; then
  1867. < if [[ "$cur" == -* ]]; then
  1868. < COMPREPLY=( $( compgen -W '--help --version' -- $cur ) )
  1869. < else
  1870. < _available_interfaces -w
  1871. < fi
  1872. < else
  1873. < COMPREPLY=( $( compgen -W 'scan scanning freq frequency \
  1874. < channel rate bit bitrate key enc encryption power \
  1875. < txpower retry ap accesspoint peers event' -- $cur ) )
  1876. < fi
  1877. < } &&
  1878. < complete -F _iwlist iwlist
  1879. <
  1880. < # Linux iwspy(8) completion
  1881. < #
  1882. < [ $UNAME = Linux ] && have iwspy &&
  1883. < _iwspy()
  1884. < {
  1885. < local cur
  1886. <
  1887. < COMPREPLY=()
  1888. < cur=`_get_cword`
  1889. <
  1890. < if [ $COMP_CWORD -eq 1 ]; then
  1891. < if [[ "$cur" == -* ]]; then
  1892. < COMPREPLY=( $( compgen -W '--help --version' -- $cur ) )
  1893. < else
  1894. < _available_interfaces -w
  1895. < fi
  1896. < else
  1897. < COMPREPLY=( $( compgen -W 'setthr getthr off' -- $cur ) )
  1898. < fi
  1899. < } &&
  1900. < complete -F _iwspy iwspy
  1901. <
  1902. < # Linux iwpriv(8) completion
  1903. < #
  1904. < [ $UNAME = Linux ] && have iwpriv &&
  1905. < _iwpriv()
  1906. < {
  1907. < local cur prev
  1908. <
  1909. < COMPREPLY=()
  1910. < cur=`_get_cword`
  1911. < prev=${COMP_WORDS[COMP_CWORD-1]}
  1912. <
  1913. < case "$prev" in
  1914. < roam)
  1915. < COMPREPLY=( $( compgen -W 'on off' -- $cur ) )
  1916. < return 0
  1917. < ;;
  1918. < port)
  1919. < COMPREPLY=( $( compgen -W 'ad-hoc managed' -- $cur ) )
  1920. < return 0
  1921. < ;;
  1922. < esac
  1923. <
  1924. < if [ $COMP_CWORD -eq 1 ]; then
  1925. < if [[ "$cur" == -* ]]; then
  1926. < COMPREPLY=( $( compgen -W '--help --version' -- $cur ) )
  1927. < else
  1928. < _available_interfaces -w
  1929. < fi
  1930. < else
  1931. < COMPREPLY=( $( compgen -W '--all roam port' -- $cur ) )
  1932. < fi
  1933. < } &&
  1934. < complete -F _iwpriv iwpriv
  1935. <
  1936. < # RedHat & Debian GNU/Linux if{up,down} completion
  1937. < #
  1938. < [ $UNAME = Linux ] && { have ifup || have ifdown; } &&
  1939. < _ifupdown()
  1940. < {
  1941. < local cur
  1942. <
  1943. < COMPREPLY=()
  1944. < cur=`_get_cword`
  1945. <
  1946. < if [ $COMP_CWORD -eq 1 ]; then
  1947. < _configured_interfaces
  1948. < COMPREPLY=( $(compgen -W '${COMPREPLY[@]}' -- "$cur") )
  1949. < fi
  1950. <
  1951. < return 0
  1952. < } &&
  1953. < complete -F _ifupdown ifup ifdown
  1954. < [ $UNAME = Linux ] && have ifstatus && complete -F _ifupdown ifstatus
  1955. <
  1956. < # Linux ipsec(8) completion (for FreeS/WAN)
  1957. < #
  1958. < [ $UNAME = Linux ] && have ipsec &&
  1959. < _ipsec()
  1960. < {
  1961. < local cur
  1962. <
  1963. < COMPREPLY=()
  1964. < cur=`_get_cword`
  1965. <
  1966. <
  1967. < if [ $COMP_CWORD -eq 1 ]; then
  1968. < COMPREPLY=( $( compgen -W 'auto barf eroute klipsdebug look \
  1969. < manual pluto ranbits rsasigkey \
  1970. < setup showdefaults showhostkey spi \
  1971. < spigrp tncfg whack' -- $cur ) )
  1972. < return 0
  1973. < fi
  1974. <
  1975. < case ${COMP_WORDS[1]} in
  1976. < auto)
  1977. < COMPREPLY=( $( compgen -W '--asynchronous --up --add --delete \
  1978. < --replace --down --route --unroute \
  1979. < --ready --status --rereadsecrets' \
  1980. < -- $cur ) )
  1981. < ;;
  1982. < manual)
  1983. < COMPREPLY=( $( compgen -W '--up --down --route --unroute \
  1984. < --union' -- $cur ) )
  1985. < ;;
  1986. < ranbits)
  1987. < COMPREPLY=( $( compgen -W '--quick --continuous --bytes' \
  1988. < -- $cur ) )
  1989. < ;;
  1990. < setup)
  1991. < COMPREPLY=( $( compgen -W '--start --stop --restart' -- $cur ) )
  1992. < ;;
  1993. <
  1994. < *)
  1995. < ;;
  1996. < esac
  1997. <
  1998. < return 0
  1999. < } &&
  2000. < complete -F _ipsec ipsec
  2001. <
  2002. < # Postfix completion.
  2003. < #
  2004. < have postfix && {
  2005. < # postfix(1)
  2006. < #
  2007. < _postfix()
  2008. < {
  2009. < local cur prev
  2010. <
  2011. < cur=`_get_cword`
  2012. < prev=${COMP_WORDS[COMP_CWORD-1]}
  2013. <
  2014. < if [[ $cur == '-' ]]; then
  2015. < COMPREPLY=(-c -D -v)
  2016. < return 0
  2017. < fi
  2018. < if [[ $prev == '-c' ]]; then
  2019. < _filedir -d
  2020. < return 0
  2021. < fi
  2022. < if [[ $prev == '-D' ]]; then
  2023. < COMPREPLY=( $( compgen -W 'start' -- "`get_cword`" ) )
  2024. < return 0
  2025. < fi
  2026. < COMPREPLY=( $( compgen -W 'start stop reload abort flush check' -- \
  2027. < "`get_cword`" ) )
  2028. < }
  2029. < complete -F _postfix postfix
  2030. <
  2031. < # postalias(1) and postmap(1)
  2032. < #
  2033. < _postmap()
  2034. < {
  2035. < local cur prev len idx
  2036. <
  2037. < cur=`_get_cword`
  2038. < prev=${COMP_WORDS[COMP_CWORD-1]}
  2039. <
  2040. < if [[ $cur == '-' ]]; then
  2041. < COMPREPLY=(-N -f -i -n -o -p -r -v -w -c -d -q)
  2042. < return 0
  2043. < fi
  2044. < if [[ $prev == '-c' ]]; then
  2045. < _filedir -d
  2046. < return 0
  2047. < fi
  2048. < if [[ $prev == -[dq] ]]; then
  2049. < return 0
  2050. < fi
  2051. <
  2052. < if [[ "$cur" == *:* ]]; then
  2053. < COMPREPLY=( $( compgen -f -- ${cur#*:} ) )
  2054. < else
  2055. < len=${#cur}
  2056. < idx=0
  2057. < for pval in $( /usr/sbin/postconf -m ); do
  2058. < if [[ "$cur" == "${pval:0:$len}" ]]; then
  2059. < COMPREPLY[$idx]="$pval:"
  2060. < idx=$(($idx+1))
  2061. < fi
  2062. < done
  2063. < if [[ $idx -eq 0 ]]; then
  2064. < COMPREPLY=( $( compgen -f -- "$cur" ) )
  2065. < fi
  2066. < fi
  2067. < return 0
  2068. < }
  2069. < complete -F _postmap postmap postalias
  2070. <
  2071. < # postcat(1)
  2072. < #
  2073. < _postcat()
  2074. < {
  2075. < local cur prev pval len idx qfile
  2076. <
  2077. < cur=`_get_cword`
  2078. < prev=${COMP_WORDS[COMP_CWORD-1]}
  2079. <
  2080. < if [[ $cur == '-' ]]; then
  2081. < COMPREPLY=(-c -q -v)
  2082. < return 0
  2083. < fi
  2084. < if [[ $prev == '-c' ]]; then
  2085. < _filedir -d
  2086. < return 0
  2087. < fi
  2088. <
  2089. < qfile=0
  2090. < for idx in ${COMP_WORDS[@]}; do
  2091. < [[ "$idx" = -q ]] && qfile=1 && break
  2092. < done
  2093. < if [[ $qfile == 1 ]]; then
  2094. < len=${#cur}
  2095. < idx=0
  2096. < for pval in $( mailq | \
  2097. < sed -e '1d; $d; /^[^0-9A-Z]\|^$/d; s/[* !].*$//' ); do
  2098. < if [[ "$cur" == "${pval:0:$len}" ]]; then
  2099. < COMPREPLY[$idx]=$pval
  2100. < idx=$(($idx+1))
  2101. < fi
  2102. < done
  2103. < return 0
  2104. < else
  2105. < _filedir
  2106. < return 0
  2107. < fi
  2108. < }
  2109. < complete -F _postcat postcat
  2110. <
  2111. < # postconf(1)
  2112. < #
  2113. < _postconf()
  2114. < {
  2115. < local cur prev pval len idx eqext
  2116. <
  2117. < cur=`_get_cword`
  2118. < prev=${COMP_WORDS[COMP_CWORD-1]}
  2119. < if [[ $cur == '-' ]]; then
  2120. < COMPREPLY=(-c -d -e -h -m -l -n -v)
  2121. < return 0
  2122. < fi
  2123. < if [[ $prev == '-c' ]]; then
  2124. < _filedir -d
  2125. < return 0
  2126. < fi
  2127. < if [[ $prev == '-e' ]]; then
  2128. < cur=${cur#[\"\']}
  2129. < eqext='='
  2130. < fi
  2131. < len=${#cur}
  2132. < idx=0
  2133. < for pval in $( /usr/sbin/postconf | cut -d ' ' -f 1 ); do
  2134. < if [[ "$cur" == "${pval:0:$len}" ]]; then
  2135. < COMPREPLY[$idx]="$pval$eqext"
  2136. < idx=$(($idx+1))
  2137. < fi
  2138. < done
  2139. < return 0
  2140. < }
  2141. < complete -F _postconf postconf
  2142. <
  2143. < # postsuper(1)
  2144. < #
  2145. < _postsuper()
  2146. < {
  2147. < local cur prev pval len idx
  2148. <
  2149. < cur=`_get_cword`
  2150. < prev=${COMP_WORDS[COMP_CWORD-1]}
  2151. <
  2152. < if [[ $cur == '-' ]]; then
  2153. < COMPREPLY=(-c -d -h -H -p -r -s -v)
  2154. < return 0
  2155. < fi
  2156. < case $prev in
  2157. < -[dr])
  2158. < len=${#cur}
  2159. < idx=0
  2160. < for pval in $( echo ALL; mailq | \
  2161. < sed -e '1d; $d; /^[^0-9A-Z]\|^$/d; s/[* !].*$//' ); do
  2162. < if [[ "$cur" == "${pval:0:$len}" ]]; then
  2163. < COMPREPLY[$idx]=$pval
  2164. < idx=$(($idx+1))
  2165. < fi
  2166. < done
  2167. < return 0
  2168. < ;;
  2169. < -h)
  2170. < len=${#cur}
  2171. < idx=0
  2172. < for pval in $( echo ALL; mailq | \
  2173. < sed -e '1d; $d; /^[^0-9A-Z]\|^$/d; s/[* ].*$//; /!$/d' ); do
  2174. < if [[ "$cur" == "${pval:0:$len}" ]]; then
  2175. < COMPREPLY[$idx]=$pval
  2176. < idx=$(($idx+1))
  2177. < fi
  2178. < done
  2179. < return 0
  2180. < ;;
  2181. < -H)
  2182. < len=${#cur}
  2183. < idx=0
  2184. < for pval in $( echo ALL; mailq | \
  2185. < sed -e '1d; $d; /^[^0-9A-Z]\|^$/d; /^[0-9A-Z]*[* ]/d; s/!.*$//' ); do
  2186. < if [[ "$cur" == "${pval:0:$len}" ]]; then
  2187. < COMPREPLY[$idx]=$pval
  2188. < idx=$(($idx+1))
  2189. < fi
  2190. < done
  2191. < return 0
  2192. < ;;
  2193. < esac
  2194. < COMPREPLY=( $( compgen -W 'hold incoming active deferred' -- $cur ) )
  2195. < return 0
  2196. < }
  2197. < complete -F _postsuper postsuper
  2198. < }
  2199. <
  2200. < # cvs(1) completion
  2201. < #
  2202. < have cvs && {
  2203. < set_prefix()
  2204. < {
  2205. < [ -z ${prefix:-} ] || prefix=${cur%/*}/
  2206. < [ -r ${prefix:-}CVS/Entries ] || prefix=""
  2207. < }
  2208. <
  2209. < get_entries()
  2210. < {
  2211. < local IFS=$'\n'
  2212. < [ -r ${prefix:-}CVS/Entries ] && \
  2213. < entries=$(cut -d/ -f2 -s ${prefix:-}CVS/Entries)
  2214. < }
  2215. <
  2216. < get_modules()
  2217. < {
  2218. < if [ -n "$prefix" ]; then
  2219. < COMPREPLY=( $( command ls -d ${cvsroot}/${prefix}/!(CVSROOT) ) )
  2220. < else
  2221. < COMPREPLY=( $( command ls -d ${cvsroot}/!(CVSROOT) ) )
  2222. < fi
  2223. < }
  2224. <
  2225. < _cvs()
  2226. < {
  2227. < local cur count mode i cvsroot cvsroots pwd
  2228. < local -a flags miss files entries changed newremoved
  2229. <
  2230. < COMPREPLY=()
  2231. < cur=`_get_cword`
  2232. <
  2233. < count=0
  2234. < for i in ${COMP_WORDS[@]}; do
  2235. < [ $count -eq $COMP_CWORD ] && break
  2236. < # Last parameter was the CVSROOT, now go back to mode selection
  2237. < if [ "${COMP_WORDS[((count))]}" == "$cvsroot" -a "$mode" == "cvsroot" ]; then
  2238. < mode=""
  2239. < fi
  2240. < if [ -z "$mode" ]; then
  2241. < case $i in
  2242. < -d)
  2243. < mode=cvsroot
  2244. < cvsroot=${COMP_WORDS[((count+1))]}
  2245. < ;;
  2246. < @(ad?(d)|new))
  2247. < mode=add
  2248. < ;;
  2249. < @(adm?(in)|rcs))
  2250. < mode=admin
  2251. < ;;
  2252. < ann?(notate))
  2253. < mode=annotate
  2254. < ;;
  2255. < @(checkout|co|get))
  2256. < mode=checkout
  2257. < ;;
  2258. < @(com?(mit)|ci))
  2259. < mode=commit
  2260. < ;;
  2261. < di?(f?(f)))
  2262. < mode=diff
  2263. < ;;
  2264. < ex?(p?(ort)))
  2265. < mode=export
  2266. < ;;
  2267. < ?(un)edit)
  2268. < mode=$i
  2269. < ;;
  2270. < hi?(s?(tory)))
  2271. < mode=history
  2272. < ;;
  2273. < im?(p?(ort)))
  2274. < mode=import
  2275. < ;;
  2276. < re?(l?(ease)))
  2277. < mode=release
  2278. < ;;
  2279. < ?(r)log)
  2280. < mode=log
  2281. < ;;
  2282. < @(rdiff|patch))
  2283. < mode=rdiff
  2284. < ;;
  2285. < @(remove|rm|delete))
  2286. < mode=remove
  2287. < ;;
  2288. < @(rtag|rfreeze))
  2289. < mode=rtag
  2290. < ;;
  2291. < st?(at?(us)))
  2292. < mode=status
  2293. < ;;
  2294. < @(tag|freeze))
  2295. < mode=tag
  2296. < ;;
  2297. < up?(d?(ate)))
  2298. < mode=update
  2299. < ;;
  2300. < *)
  2301. < ;;
  2302. < esac
  2303. < elif [[ "$i" = -* ]]; then
  2304. < flags=( ${flags[@]:-} $i )
  2305. < fi
  2306. < count=$((++count))
  2307. < done
  2308. <
  2309. < case "$mode" in
  2310. < add)
  2311. < if [[ "$cur" != -* ]]; then
  2312. < set_prefix
  2313. < if [ $COMP_CWORD -gt 1 -a -r ${prefix:-}CVS/Entries ]; then
  2314. < get_entries
  2315. < [ -z "$cur" ] && \
  2316. < files=$( command ls -Ad !(CVS) ) || \
  2317. < files=$( command ls -d ${cur}* 2>/dev/null )
  2318. < for i in ${entries[@]:-}; do
  2319. < files=( ${files[@]/#$i//} )
  2320. < done
  2321. < COMPREPLY=( $( compgen -W '${files[@]}' -- \
  2322. < $cur ) )
  2323. < fi
  2324. < else
  2325. < COMPREPLY=( $( compgen -W '-k -m' -- $cur ) )
  2326. < fi
  2327. < ;;
  2328. < admin)
  2329. < if [[ "$cur" = -* ]]; then
  2330. < COMPREPLY=( $( compgen -W '-i -a -A -e -b -c -k -l -u \
  2331. < -L -U -m -M -n -N -o -q -I \
  2332. < -s -t -t- -T -V -x -z' -- \
  2333. < $cur ) )
  2334. < fi
  2335. < ;;
  2336. < annotate)
  2337. < if [[ "$cur" = -* ]]; then
  2338. < COMPREPLY=( $( compgen -W '-D -F -f -l -R -r' -- $cur ) )
  2339. < else
  2340. < get_entries
  2341. < COMPREPLY=( $( compgen -W '${entries[@]}' -- $cur ) )
  2342. < fi
  2343. < ;;
  2344. < checkout)
  2345. < if [[ "$cur" != -* ]]; then
  2346. < [ -z "$cvsroot" ] && cvsroot=$CVSROOT
  2347. < COMPREPLY=( $( cvs -d "$cvsroot" co -c 2> /dev/null | \
  2348. < awk '{print $1}' ) )
  2349. < COMPREPLY=( $( compgen -W '${COMPREPLY[@]}' -- $cur ) )
  2350. < else
  2351. < COMPREPLY=( $( compgen -W '-A -N -P -R -c -f -l -n -p \
  2352. < -s -r -D -d -k -j' -- $cur ) )
  2353. < fi
  2354. < ;;
  2355. < commit)
  2356. < set_prefix
  2357. <
  2358. < if [[ "$cur" != -* ]] && [ -r ${prefix:-}CVS/Entries ]; then
  2359. < # if $COMP_CVS_REMOTE is not null, 'cvs commit' will
  2360. < # complete on remotely checked-out files (requires
  2361. < # passwordless access to the remote repository
  2362. < if [ -n "${COMP_CVS_REMOTE:-}" ]; then
  2363. < # this is the least computationally intensive
  2364. < # way found so far, but other changes
  2365. < # (something other than changed/removed/new)
  2366. < # may be missing
  2367. < changed=( $( cvs -q diff --brief 2>&1 | \
  2368. < sed -ne 's/^Files [^ ]* and \([^ ]*\) differ$/\1/p' ) )
  2369. < newremoved=( $( cvs -q diff --brief 2>&1 | \
  2370. < sed -ne 's/^cvs diff: \([^ ]*\) .*, no comparison available$/\1/p' ) )
  2371. < COMPREPLY=( $( compgen -W '${changed[@]:-} \
  2372. < ${newremoved[@]:-}' -- $cur ) )
  2373. < else
  2374. < _filedir
  2375. < fi
  2376. < else
  2377. < COMPREPLY=( $( compgen -W '-n -R -l -f -F -m -r' -- \
  2378. < $cur ) )
  2379. < fi
  2380. < ;;
  2381. < cvsroot)
  2382. < if [ -r ~/.cvspass ]; then
  2383. < # Ugly escaping because of bash treating ':' specially
  2384. < cvsroots=$( sed 's/^[^ ]* //; s/:/\\:/g' ~/.cvspass )
  2385. < COMPREPLY=( $( compgen -W '$cvsroots' -- $cur ) )
  2386. < fi
  2387. < ;;
  2388. < export)
  2389. < if [[ "$cur" != -* ]]; then
  2390. < [ -z "$cvsroot" ] && cvsroot=$CVSROOT
  2391. < COMPREPLY=( $( cvs -d "$cvsroot" co -c | awk '{print $1}' ) )
  2392. < COMPREPLY=( $( compgen -W '${COMPREPLY[@]}' -- $cur ) )
  2393. < else
  2394. < COMPREPLY=( $( compgen -W '-N -f -l -R -n \
  2395. < -r -D -d -k' -- $cur ) )
  2396. < fi
  2397. < ;;
  2398. < diff)
  2399. < if [[ "$cur" == -* ]]; then
  2400. < _longopt diff
  2401. < else
  2402. < get_entries
  2403. < COMPREPLY=( $( compgen -W '${entries[@]:-}' -- $cur ) )
  2404. < fi
  2405. < ;;
  2406. < remove)
  2407. < if [[ "$cur" != -* ]]; then
  2408. < set_prefix
  2409. < if [ $COMP_CWORD -gt 1 -a -r ${prefix:-}CVS/Entries ]; then
  2410. < get_entries
  2411. < # find out what files are missing
  2412. < for i in ${entries[@]}; do
  2413. < [ ! -r "$i" ] && miss=( ${miss[@]:-} $i )
  2414. < done
  2415. < COMPREPLY=( $(compgen -W '${miss[@]:-}' -- $cur) )
  2416. < fi
  2417. < else
  2418. < COMPREPLY=( $( compgen -W '-f -l -R' -- $cur ) )
  2419. < fi
  2420. < ;;
  2421. < import)
  2422. < if [[ "$cur" != -* ]]; then
  2423. < # starts with same algorithm as checkout
  2424. < [ -z "$cvsroot" ] && cvsroot=$CVSROOT
  2425. < prefix=${cur%/*}
  2426. < if [ -r ${cvsroot}/${prefix} ]; then
  2427. < get_modules
  2428. < COMPREPLY=( ${COMPREPLY[@]#$cvsroot} )
  2429. < COMPREPLY=( ${COMPREPLY[@]#\/} )
  2430. < fi
  2431. < pwd=$( pwd )
  2432. < pwd=${pwd##*/}
  2433. < COMPREPLY=( $( compgen -W '${COMPREPLY[@]} $pwd' -- \
  2434. < $cur ) )
  2435. < else
  2436. < COMPREPLY=( $( compgen -W '-d -k -I -b -m -W' -- $cur ))
  2437. < fi
  2438. < ;;
  2439. < update)
  2440. < if [[ "$cur" = -* ]]; then
  2441. < COMPREPLY=( $( compgen -W '-A -P -C -d -f -l -R -p \
  2442. < -k -r -D -j -I -W' -- \
  2443. < $cur ) )
  2444. < fi
  2445. < ;;
  2446. < "")
  2447. < COMPREPLY=( $( compgen -W 'add admin annotate checkout ci co \
  2448. < commit diff delete edit export \
  2449. < freeze get history import log new \
  2450. < patch rcs rdiff release remove \
  2451. < rfreeze rlog rm rtag stat status \
  2452. < tag unedit up update -H -Q -q -b \
  2453. < -d -e -f -l -n -t -r -v -w -x -z \
  2454. < --help --version' -- $cur ) )
  2455. < ;;
  2456. < *)
  2457. < ;;
  2458. < esac
  2459. <
  2460. < return 0
  2461. < }
  2462. < complete -F _cvs $default cvs
  2463. < }
  2464. <
  2465. < have rpm && {
  2466. < # helper functions for rpm completion
  2467. < #
  2468. < _rpm_installed_packages()
  2469. < {
  2470. < local ver nodig nosig
  2471. <
  2472. < if [ -r /var/log/rpmpkgs -a \
  2473. < /var/log/rpmpkgs -nt /var/lib/rpm/Packages ]; then
  2474. < # using RHL 7.2 or later - this is quicker than querying the DB
  2475. < COMPREPLY=( $( sed -ne \
  2476. < 's|^\('$cur'.*\)-[0-9a-zA-Z._]\+-[0-9a-z.@]\+.*\.rpm$|\1|p' \
  2477. < /var/log/rpmpkgs ) )
  2478. < else
  2479. < nodig=""
  2480. < nosig=""
  2481. < ver=$(rpm --version)
  2482. < ver=${ver##* }
  2483. <
  2484. < if [[ "$ver" > "4.0.4" ]]; then
  2485. < nodig="--nodigest"
  2486. < fi
  2487. < if [[ "$ver" > "4.0.99" ]]; then
  2488. < nosig="--nosignature"
  2489. < fi
  2490. <
  2491. < COMPREPLY=( $( rpm -qa $nodig $nosig | sed -ne \
  2492. < 's|^\('$cur'.*\)-[0-9a-zA-Z._]\+-[0-9a-z.@]\+$|\1|p' ) )
  2493. < fi
  2494. < }
  2495. <
  2496. < _rpm_groups()
  2497. < {
  2498. < local IFS=$'\t'
  2499. < # remove trailing backslash, or grep will complain
  2500. < cur=${cur%"\\"}
  2501. < COMPREPLY=( $( rpm -qa $nodig $nosig --queryformat '%{group}\n' | \
  2502. < grep "^$cur" ) )
  2503. < # backslash escape spaces and translate newlines to tabs
  2504. < COMPREPLY=( $( echo ${COMPREPLY[@]} | sed 's/ /\\ /g' | tr '\n' '\t' ) )
  2505. < }
  2506. <
  2507. < # rpm(8) completion
  2508. < #
  2509. < _rpm()
  2510. < {
  2511. < local cur prev ver nodig nosig
  2512. <
  2513. < COMPREPLY=()
  2514. < cur=`_get_cword`
  2515. < prev=${COMP_WORDS[COMP_CWORD-1]}
  2516. < nodig=""
  2517. < nosig=""
  2518. < ver=$(rpm --version); ver=${ver##* }
  2519. <
  2520. < if [[ "$ver" > "4.0.4" ]]; then
  2521. < nodig="--nodigest"
  2522. < fi
  2523. < if [[ "$ver" > "4.0.99" ]]; then
  2524. < nosig="--nosignature"
  2525. < fi
  2526. <
  2527. < if [ $COMP_CWORD -eq 1 ]; then
  2528. < # first parameter on line
  2529. < case "$cur" in
  2530. < -b*)
  2531. < COMPREPLY=( $( compgen -W '-ba -bb -bc -bi -bl -bp -bs'\
  2532. < -- $cur ) )
  2533. < ;;
  2534. < -t*)
  2535. < COMPREPLY=( $( compgen -W '-ta -tb -tc -ti -tl -tp -ts'\
  2536. < -- $cur ) )
  2537. < ;;
  2538. < --*)
  2539. < COMPREPLY=( $( compgen -W '--help --version --initdb \
  2540. < --checksig --recompile --rebuild --resign --addsign \
  2541. < --rebuilddb --showrc --setperms --setugids --tarbuild \
  2542. < --eval --install --upgrade --query --freshen --erase \
  2543. < --verify --querytags --rmsource --rmspec --clean \
  2544. < --import' -- $cur ) )
  2545. < ;;
  2546. < *)
  2547. < COMPREPLY=( $( compgen -W '-b -e -F -i -q -t -U -V' \
  2548. < -- $cur ) )
  2549. < ;;
  2550. < esac
  2551. <
  2552. < return 0
  2553. < fi
  2554. <
  2555. < case "$prev" in
  2556. < --@(@(db|exclude)path|prefix|relocate|root))
  2557. < _filedir -d
  2558. < return 0
  2559. < ;;
  2560. < --eval)
  2561. < # get a list of macros
  2562. < COMPREPLY=( $( sed -ne 's|^\(%'${cur#\%}'[^ '$'\t'']*\).*$|\1|p' \
  2563. < /usr/lib/rpm/macros ) )
  2564. < return 0
  2565. < ;;
  2566. < --pipe)
  2567. < COMPREPLY=( $( compgen -c -- $cur ) )
  2568. < return 0
  2569. < ;;
  2570. < --rcfile)
  2571. < _filedir
  2572. < return 0
  2573. < ;;
  2574. < --specfile)
  2575. < # complete on .spec files
  2576. < _filedir spec
  2577. < return 0
  2578. < ;;
  2579. < --whatprovides)
  2580. < if [[ "$cur" == */* ]]; then
  2581. < _filedir
  2582. < else
  2583. < # complete on capabilities
  2584. < COMPREPLY=( $( rpm -qa $nodig $nosig --queryformat \
  2585. < '%{providename}\n' | grep "^$cur" ) )
  2586. < fi
  2587. < return 0
  2588. < ;;
  2589. < --whatrequires)
  2590. < # complete on capabilities
  2591. < COMPREPLY=( $( rpm -qa $nodig $nosig --queryformat \
  2592. < '%{requirename}\n' | grep "^$cur" ) )
  2593. < return 0
  2594. < ;;
  2595. < esac
  2596. <
  2597. < case "${COMP_WORDS[1]}" in
  2598. < -@([iFU]*|-install|-freshen|-upgrade))
  2599. < if [[ "$cur" == -* ]]; then
  2600. < COMPREPLY=( $( compgen -W '--percent --force --test \
  2601. < --replacepkgs --replacefiles --root --excludedocs \
  2602. < --includedocs --noscripts --rcfile --ignorearch \
  2603. < --dbpath --prefix --ignoreos --nodeps --allfiles \
  2604. < --ftpproxy --ftpport --justdb --httpproxy --httpport \
  2605. < --noorder --relocate --badreloc --notriggers \
  2606. < --excludepath --ignoresize --oldpackage --define \
  2607. < --eval --pipe --queryformat --repackage --nosuggests \
  2608. < --nodigest --nosignature' -- $cur ) )
  2609. < else
  2610. < _filedir 'rpm'
  2611. < fi
  2612. < ;;
  2613. < -@(e|-erase))
  2614. < if [[ "$cur" == -* ]]; then
  2615. < COMPREPLY=( $( compgen -W '--allmatches --noscripts \
  2616. < --notriggers --nodeps --test --repackage' -- $cur ) )
  2617. < else
  2618. < _rpm_installed_packages
  2619. < fi
  2620. < ;;
  2621. < -@(q*|-query))
  2622. < # check whether we're doing file completion
  2623. < if [ "${COMP_LINE#* -*([^ -])f}" != "$COMP_LINE" ]; then
  2624. < if [[ "$cur" == -* ]]; then
  2625. < COMPREPLY=( $( compgen -W '--scripts --root \
  2626. < --rcfile --requires --ftpport --ftpproxy \
  2627. < --httpproxy --httpport --provides --triggers \
  2628. < --dump --changelog --dbpath \
  2629. < --last --filesbypkg \
  2630. < --info --list --state \
  2631. < --docfiles --configfiles --queryformat \
  2632. < --conflicts --obsoletes \
  2633. < --nodigest --nosignature \
  2634. < --triggerscripts' -- $cur ) )
  2635. < else
  2636. < _filedir
  2637. < fi
  2638. < elif [ "${COMP_LINE#* -*([^ -])g}" != "$COMP_LINE" ]; then
  2639. < _rpm_groups
  2640. < elif [ "${COMP_LINE#* -*([^ -])p}" != "$COMP_LINE" ]; then
  2641. < # uninstalled package completion
  2642. < if [[ "$cur" == -* ]]; then
  2643. < COMPREPLY=( $( compgen -W '--scripts --root \
  2644. < --rcfile --whatprovides --whatrequires \
  2645. < --requires --triggeredby --ftpport --ftpproxy \
  2646. < --httpproxy --httpport --provides --triggers \
  2647. < --dump --changelog --dbpath --filesbypkg \
  2648. < --define --eval --pipe --showrc --info --list \
  2649. < --state --docfiles --configfiles --queryformat\
  2650. < --conflicts --obsoletes --nodigest \
  2651. < --nosignature' -- $cur ) )
  2652. < else
  2653. < _filedir 'rpm'
  2654. < fi
  2655. < else
  2656. < # installed package completion
  2657. < if [[ "$cur" == -* ]]; then
  2658. < COMPREPLY=( $( compgen -W '--scripts --root \
  2659. < --rcfile --whatprovides --whatrequires \
  2660. < --requires --triggeredby --ftpport --ftpproxy \
  2661. < --httpproxy --httpport --provides --triggers \
  2662. < --dump --changelog --dbpath --specfile \
  2663. < --querybynumber --last --filesbypkg --define \
  2664. < --eval --pipe --showrc --info --list --state \
  2665. < --docfiles --configfiles --queryformat \
  2666. < --conflicts --obsoletes --pkgid --hdrid \
  2667. < --fileid --tid --nodigest --nosignature \
  2668. < --triggerscripts' -- $cur ) )
  2669. < elif [ "${COMP_LINE#* -*([^ -])a}" == "$COMP_LINE" ]; then
  2670. < _rpm_installed_packages
  2671. < fi
  2672. < fi
  2673. < ;;
  2674. < -@(K*|-checksig))
  2675. < if [[ "$cur" == -* ]]; then
  2676. < COMPREPLY=( $( compgen -W '--nopgp --nogpg --nomd5 \
  2677. < --nodigest --nosignature' -- $cur ) )
  2678. < else
  2679. < _filedir 'rpm'
  2680. < fi
  2681. < ;;
  2682. < -@([Vy]*|-verify))
  2683. < if [[ "$cur" == -* ]]; then
  2684. < COMPREPLY=( $( compgen -W '--root --rcfile --dbpath \
  2685. < --nodeps --nogroup --nolinkto --nomode --nomtime \
  2686. < --nordev --nouser --nofiles --noscripts --nomd5 \
  2687. < --querytags --specfile --whatrequires --whatprovides \
  2688. < --nodigest --nosignature' -- $cur ) )
  2689. < # check whether we're doing file completion
  2690. < elif [ "${COMP_LINE#* -*([^ -])f}" != "$COMP_LINE" ]; then
  2691. < _filedir
  2692. < elif [ "${COMP_LINE#* -*([^ -])g}" != "$COMP_LINE" ]; then
  2693. < _rpm_groups
  2694. < elif [ "${COMP_LINE#* -*([^ -])p}" != "$COMP_LINE" ]; then
  2695. < _filedir 'rpm'
  2696. < else
  2697. < _rpm_installed_packages
  2698. < fi
  2699. < ;;
  2700. < -[bt]*)
  2701. < if [[ "$cur" == -* ]]; then
  2702. < COMPREPLY=( $( compgen -W '--short-circuit --timecheck \
  2703. < --clean --rmsource --rmspec --test --sign --buildroot \
  2704. < --target -- buildarch --buildos --nobuild --nodeps \
  2705. < --nodirtokens' -- $cur ) )
  2706. < elif [[ ${COMP_WORDS[1]} == -b* ]]; then
  2707. < _filedir 'spec'
  2708. < else
  2709. < _filedir '@(tgz|tar.@(gz|bz2))'
  2710. < fi
  2711. < ;;
  2712. < --re@(build|compile))
  2713. < if [[ "$cur" == -* ]]; then
  2714. < COMPREPLY=( $( compgen -W '--nodeps --rmsource \
  2715. < --rmspec --sign --nodirtokens --target' -- $cur ) )
  2716. < else
  2717. < _filedir '?(no)src.rpm'
  2718. < fi
  2719. < ;;
  2720. < --tarbuild)
  2721. < _filedir '@(tgz|tar.@(gz|bz2))'
  2722. < ;;
  2723. < --@(re|add)sign)
  2724. < _filedir 'rpm'
  2725. < ;;
  2726. < --set@(perms|gids))
  2727. < _rpm_installed_packages
  2728. < ;;
  2729. < --@(clean|rms@(ource|pec)))
  2730. < if [[ "$cur" == -* ]]; then
  2731. < COMPREPLY=( $( compgen -W '--clean --rmsource \
  2732. < --rmspec' -- $cur ) )
  2733. < else
  2734. < _filedir 'spec'
  2735. < fi
  2736. < ;;
  2737. < --@(import|dbpath|root))
  2738. < if [[ "$cur" == -* ]]; then
  2739. < COMPREPLY=( $( compgen -W '--import --dbpath --root' \
  2740. < -- $cur ) )
  2741. < else
  2742. < _filedir
  2743. < fi
  2744. < ;;
  2745. < esac
  2746. <
  2747. < return 0
  2748. < }
  2749. < complete -F _rpm $filenames rpm rpmbuild
  2750. < }
  2751. <
  2752. < # Debian apt-get(8) completion.
  2753. < #
  2754. < have apt-get &&
  2755. < _apt_get()
  2756. < {
  2757. < local cur prev special i
  2758. <
  2759. < COMPREPLY=()
  2760. < cur=`_get_cword`
  2761. < prev=${COMP_WORDS[COMP_CWORD-1]}
  2762. <
  2763. < for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  2764. < if [[ ${COMP_WORDS[i]} == @(install|remove|purge|source|build-dep) ]]; then
  2765. < special=${COMP_WORDS[i]}
  2766. < fi
  2767. < done
  2768. <
  2769. < if [ -n "$special" ]; then
  2770. < case $special in
  2771. < remove|purge)
  2772. < if [ -f /etc/debian_version ]; then
  2773. < # Debian system
  2774. < COMPREPLY=( $( _comp_dpkg_installed_packages \
  2775. < $cur ) )
  2776. < else
  2777. < # assume RPM based
  2778. < _rpm_installed_packages
  2779. < fi
  2780. < return 0
  2781. < ;;
  2782. < *)
  2783. < COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
  2784. < return 0
  2785. < ;;
  2786. <
  2787. < esac
  2788. < fi
  2789. <
  2790. < case "$prev" in
  2791. < -@(c|-config-file))
  2792. < _filedir
  2793. < return 0
  2794. < ;;
  2795. <
  2796. < -@(t|-target-release|-default-release))
  2797. < COMPREPLY=( $( apt-cache policy | \
  2798. < grep "release.o=Debian,a=$cur" | \
  2799. < sed -e "s/.*a=\(\w*\).*/\1/" | uniq 2> /dev/null) )
  2800. < return 0
  2801. < ;;
  2802. <
  2803. < esac
  2804. <
  2805. < if [[ "$cur" == -* ]]; then
  2806. <
  2807. < COMPREPLY=( $( compgen -W '-d -f -h -v -m -q -s -y \
  2808. < -u -t -b -c -o --download-only --fix-broken \
  2809. < --help --version --ignore-missing \
  2810. < --fix-missing --no-download --quiet --simulate \
  2811. < --just-print --dry-run --recon --no-act --yes \
  2812. < --assume-yes --show-upgraded --only-source \
  2813. < --compile --build --ignore-hold \
  2814. < --target-release --no-upgrade --force-yes \
  2815. < --print-uris --purge --reinstall \
  2816. < --list-cleanup --default-release \
  2817. < --trivial-only --no-remove --diff-only \
  2818. < --tar-only --config-file --option --auto-remove' -- $cur ) )
  2819. < else
  2820. <
  2821. < COMPREPLY=( $( compgen -W 'update upgrade dselect-upgrade \
  2822. < dist-upgrade install remove purge source \
  2823. < build-dep check clean autoclean autoremove' \
  2824. < -- $cur ) )
  2825. <
  2826. < fi
  2827. <
  2828. <
  2829. < return 0
  2830. < } &&
  2831. < complete -F _apt_get $filenames apt-get
  2832. <
  2833. < # Debian apt-cache(8) completion.
  2834. < #
  2835. < have apt-cache &&
  2836. < _apt_cache()
  2837. < {
  2838. < local cur prev special i
  2839. <
  2840. < COMPREPLY=()
  2841. < cur=`_get_cword`
  2842. < prev=${COMP_WORDS[COMP_CWORD-1]}
  2843. <
  2844. <
  2845. < if [ "$cur" != show ]; then
  2846. < for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  2847. < if [[ ${COMP_WORDS[i]} == @(add|depends|dotty|policy|rdepends|madison|show?(pkg|src|)) ]]; then
  2848. < special=${COMP_WORDS[i]}
  2849. < fi
  2850. < done
  2851. < fi
  2852. <
  2853. <
  2854. < if [ -n "$special" ]; then
  2855. < case $special in
  2856. < add)
  2857. < _filedir
  2858. < return 0
  2859. < ;;
  2860. <
  2861. < *)
  2862. < COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
  2863. < return 0
  2864. < ;;
  2865. <
  2866. < esac
  2867. < fi
  2868. <
  2869. <
  2870. < case "$prev" in
  2871. < -@(c|p|s|-config-file|-@(pkg|src)-cache))
  2872. < _filedir
  2873. < return 0
  2874. < ;;
  2875. < search)
  2876. < if [[ "$cur" != -* ]]; then
  2877. < return 0
  2878. < fi
  2879. < ;;
  2880. < esac
  2881. <
  2882. < if [[ "$cur" == -* ]]; then
  2883. <
  2884. < COMPREPLY=( $( compgen -W '-h -v -p -s -q -i -f -a -g -c \
  2885. < -o --help --version --pkg-cache --src-cache \
  2886. < --quiet --important --full --all-versions \
  2887. < --no-all-versions --generate --no-generate \
  2888. < --names-only --all-names --recurse \
  2889. < --config-file --option' -- $cur ) )
  2890. < else
  2891. <
  2892. < COMPREPLY=( $( compgen -W 'add gencaches show showpkg showsrc \
  2893. < stats dump dumpavail unmet search search \
  2894. < depends rdepends pkgnames dotty xvcg \
  2895. < policy madison' -- $cur ) )
  2896. <
  2897. < fi
  2898. <
  2899. <
  2900. < return 0
  2901. < } &&
  2902. < complete -F _apt_cache $filenames apt-cache
  2903. <
  2904. <
  2905. < # Debian aptitude(1) completion
  2906. < #
  2907. < have aptitude && {
  2908. < have grep-status && {
  2909. < _comp_dpkg_hold_packages()
  2910. < {
  2911. < grep-status -P -e "^$1" -a -FStatus 'hold' -n -s Package
  2912. < }
  2913. < } || {
  2914. < _comp_dpkg_hold_packages()
  2915. < {
  2916. < grep -B 2 'hold' /var/lib/dpkg/status | grep "Package: $1" \
  2917. < | cut -d\ -f2
  2918. < }
  2919. < }
  2920. <
  2921. < _aptitude()
  2922. < {
  2923. < local cur dashoptions prev special i
  2924. <
  2925. < COMPREPLY=()
  2926. < cur=`_get_cword`
  2927. < prev=${COMP_WORDS[COMP_CWORD-1]}
  2928. <
  2929. <
  2930. < dashoptions='-S -u -i -h --help --version -s --simulate -d \
  2931. < --download-only -P --prompt -y --assume-yes -F \
  2932. < --display-format -O --sort -w --width -f -r -g \
  2933. < --with-recommends --with-suggests -R -G \
  2934. < --without-recommends --without-suggests -t \
  2935. < --target-release -V --show-versions -D --show-deps\
  2936. < -Z -v --verbose --purge-unused'
  2937. <
  2938. < for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  2939. < if [[ ${COMP_WORDS[i]} == @(install|reinstall|hold|unhold|markauto|unmarkauto|dist-upgrade|full-upgrade|download|show|forbid-version|purge|remove|changelog|why|why-not|keep|keep-all) ]]; then
  2940. < special=${COMP_WORDS[i]}
  2941. < fi
  2942. < #exclude some mutually exclusive options
  2943. < [[ ${COMP_WORDS[i]} == '-u' ]] && dashoptions=${dashoptions/-i}
  2944. < [[ ${COMP_WORDS[i]} == '-i' ]] && dashoptions=${dashoptions/-u}
  2945. < done
  2946. <
  2947. < if [[ -n "$special" ]]; then
  2948. < case $special in
  2949. < @(install|hold|markauto|unmarkauto|dist-upgrade|full-upgrade|download|show|changelog|why|why-not))
  2950. < COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
  2951. < return 0
  2952. < ;;
  2953. < @(purge|remove|reinstall|forbid-version))
  2954. < COMPREPLY=( $( _comp_dpkg_installed_packages $cur ) )
  2955. < return 0
  2956. < ;;
  2957. < unhold)
  2958. < COMPREPLY=( $( _comp_dpkg_hold_packages $cur ) )
  2959. < return 0
  2960. < ;;
  2961. <
  2962. < esac
  2963. < fi
  2964. <
  2965. < case $prev in
  2966. < # don't complete anything if these options are found
  2967. < @(autoclean|clean|forget-new|search|upgrade|safe-upgrade|update|keep-all))
  2968. < return 0
  2969. < ;;
  2970. <
  2971. < -S)
  2972. < _filedir
  2973. < return 0
  2974. < ;;
  2975. <
  2976. < -@(t|-target-release|-default-release))
  2977. < COMPREPLY=( $( apt-cache policy | \
  2978. < grep "release.o=Debian,a=$cur" | \
  2979. < sed -e "s/.*a=\(\w*\).*/\1/" | uniq 2> /dev/null ) )
  2980. < return 0
  2981. < ;;
  2982. <
  2983. < esac
  2984. <
  2985. < if [[ "$cur" == -* ]]; then
  2986. < COMPREPLY=( $( compgen -W "$dashoptions" -- $cur ) )
  2987. < else
  2988. < COMPREPLY=( $( compgen -W 'update upgrade safe-upgrade forget-new clean \
  2989. < autoclean install reinstall remove \
  2990. < hold unhold purge markauto unmarkauto why why-not \
  2991. < dist-upgrade full-upgrade download search show \
  2992. < forbid-version changelog keep-all' -- $cur ) )
  2993. < fi
  2994. <
  2995. <
  2996. < return 0
  2997. < }
  2998. < complete -F _aptitude $default aptitude
  2999. < }
  3000. <
  3001. < # Debian apt-build(1) completion.
  3002. < #
  3003. < have apt-build &&
  3004. < _apt_build()
  3005. < {
  3006. < local cur prev special i
  3007. <
  3008. < COMPREPLY=()
  3009. < cur=`_get_cword`
  3010. < prev=${COMP_WORDS[COMP_CWORD-1]}
  3011. <
  3012. < for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  3013. < if [[ ${COMP_WORDS[i]} == @(install|remove|source|info|clean) ]]; then
  3014. < special=${COMP_WORDS[i]}
  3015. < fi
  3016. < done
  3017. <
  3018. < if [ -n "$special" ]; then
  3019. < case $special in
  3020. < @(install|source|info))
  3021. < COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
  3022. < return 0
  3023. < ;;
  3024. < remove)
  3025. < COMPREPLY=( $( _comp_dpkg_installed_packages \
  3026. < $cur ) )
  3027. < return 0
  3028. < ;;
  3029. < *)
  3030. < return 0
  3031. < ;;
  3032. < esac
  3033. < fi
  3034. <
  3035. < case "$prev" in
  3036. <
  3037. < --@(patch|build-dir|repository-dir))
  3038. < _filedir
  3039. < return 0
  3040. < ;;
  3041. <
  3042. < -@(h|-help))
  3043. < return 0
  3044. < ;;
  3045. <
  3046. < esac
  3047. <
  3048. < if [[ "$cur" == -* ]]; then
  3049. < COMPREPLY=( $( compgen -W '--help --show-upgraded -u --build-dir \
  3050. < --repository-dir --build-only \
  3051. < --build-command --reinstall --rebuild \
  3052. < --remove-builddep --no-wrapper --purge \
  3053. < --patch --patch-strip -p --yes -y \
  3054. < --version -v --no-source' -- $cur ) )
  3055. <
  3056. < else
  3057. < COMPREPLY=( $( compgen -W 'update upgrade install remove \
  3058. < source dist-upgrade world clean info \
  3059. < clean-build update-repository ' -- $cur ) )
  3060. < fi
  3061. <
  3062. <
  3063. < return 0
  3064. < } &&
  3065. < complete -F _apt_build $filenames apt-build
  3066. <
  3067. < # chsh(1) completion
  3068. < #
  3069. < _chsh()
  3070. < {
  3071. < local cur prev
  3072. <
  3073. < COMPREPLY=()
  3074. < cur=`_get_cword`
  3075. < prev=${COMP_WORDS[COMP_CWORD-1]}
  3076. <
  3077. < if [ "$prev" = "-s" ]; then
  3078. < if [ -f /etc/debian_version ]; then
  3079. < COMPREPLY=( $( </etc/shells ) )
  3080. < else
  3081. < COMPREPLY=( $( chsh -l | grep "^$cur" ) )
  3082. < fi
  3083. < else
  3084. < COMPREPLY=( $( compgen -u -- $cur ) )
  3085. < fi
  3086. <
  3087. < return 0
  3088. < }
  3089. < complete -F _chsh chsh
  3090. <
  3091. < # chkconfig(8) completion
  3092. < #
  3093. < have chkconfig &&
  3094. < _chkconfig()
  3095. < {
  3096. < local cur prev
  3097. <
  3098. < COMPREPLY=()
  3099. < cur=`_get_cword`
  3100. < prev=${COMP_WORDS[COMP_CWORD-1]}
  3101. <
  3102. < case "$prev" in
  3103. < @([1-6]|--@(list|add|del)))
  3104. < _services
  3105. < return 0
  3106. < ;;
  3107. < --level)
  3108. < COMPREPLY=( $( compgen -W '1 2 3 4 5 6' -- $cur ) )
  3109. < return 0
  3110. < ;;
  3111. < esac
  3112. <
  3113. < if [[ "$cur" == -* ]]; then
  3114. < COMPREPLY=( $( compgen -W '--list --add --del --level' -- $cur ) )
  3115. < else
  3116. < if [ $COMP_CWORD -eq 2 -o $COMP_CWORD -eq 4 ]; then
  3117. < COMPREPLY=( $( compgen -W 'on off reset' -- $cur ) )
  3118. < else
  3119. < _services
  3120. < fi
  3121. < fi
  3122. < } &&
  3123. < complete -F _chkconfig chkconfig
  3124. ---
  3125. > # This function completes on valid shells
  3126. > #
  3127. > _shells()
  3128. > {
  3129. > COMPREPLY=( "${COMPREPLY[@]}" $( compgen -W \
  3130. > '$( command grep "^[[:space:]]*/" /etc/shells 2>/dev/null )' \
  3131. > -- "$cur" ) )
  3132. > }
  3133. 2430c1024
  3134. < # This function provides simple user@host completion
  3135. ---
  3136. > # This function completes on valid filesystem types
  3137. 2432,2433c1026,1028
  3138. < _user_at_host() {
  3139. < local cur
  3140. ---
  3141. > _fstypes()
  3142. > {
  3143. > local fss
  3144. 2435,2436c1030,1041
  3145. < COMPREPLY=()
  3146. < cur=`_get_cword`
  3147. ---
  3148. > if [ -e /proc/filesystems ] ; then
  3149. > # Linux
  3150. > fss="$( cut -d$'\t' -f2 /proc/filesystems )
  3151. > $( awk '! /\*/ { print $NF }' /etc/filesystems 2>/dev/null )"
  3152. > else
  3153. > # Generic
  3154. > fss="$( awk '/^[ \t]*[^#]/ { print $3 }' /etc/fstab 2>/dev/null )
  3155. > $( awk '/^[ \t]*[^#]/ { print $3 }' /etc/mnttab 2>/dev/null )
  3156. > $( awk '/^[ \t]*[^#]/ { print $4 }' /etc/vfstab 2>/dev/null )
  3157. > $( awk '{ print $1 }' /etc/dfs/fstypes 2>/dev/null )
  3158. > $( [ -d /etc/fs ] && command ls /etc/fs )"
  3159. > fi
  3160. 2438,2442c1043,1045
  3161. < if [[ $cur == *@* ]]; then
  3162. < _known_hosts
  3163. < else
  3164. < COMPREPLY=( $( compgen -u -- "$cur" ) )
  3165. < fi
  3166. ---
  3167. > [ -n "$fss" ] && \
  3168. > COMPREPLY=( "${COMPREPLY[@]}" $( compgen -W "$fss" -- "$cur" ) )
  3169. > }
  3170. 2444c1047,1078
  3171. < return 0
  3172. ---
  3173. > # Get real command.
  3174. > # - arg: $1 Command
  3175. > # - stdout: Filename of command in PATH with possible symbolic links resolved.
  3176. > # Empty string if command not found.
  3177. > # - return: True (0) if command found, False (> 0) if not.
  3178. > _realcommand()
  3179. > {
  3180. > type -P "$1" > /dev/null && {
  3181. > if type -p realpath > /dev/null; then
  3182. > realpath "$(type -P "$1")"
  3183. > elif type -p readlink > /dev/null; then
  3184. > readlink -f "$(type -P "$1")"
  3185. > else
  3186. > type -P "$1"
  3187. > fi
  3188. > }
  3189. > }
  3190. >
  3191. > # This function returns the first arugment, excluding options
  3192. > # @param $1 chars Characters out of $COMP_WORDBREAKS which should
  3193. > # NOT be considered word breaks. See __reassemble_comp_words_by_ref.
  3194. > _get_first_arg()
  3195. > {
  3196. > local i
  3197. >
  3198. > arg=
  3199. > for (( i=1; i < COMP_CWORD; i++ )); do
  3200. > if [[ "${COMP_WORDS[i]}" != -* ]]; then
  3201. > arg=${COMP_WORDS[i]}
  3202. > break
  3203. > fi
  3204. > done
  3205. 2446d1079
  3206. < shopt -u hostcomplete && complete -F _user_at_host $nospace talk ytalk finger
  3207. 2448,2454d1080
  3208. < # This function performs host completion based on ssh's known_hosts files,
  3209. < # defaulting to standard host completion if they don't exist.
  3210. < #
  3211. < _known_hosts()
  3212. < {
  3213. < local cur curd ocur user suffix aliases global_kh user_kh hosts i host
  3214. < local -a kh khd config
  3215. 2456,3075c1082,1088
  3216. < COMPREPLY=()
  3217. < cur=`_get_cword`
  3218. < ocur=$cur
  3219. <
  3220. < [ "$1" = -a ] || [ "$2" = -a ] && aliases='yes'
  3221. < [ "$1" = -c ] || [ "$2" = -c ] && suffix=':'
  3222. < [[ $cur == *@* ]] && user=${cur%@*}@ && cur=${cur#*@}
  3223. < kh=()
  3224. <
  3225. < # ssh config files
  3226. < [ -r /etc/ssh/ssh_config ] &&
  3227. < config=( "${config[@]}" "/etc/ssh/ssh_config" )
  3228. < [ -r "${HOME}/.ssh/config" ] &&
  3229. < config=( "${config[@]}" "${HOME}/.ssh/config" )
  3230. < [ -r "${HOME}/.ssh2/config" ] &&
  3231. < config=( "${config[@]}" "${HOME}/.ssh2/config" )
  3232. <
  3233. < if [ ${#config[@]} -gt 0 ]; then
  3234. < # expand path (if present) to global known hosts file
  3235. < global_kh=$( eval echo $( sed -ne 's/^[ \t]*[Gg][Ll][Oo][Bb][Aa][Ll][Kk][Nn][Oo][Ww][Nn][Hh][Oo][Ss][Tt][Ss][Ff][Ii][Ll][Ee]['"$'\t '"']*\(.*\)$/\1/p' "${config[@]}" ) )
  3236. < # expand path (if present) to user known hosts file
  3237. < user_kh=$( eval echo $( sed -ne 's/^[ \t]*[Uu][Ss][Ee][Rr][Kk][Nn][Oo][Ww][Nn][Hh][Oo][Ss][Tt][Ss][Ff][Ii][Ll][Ee]['"$'\t '"']*\(.*\)$/\1/p' "${config[@]}" ) )
  3238. < fi
  3239. <
  3240. < # choose which global known hosts file to use
  3241. < if [ -r "$global_kh" ]; then
  3242. < kh=( "$global_kh" )
  3243. < else
  3244. < [ -r /etc/ssh/ssh_known_hosts ] &&
  3245. < kh=( ${kh[@]} /etc/ssh/ssh_known_hosts )
  3246. < [ -r /etc/ssh/ssh_known_hosts2 ] &&
  3247. < kh=( ${kh[@]} /etc/ssh/ssh_known_hosts2 )
  3248. < [ -r /etc/known_hosts ] &&
  3249. < kh=( ${kh[@]} /etc/known_hosts )
  3250. < [ -r /etc/known_hosts2 ] &&
  3251. < kh=( ${kh[@]} /etc/known_hosts2 )
  3252. < [ -d /etc/ssh2/knownhosts ] &&
  3253. < khd=( ${khd[@]} /etc/ssh2/knownhosts/*pub )
  3254. < fi
  3255. <
  3256. < # choose which user known hosts file to use
  3257. < if [ -r "$user_kh" ]; then
  3258. < kh=( ${kh[@]} "$user_kh" )
  3259. < else
  3260. < [ -r ~/.ssh/known_hosts ] &&
  3261. < kh=( ${kh[@]} ~/.ssh/known_hosts )
  3262. < [ -r ~/.ssh/known_hosts2 ] &&
  3263. < kh=( ${kh[@]} ~/.ssh/known_hosts2 )
  3264. < [ -d ~/.ssh2/hostkeys ] &&
  3265. < khd=( ${khd[@]} ~/.ssh2/hostkeys/*pub )
  3266. < fi
  3267. <
  3268. < # If we have known_hosts files to use
  3269. < if [ ${#kh[@]} -gt 0 -o ${#khd[@]} -gt 0 ]; then
  3270. < # Escape slashes and dots in paths for awk
  3271. < cur=${cur//\//\\\/}
  3272. < cur=${cur//\./\\\.}
  3273. < curd=$cur
  3274. <
  3275. < if [[ "$cur" == [0-9]*.* ]]; then
  3276. < # Digits followed by a dot - just search for that
  3277. < cur="^$cur.*"
  3278. < elif [[ "$cur" == [0-9]* ]]; then
  3279. < # Digits followed by no dot - search for digits followed
  3280. < # by a dot
  3281. < cur="^$cur.*\."
  3282. < elif [ -z "$cur" ]; then
  3283. < # A blank - search for a dot or an alpha character
  3284. < cur="[a-z.]"
  3285. < else
  3286. < cur="^$cur"
  3287. < fi
  3288. <
  3289. < if [ ${#kh[@]} -gt 0 ]; then
  3290. <
  3291. < # FS needs to look for a comma separated list
  3292. < COMPREPLY=( $( awk 'BEGIN {FS=","}
  3293. < /^[^|]/ {for (i=1; i<=2; ++i) { \
  3294. < gsub(" .*$", "", $i); \
  3295. < if ($i ~ /'$cur'/) {print $i} \
  3296. < }}' ${kh[@]} 2>/dev/null ) )
  3297. < fi
  3298. < if [ ${#khd[@]} -gt 0 ]; then
  3299. < # Needs to look for files called
  3300. < # .../.ssh2/key_22_<hostname>.pub
  3301. < # dont fork any processes, because in a cluster environment,
  3302. < # there can be hundreds of hostkeys
  3303. < for i in ${khd[@]} ; do
  3304. < if [[ "$i" == *key_22_$curd*.pub ]] && [ -r "$i" ] ; then
  3305. < host=${i/#*key_22_/}
  3306. < host=${host/%.pub/}
  3307. < COMPREPLY=( ${COMPREPLY[@]} $host )
  3308. < fi
  3309. < done
  3310. < fi
  3311. < # append any available aliases from config files
  3312. < if [ ${#config[@]} -gt 0 ] && [ -n "$aliases" ]; then
  3313. < local host_aliases=$( sed -ne 's/^[Hh][Oo][Ss][Tt]\([Nn][Aa][Mm][Ee]\)\?['"$'\t '"']*\([^*?]*\)$/\2/p' "${config[@]}" )
  3314. < hosts=$( compgen -W "$host_aliases" -- $ocur )
  3315. < COMPREPLY=( ${COMPREPLY[@]} $hosts )
  3316. < fi
  3317. <
  3318. < # Now add results of normal hostname completion
  3319. < COMPREPLY=( ${COMPREPLY[@]} $( compgen -A hostname -- $ocur ) )
  3320. <
  3321. < # apply suffix
  3322. < for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
  3323. < COMPREPLY[i]=$user${COMPREPLY[i]}$suffix
  3324. < done
  3325. < else
  3326. < # Just do normal hostname completion
  3327. < COMPREPLY=( $( compgen -A hostname -S "$suffix" -- $cur ) )
  3328. < fi
  3329. <
  3330. < return 0
  3331. < }
  3332. < complete -F _known_hosts traceroute traceroute6 tracepath tracepath6 \
  3333. < ping ping6 fping fping6 telnet host nslookup rsh rlogin ftp dig ssh-installkeys mtr
  3334. <
  3335. < # ssh(1) completion
  3336. < #
  3337. < have ssh && {
  3338. < _ssh()
  3339. < {
  3340. < local cur prev
  3341. < local -a config
  3342. <
  3343. < COMPREPLY=()
  3344. < cur=`_get_cword`
  3345. < prev=${COMP_WORDS[COMP_CWORD-1]}
  3346. <
  3347. < case "$prev" in
  3348. < -*c)
  3349. < COMPREPLY=( $( compgen -W 'blowfish 3des 3des-cbc blowfish-cbc \
  3350. < arcfour cast128-cbc' -- $cur ) )
  3351. < ;;
  3352. < -*i)
  3353. < _filedir
  3354. < ;;
  3355. < -*l)
  3356. < COMPREPLY=( $( compgen -u -- $cur ) )
  3357. < ;;
  3358. < *)
  3359. < _known_hosts -a
  3360. <
  3361. < [ $COMP_CWORD -eq 1 ] || \
  3362. < COMPREPLY=( ${COMPREPLY[@]} $( compgen -c -- $cur ) )
  3363. < esac
  3364. <
  3365. < return 0
  3366. < }
  3367. < shopt -u hostcomplete && complete -F _ssh ssh slogin sftp xhost autossh
  3368. <
  3369. < # scp(1) completion
  3370. < #
  3371. < _scp()
  3372. < {
  3373. < local cur userhost path
  3374. <
  3375. < COMPREPLY=()
  3376. < cur=`_get_cword ":"`
  3377. <
  3378. < _expand || return 0
  3379. <
  3380. < if [[ "$cur" == *:* ]]; then
  3381. < local IFS=$'\t\n'
  3382. < # remove backslash escape from :
  3383. < cur=${cur/\\:/:}
  3384. < userhost=${cur%%?(\\):*}
  3385. < path=${cur#*:}
  3386. < # unescape spaces
  3387. < path=${path//\\\\\\\\ / }
  3388. < if [ -z "$path" ]; then
  3389. < # default to home dir of specified user on remote host
  3390. < path=$(ssh -o 'Batchmode yes' $userhost pwd 2>/dev/null)
  3391. < fi
  3392. < # escape spaces; remove executables, aliases, pipes and sockets;
  3393. < # add space at end of file names
  3394. < COMPREPLY=( $( ssh -o 'Batchmode yes' $userhost \
  3395. < command ls -aF1d "$path*" 2>/dev/null | \
  3396. < sed -e "s/[][(){}<>\",:;^&!$&=?\`|\\ ']/\\\\\\\\\\\\&/g" \
  3397. < -e 's/[*@|=]$//g' -e 's/[^\/]$/& /g' ) )
  3398. < return 0
  3399. < fi
  3400. <
  3401. < [[ "$cur" == */* ]] || _known_hosts -c -a
  3402. < local IFS=$'\t\n'
  3403. < COMPREPLY=( ${COMPREPLY[@]} $( command ls -aF1d $cur* \
  3404. < 2>/dev/null | sed \
  3405. < -e "s/[][(){}<>\",:;^&!$&=?\`|\\ ']/\\\\&/g" \
  3406. < -e 's/[*@|=]$//g' -e 's/[^\/]$/& /g' ) )
  3407. < return 0
  3408. < }
  3409. < complete -F _scp $nospace scp
  3410. < }
  3411. <
  3412. < # rsync(1) completion
  3413. < #
  3414. < have rsync &&
  3415. < _rsync()
  3416. < {
  3417. < local cur prev shell i userhost path
  3418. <
  3419. < COMPREPLY=()
  3420. < cur=`_get_cword`
  3421. < prev=${COMP_WORDS[COMP_CWORD-1]}
  3422. <
  3423. < _expand || return 0
  3424. <
  3425. < case "$prev" in
  3426. < --@(config|password-file|include-from|exclude-from))
  3427. < _filedir
  3428. < return 0
  3429. < ;;
  3430. < -@(T|-temp-dir|-compare-dest))
  3431. < _filedir -d
  3432. < return 0
  3433. < ;;
  3434. < -@(e|-rsh))
  3435. < COMPREPLY=( $( compgen -W 'rsh ssh' -- $cur ) )
  3436. < return 0
  3437. < ;;
  3438. < esac
  3439. <
  3440. < case "$cur" in
  3441. < -*)
  3442. < COMPREPLY=( $( compgen -W '-v -q -c -a -r -R -b -u -l -L -H \
  3443. < -p -o -g -D -t -S -n -W -x -B -e -C -I -T -P \
  3444. < -z -h -4 -6 --verbose --quiet --checksum \
  3445. < --archive --recursive --relative --backup \
  3446. < --backup-dir --suffix= --update --links \
  3447. < --copy-links --copy-unsafe-links --safe-links \
  3448. < --hard-links --perms --owner --group --devices\
  3449. < --times --sparse --dry-run --whole-file \
  3450. < --no-whole-file --one-file-system \
  3451. < --block-size= --rsh= --rsync-path= \
  3452. < --cvs-exclude --existing --ignore-existing \
  3453. < --delete --delete-excluded --delete-after \
  3454. < --ignore-errors --max-delete= --partial \
  3455. < --force --numeric-ids --timeout= \
  3456. < --ignore-times --size-only --modify-window= \
  3457. < --temp-dir= --compare-dest= --compress \
  3458. < --exclude= --exclude-from= --include= \
  3459. < --include-from= --version --daemon --no-detach\
  3460. < --address= --config= --port= --blocking-io \
  3461. < --no-blocking-io --stats --progress \
  3462. < --log-format= --password-file= --bwlimit= \
  3463. < --write-batch= --read-batch= --help' -- $cur ))
  3464. < ;;
  3465. < *:*)
  3466. < # find which remote shell is used
  3467. < shell=rsh
  3468. < for (( i=1; i < COMP_CWORD; i++ )); do
  3469. < if [[ "${COMP_WORDS[i]}" == -@(e|-rsh) ]]; then
  3470. < shell=${COMP_WORDS[i+1]}
  3471. < break
  3472. < fi
  3473. < done
  3474. < if [[ "$shell" == ssh ]]; then
  3475. < # remove backslash escape from :
  3476. < cur=${cur/\\:/:}
  3477. < userhost=${cur%%?(\\):*}
  3478. < path=${cur#*:}
  3479. < # unescape spaces
  3480. < path=${path//\\\\\\\\ / }
  3481. < if [ -z "$path" ]; then
  3482. < # default to home dir of specified
  3483. < # user on remote host
  3484. < path=$(ssh -o 'Batchmode yes' \
  3485. < $userhost pwd 2>/dev/null)
  3486. < fi
  3487. < # escape spaces; remove executables, aliases, pipes
  3488. < # and sockets; add space at end of file names
  3489. < COMPREPLY=( $( ssh -o 'Batchmode yes' $userhost \
  3490. < command ls -aF1d "$path*" 2>/dev/null | \
  3491. < sed -e 's/ /\\\\\\\ /g' -e 's/[*@|=]$//g' \
  3492. < -e 's/[^\/]$/& /g' ) )
  3493. < fi
  3494. < ;;
  3495. < *)
  3496. < _known_hosts -c -a
  3497. < _filedir
  3498. < ;;
  3499. < esac
  3500. <
  3501. < return 0
  3502. < } &&
  3503. < complete -F _rsync $nospace $filenames rsync
  3504. <
  3505. < # Linux route(8) completion
  3506. < #
  3507. < [ $UNAME = Linux ] &&
  3508. < _route()
  3509. < {
  3510. < local cur prev
  3511. <
  3512. < COMPREPLY=()
  3513. < cur=`_get_cword`
  3514. < prev=${COMP_WORDS[COMP_CWORD-1]}
  3515. <
  3516. < if [ "$prev" = dev ]; then
  3517. < COMPREPLY=( $( ifconfig -a | sed -ne 's|^\('$cur'[^ ]*\).*$|\1|p' ))
  3518. < return 0
  3519. < fi
  3520. <
  3521. < COMPREPLY=( $( compgen -W 'add del -host -net netmask metric mss \
  3522. < window irtt reject mod dyn reinstate dev \
  3523. < default gw' -- $cur ) )
  3524. <
  3525. < COMPREPLY=( $( echo " ${COMP_WORDS[@]}" | \
  3526. < (while read -d ' ' i; do
  3527. < [ "$i" == "" ] && continue
  3528. < # flatten array with spaces on either side,
  3529. < # otherwise we cannot grep on word
  3530. < # boundaries of first and last word
  3531. < COMPREPLY=" ${COMPREPLY[@]} "
  3532. < # remove word from list of completions
  3533. < COMPREPLY=( ${COMPREPLY/ $i / } )
  3534. < done
  3535. < echo ${COMPREPLY[@]})
  3536. < ) )
  3537. < return 0
  3538. < }
  3539. < [ $UNAME = Linux ] && complete -F _route route
  3540. <
  3541. < # GNU make(1) completion
  3542. < #
  3543. < have make || have gmake || have gnumake || have pmake &&
  3544. < _make()
  3545. < {
  3546. < local file makef makef_dir="." makef_inc cur prev i
  3547. <
  3548. < COMPREPLY=()
  3549. < cur=`_get_cword`
  3550. < prev=${COMP_WORDS[COMP_CWORD-1]}
  3551. <
  3552. < # --name value style option
  3553. < case $prev in
  3554. < -@(f|o|W))
  3555. < _filedir
  3556. < return 0
  3557. < ;;
  3558. < -@(I|C))
  3559. < _filedir -d
  3560. < return 0
  3561. < ;;
  3562. < esac
  3563. <
  3564. < # --name=value style option
  3565. < if [[ "$cur" == *=* ]]; then
  3566. < prev=${cur/=*/}
  3567. < cur=${cur/*=/}
  3568. < case "$prev" in
  3569. < --@(file|makefile))
  3570. < _filedir
  3571. < return 0
  3572. < ;;
  3573. < --@(directory|include-dir))
  3574. < _filedir -d
  3575. < return 0
  3576. < ;;
  3577. < esac
  3578. < fi
  3579. <
  3580. < if [[ "$cur" == -* ]]; then
  3581. < COMPREPLY=( $( compgen -W '-b -m -B -C -d -e -f -h -i -I\
  3582. < -j -l -k -n -o -p -q -r -R - s -S -t -v -w -W \
  3583. < --always-make --directory= --debug \
  3584. < --environment-overrides --file= --makefile= --help \
  3585. < --ignore-errors --include-dir= --jobs --load-average \
  3586. < --max-load --keep-going --just-print --dry-run \
  3587. < --recon --old-file= --assume-old= --print-data-base \
  3588. < --question --no-builtin-rules --no-builtin-variables \
  3589. < --silent --quiet --no-keep-goind --stop --touch \
  3590. < --version --print-directory --no-print-directory \
  3591. < --what-if= --new-file= --assume-new= \
  3592. < --warn-undefined-variables' -- $cur ) )
  3593. < else
  3594. < # before we check for makefiles, see if a path was specified
  3595. < # with -C
  3596. < for (( i=0; i < ${#COMP_WORDS[@]}; i++ )); do
  3597. < if [[ ${COMP_WORDS[i]} == -C ]]; then
  3598. < # eval for tilde expansion
  3599. < eval makef_dir=${COMP_WORDS[i+1]}
  3600. < break
  3601. < fi
  3602. < done
  3603. <
  3604. < # make reads `GNUmakefile', then `makefile', then `Makefile'
  3605. < if [ -f ${makef_dir}/GNUmakefile ]; then
  3606. < makef=${makef_dir}/GNUmakefile
  3607. < elif [ -f ${makef_dir}/makefile ]; then
  3608. < makef=${makef_dir}/makefile
  3609. < elif [ -f ${makef_dir}/Makefile ]; then
  3610. < makef=${makef_dir}/Makefile
  3611. < else
  3612. < makef=${makef_dir}/*.mk # local convention
  3613. < fi
  3614. <
  3615. < # before we scan for targets, see if a Makefile name was
  3616. < # specified with -f
  3617. < for (( i=0; i < ${#COMP_WORDS[@]}; i++ )); do
  3618. < if [[ ${COMP_WORDS[i]} == -f ]]; then
  3619. < # eval for tilde expansion
  3620. < eval makef=${COMP_WORDS[i+1]}
  3621. < break
  3622. < fi
  3623. < done
  3624. <
  3625. < [ ! -f $makef ] && return 0
  3626. <
  3627. < # deal with included Makefiles
  3628. < makef_inc=$( grep -E '^-?include' $makef | sed -e "s,^.* ,"$makef_dir"/," )
  3629. <
  3630. < for file in $makef_inc; do
  3631. < [ -f $file ] && makef="$makef $file"
  3632. < done
  3633. <
  3634. < COMPREPLY=( $( awk -F':' '/^[a-zA-Z0-9][^$#\/\t=]*:([^=]|$)/ \
  3635. < {split($1,A,/ /);for(i in A)print A[i]}' \
  3636. < $makef 2>/dev/null | command grep "^$cur" ))
  3637. < fi
  3638. < } &&
  3639. < complete -f -F _make $filenames make gmake gnumake pmake
  3640. <
  3641. < # GNU tar(1) completion
  3642. < #
  3643. < _tar()
  3644. < {
  3645. < local cur ext regex tar untar
  3646. <
  3647. < COMPREPLY=()
  3648. < cur=`_get_cword`
  3649. <
  3650. < if [ $COMP_CWORD -eq 1 ]; then
  3651. < COMPREPLY=( $( compgen -W 'c t x u r d A' -- $cur ) )
  3652. < return 0
  3653. < fi
  3654. <
  3655. < case "${COMP_WORDS[1]}" in
  3656. < ?(-)[cr]*f)
  3657. < _filedir
  3658. < return 0
  3659. < ;;
  3660. < +([^IZzjy])f)
  3661. < ext='t@(ar?(.@(Z|gz|bz?(2)))|gz|bz?(2))'
  3662. < regex='t\(ar\(\.\(Z\|gz\|bz2\?\)\)\?\|gz\|bz2\?\)'
  3663. < ;;
  3664. < *[Zz]*f)
  3665. < ext='t?(ar.)@(gz|Z)'
  3666. < regex='t\(ar\.\)\?\(gz\|Z\)'
  3667. < ;;
  3668. < *[Ijy]*f)
  3669. < ext='t?(ar.)bz?(2)'
  3670. < regex='t\(ar\.\)\?bz2\?'
  3671. < ;;
  3672. < *)
  3673. < _filedir
  3674. < return 0
  3675. < ;;
  3676. <
  3677. < esac
  3678. <
  3679. < if [[ "$COMP_LINE" == *$ext' ' ]]; then
  3680. < # complete on files in tar file
  3681. < #
  3682. < # get name of tar file from command line
  3683. < tar=$( echo "$COMP_LINE" | \
  3684. < sed -e 's/^.* \([^ ]*'$regex'\) .*$/\1/' )
  3685. < # devise how to untar and list it
  3686. < untar=t${COMP_WORDS[1]//[^Izjyf]/}
  3687. <
  3688. < COMPREPLY=( $( compgen -W "$( echo $( tar $untar $tar \
  3689. < 2>/dev/null ) )" -- "$cur" ) )
  3690. < return 0
  3691. < fi
  3692. <
  3693. < # file completion on relevant files
  3694. < _filedir $ext
  3695. <
  3696. < return 0
  3697. < }
  3698. < [ -n "${COMP_TAR_INTERNAL_PATHS:-}" ] && complete -F _tar $dirnames tar ||
  3699. < complete -F _tar $filenames tar
  3700. <
  3701. < # jar(1) completion
  3702. < #
  3703. < have jar &&
  3704. < _jar()
  3705. < {
  3706. < local cur
  3707. <
  3708. < COMPREPLY=()
  3709. < cur=`_get_cword`
  3710. <
  3711. < if [ $COMP_CWORD = 1 ]; then
  3712. < COMPREPLY=( $( compgen -W 'c t x u' -- $cur ) )
  3713. < return 0
  3714. < fi
  3715. <
  3716. < case "${COMP_WORDS[1]}" in
  3717. < *c*f)
  3718. < _filedir
  3719. < ;;
  3720. < *f)
  3721. < _filedir '?(e|j|w)ar'
  3722. < ;;
  3723. < *)
  3724. < _filedir
  3725. < ;;
  3726. < esac
  3727. < } &&
  3728. < complete -F _jar $filenames jar
  3729. <
  3730. < # Linux iptables(8) completion
  3731. < #
  3732. < have iptables &&
  3733. < _iptables()
  3734. < {
  3735. < local cur prev table chain
  3736. <
  3737. < COMPREPLY=()
  3738. < cur=`_get_cword`
  3739. < prev=${COMP_WORDS[COMP_CWORD-1]}
  3740. < chain='s/^Chain \([^ ]\+\).*$/\1/p'
  3741. <
  3742. < if [[ $COMP_LINE == *-t\ *filter* ]]; then
  3743. < table="-t filter"
  3744. < elif [[ $COMP_LINE == *-t\ *nat* ]]; then
  3745. < table="-t nat"
  3746. < elif [[ $COMP_LINE == *-t\ *mangle* ]]; then
  3747. < table="-t mangle"
  3748. < fi
  3749. <
  3750. < case "$prev" in
  3751. < -*[AIDRPFXLZ])
  3752. < COMPREPLY=( $( compgen -W '`iptables $table -nL | \
  3753. < sed -ne "s/^Chain \([^ ]\+\).*$/\1/p"`' -- $cur ) )
  3754. < ;;
  3755. < -*t)
  3756. < COMPREPLY=( $( compgen -W 'nat filter mangle' -- $cur ) )
  3757. < ;;
  3758. < -j)
  3759. < if [ "$table" = "-t filter" -o "$table" = "" ]; then
  3760. < COMPREPLY=( $( compgen -W 'ACCEPT DROP LOG ULOG REJECT \
  3761. < `iptables $table -nL | sed -ne "$chain" \
  3762. < -e "s/INPUT|OUTPUT|FORWARD|PREROUTING|POSTROUTING//"`' -- \
  3763. < $cur ) )
  3764. < elif [ "$table" = "-t nat" ]; then
  3765. < COMPREPLY=( $( compgen -W 'ACCEPT DROP LOG ULOG REJECT \
  3766. < MIRROR SNAT DNAT MASQUERADE `iptables $table -nL | \
  3767. < sed -ne "$chain" -e "s/OUTPUT|PREROUTING|POSTROUTING//"`' \
  3768. < -- $cur ) )
  3769. < elif [ "$table" = "-t mangle" ]; then
  3770. < COMPREPLY=( $( compgen -W 'ACCEPT DROP LOG ULOG REJECT \
  3771. < MARK TOS `iptables $table -nL | sed -ne "$chain" \
  3772. < -e "s/INPUT|OUTPUT|FORWARD|PREROUTING|POSTROUTING//"`' -- \
  3773. < $cur ) )
  3774. < fi
  3775. < ;;
  3776. < *)
  3777. < if [[ "$cur" == -* ]]; then
  3778. < COMPREPLY=( $( compgen -W '-i -o -s -d -p -f -m --append \
  3779. < --delete --insert --replace --list --flush --zero --new \
  3780. < --delete-chain --policy --rename-chain --proto --source \
  3781. < --destination --in-interface --jump --match --numeric \
  3782. < --out-interface --table --verbose --line-numbers --exact \
  3783. < --fragment --modprobe= --set-counters --version' -- "$cur") )
  3784. < fi
  3785. < ;;
  3786. < esac
  3787. <
  3788. < } &&
  3789. < complete -F _iptables iptables
  3790. <
  3791. < # tcpdump(8) completion
  3792. < #
  3793. < have tcpdump &&
  3794. < _tcpdump()
  3795. < {
  3796. < local cur
  3797. <
  3798. < COMPREPLY=()
  3799. < cur=`_get_cword`
  3800. < prev=${COMP_WORDS[COMP_CWORD-1]}
  3801. <
  3802. < case "$prev" in
  3803. < -@(r|w|F))
  3804. < _filedir
  3805. < return 0
  3806. < ;;
  3807. < -i)
  3808. < _available_interfaces -a
  3809. < return 0
  3810. < ;;
  3811. < esac
  3812. <
  3813. <
  3814. < if [[ "$cur" == -* ]]; then
  3815. < COMPREPLY=( $( compgen -W '-a -d -e -f -l -n -N -O -p \
  3816. < -q -R -S -t -u -v -x -C -F -i -m -r -s -T -w \
  3817. < -E' -- $cur ) )
  3818. < fi
  3819. <
  3820. < } &&
  3821. < complete -F _tcpdump tcpdump
  3822. <
  3823. < # autorpm(8) completion
  3824. < #
  3825. < have autorpm &&
  3826. < _autorpm()
  3827. < {
  3828. < local cur
  3829. <
  3830. < COMPREPLY=()
  3831. < cur=`_get_cword`
  3832. <
  3833. < COMPREPLY=( $( compgen -W '--notty --debug --help --version \
  3834. < auto add fullinfo info help install list \
  3835. < remove set' -- $cur ) )
  3836. ---
  3837. > # This function counts the number of args, excluding options
  3838. > # @param $1 chars Characters out of $COMP_WORDBREAKS which should
  3839. > # NOT be considered word breaks. See __reassemble_comp_words_by_ref.
  3840. > _count_args()
  3841. > {
  3842. > local i cword words
  3843. > __reassemble_comp_words_by_ref "$1" words cword
  3844. 3077,3078c1090,1094
  3845. < } &&
  3846. < complete -F _autorpm autorpm
  3847. ---
  3848. > args=1
  3849. > for i in "${words[@]:1:cword-1}"; do
  3850. > [[ "$i" != -* ]] && args=$(($args+1))
  3851. > done
  3852. > }
  3853. 3080,3081c1096
  3854. < # This meta-cd function observes the CDPATH variable, so that cd additionally
  3855. < # completes on directories under those specified in CDPATH.
  3856. ---
  3857. > # This function completes on PCI IDs
  3858. 3083c1098
  3859. < _cd()
  3860. ---
  3861. > _pci_ids()
  3862. 3085,3124c1100,1101
  3863. < local IFS=$'\t\n' cur=`_get_cword` i j k
  3864. <
  3865. < # try to allow variable completion
  3866. < if [[ "$cur" == ?(\\)\$* ]]; then
  3867. < COMPREPLY=( $( compgen -v -P '$' -- "${cur#?(\\)$}" ) )
  3868. < return 0
  3869. < fi
  3870. <
  3871. < # Use standard dir completion if no CDPATH or parameter starts with /,
  3872. < # ./ or ../
  3873. < if [ -z "${CDPATH:-}" ] || [[ "$cur" == ?(.)?(.)/* ]]; then
  3874. < _filedir -d
  3875. < return 0
  3876. < fi
  3877. <
  3878. < local -r mark_dirs=$(_rl_enabled mark-directories && echo y)
  3879. < local -r mark_symdirs=$(_rl_enabled mark-symlinked-directories && echo y)
  3880. <
  3881. < # we have a CDPATH, so loop on its contents
  3882. < for i in ${CDPATH//:/$'\t'}; do
  3883. < # create an array of matched subdirs
  3884. < k=${#COMPREPLY[@]}
  3885. < for j in $( compgen -d $i/$cur ); do
  3886. < if [[ ( $mark_symdirs && -h $j || $mark_dirs && ! -h $j ) && ! -d ${j#$i/} ]]; then
  3887. < j="${j}/"
  3888. < fi
  3889. < COMPREPLY[k++]=${j#$i/}
  3890. < done
  3891. < done
  3892. <
  3893. < _filedir -d
  3894. <
  3895. < if [[ ${#COMPREPLY[@]} -eq 1 ]]; then
  3896. < i=${COMPREPLY[0]}
  3897. < if [ "$i" == "$cur" ] && [[ $i != "*/" ]]; then
  3898. < COMPREPLY[0]="${i}/"
  3899. < fi
  3900. < fi
  3901. <
  3902. < return 0
  3903. ---
  3904. > COMPREPLY=( ${COMPREPLY[@]:-} $( compgen -W \
  3905. > "$( PATH="$PATH:/sbin" lspci -n | awk '{print $3}')" -- "$cur" ) )
  3906. 3126,3130d1102
  3907. < if shopt -q cdable_vars; then
  3908. < complete -v -F _cd $nospace $filenames cd
  3909. < else
  3910. < complete -F _cd $nospace $filenames cd
  3911. < fi
  3912. 3132,3135c1104
  3913. < # A meta-command completion function for commands like sudo(8), which need to
  3914. < # first complete on a command, then complete according to that command's own
  3915. < # completion definition - currently not quite foolproof (e.g. mount and umount
  3916. < # don't work properly), but still quite useful.
  3917. ---
  3918. > # This function completes on USB IDs
  3919. 3137c1106
  3920. < _command()
  3921. ---
  3922. > _usb_ids()
  3923. 3139,3213c1108,1109
  3924. < local cur func cline cspec noglob cmd done i \
  3925. < _COMMAND_FUNC _COMMAND_FUNC_ARGS
  3926. <
  3927. < COMPREPLY=()
  3928. < cur=`_get_cword`
  3929. < # If the the first arguments following our meta-command-invoker are
  3930. < # switches, get rid of them. Most definitely not foolproof.
  3931. < done=
  3932. < while [ -z $done ] ; do
  3933. < cmd=${COMP_WORDS[1]}
  3934. < if [[ "$cmd" == -* ]] && [ $COMP_CWORD -gt 1 ]; then
  3935. < for (( i=1 ; i<COMP_CWORD ; i++)) ; do
  3936. < COMP_WORDS[i]=${COMP_WORDS[i+1]}
  3937. < done
  3938. < COMP_CWORD=$(($COMP_CWORD-1))
  3939. < else
  3940. < done=1
  3941. < fi
  3942. < done
  3943. <
  3944. < if [ $COMP_CWORD -eq 1 ]; then
  3945. < COMPREPLY=( $( compgen -c -- $cur ) )
  3946. < elif complete -p $cmd &>/dev/null; then
  3947. < cspec=$( complete -p $cmd )
  3948. < if [ "${cspec#* -F }" != "$cspec" ]; then
  3949. < # complete -F <function>
  3950. < #
  3951. < # COMP_CWORD and COMP_WORDS() are not read-only,
  3952. < # so we can set them before handing off to regular
  3953. < # completion routine
  3954. <
  3955. < # set current token number to 1 less than now
  3956. < COMP_CWORD=$(( $COMP_CWORD - 1 ))
  3957. <
  3958. < # get function name
  3959. < func=${cspec#*-F }
  3960. < func=${func%% *}
  3961. < # get current command line minus initial command
  3962. < cline="${COMP_LINE#*( )$1 }"
  3963. < # save noglob state
  3964. < shopt -qo noglob; noglob=$?
  3965. < # turn on noglob, as things like 'sudo ls *<Tab>'
  3966. < # don't work otherwise
  3967. < shopt -so noglob
  3968. < # split current command line tokens into array
  3969. < COMP_WORDS=( $cline )
  3970. < # reset noglob if necessary
  3971. < [ $noglob -eq 1 ] && shopt -uo noglob
  3972. < $func $cline
  3973. < # This is needed in case user finished entering
  3974. < # command and pressed tab (e.g. sudo ls <Tab>)
  3975. < COMP_CWORD=$(( $COMP_CWORD > 0 ? $COMP_CWORD : 1 ))
  3976. < cur=`_get_cword`
  3977. < _COMMAND_FUNC=$func
  3978. < _COMMAND_FUNC_ARGS=( $cmd $2 $3 )
  3979. < COMP_LINE=$cline
  3980. < COMP_POINT=$(( ${COMP_POINT} - ${#1} - 1 ))
  3981. < $func $cmd $2 $3
  3982. < # remove any \: generated by a command that doesn't
  3983. < # default to filenames or dirnames (e.g. sudo chown)
  3984. < if [ "${cspec#*-o }" != "$cspec" ]; then
  3985. < cspec=${cspec#*-o }
  3986. < cspec=${cspec%% *}
  3987. < if [[ "$cspec" != @(dir|file)names ]]; then
  3988. < COMPREPLY=("${COMPREPLY[@]//\\\\:/:}")
  3989. < fi
  3990. < fi
  3991. < elif [ -n "$cspec" ]; then
  3992. < cspec=${cspec#complete};
  3993. < cspec=${cspec%%$cmd};
  3994. < COMPREPLY=( $( eval compgen "$cspec" -- "$cur" ) );
  3995. < fi
  3996. < fi
  3997. <
  3998. < [ ${#COMPREPLY[@]} -eq 0 ] && _filedir
  3999. ---
  4000. > COMPREPLY=( ${COMPREPLY[@]:-} $( compgen -W \
  4001. > "$( PATH="$PATH:/sbin" lsusb | awk '{print $6}' )" -- "$cur" ) )
  4002. 3215,3216d1110
  4003. < complete -F _command $filenames nohup exec nice eval strace time ltrace then \
  4004. < else do vsound command xargs
  4005. 3218c1112,1113
  4006. < _root_command()
  4007. ---
  4008. > # CD device names
  4009. > _cd_devices()
  4010. 3220c1115,1116
  4011. < PATH=$PATH:/sbin:/usr/sbin:/usr/local/sbin _command $1 $2 $3
  4012. ---
  4013. > COMPREPLY=( "${COMPREPLY[@]}"
  4014. > $( compgen -f -d -X "!*/?([amrs])cd*" -- "${cur:-/dev/}" ) )
  4015. 3222d1117
  4016. < complete -F _root_command $filenames sudo fakeroot really
  4017. 3224,3227c1119,1120
  4018. < # ant(1) completion
  4019. < #
  4020. < have ant && {
  4021. < _ant()
  4022. ---
  4023. > # DVD device names
  4024. > _dvd_devices()
  4025. 3229,4132c1122,1123
  4026. < local cur prev buildfile i
  4027. <
  4028. < COMPREPLY=()
  4029. < cur=`_get_cword`
  4030. < prev=${COMP_WORDS[COMP_CWORD-1]}
  4031. <
  4032. < case "$prev" in
  4033. < -buildfile|-f)
  4034. < _filedir 'xml'
  4035. < return 0
  4036. < ;;
  4037. < -logfile)
  4038. < _filedir
  4039. < return 0
  4040. < ;;
  4041. < esac
  4042. <
  4043. < if [[ "$cur" == -* ]]; then
  4044. < # relevant options completion
  4045. < COMPREPLY=( $( compgen -W '-help -projecthelp -version -quiet \
  4046. < -verbose -debug -emacs -logfile -logger \
  4047. < -listener -buildfile -f -D -find' -- $cur ) )
  4048. < else
  4049. < # available targets completion
  4050. < # find which buildfile to use
  4051. < buildfile=build.xml
  4052. < for (( i=1; i < COMP_CWORD; i++ )); do
  4053. < if [[ "${COMP_WORDS[i]}" == -buildfile ]]; then
  4054. < buildfile=${COMP_WORDS[i+1]}
  4055. < break
  4056. < fi
  4057. < done
  4058. < [ ! -f $buildfile ] && return 0
  4059. <
  4060. < # parse buildfile for targets
  4061. < COMPREPLY=( $( awk -F'"' '/<target name="/ {print $2}' \
  4062. < $buildfile | grep "^$cur" )
  4063. < $( awk -F"'" "/<target name='/ "'{print $2}' \
  4064. < $buildfile | grep "^$cur" )
  4065. < $( awk -F'"' '/<target [^n]/ {if ($1 ~ /name=/) { print $2 } else if ($3 ~ /name=/) {print $4} else if ($5 ~ /name=/) {print $6}}' \
  4066. < $buildfile | grep "^$cur" ) )
  4067. < fi
  4068. < }
  4069. < have complete-ant-cmd.pl && \
  4070. < complete -C complete-ant-cmd.pl -F _ant $filenames ant || \
  4071. < complete -F _ant $filenames ant
  4072. < }
  4073. <
  4074. < have nslookup &&
  4075. < _nslookup()
  4076. < {
  4077. < local cur
  4078. <
  4079. < COMPREPLY=()
  4080. < cur=${COMP_WORDS[COMP_CWORD]#-}
  4081. <
  4082. < COMPREPLY=( $( compgen -P '-' -W 'all class= debug d2 domain= \
  4083. < srchlist= defname search port= querytype= \
  4084. < type= recurse retry root timeout vc \
  4085. < ignoretc' -- $cur ) )
  4086. < } &&
  4087. < complete -F _nslookup nslookup
  4088. <
  4089. < # mysqladmin(1) completion
  4090. < #
  4091. < have mysqladmin &&
  4092. < _mysqladmin()
  4093. < {
  4094. < local cur prev
  4095. <
  4096. < COMPREPLY=()
  4097. < cur=`_get_cword`
  4098. < prev=${COMP_WORDS[COMP_CWORD-1]}
  4099. <
  4100. < case "$prev" in
  4101. < -u)
  4102. < COMPREPLY=( $( compgen -u -- $cur ) )
  4103. < return 0
  4104. < ;;
  4105. < *)
  4106. < ;;
  4107. < esac
  4108. <
  4109. < COMPREPLY=( $( compgen -W '-# -f -? -C -h -p -P -i -r -E -s -S -t -u \
  4110. < -v -V -w' -- $cur ) )
  4111. <
  4112. < COMPREPLY=( ${COMPREPLY[@]} \
  4113. < $( compgen -W 'create drop extended-status flush-hosts \
  4114. < flush-logs flush-status flush-tables \
  4115. < flush-threads flush-privileges kill \
  4116. < password ping processlist reload refresh \
  4117. < shutdown status variables version' \
  4118. < -- $cur ) )
  4119. < } &&
  4120. < complete -F _mysqladmin mysqladmin
  4121. <
  4122. < # gzip(1) completion
  4123. < #
  4124. < have gzip &&
  4125. < _gzip()
  4126. < {
  4127. < local cur prev xspec IFS=$'\t\n'
  4128. <
  4129. < COMPREPLY=()
  4130. < cur=`_get_cword`
  4131. < prev=${COMP_WORDS[COMP_CWORD-1]}
  4132. <
  4133. < if [[ "$cur" == -* ]]; then
  4134. < COMPREPLY=( $( compgen -W '-c -d -f \
  4135. < -h -l -L -n -N -q -r -S -t -v -V \
  4136. < -1 -2 -3 -4 -5 -6 -7 -8 -9 \
  4137. < --stdout --decompress --force --help --list \
  4138. < --license --no-name --name --quiet --recursive \
  4139. < --suffix --test --verbose --version --fast \
  4140. < --best' -- $cur ) )
  4141. < return 0
  4142. < fi
  4143. <
  4144. < xspec="*.?(t)gz"
  4145. < if [[ "$prev" == --* ]]; then
  4146. < [[ "$prev" == --decompress || \
  4147. < "$prev" == --list || \
  4148. < "$prev" == --test ]] && xspec="!"$xspec
  4149. < [[ "$prev" == --force ]] && xspec=
  4150. < elif [[ "$prev" == -* ]]; then
  4151. < [[ "$prev" == -*[dlt]* ]] && xspec="!"$xspec
  4152. < [[ "$prev" == -*f* ]] && xspec=
  4153. < elif [ "$prev" = '>' ]; then
  4154. < xspec=
  4155. < elif [ "$prev" = '<' ]; then
  4156. < xspec=
  4157. < fi
  4158. <
  4159. < _expand || return 0
  4160. <
  4161. < COMPREPLY=( $( compgen -f -X "$xspec" -- $cur ) \
  4162. < $( compgen -d -- $cur ) )
  4163. < } &&
  4164. < complete -F _gzip $filenames gzip
  4165. <
  4166. < # bzip2(1) completion
  4167. < #
  4168. < have bzip2 &&
  4169. < _bzip2()
  4170. < {
  4171. < local cur prev xspec IFS=$'\t\n'
  4172. <
  4173. < COMPREPLY=()
  4174. < cur=`_get_cword`
  4175. < prev=${COMP_WORDS[COMP_CWORD-1]}
  4176. <
  4177. < if [[ "$cur" == -* ]]; then
  4178. < COMPREPLY=( $( compgen -W '-c -d -f -h -k -L -q -s \
  4179. < -t -v -V -z -1 -2 -3 -4 -5 -6 -7 -8 -9 \
  4180. < --help --decompress --compress --keep --force \
  4181. < --test --stdout --quiet --verbose --license \
  4182. < --version --small --fast --best' -- $cur ) )
  4183. < return 0
  4184. < fi
  4185. <
  4186. < xspec="*.bz2"
  4187. < if [[ "$prev" == --* ]]; then
  4188. < [[ "$prev" == --decompress || \
  4189. < "$prev" == --list || \
  4190. < "$prev" == --test ]] && xspec="!"$xspec
  4191. < [[ "$prev" == --compress ]] && xspec=
  4192. < elif [[ "$prev" == -* ]]; then
  4193. < [[ "$prev" == -*[dt]* ]] && xspec="!"$xspec
  4194. < [[ "$prev" == -*z* ]] && xspec=
  4195. < fi
  4196. <
  4197. < _expand || return 0
  4198. <
  4199. < COMPREPLY=( $( compgen -f -X "$xspec" -- $cur ) \
  4200. < $( compgen -d -- $cur ) )
  4201. < } &&
  4202. < complete -F _bzip2 $filenames bzip2
  4203. <
  4204. < # openssl(1) completion
  4205. < #
  4206. < have openssl && {
  4207. < _openssl_sections()
  4208. < {
  4209. < local config
  4210. <
  4211. < config=/etc/ssl/openssl.cnf
  4212. < [ ! -f $config ] && config=/usr/share/ssl/openssl.cnf
  4213. < for (( i=2; i < COMP_CWORD; i++ )); do
  4214. < if [[ "${COMP_WORDS[i]}" == -config ]]; then
  4215. < config=${COMP_WORDS[i+1]}
  4216. < break
  4217. < fi
  4218. < done
  4219. < [ ! -f $config ] && return 0
  4220. <
  4221. < COMPREPLY=( $( awk '/\[.*\]/ {print $2} ' $config | grep "^$cur" ) )
  4222. < }
  4223. <
  4224. < _openssl()
  4225. < {
  4226. < local cur prev
  4227. <
  4228. < COMPREPLY=()
  4229. < cur=`_get_cword`
  4230. <
  4231. < if [ $COMP_CWORD -eq 1 ]; then
  4232. < COMPREPLY=( $( compgen -W 'asn1parse ca ciphers crl crl2pkcs7 \
  4233. < dgst dh dhparam dsa dsaparam enc errstr gendh gendsa \
  4234. < genrsa nseq passwd pkcs12 pkcs7 pkcs8 rand req rsa \
  4235. < rsautl s_client s_server s_time sess_id smime speed \
  4236. < spkac verify version x509 md2 md4 md5 mdc2 rmd160 sha \
  4237. < sha1 base64 bf bf-cbc bf-cfb bf-ecb bf-ofb cast \
  4238. < cast-cbc cast5-cbc cast5-cfb cast5-ecb cast5-ofb des \
  4239. < des-cbc des-cfb des-ecb des-ede des-ede-cbc \
  4240. < des-ede-cfb des-ede-ofb des-ede3 des-ede3-cbc \
  4241. < des-ede3-cfb des-ede3-ofb des-ofb des3 desx rc2 \
  4242. < rc2-40-cbc rc2-64-cbc rc2-cbc rc2-cfb rc2-ecb rc2-ofb \
  4243. < rc4 rc4-40' -- $cur ) )
  4244. < else
  4245. < prev=${COMP_WORDS[COMP_CWORD-1]}
  4246. < case ${COMP_WORDS[1]} in
  4247. < asn1parse)
  4248. < case $prev in
  4249. < -inform)
  4250. < COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  4251. < return 0
  4252. < ;;
  4253. < -@(in|out|oid))
  4254. < _filedir
  4255. < return 0
  4256. < ;;
  4257. < esac
  4258. <
  4259. < if [[ "$cur" == -* ]]; then
  4260. < COMPREPLY=( $( compgen -W '-inform -in -out -noout -offset \
  4261. < -length -i -oid -strparse' -- $cur ) )
  4262. < fi
  4263. < ;;
  4264. < ca)
  4265. < case $prev in
  4266. < -@(config|revoke|cert|in|out|spkac|ss_cert))
  4267. < _filedir
  4268. < return 0
  4269. < ;;
  4270. < -outdir)
  4271. < _filedir -d
  4272. < return 0
  4273. < ;;
  4274. < -@(name|crlexts|extensions))
  4275. < _openssl_sections
  4276. < return 0
  4277. < ;;
  4278. < esac
  4279. <
  4280. < if [[ "$cur" == -* ]]; then
  4281. < COMPREPLY=( $( compgen -W '-verbose -config -name \
  4282. < -gencrl -revoke -crldays -crlhours -crlexts \
  4283. < -startdate -enddate -days -md -policy -keyfile \
  4284. < -key -passin -cert -in -out -notext -outdir \
  4285. < -infiles -spkac -ss_cert -preserveDN -batch \
  4286. < -msie_hack -extensions' -- $cur ) )
  4287. < fi
  4288. < ;;
  4289. < ciphers)
  4290. < if [[ "$cur" == -* ]]; then
  4291. < COMPREPLY=( $( compgen -W '-v -ssl2 -ssl3 -tls1' -- $cur ) )
  4292. < fi
  4293. < ;;
  4294. < crl)
  4295. < case $prev in
  4296. < -@(in|out)form)
  4297. < COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  4298. < return 0
  4299. < ;;
  4300. < -@(in|out|CAfile))
  4301. < _filedir
  4302. < return 0
  4303. < ;;
  4304. < -CAPath)
  4305. < _filedir -d
  4306. < return 0
  4307. < ;;
  4308. < esac
  4309. <
  4310. < if [[ "$cur" == -* ]]; then
  4311. < COMPREPLY=( $( compgen -W '-inform -outform -text -in -out -noout \
  4312. < -hash -issuer -lastupdate -nextupdate -CAfile -CApath' -- $cur ) )
  4313. < fi
  4314. < ;;
  4315. < crl2pkcs7)
  4316. < case $prev in
  4317. < -@(in|out)form)
  4318. < COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  4319. < return 0
  4320. < ;;
  4321. < -@(in|out))
  4322. < _filedir
  4323. < return 0
  4324. < ;;
  4325. < esac
  4326. <
  4327. < if [[ "$cur" == -* ]]; then
  4328. < COMPREPLY=( $( compgen -W '-inform -outform -in -out -print_certs' -- $cur ) )
  4329. < fi
  4330. < ;;
  4331. < dgst)
  4332. < case $prev in
  4333. < -@(out|sign|verify|prvrify|signature))
  4334. < _filedir
  4335. < return 0
  4336. < ;;
  4337. < esac
  4338. <
  4339. < if [[ "$cur" == -* ]]; then
  4340. < COMPREPLY=( $( compgen -W '-md5 -md4 -md2 -sha1 -sha -mdc2 -ripemd160 -dss1 \
  4341. < -c -d -hex -binary -out -sign -verify -prverify -signature' -- $cur ) )
  4342. < else
  4343. < _filedir
  4344. < fi
  4345. < ;;
  4346. < dsa)
  4347. < case $prev in
  4348. < -@(in|out)form)
  4349. < COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  4350. < return 0
  4351. < ;;
  4352. < -@(in|out))
  4353. < _filedir
  4354. < return 0
  4355. < ;;
  4356. < esac
  4357. <
  4358. < if [[ "$cur" == -* ]]; then
  4359. < COMPREPLY=( $( compgen -W '-inform -outform -in -passin -out -passout -des -des3 -idea -text -noout \
  4360. < -modulus -pubin -pubout' -- $cur ) )
  4361. < fi
  4362. < ;;
  4363. < dsaparam)
  4364. < case $prev in
  4365. < -@(in|out)form)
  4366. < COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  4367. < return 0
  4368. < ;;
  4369. < -@(in|out|rand))
  4370. < _filedir
  4371. < return 0
  4372. < ;;
  4373. < esac
  4374. <
  4375. < if [[ "$cur" == -* ]]; then
  4376. < COMPREPLY=( $( compgen -W '-inform -outform -in -out -noout \
  4377. < -text -C -rand -genkey' -- $cur ) )
  4378. < fi
  4379. < ;;
  4380. < enc)
  4381. < case $prev in
  4382. < -@(in|out|kfile))
  4383. < _filedir
  4384. < return 0
  4385. < ;;
  4386. < esac
  4387. <
  4388. < if [[ "$cur" == -* ]]; then
  4389. < COMPREPLY=( $( compgen -W '-ciphername -in -out -pass \
  4390. < -e -d -a -A -k -kfile -S -K -iv -p -P -bufsize -debug' -- $cur ) )
  4391. < fi
  4392. < ;;
  4393. < dhparam)
  4394. < case $prev in
  4395. < -@(in|out)form)
  4396. < COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  4397. < return 0
  4398. < ;;
  4399. < -@(in|out|rand))
  4400. < _filedir
  4401. < return 0
  4402. < ;;
  4403. < esac
  4404. <
  4405. < if [[ "$cur" == -* ]]; then
  4406. < COMPREPLY=( $( compgen -W '-inform -outform -in -out -dsaparam -noout \
  4407. < -text -C -2 -5 -rand' -- $cur ) )
  4408. < fi
  4409. < ;;
  4410. < gendsa)
  4411. < case $prev in
  4412. < -@(out|rand))
  4413. < _filedir
  4414. < return 0
  4415. < ;;
  4416. < esac
  4417. <
  4418. < if [[ "$cur" == -* ]]; then
  4419. < COMPREPLY=( $( compgen -W '-out -des -des3 -idea -rand' -- $cur ) )
  4420. < else
  4421. < _filedir
  4422. < fi
  4423. < ;;
  4424. < genrsa)
  4425. < case $prev in
  4426. < -@(out|rand))
  4427. < _filedir
  4428. < return 0
  4429. < ;;
  4430. < esac
  4431. <
  4432. < if [[ "$cur" == -* ]]; then
  4433. < COMPREPLY=( $( compgen -W '-out -passout -des -des3 -idea -f4 -3 -rand' -- $cur ) )
  4434. < fi
  4435. < ;;
  4436. < pkcs7)
  4437. < case $prev in
  4438. < -@(in|out)form)
  4439. < COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  4440. < return 0
  4441. < ;;
  4442. < -@(in|out))
  4443. < _filedir
  4444. < return 0
  4445. < ;;
  4446. < esac
  4447. <
  4448. < if [[ "$cur" == -* ]]; then
  4449. < COMPREPLY=( $( compgen -W '-inform -outform -in -out -print_certs -text -noout' -- $cur ) )
  4450. < fi
  4451. < ;;
  4452. < rand)
  4453. < case $prev in
  4454. < -@(out|rand))
  4455. < _filedir
  4456. < return 0
  4457. < ;;
  4458. < esac
  4459. <
  4460. < if [[ "$cur" == -* ]]; then
  4461. < COMPREPLY=( $( compgen -W '-out -rand -base64' -- $cur ) )
  4462. < fi
  4463. < ;;
  4464. < req)
  4465. < case "$prev" in
  4466. < -@(in|out|key)form)
  4467. < COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  4468. < return 0
  4469. < ;;
  4470. <
  4471. < -@(in|out|rand|key|keyout|config))
  4472. < _filedir
  4473. < return 0
  4474. < ;;
  4475. < -extensions)
  4476. < _openssl_sections
  4477. < return 0
  4478. < ;;
  4479. < esac
  4480. <
  4481. < if [[ "$cur" == -* ]]; then
  4482. < COMPREPLY=( $( compgen -W '-inform -outform -in \
  4483. < -passin -out -passout -text -noout -verify \
  4484. < -modulus -new -rand -newkey -newkey -nodes \
  4485. < -key -keyform -keyout -md5 -sha1 -md2 -mdc2 \
  4486. < -config -x509 -days -asn1-kludge -newhdr \
  4487. < -extensions -reqexts section' -- $cur ) )
  4488. < fi
  4489. < ;;
  4490. < rsa)
  4491. < case $prev in
  4492. < -@(in|out)form)
  4493. < COMPREPLY=( $( compgen -W 'DER NET PEM' -- $cur ) )
  4494. < return 0
  4495. < ;;
  4496. < -@(in|out))
  4497. < _filedir
  4498. < return 0
  4499. < ;;
  4500. < esac
  4501. <
  4502. < if [[ "$cur" == -* ]]; then
  4503. < COMPREPLY=( $( compgen -W '-inform -outform -in -passin -out -passout \
  4504. < -sgckey -des -des3 -idea -text -noout -modulus -check -pubin \
  4505. < -pubout -engine' -- $cur ) )
  4506. < fi
  4507. < ;;
  4508. < rsautl)
  4509. < case $prev in
  4510. < -@(in|out|inkey))
  4511. < _filedir
  4512. < return 0
  4513. < ;;
  4514. < esac
  4515. <
  4516. < if [[ "$cur" == -* ]]; then
  4517. < COMPREPLY=( $( compgen -W '-in -out -inkey -pubin -certin -sign -verify \
  4518. < -encrypt -decrypt -pkcs -ssl -raw -hexdump -asn1parse' -- $cur ) )
  4519. < fi
  4520. < ;;
  4521. < s_client)
  4522. < case $prev in
  4523. < -connect)
  4524. < _known_hosts
  4525. < return 0
  4526. < ;;
  4527. < -@(cert|key|CAfile|rand))
  4528. < _filedir
  4529. < return 0
  4530. < ;;
  4531. < -CApath)
  4532. < _filedir -d
  4533. < return 0
  4534. < ;;
  4535. < esac
  4536. <
  4537. < if [[ "$cur" == -* ]]; then
  4538. < COMPREPLY=( $( compgen -W '-connect -verify -cert -key -CApath -CAfile \
  4539. < -reconnect -pause -showcerts -debug -msg -nbio_test -state -nbio \
  4540. < -crlf -ign_eof -quiet -ssl2 -ssl3 -tls1 -no_ssl2 -no_ssl3 -no_tls1 \
  4541. < -bugs -cipher -starttls -engine -rand' -- $cur ) )
  4542. < fi
  4543. < ;;
  4544. < s_server)
  4545. < case $prev in
  4546. < -@(cert|key|dcert|dkey|dhparam|CAfile|rand))
  4547. < _filedir
  4548. < return 0
  4549. < ;;
  4550. < -CApath)
  4551. < _filedir -d
  4552. < return 0
  4553. < ;;
  4554. < esac
  4555. <
  4556. < if [[ "$cur" == -* ]]; then
  4557. < COMPREPLY=( $( compgen -W '-accept -context -verify -Verify -cert -key \
  4558. < -dcert -dkey -dhparam -nbio -nbio_test -crlf -debug -msg -state -CApath \
  4559. < -CAfile -nocert -cipher -quiet -no_tmp_rsa -ssl2 -ssl3 -tls1 -no_ssl2 \
  4560. < -no_ssl3 -no_tls1 -no_dhe -bugs -hack -www -WWW -HTTP -engine -id_prefix \
  4561. < -rand' -- $cur ) )
  4562. < fi
  4563. < ;;
  4564. < s_time)
  4565. < case $prev in
  4566. < -connect)
  4567. < _known_hosts
  4568. < return 0
  4569. < ;;
  4570. < -@(cert|key|CAfile))
  4571. < _filedir
  4572. < return 0
  4573. < ;;
  4574. < -CApath)
  4575. < _filedir -d
  4576. < return 0
  4577. < ;;
  4578. < esac
  4579. <
  4580. < if [[ "$cur" == -* ]]; then
  4581. < COMPREPLY=( $( compgen -W '-connect -www -cert -key -CApath -CAfile -reuse \
  4582. < -new -verify -nbio -time -ssl2 -ssl3 -bugs -cipher' -- $cur ) )
  4583. < fi
  4584. < ;;
  4585. <
  4586. < sess_id)
  4587. < case $prev in
  4588. < -@(in|out)form)
  4589. < COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  4590. < return 0
  4591. < ;;
  4592. < -@(in|out))
  4593. < _filedir
  4594. < return 0
  4595. < ;;
  4596. < esac
  4597. <
  4598. <
  4599. < if [[ "$cur" == -* ]]; then
  4600. < COMPREPLY=( $( compgen -W '-inform -outform -in -out -text -noout \
  4601. < -context ID' -- $cur ) )
  4602. < fi
  4603. < ;;
  4604. < smime)
  4605. < case $prev in
  4606. < -@(in|out)form)
  4607. < COMPREPLY=( $( compgen -W 'SMIME DER PEM' -- $cur ) )
  4608. < return 0
  4609. < ;;
  4610. < -@(in|out|certfile|signer|recip|inkey|content|rand))
  4611. < _filedir
  4612. < return 0
  4613. < ;;
  4614. < esac
  4615. <
  4616. < if [[ "$cur" == -* ]]; then
  4617. < COMPREPLY=( $( compgen -W '-encrypt -decrypt -sign -verify -pk7out -des -des3 \
  4618. < -rc2-40 -rc2-64 -rc2-128 -aes128 -aes192 -aes256 -in -certfile -signer \
  4619. < -recip -inform -passin -inkey -out -outform -content -to -from -subject \
  4620. < -text -rand' -- $cur ) )
  4621. < else
  4622. < _filedir
  4623. < fi
  4624. < ;;
  4625. < speed)
  4626. < if [[ "$cur" == -* ]]; then
  4627. < COMPREPLY=( $( compgen -W '-engine' -- $cur ) )
  4628. < else
  4629. < COMPREPLY=( $( compgen -W 'md2 mdc2 md5 hmac sha1 rmd160 idea-cbc \
  4630. < rc2-cbc rc5-cbc bf-cbc des-cbc des-ede3 rc4 rsa512 rsa1024 rsa2048 \
  4631. < rsa4096 dsa512 dsa1024 dsa2048 idea rc2 des rsa blowfish' -- $cur ) )
  4632. < fi
  4633. < ;;
  4634. < verify)
  4635. < case $prev in
  4636. < -@(CAfile|untrusted))
  4637. < _filedir
  4638. < return 0
  4639. < ;;
  4640. < -CApath)
  4641. < _filedir -d
  4642. < return 0
  4643. < ;;
  4644. < esac
  4645. <
  4646. < if [[ "$cur" == -* ]]; then
  4647. < COMPREPLY=( $( compgen -W '-CApath -CAfile -purpose -untrusted -help -issuer_checks \
  4648. < -verbose -certificates' -- $cur ) )
  4649. < else
  4650. < _filedir
  4651. < fi
  4652. < ;;
  4653. < x509)
  4654. < case "$prev" in
  4655. < -@(in|out|CA|CAkey|CAserial|extfile))
  4656. < _filedir
  4657. < return 0
  4658. < ;;
  4659. < -@(in|out)form)
  4660. < COMPREPLY=( $( compgen -W 'DER PEM NET' -- $cur ) )
  4661. < return 0
  4662. < ;;
  4663. < -@(key|CA|CAkey)form)
  4664. < COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  4665. < return 0
  4666. < ;;
  4667. < -extensions)
  4668. < _openssl_sections
  4669. < return 0
  4670. < ;;
  4671. < esac
  4672. <
  4673. < if [[ "$cur" == -* ]]; then
  4674. < COMPREPLY=( $( compgen -W '-inform -outform \
  4675. < -keyform -CAform -CAkeyform -in -out \
  4676. < -serial -hash -subject -issuer -nameopt \
  4677. < -email -startdate -enddate -purpose \
  4678. < -dates -modulus -fingerprint -alias \
  4679. < -noout -trustout -clrtrust -clrreject \
  4680. < -addtrust -addreject -setalias -days \
  4681. < -set_serial -signkey -x509toreq -req \
  4682. < -CA -CAkey -CAcreateserial -CAserial \
  4683. < -text -C -md2 -md5 -sha1 -mdc2 -clrext \
  4684. < -extfile -extensions -engine' -- $cur ) )
  4685. < fi
  4686. < ;;
  4687. < @(md5|md4|md2|sha1|sha|mdc2|ripemd160))
  4688. < if [[ "$cur" == -* ]]; then
  4689. < COMPREPLY=( $( compgen -W '-c -d' -- $cur ) )
  4690. < else
  4691. < _filedir
  4692. < fi
  4693. < ;;
  4694. < esac
  4695. < fi
  4696. <
  4697. < return 0
  4698. < }
  4699. < complete -F _openssl $default openssl
  4700. < }
  4701. <
  4702. < # screen(1) completion
  4703. < #
  4704. < have screen &&
  4705. < _screen()
  4706. < {
  4707. < local cur prev preprev
  4708. <
  4709. < COMPREPLY=()
  4710. < cur=`_get_cword`
  4711. < prev=${COMP_WORDS[COMP_CWORD-1]}
  4712. <
  4713. < [ "$COMP_CWORD" -ge 2 ] && preprev=${COMP_WORDS[COMP_CWORD-2]}
  4714. <
  4715. < if [ "$preprev" = "-d" -o "$preprev" = "-D" -a "$prev" = "-r" -o \
  4716. < "$prev" = "-R" ]; then
  4717. < # list all
  4718. < COMPREPLY=( $( command screen -ls | \
  4719. < sed -ne 's|^['$'\t'']\+\('$cur'[0-9]\+\.[^'$'\t'']\+\).*$|\1|p' ) )
  4720. < else
  4721. < case "$prev" in
  4722. < -[rR])
  4723. < # list detached
  4724. < COMPREPLY=( $( command screen -ls | \
  4725. < sed -ne 's|^['$'\t'']\+\('$cur'[0-9]\+\.[^'$'\t'']\+\).*Detached.*$|\1|p' ) )
  4726. < ;;
  4727. < -[dDx])
  4728. < # list attached
  4729. < COMPREPLY=( $( command screen -ls | \
  4730. < sed -ne 's|^['$'\t'']\+\('$cur'[0-9]\+\.[^'$'\t'']\+\).*Attached.*$|\1|p' ) )
  4731. < ;;
  4732. < -s)
  4733. < # shells
  4734. < COMPREPLY=( $( grep ^${cur:-[^#]} /etc/shells ) )
  4735. < ;;
  4736. < *)
  4737. < ;;
  4738. < esac
  4739. < fi
  4740. <
  4741. < return 0
  4742. < } &&
  4743. < complete -F _screen $default screen
  4744. <
  4745. < # lftp(1) bookmark completion
  4746. < #
  4747. < have lftp &&
  4748. < _lftp()
  4749. < {
  4750. < local cur
  4751. <
  4752. < COMPREPLY=()
  4753. < cur=`_get_cword`
  4754. <
  4755. < if [ $COMP_CWORD -eq 1 ] && [ -f ~/.lftp/bookmarks ]; then
  4756. < COMPREPLY=( $( compgen -W '$( sed -ne "s/^\(.*\)'$'\t''.*$/\1/p" \
  4757. < ~/.lftp/bookmarks )' -- $cur ) )
  4758. < fi
  4759. <
  4760. < return 0
  4761. < } &&
  4762. < complete -F _lftp $default lftp
  4763. <
  4764. < # ncftp(1) bookmark completion
  4765. < #
  4766. < have ncftp &&
  4767. < _ncftp()
  4768. < {
  4769. < local cur
  4770. <
  4771. < COMPREPLY=()
  4772. < cur=`_get_cword`
  4773. <
  4774. < if [ $COMP_CWORD -eq 1 ] && [ -f ~/.ncftp/bookmarks ]; then
  4775. < COMPREPLY=( $( compgen -W '$( sed -ne "s/^\([^,]\{1,\}\),.*$/\1/p" \
  4776. < ~/.ncftp/bookmarks )' -- $cur ) )
  4777. < fi
  4778. <
  4779. < return 0
  4780. < } &&
  4781. < complete -F _ncftp $default ncftp
  4782. <
  4783. < # gdb(1) completion
  4784. < #
  4785. < have gdb &&
  4786. < _gdb()
  4787. < {
  4788. < local cur prev
  4789. <
  4790. < COMPREPLY=()
  4791. < cur=`_get_cword`
  4792. < prev=${COMP_WORDS[COMP_CWORD-1]}
  4793. <
  4794. < if [ $COMP_CWORD -eq 1 ]; then
  4795. < COMPREPLY=( $( compgen -c -- $cur ) )
  4796. < elif [ $COMP_CWORD -eq 2 ]; then
  4797. < prev=${prev##*/}
  4798. < COMPREPLY=( $( compgen -fW "$( command ps axo comm,pid | \
  4799. < awk '{if ($1 ~ /^'"$prev"'/) print $2}' ) )" \
  4800. < -- "$cur" ) )
  4801. < fi
  4802. < } &&
  4803. < complete -F _gdb $filenames gdb
  4804. <
  4805. < # Postgresql completion
  4806. < #
  4807. < have psql && {
  4808. < _pg_databases()
  4809. < {
  4810. < COMPREPLY=( $( psql -l 2>/dev/null | \
  4811. < sed -e '1,/^-/d' -e '/^(/,$d' | \
  4812. < awk '{print $1}' | grep "^$cur" ) )
  4813. < }
  4814. <
  4815. < _pg_users()
  4816. < {
  4817. < COMPREPLY=( $( psql -qtc 'select usename from pg_user' template1 2>/dev/null | \
  4818. < grep "^ $cur" ) )
  4819. < [ ${#COMPREPLY[@]} -eq 0 ] && COMPREPLY=( $( compgen -u -- $cur ) )
  4820. < }
  4821. <
  4822. < # createdb(1) completion
  4823. < #
  4824. < _createdb()
  4825. < {
  4826. < local cur prev
  4827. <
  4828. < COMPREPLY=()
  4829. < cur=`_get_cword`
  4830. < prev=${COMP_WORDS[COMP_CWORD-1]}
  4831. <
  4832. < case "$prev" in
  4833. < -@(h|-host=))
  4834. < _known_hosts
  4835. < return 0
  4836. < ;;
  4837. < -@(U|-username=))
  4838. < _pg_users
  4839. < return 0
  4840. < ;;
  4841. < esac
  4842. <
  4843. < if [[ "$cur" == -* ]]; then
  4844. < COMPREPLY=( $( compgen -W '-D -T -E -h -p -U -W -e -q \
  4845. < --location= --template= --encoding= --host= --port= \
  4846. < --username= --password --echo --quiet --help' -- $cur ))
  4847. < else
  4848. < _pg_databases
  4849. < fi
  4850. < }
  4851. < complete -F _createdb $default createdb
  4852. <
  4853. < # dropdb(1) completion
  4854. < #
  4855. < _dropdb()
  4856. < {
  4857. < local cur prev
  4858. <
  4859. < COMPREPLY=()
  4860. < cur=`_get_cword`
  4861. < prev=${COMP_WORDS[COMP_CWORD-1]}
  4862. <
  4863. < case "$prev" in
  4864. < -@(h|-host=))
  4865. < _known_hosts
  4866. < return 0
  4867. < ;;
  4868. < -@(U|-username=))
  4869. < _pg_users
  4870. < return 0
  4871. < ;;
  4872. < esac
  4873. <
  4874. < if [[ "$cur" == -* ]]; then
  4875. < COMPREPLY=( $( compgen -W '-h -p -U -W -e -q \
  4876. < --host= --port= --username= --password \
  4877. < --interactive --echo --quiet --help' -- $cur ) )
  4878. < else
  4879. < _pg_databases
  4880. < fi
  4881. < }
  4882. < complete -F _dropdb $default dropdb
  4883. <
  4884. < # psql(1) completion
  4885. < #
  4886. < _psql()
  4887. < {
  4888. < local cur prev
  4889. <
  4890. < COMPREPLY=()
  4891. < cur=`_get_cword`
  4892. < prev=${COMP_WORDS[COMP_CWORD-1]}
  4893. <
  4894. < case "$prev" in
  4895. < -h|--host)
  4896. < _known_hosts
  4897. < return 0
  4898. < ;;
  4899. < -U|--username)
  4900. < _pg_users
  4901. < return 0
  4902. < ;;
  4903. < -d|--dbname)
  4904. < _pg_databases
  4905. < return 0
  4906. < ;;
  4907. < -@(o|f)|--output|--file)
  4908. < _filedir
  4909. < return 0
  4910. < ;;
  4911. < esac
  4912. <
  4913. < if [[ "$cur" == -* ]]; then
  4914. < # return list of available options
  4915. < COMPREPLY=( $( compgen -W '-a --echo-all -A --no-align \
  4916. < -c --command -d --dbname -e --echo-queries \
  4917. < -E --echo-hidden -f --file -F --filed-separator \
  4918. < -h --host -H --html -l --list -n -o --output \
  4919. < -p --port -P --pset -q -R --record-separator \
  4920. < -s --single-step -S --single-line -t --tuples-only \
  4921. < -T --table-attr -U --username -v --variable \
  4922. < -V --version -W --password -x --expanded -X --nopsqlrc \
  4923. < -? --help ' -- $cur ) )
  4924. < else
  4925. < # return list of available databases
  4926. < _pg_databases
  4927. < fi
  4928. < }
  4929. < complete -F _psql $default psql
  4930. ---
  4931. > COMPREPLY=( "${COMPREPLY[@]}"
  4932. > $( compgen -f -d -X "!*/?(r)dvd*" -- "${cur:-/dev/}" ) )
  4933. 4135,4137c1126
  4934. < _longopt()
  4935. < {
  4936. < local cur opt
  4937. ---
  4938. > # start of section containing completion functions for external programs
  4939. 4139c1128,1131
  4940. < cur=`_get_cword`
  4941. ---
  4942. > # a little help for FreeBSD ports users
  4943. > [ $UNAME = FreeBSD ] && complete -W 'index search fetch fetch-list extract \
  4944. > patch configure build install reinstall deinstall clean clean-depends \
  4945. > kernel buildworld' make
  4946. 4141,4169c1133,1136
  4947. < if [[ "$cur" == --*=* ]]; then
  4948. < opt=${cur%%=*}
  4949. < # cut backslash that gets inserted before '=' sign
  4950. < opt=${opt%\\*}
  4951. < cur=${cur#*=}
  4952. < _filedir
  4953. < COMPREPLY=( $( compgen -P "$opt=" -W '${COMPREPLY[@]}' -- $cur))
  4954. < return 0
  4955. < fi
  4956. <
  4957. < if [[ "$cur" == -* ]]; then
  4958. < COMPREPLY=( $( $1 --help 2>&1 | sed -e '/--/!d' \
  4959. < -e 's/.*\(--[-A-Za-z0-9]\+=\?\).*/\1/' | \
  4960. < command grep "^$cur" | sort -u ) )
  4961. < elif [[ "$1" == @(mk|rm)dir ]]; then
  4962. < _filedir -d
  4963. < else
  4964. < _filedir
  4965. < fi
  4966. < }
  4967. < # makeinfo and texi2dvi are defined elsewhere.
  4968. < for i in a2ps autoconf automake bc gprof ld nm objcopy objdump readelf strip \
  4969. < bison cpio diff patch enscript cp df dir du ln ls mkfifo mknod mv rm \
  4970. < touch vdir awk gperf grep grub indent less m4 sed shar date \
  4971. < tee who texindex cat csplit cut expand fmt fold head \
  4972. < md5sum nl od paste pr ptx sha1sum sort split tac tail tr unexpand \
  4973. < uniq wc ldd bash id irb mkdir rmdir; do
  4974. < have $i && complete -F _longopt $filenames $i
  4975. < done
  4976. ---
  4977. > # This function provides simple user@host completion
  4978. > #
  4979. > _user_at_host() {
  4980. > local cur
  4981. 4171,4175c1138,1139
  4982. < # These commands use filenames, so '-o filenames' is not needed.
  4983. < for i in env netstat seq uname units wget; do
  4984. < have $i && complete -F _longopt $default $i
  4985. < done
  4986. < unset i
  4987. ---
  4988. > COMPREPLY=()
  4989. > _get_comp_words_by_ref -n : cur
  4990. 4177,5215c1141,1147
  4991. < # gcc(1) completion
  4992. < #
  4993. < # The only unusual feature is that we don't parse "gcc --help -v" output
  4994. < # directly, because that would include the options of all the other backend
  4995. < # tools (linker, assembler, preprocessor, etc) without any indication that
  4996. < # you cannot feed such options to the gcc driver directly. (For example, the
  4997. < # linker takes a -z option, but you must type -Wl,-z for gcc.) Instead, we
  4998. < # ask the driver ("g++") for the name of the compiler ("cc1"), and parse the
  4999. < # --help output of the compiler.
  5000. < #
  5001. < have gcc &&
  5002. < _gcc()
  5003. < {
  5004. < local cur cc backend
  5005. <
  5006. < COMPREPLY=()
  5007. < cur=`_get_cword`
  5008. <
  5009. < _expand || return 0
  5010. <
  5011. < case "$1" in
  5012. < gcj)
  5013. < backend=jc1
  5014. < ;;
  5015. < gpc)
  5016. < backend=gpc1
  5017. < ;;
  5018. < *77)
  5019. < backend=f771
  5020. < ;;
  5021. < *)
  5022. < backend=cc1 # (near-)universal backend
  5023. < ;;
  5024. < esac
  5025. <
  5026. < if [[ "$cur" == -* ]]; then
  5027. < cc=$( $1 -print-prog-name=$backend )
  5028. < # sink stderr:
  5029. < # for C/C++/ObjectiveC it's useless
  5030. < # for FORTRAN/Java it's an error
  5031. < COMPREPLY=( $( $cc --help 2>/dev/null | tr '\t' ' ' | \
  5032. < sed -e '/^ *-/!d' -e 's/ *-\([^ ]*\).*/-\1/' | \
  5033. < command grep "^$cur" | sort -u ) )
  5034. < else
  5035. < _filedir
  5036. < fi
  5037. < } &&
  5038. < complete $filenames -F _gcc gcc g++ c++ g77 gcj gpc
  5039. < [ $UNAME = GNU -o $UNAME = Linux -o $UNAME = Cygwin ] && \
  5040. < [ -n "${have:-}" ] && complete $filenames -F _gcc cc
  5041. <
  5042. < # Linux cardctl(8) completion
  5043. < #
  5044. < have cardctl &&
  5045. < _cardctl()
  5046. < {
  5047. < local cur
  5048. <
  5049. < COMPREPLY=()
  5050. < cur=`_get_cword`
  5051. <
  5052. < if [ $COMP_CWORD -eq 1 ]; then
  5053. < COMPREPLY=( $( compgen -W 'status config ident suspend \
  5054. < resume reset eject insert scheme' \
  5055. < -- $cur ) )
  5056. < fi
  5057. < } &&
  5058. < complete -F _cardctl cardctl
  5059. <
  5060. < # This function is required by _dpkg() and _dpkg-reconfigure()
  5061. < #
  5062. < have dpkg && {
  5063. < _comp_dpkg_installed_packages()
  5064. < {
  5065. < grep -A 1 "Package: $1" /var/lib/dpkg/status | \
  5066. < grep -B 1 -E "ok installed|half-installed|unpacked| \
  5067. < half-configured|config-files" | \
  5068. < grep "Package: $1" | cut -d\ -f2
  5069. < }
  5070. <
  5071. < # Debian dpkg(8) completion
  5072. < #
  5073. < _dpkg()
  5074. < {
  5075. < local cur prev i
  5076. <
  5077. < COMPREPLY=()
  5078. < cur=`_get_cword`
  5079. < prev=${COMP_WORDS[COMP_CWORD-1]}
  5080. < i=$COMP_CWORD
  5081. <
  5082. < _expand || return 0
  5083. <
  5084. < # find the last option flag
  5085. < if [[ $cur != -* ]]; then
  5086. < while [[ $prev != -* && $i != 1 ]]; do
  5087. < i=$((i-1))
  5088. < prev=${COMP_WORDS[i-1]}
  5089. < done
  5090. < fi
  5091. <
  5092. < case "$prev" in
  5093. < -@(c|i|A|I|f|e|x|X|-@(install|unpack|record-avail|contents|info| \
  5094. < fsys-tarfile|field|control|extract)))
  5095. < _filedir '?(u)deb'
  5096. < return 0
  5097. < ;;
  5098. < -@(b|-build))
  5099. < _filedir -d
  5100. < return 0
  5101. < ;;
  5102. < -@(s|p|l|-@(status|print-avail|list)))
  5103. < COMPREPLY=( $( apt-cache pkgnames $cur 2>/dev/null ) )
  5104. < return 0
  5105. < ;;
  5106. < -@(S|-search))
  5107. < _filedir
  5108. < return 0
  5109. < ;;
  5110. < -@(r|L|P|-@(remove|purge|listfiles)))
  5111. < COMPREPLY=( $( _comp_dpkg_installed_packages $cur ) )
  5112. < return 0
  5113. < ;;
  5114. < *)
  5115. <
  5116. < COMPREPLY=( $( compgen -W '-i --install --unpack -A --record-avail \
  5117. < --configure -r --remove -P --purge --get-selections \
  5118. < --set-selections --update-avail --merge-avail \
  5119. < --clear-avail --command-fd --forget-old-unavail -s \
  5120. < --status -p --print-avail -L --listfiles -l --list \
  5121. < -S --search -C --audit --print-architecture \
  5122. < --print-gnu-build-architecture \
  5123. < --print-installation-architecture \
  5124. < --compare-versions --help --version --force-help \
  5125. < --force-all --force-auto-select --force-downgrade \
  5126. < --force-configure-any --force-hold --force-bad-path \
  5127. < --force-not-root --force-overwrite \
  5128. < --force-overwrite-diverted --force-bad-verify \
  5129. < --force-depends-version --force-depends \
  5130. < --force-confnew --force-confold --force-confdef \
  5131. < --force-confmiss --force-conflicts --force-architecture\
  5132. < --force-overwrite-dir --force-remove-reinstreq \
  5133. < --force-remove-essential -Dh \
  5134. < --debug=help --licence --admindir= --root= --instdir= \
  5135. < -O --selected-only -E --skip-same-version \
  5136. < -G --refuse-downgrade -B --auto-deconfigure \
  5137. < --no-debsig --no-act -D --debug= --status-fd \
  5138. < -b --build -I --info -f --field -c --contents \
  5139. < -x --extract -X --vextract --fsys-tarfile -e --control \
  5140. < --ignore-depends= --abort-after' -- $cur ) )
  5141. < ;;
  5142. < esac
  5143. <
  5144. <
  5145. < }
  5146. < complete -F _dpkg $filenames dpkg dpkg-deb
  5147. < }
  5148. <
  5149. < # Debian GNU dpkg-reconfigure(8) completion
  5150. < #
  5151. < have dpkg-reconfigure &&
  5152. < _dpkg_reconfigure()
  5153. < {
  5154. < local cur prev opt
  5155. <
  5156. < COMPREPLY=()
  5157. < cur=`_get_cword`
  5158. < prev=${COMP_WORDS[COMP_CWORD-1]}
  5159. <
  5160. <
  5161. < case "$prev" in
  5162. < -@(f|-frontend))
  5163. < opt=( $( echo /usr/share/perl5/Debconf/FrontEnd/* ) )
  5164. < opt=( ${opt[@]##*/} )
  5165. < opt=( ${opt[@]%.pm} )
  5166. < COMPREPLY=( $( compgen -W '${opt[@]}' -- $cur ) )
  5167. < return 0
  5168. < ;;
  5169. < -@(p|-priority))
  5170. < COMPREPLY=( $( compgen -W 'low medium high critical' -- $cur ) )
  5171. < return 0
  5172. < ;;
  5173. < esac
  5174. <
  5175. < if [[ "$cur" == -* ]]; then
  5176. < COMPREPLY=( $( compgen -W '-f --frontend -p --priority -a --all \
  5177. < -u --unseen-only -h --help -s --showold \
  5178. < --force --terse' -- $cur ) )
  5179. < else
  5180. < COMPREPLY=( $( _comp_dpkg_installed_packages $cur ) )
  5181. < fi
  5182. < } &&
  5183. < complete -F _dpkg_reconfigure $default dpkg-reconfigure
  5184. <
  5185. < # Debian dpkg-source completion
  5186. < #
  5187. < have dpkg-source &&
  5188. < _dpkg_source()
  5189. < {
  5190. < local cur prev options work i action packopts unpackopts
  5191. <
  5192. < packopts="-c -l -F -V -T -D -U -W -E -sa -i -I -sk -sp -su -sr -ss -sn -sA -sK -sP -sU -sR"
  5193. < unpackopts="-sp -sn -su"
  5194. < options=`echo "-x -b $packopts $unpackopts" | xargs echo | sort -u | xargs echo`
  5195. <
  5196. < COMPREPLY=()
  5197. < if [ "$1" != "dpkg-source" ]; then
  5198. < exit 1
  5199. < fi
  5200. < cur=`_get_cword`
  5201. < prev=${COMP_WORDS[COMP_CWORD-1]}
  5202. < action="options"
  5203. < for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  5204. < if [[ ${COMP_WORDS[$i]} == "-x" ]]; then
  5205. < action=unpack
  5206. < elif [[ ${COMP_WORDS[$i]} == "-b" ]]; then
  5207. < action=pack
  5208. < elif [[ ${COMP_WORDS[$i]} == "-h" ]]; then
  5209. < action=help
  5210. < fi
  5211. < done
  5212. < # if currently seeing a complete option, return just itself.
  5213. < for i in $options; do
  5214. < if [ "$cur" = "$i" ]; then
  5215. < COMPREPLY=( "$cur" )
  5216. < return 0
  5217. < fi
  5218. < done
  5219. < case "$action" in
  5220. < "unpack")
  5221. < if [ "$cur" = "-" -o "$cur" = "-s" ]; then
  5222. < COMPREPLY=( $unpackots )
  5223. < return 0
  5224. < fi
  5225. < case "$prev" in
  5226. < "-x")
  5227. < COMPREPLY=( $( compgen -d -- "$cur" ) \
  5228. < $( compgen -f -X '!*.dsc' -- "$cur" ) )
  5229. < return 0
  5230. < ;;
  5231. < *)
  5232. < COMPREPLY=( $unpackopts $(compgen -d -f -- "$cur" ) )
  5233. < return 0
  5234. < ;;
  5235. < esac
  5236. < return 0
  5237. < ;;
  5238. < "pack")
  5239. < if [ "$cur" = "-" ]; then
  5240. < COMPREPLY=( $packopts )
  5241. < return 0
  5242. < fi
  5243. < if [ "$cur" = "-s" ]; then
  5244. < COMPREPLY=( "-sa" "-sk" "-sp" "-su" "-sr" "-ss" "-sn" \
  5245. < "-sA" "-sK" "-sP" "-sU" "-sR" )
  5246. < return 0
  5247. < fi
  5248. < case "$prev" in
  5249. < "-b")
  5250. < COMPREPLY=( $( compgen -d -- "$cur" ) )
  5251. < return 0
  5252. < ;;
  5253. < "-c"|"-l"|"-T"|"-i"|"-I")
  5254. < # -c: get controlfile
  5255. < # -l: get per-version info from this file
  5256. < # -T: read variables here, not debian/substvars
  5257. < # -i: <regexp> filter out files to ignore diffs of.
  5258. < # -I: filter out files when building tarballs.
  5259. < # return directory names and file names
  5260. < COMPREPLY=( $( compgen -d -f ) )
  5261. < return 0
  5262. < ;;
  5263. < "-F")
  5264. < # -F: force change log format
  5265. < COMPREPLY=( $( ( cd /usr/lib/dpkg/parsechangelog; compgen -f "$cur" ) ) )
  5266. < return 0
  5267. < ;;
  5268. < "-V"|"-D")
  5269. < # -V: set a substitution variable
  5270. < # we don't know anything about possible variables or values
  5271. < # so we don't try to suggest any completion.
  5272. < COMPREPLY=()
  5273. < return 0
  5274. < ;;
  5275. < "-D")
  5276. < # -D: override or add a .dsc field and value
  5277. < # if $cur doesn't contain a = yet, suggest variable names
  5278. < if echo -- "$cur" | grep -q "="; then
  5279. < # $cur contains a "="
  5280. < COMPREPLY=()
  5281. < return 0
  5282. < else
  5283. < COMPREPLY=( Format Source Version Binary Maintainer Uploader Architecture Standards-Version Build-Depends Files )
  5284. < return 0
  5285. < fi
  5286. < ;;
  5287. < "-U")
  5288. < # -U: remove a field
  5289. < # Suggest possible fieldnames
  5290. < COMPREPLY=( Format Source Version Binary Maintainer Uploader Architecture Standards-Version Build-Depends Files )
  5291. < return 0
  5292. < ;;
  5293. < *)
  5294. < COMPREPLY=( $packopts )
  5295. < return 0
  5296. < ;;
  5297. < esac
  5298. < return 0
  5299. < ;;
  5300. < *)
  5301. < # if seeing a partial option, return possible completions.
  5302. < if [ "$cur" = "-s" ]; then
  5303. < COMPREPLY=( "-sa" "-sk" "-sp" "-su" "-sr" "-ss" "-sn" \
  5304. < "-sA" "-sK" "-sP" "-sU" "-sR" )
  5305. < return 0
  5306. < fi
  5307. < # else return all possible options.
  5308. < COMPREPLY=( $options )
  5309. < return 0
  5310. < ;;
  5311. < esac
  5312. < } &&
  5313. < complete -F _dpkg_source dpkg-source
  5314. <
  5315. < # Debian Linux dselect(8) completion.
  5316. < #
  5317. < have dselect &&
  5318. < _dselect()
  5319. < {
  5320. < local cur prev
  5321. <
  5322. < COMPREPLY=()
  5323. < cur=`_get_cword`
  5324. < prev=${COMP_WORDS[COMP_CWORD-1]}
  5325. <
  5326. < case "$prev" in
  5327. < --admindir)
  5328. < _filedir -d
  5329. < return 0
  5330. < ;;
  5331. <
  5332. < -@(D|debug))
  5333. < _filedir
  5334. < return 0
  5335. < ;;
  5336. < esac
  5337. <
  5338. < if [[ "$cur" == -* ]]; then
  5339. < COMPREPLY=( $( compgen -W '--admindir --help --version --licence \
  5340. < --license --expert --debug' -- $cur ) )
  5341. < else
  5342. < COMPREPLY=( $( compgen -W 'access update select install config \
  5343. < remove quit' -- $cur ) )
  5344. < fi
  5345. <
  5346. <
  5347. < return 0
  5348. < } &&
  5349. < complete -F _dselect $filenames dselect
  5350. <
  5351. < # Java completion
  5352. < #
  5353. <
  5354. < # available path elements completion
  5355. < have java && {
  5356. < _java_path()
  5357. < {
  5358. < cur=${cur##*:}
  5359. < _filedir '@(jar|zip)'
  5360. < }
  5361. <
  5362. < # exact classpath determination
  5363. < _java_find_classpath()
  5364. < {
  5365. < local i
  5366. <
  5367. < # search first in current options
  5368. < for (( i=1; i < COMP_CWORD; i++ )); do
  5369. < if [[ "${COMP_WORDS[i]}" == -@(cp|classpath) ]]; then
  5370. < classpath=${COMP_WORDS[i+1]}
  5371. < break
  5372. < fi
  5373. < done
  5374. <
  5375. < # default to environment
  5376. < [ -z "$classpath" ] && classpath=$CLASSPATH
  5377. <
  5378. < # default to current directory
  5379. < [ -z "$classpath" ] && classpath=.
  5380. < }
  5381. <
  5382. < # exact sourcepath determination
  5383. < _java_find_sourcepath()
  5384. < {
  5385. < local i
  5386. <
  5387. < # search first in current options
  5388. < for (( i=1; i < COMP_CWORD; i++ )); do
  5389. < if [[ "${COMP_WORDS[i]}" == -sourcepath ]]; then
  5390. < sourcepath=${COMP_WORDS[i+1]}
  5391. < break
  5392. < fi
  5393. < done
  5394. <
  5395. < # default to classpath
  5396. < [ -z "$sourcepath" ] && _java_find_classpath
  5397. < sourcepath=$classpath
  5398. < }
  5399. <
  5400. < # available classes completion
  5401. < _java_classes()
  5402. < {
  5403. < local classpath i
  5404. <
  5405. < # find which classpath to use
  5406. < _java_find_classpath
  5407. <
  5408. < # convert package syntax to path syntax
  5409. < cur=${cur//.//}
  5410. < # parse each classpath element for classes
  5411. < for i in ${classpath//:/ }; do
  5412. < if [ -r $i ] && [[ "$i" == *.@(jar|zip) ]]; then
  5413. < if type zipinfo &> /dev/null; then
  5414. < COMPREPLY=( ${COMPREPLY[@]} $( zipinfo -1 \
  5415. < "$i" | grep "^$cur" | grep '\.class$' | \
  5416. < grep -v "\\$" ) )
  5417. < else
  5418. < COMPREPLY=( ${COMPREPLY[@]} $( jar tf "$i" \
  5419. < "$cur" | grep "\.class$" | grep -v "\\$" ) )
  5420. < fi
  5421. <
  5422. < elif [ -d $i ]; then
  5423. < i=${i%/}
  5424. < COMPREPLY=( ${COMPREPLY[@]} $( find "$i" -type f \
  5425. < -path "$i/$cur*.class" 2>/dev/null | \
  5426. < grep -v "\\$" | sed -e "s|^$i/||" ) )
  5427. < fi
  5428. < done
  5429. <
  5430. < # remove class extension
  5431. < COMPREPLY=( ${COMPREPLY[@]%.class} )
  5432. < # convert path syntax to package syntax
  5433. < COMPREPLY=( ${COMPREPLY[@]//\//.} )
  5434. < }
  5435. <
  5436. < # available packages completion
  5437. < _java_packages()
  5438. < {
  5439. < local sourcepath i
  5440. <
  5441. < # find wich sourcepath to use
  5442. < _java_find_sourcepath
  5443. <
  5444. < # convert package syntax to path syntax
  5445. < cur=${cur//.//}
  5446. < # parse each sourcepath element for packages
  5447. < for i in ${sourcepath//:/ }; do
  5448. < if [ -d $i ]; then
  5449. < COMPREPLY=( ${COMPREPLY[@]} $( command ls -F -d \
  5450. < $i/$cur* 2>/dev/null | sed -e 's|^'$i'/||' ) )
  5451. < fi
  5452. < done
  5453. < # keep only packages
  5454. < COMPREPLY=( $( echo ${COMPREPLY[@]} | tr " " "\n" | grep "/$" ) )
  5455. < # remove packages extension
  5456. < COMPREPLY=( ${COMPREPLY[@]%/} )
  5457. < # convert path syntax to package syntax
  5458. < cur=${COMPREPLY[@]//\//.}
  5459. < }
  5460. <
  5461. < # java completion
  5462. < #
  5463. < _java()
  5464. < {
  5465. < local cur prev i
  5466. <
  5467. < COMPREPLY=()
  5468. < cur=`_get_cword`
  5469. < prev=${COMP_WORDS[COMP_CWORD-1]}
  5470. <
  5471. < for ((i=1; i < $COMP_CWORD; i++)); do
  5472. < case ${COMP_WORDS[$i]} in
  5473. < -cp|-classpath)
  5474. < ((i++)) # skip the classpath string.
  5475. < ;;
  5476. < -*)
  5477. < # this is an option, not a class/jarfile name.
  5478. < ;;
  5479. < *)
  5480. < # once we've seen a class, just do filename completion
  5481. < _filedir
  5482. < return 0
  5483. < ;;
  5484. < esac
  5485. < done
  5486. <
  5487. < case $prev in
  5488. < -@(cp|classpath))
  5489. < _java_path
  5490. < return 0
  5491. < ;;
  5492. < esac
  5493. <
  5494. < if [[ "$cur" == -* ]]; then
  5495. < # relevant options completion
  5496. < COMPREPLY=( $( compgen -W '-client -hotspot -server -classic \
  5497. < -cp -classpath -D -verbose -verbose:class \
  5498. < -verbose:gc -version:jni -version \
  5499. < -showversion -? -help -X -jar \
  5500. < -ea -enableassertions -da -disableassertions \
  5501. < -esa -enablesystemassertions \
  5502. < -dsa -disablesystemassertions ' -- $cur ) )
  5503. < else
  5504. < if [[ "$prev" == -jar ]]; then
  5505. < # jar file completion
  5506. < _filedir jar
  5507. < else
  5508. < # classes completion
  5509. < _java_classes
  5510. < fi
  5511. < fi
  5512. < }
  5513. < complete -F _java $filenames java
  5514. < }
  5515. <
  5516. < # javadoc completion
  5517. < #
  5518. < have javadoc &&
  5519. < _javadoc()
  5520. < {
  5521. < COMPREPLY=()
  5522. < local cur prev
  5523. <
  5524. < cur=`_get_cword`
  5525. < prev=${COMP_WORDS[COMP_CWORD-1]}
  5526. <
  5527. < case $prev in
  5528. < -@(overview|helpfile|stylesheetfile))
  5529. < _filedir
  5530. < return 0
  5531. < ;;
  5532. < -d)
  5533. < _filedir -d
  5534. < return 0
  5535. < ;;
  5536. < -@(classpath|bootclasspath|docletpath|sourcepath|extdirs))
  5537. < _java_path
  5538. < return 0
  5539. < ;;
  5540. < esac
  5541. <
  5542. < if [[ "$cur" == -* ]]; then
  5543. < # relevant options completion
  5544. < COMPREPLY=( $( compgen -W '-overview -public -protected \
  5545. < -package -private -help -doclet -docletpath \
  5546. < -sourcepath -classpath -exclude -subpackages \
  5547. < -breakiterator -bootclasspath -source -extdirs \
  5548. < -verbose -locale -encoding -J -d -use -version \
  5549. < -author -docfilessubdirs -splitindex \
  5550. < -windowtitle -doctitle -header -footer -bottom \
  5551. < -link -linkoffline -excludedocfilessubdir \
  5552. < -group -nocomment -nodeprecated -noqualifier \
  5553. < -nosince -nodeprecatedlist -notree -noindex \
  5554. < -nohelp -nonavbar -quiet -serialwarn -tag \
  5555. < -taglet -tagletpath -charset -helpfile \
  5556. < -linksource -stylesheetfile -docencoding' -- \
  5557. < $cur ) )
  5558. < else
  5559. < # source files completion
  5560. < _filedir java
  5561. < # packages completion
  5562. < _java_packages
  5563. < fi
  5564. < } &&
  5565. < complete -F _javadoc $filenames javadoc
  5566. <
  5567. < # javac completion
  5568. < #
  5569. < have javac &&
  5570. < _javac()
  5571. < {
  5572. < COMPREPLY=()
  5573. < local cur prev
  5574. <
  5575. < cur=`_get_cword`
  5576. < prev=${COMP_WORDS[COMP_CWORD-1]}
  5577. <
  5578. < case $prev in
  5579. < -d)
  5580. < _filedir -d
  5581. < return 0
  5582. < ;;
  5583. < -@(classpath|bootclasspath|sourcepath|extdirs))
  5584. < _java_path
  5585. < return 0
  5586. < ;;
  5587. < esac
  5588. <
  5589. < if [[ "$cur" == -* ]]; then
  5590. < # relevant options completion
  5591. < COMPREPLY=( $( compgen -W '-g -g:none -g:lines -g:vars\
  5592. < -g:source -O -nowarn -verbose -deprecation -classpath\
  5593. < -sourcepath -bootclasspath -extdirs -d -encoding -source\
  5594. < -target -help' -- $cur ) )
  5595. < else
  5596. < # source files completion
  5597. < _filedir java
  5598. < fi
  5599. < } &&
  5600. < complete -F _javac $filenames javac
  5601. <
  5602. < # PINE address-book completion
  5603. < #
  5604. < have pine &&
  5605. < _pineaddr()
  5606. < {
  5607. < local cur
  5608. <
  5609. < COMPREPLY=()
  5610. < cur=`_get_cword`
  5611. <
  5612. < COMPREPLY=( $( compgen -W '$( awk "{print \$1}" ~/.addressbook 2>/dev/null)' \
  5613. < -- $cur ) )
  5614. < } &&
  5615. < complete -F _pineaddr $default pine
  5616. <
  5617. < # mutt completion
  5618. < #
  5619. < # Mutt doesn't have an "addressbook" like Pine, but it has aliases and
  5620. < # a "query" function to retrieve addresses, so that's what we use here.
  5621. < have mutt || have muttng && {
  5622. < _muttaddr()
  5623. < {
  5624. < _muttaliases
  5625. < _muttquery
  5626. < return 0
  5627. < }
  5628. <
  5629. < _muttconffiles()
  5630. < {
  5631. < local file sofar
  5632. < local -a newconffiles
  5633. <
  5634. < sofar=" $1 "
  5635. < shift
  5636. < while [[ "$1" ]]; do
  5637. < newconffiles=( $(sed -rn 's|^source[[:space:]]+([^[:space:]]+).*$|\1|p' $(eval echo $1) ) )
  5638. < for file in ${newconffiles[@]}; do
  5639. < [[ ! "$file" ]] || [[ "${sofar/ ${file} / }" != "$sofar" ]] &&
  5640. < continue
  5641. < sofar="$sofar $file"
  5642. < sofar=" $(eval _muttconffiles \"$sofar\" $file) "
  5643. < done
  5644. < shift
  5645. < done
  5646. < echo $sofar
  5647. < }
  5648. <
  5649. < _muttaliases()
  5650. < {
  5651. < local cur muttrc
  5652. < local -a conffiles aliases
  5653. < cur=`_get_cword`
  5654. <
  5655. < [ -f ~/.${muttcmd}/${muttcmd}rc ] && muttrc="~/.${muttcmd}/${muttcmd}rc"
  5656. < [ -f ~/.${muttcmd}rc ] && muttrc="~/.${muttcmd}rc"
  5657. < [ -z "$muttrc" ] && return 0
  5658. <
  5659. < conffiles=( $(eval _muttconffiles $muttrc $muttrc) )
  5660. < aliases=( $( sed -rn 's|^alias[[:space:]]+([^[:space:]]+).*$|\1|p' \
  5661. < $(eval echo ${conffiles[@]}) ) )
  5662. < COMPREPLY=( ${COMPREPLY[@]} $( compgen -W "${aliases[*]}" -- $cur ) )
  5663. <
  5664. < return 0
  5665. < }
  5666. <
  5667. < _muttquery()
  5668. < {
  5669. < local cur querycmd
  5670. < local -a queryresults
  5671. < cur=`_get_cword`
  5672. <
  5673. < querycmd="$( $muttcmd -Q query_command | sed -r 's|^query_command=\"(.*)\"$|\1|; s|%s|'$cur'|' )"
  5674. < if [ -z "$cur" -o -z "$querycmd" ]; then
  5675. < queryresults=()
  5676. < else
  5677. < queryresults=( $( $querycmd | \
  5678. < sed -nr '2,$s|^([^[:space:]]+).*|\1|p' ) )
  5679. < fi
  5680. <
  5681. < COMPREPLY=( ${COMPREPLY[@]} $( compgen -W "${queryresults[*]}" \
  5682. < -- $cur ) )
  5683. <
  5684. < return 0
  5685. < }
  5686. <
  5687. < _muttfiledir()
  5688. < {
  5689. < local cur folder spoolfile
  5690. < cur=`_get_cword`
  5691. <
  5692. < # This is currently not working so well. Perhaps this function should
  5693. < # just call _filedir() for the moment.
  5694. < if [[ $cur == [=+]* ]]; then
  5695. < folder="$( $muttcmd -Q folder | sed -r 's|^folder=\"(.*)\"$|\1|' )"
  5696. < : folder:=~/Mail
  5697. <
  5698. < # Match any file in $folder beginning with $cur
  5699. < # (minus the leading '=' sign).
  5700. < COMPREPLY=( $( compgen -f -- "$folder/${cur:1}" ) )
  5701. < COMPREPLY=( ${COMPREPLY[@]#$folder/} )
  5702. < return 0
  5703. < elif [ "$cur" == !* ]; then
  5704. < spoolfile="$( $muttcmd -Q spoolfile | sed -r 's|^spoolfile=\"(.*)\"$|\1|' )"
  5705. < [ ! -z "$spoolfile" ] && eval cur="${cur/^!/$spoolfile}";
  5706. < fi
  5707. < _filedir
  5708. <
  5709. < return 0
  5710. < }
  5711. <
  5712. < _mutt()
  5713. < {
  5714. < local cur prev
  5715. < cur=`_get_cword`
  5716. < prev=${COMP_WORDS[COMP_CWORD-1]}
  5717. <
  5718. < COMPREPLY=()
  5719. <
  5720. < [ ${COMP_WORDS[0]} == muttng ] && muttcmd="muttng" || muttcmd="mutt"
  5721. <
  5722. < case "$cur" in
  5723. < -*)
  5724. < COMPREPLY=( $( compgen -W '-A -a -b -c -e -f -F -H -i -m -n \
  5725. < -p -Q -R -s -v -x -y -z -Z -h' \
  5726. < -- $cur ) )
  5727. < return 0
  5728. < ;;
  5729. < *)
  5730. < case "$prev" in
  5731. < -@(a|f|F|H|i))
  5732. < _muttfiledir
  5733. < return 0
  5734. < ;;
  5735. < -A)
  5736. < _muttaliases
  5737. < return 0
  5738. < ;;
  5739. < -@(e|m|Q|s|h|p|R|v|y|z|Z))
  5740. < return 0
  5741. < ;;
  5742. < *)
  5743. < _muttaddr
  5744. < return 0
  5745. < ;;
  5746. < esac
  5747. < ;;
  5748. < esac
  5749. <
  5750. < }
  5751. < complete -F _mutt $default $filenames mutt muttng
  5752. < }
  5753. <
  5754. < _configure_func()
  5755. < {
  5756. < local cur
  5757. <
  5758. < COMPREPLY=()
  5759. < cur=`_get_cword`
  5760. <
  5761. < # if $COMP_CONFIGURE_HINTS is not null, then completions of the form
  5762. < # --option=SETTING will include 'SETTING' as a contextual hint
  5763. < [[ "$cur" != -* ]] && return 0
  5764. <
  5765. < if [ -n "$COMP_CONFIGURE_HINTS" ]; then
  5766. < COMPREPLY=( $( $1 --help | awk '/^ --[A-Za-z]/ { print $1; if ($2 ~ /--[A-Za-z]/) print $2 }' | sed -e 's/[[,].*//g' | grep ^$cur ) )
  5767. <
  5768. < else
  5769. < COMPREPLY=( $( $1 --help | awk '/^ --[A-Za-z]/ { print $1; if ($2 ~ /--[A-Za-z]/) print $2 }' | sed -e 's/[[,=].*//g' | grep ^$cur ) )
  5770. < fi
  5771. < }
  5772. < complete -F _configure_func $default configure
  5773. <
  5774. < # Debian reportbug(1) completion
  5775. < #
  5776. < have reportbug &&
  5777. < _reportbug()
  5778. < {
  5779. < local cur prev
  5780. <
  5781. < COMPREPLY=()
  5782. < cur=`_get_cword`
  5783. < prev=${COMP_WORDS[COMP_CWORD-1]}
  5784. <
  5785. < case "$prev" in
  5786. < -f|--filename|-i|--include|--mta|-o|--output)
  5787. < _filedir
  5788. < return 0
  5789. < ;;
  5790. < -B|--bts)
  5791. < COMPREPLY=( $( compgen -W "debian guug kde mandrake help" -- \
  5792. < $cur ))
  5793. < return 0
  5794. < ;;
  5795. < -e|--editor|--mua)
  5796. < COMP_WORDS=(COMP_WORDS[0] $cur)
  5797. < COMP_CWORD=1
  5798. < _command
  5799. < return 0
  5800. < ;;
  5801. < --mode)
  5802. < COMPREPLY=( $( compgen -W "novice standard expert" -- $cur ) )
  5803. < return 0
  5804. < ;;
  5805. < -S|--severity)
  5806. < COMPREPLY=( $( compgen -W "grave serious important normal \
  5807. < minor wishlist" -- $cur ) )
  5808. < return 0
  5809. < ;;
  5810. < -u|--ui|--interface)
  5811. < COMPREPLY=( $( compgen -W "newt text gnome" -- $cur ) )
  5812. < return 0
  5813. < ;;
  5814. < -t|--type)
  5815. < COMPREPLY=( $( compgen -W "gnats debbugs" -- $cur ) )
  5816. < return 0
  5817. < ;;
  5818. < -T|--tags)
  5819. < COMPREPLY=( $( compgen -W "none patch security upstream sid \
  5820. < woody potato sarge fixed" -- $cur ))
  5821. < return 0
  5822. < ;;
  5823. < *)
  5824. < ;;
  5825. < esac
  5826. <
  5827. < COMPREPLY=($( compgen -W '-h --help -v --version -a --af -b \
  5828. < --no-query-bts --query-bts -B --bts -c --configure \
  5829. < --no-config-files --check-available -d --debug \
  5830. < --no-check-available -e --editor --email -f \
  5831. < --filename -g --gnupg -H --header -i --include -j \
  5832. < --justification -l --ldap --no-ldap -L --list-cc -m \
  5833. < --maintonly --mode --mua --mta --mutt -n --mh --nmh \
  5834. < -o --output -p --print -P --pgp --proxy --http_proxy\
  5835. < -q --quiet -Q --query-only --realname --report-quiet \
  5836. < --reply-to --replyto -s --subject -S --severity \
  5837. < --smtphost -t --type -T --tags --template -V -x \
  5838. < --no-cc --package-version -z --no-compress \
  5839. < --ui --interface -u \
  5840. < wnpp boot-floppies kernel-image' -- $cur ) \
  5841. < $( apt-cache pkgnames -- $cur 2> /dev/null ) )
  5842. < _filedir
  5843. < return 0
  5844. < } &&
  5845. < complete -F _reportbug $filenames reportbug
  5846. <
  5847. < # Debian querybts(1) completion
  5848. < #
  5849. < have querybts &&
  5850. < _querybts()
  5851. < {
  5852. < local cur prev
  5853. <
  5854. < COMPREPLY=()
  5855. < cur=`_get_cword`
  5856. < prev=${COMP_WORDS[COMP_CWORD-1]}
  5857. <
  5858. < case "$prev" in
  5859. < -B|--bts)
  5860. < COMPREPLY=( $( compgen -W "debian guug kde mandrake help" -- \
  5861. < $cur ))
  5862. < return 0
  5863. < ;;
  5864. < -u|--ui|--interface)
  5865. < COMPREPLY=($( compgen -W "newt text gnome" -- $cur ))
  5866. < return 0
  5867. < ;;
  5868. < *)
  5869. < ;;
  5870. < esac
  5871. <
  5872. < COMPREPLY=($( compgen -W '-h --help -v --version -A --archive \
  5873. < -B --bts -l --ldap --no-ldap --proxy= --http_proxy= \
  5874. < -s --source -w --web -u --ui --interface \
  5875. < wnpp boot-floppies' -- $cur ) \
  5876. < $( apt-cache pkgnames -- $cur 2> /dev/null ) )
  5877. < } &&
  5878. < complete -F _querybts $filenames querybts
  5879. <
  5880. < # update-alternatives completion
  5881. < #
  5882. < have update-alternatives && {
  5883. < installed_alternatives()
  5884. < {
  5885. < local admindir
  5886. < # find the admin dir
  5887. < for i in alternatives dpkg/alternatives rpm/alternatives; do
  5888. < [ -d /var/lib/$i ] && admindir=/var/lib/$i && break
  5889. < done
  5890. < for (( i=1; i < COMP_CWORD; i++ )); do
  5891. < if [[ "${COMP_WORDS[i]}" == --admindir ]]; then
  5892. < admindir=${COMP_WORDS[i+1]}
  5893. < break
  5894. < fi
  5895. < done
  5896. < COMPREPLY=( $( command ls $admindir | grep "^$cur" ) )
  5897. < }
  5898. <
  5899. < _update_alternatives()
  5900. < {
  5901. < local cur prev mode args i
  5902. <
  5903. < COMPREPLY=()
  5904. < cur=`_get_cword`
  5905. < prev=${COMP_WORDS[COMP_CWORD-1]}
  5906. <
  5907. < case "$prev" in
  5908. < --@(altdir|admindir))
  5909. < _filedir -d
  5910. < return 0
  5911. < ;;
  5912. < --@(help|version))
  5913. < return 0
  5914. < ;;
  5915. < esac
  5916. <
  5917. < # find wich mode to use and how many real args used so far
  5918. < for (( i=1; i < COMP_CWORD; i++ )); do
  5919. < if [[ "${COMP_WORDS[i]}" == --@(install|remove|auto|display|config|remove-all) ]]; then
  5920. < mode=${COMP_WORDS[i]}
  5921. < args=$(($COMP_CWORD - i))
  5922. < break
  5923. < fi
  5924. < done
  5925. <
  5926. < case $mode in
  5927. < --install)
  5928. < case $args in
  5929. < 1)
  5930. < _filedir
  5931. < ;;
  5932. < 2)
  5933. < installed_alternatives
  5934. < ;;
  5935. < 3)
  5936. < _filedir
  5937. < ;;
  5938. < esac
  5939. < ;;
  5940. < --remove)
  5941. < case $args in
  5942. < 1)
  5943. < installed_alternatives
  5944. < ;;
  5945. < 2)
  5946. < _filedir
  5947. < ;;
  5948. < esac
  5949. < ;;
  5950. < --auto)
  5951. < installed_alternatives
  5952. < ;;
  5953. < --remove-all)
  5954. < installed_alternatives
  5955. < ;;
  5956. < --display)
  5957. < installed_alternatives
  5958. < ;;
  5959. < --config)
  5960. < installed_alternatives
  5961. < ;;
  5962. < *)
  5963. < COMPREPLY=( $( compgen -W '--verbose --quiet --help --version \
  5964. < --altdir --admindir' -- $cur ) \
  5965. < $( compgen -W '--install --remove --auto --display \
  5966. < --config' -- $cur ) )
  5967. < esac
  5968. < }
  5969. < complete -F _update_alternatives update-alternatives
  5970. < }
  5971. <
  5972. < # Python completion
  5973. < #
  5974. < have python &&
  5975. < _python()
  5976. < {
  5977. < local prev cur
  5978. <
  5979. < COMPREPLY=()
  5980. < cur=`_get_cword`
  5981. < prev=${COMP_WORDS[COMP_CWORD-1]##*/}
  5982. <
  5983. < case "$prev" in
  5984. < -Q)
  5985. < COMPREPLY=( $( compgen -W "old new warn warnall" -- $cur ) )
  5986. < return 0
  5987. < ;;
  5988. < -W)
  5989. < COMPREPLY=( $( compgen -W "ignore default all module once error" -- $cur ) )
  5990. < return 0
  5991. < ;;
  5992. < -c)
  5993. < _filedir '@(py|pyc|pyo)'
  5994. < return 0
  5995. < ;;
  5996. < !(python|-?))
  5997. < [[ ${COMP_WORDS[COMP_CWORD-2]} != -@(Q|W) ]] && _filedir
  5998. < ;;
  5999. < esac
  6000. <
  6001. <
  6002. < # if '-c' is already given, complete all kind of files.
  6003. < for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  6004. < if [[ ${COMP_WORDS[i]} == -c ]]; then
  6005. < _filedir
  6006. < fi
  6007. < done
  6008. <
  6009. <
  6010. < if [[ "$cur" != -* ]]; then
  6011. < _filedir '@(py|pyc|pyo)'
  6012. < else
  6013. < COMPREPLY=( $( compgen -W "- -d -E -h -i -O -Q -S -t -u \
  6014. < -U -v -V -W -x -c" -- $cur ) )
  6015. < fi
  6016. <
  6017. <
  6018. <
  6019. < return 0
  6020. < } &&
  6021. < complete -F _python $filenames python
  6022. <
  6023. < # Perl completion
  6024. < #
  6025. < have perl &&
  6026. < {
  6027. < _perlmodules()
  6028. < {
  6029. < 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 ) )
  6030. ---
  6031. > if [[ $cur == *@* ]]; then
  6032. > _known_hosts_real "$cur"
  6033. > else
  6034. > COMPREPLY=( $( compgen -u -- "$cur" ) )
  6035. > fi
  6036. >
  6037. > return 0
  6038. 5216a1149
  6039. > shopt -u hostcomplete && complete -F _user_at_host -o nospace talk ytalk finger
  6040. 5218c1151,1153
  6041. < _perl()
  6042. ---
  6043. > # NOTE: Using this function as a helper function is deprecated. Use
  6044. > # `_known_hosts_real' instead.
  6045. > _known_hosts()
  6046. 5220,5221c1155
  6047. < local cur prev prefix temp
  6048. <
  6049. ---
  6050. > local options
  6051. 5223,5232c1157,1209
  6052. < cur=`_get_cword`
  6053. < prev=${COMP_WORDS[COMP_CWORD-1]}
  6054. < prefix=""
  6055. <
  6056. < # completing an option (may or may not be separated by a space)
  6057. < if [[ "$cur" == -?* ]]; then
  6058. < temp=$cur
  6059. < prev=${temp:0:2}
  6060. < cur=${temp:2}
  6061. < prefix=$prev
  6062. ---
  6063. >
  6064. > # NOTE: Using `_known_hosts' as a helper function and passing options
  6065. > # to `_known_hosts' is deprecated: Use `_known_hosts_real' instead.
  6066. > [[ "$1" == -a || "$2" == -a ]] && options=-a
  6067. > [[ "$1" == -c || "$2" == -c ]] && options="$options -c"
  6068. > _known_hosts_real $options "$(_get_cword :)"
  6069. > } # _known_hosts()
  6070. >
  6071. > # Helper function for completing _known_hosts.
  6072. > # This function performs host completion based on ssh's config and known_hosts
  6073. > # files, as well as hostnames reported by avahi-browse. Also hosts from
  6074. > # HOSTFILE (compgen -A hostname) are added, unless
  6075. > # COMP_KNOWN_HOSTS_WITH_HOSTFILE is set to an empty value.
  6076. > # Usage: _known_hosts_real [OPTIONS] CWORD
  6077. > # Options: -a Use aliases
  6078. > # -c Use `:' suffix
  6079. > # -F configfile Use `configfile' for configuration settings
  6080. > # -p PREFIX Use PREFIX
  6081. > # Return: Completions, starting with CWORD, are added to COMPREPLY[]
  6082. > _known_hosts_real()
  6083. > {
  6084. > local configfile flag prefix
  6085. > local cur curd awkcur user suffix aliases i host
  6086. > local -a kh khd config
  6087. >
  6088. > local OPTIND=1
  6089. > while getopts "acF:p:" flag "$@"; do
  6090. > case $flag in
  6091. > a) aliases='yes' ;;
  6092. > c) suffix=':' ;;
  6093. > F) configfile=$OPTARG ;;
  6094. > p) prefix=$OPTARG ;;
  6095. > esac
  6096. > done
  6097. > [ $# -lt $OPTIND ] && echo "error: $FUNCNAME: missing mandatory argument CWORD"
  6098. > cur=${!OPTIND}; let "OPTIND += 1"
  6099. > [ $# -ge $OPTIND ] && echo "error: $FUNCNAME("$@"): unprocessed arguments:"\
  6100. > $(while [ $# -ge $OPTIND ]; do printf '%s\n' ${!OPTIND}; shift; done)
  6101. >
  6102. > [[ $cur == *@* ]] && user=${cur%@*}@ && cur=${cur#*@}
  6103. > kh=()
  6104. >
  6105. > # ssh config files
  6106. > if [ -n "$configfile" ]; then
  6107. > [ -r "$configfile" ] &&
  6108. > config=( "${config[@]}" "$configfile" )
  6109. > else
  6110. > [ -r /etc/ssh/ssh_config ] &&
  6111. > config=( "${config[@]}" "/etc/ssh/ssh_config" )
  6112. > [ -r "${HOME}/.ssh/config" ] &&
  6113. > config=( "${config[@]}" "${HOME}/.ssh/config" )
  6114. > [ -r "${HOME}/.ssh2/config" ] &&
  6115. > config=( "${config[@]}" "${HOME}/.ssh2/config" )
  6116. 5235,5250c1212,1228
  6117. < # only handle module completion for now
  6118. < case "$prev" in
  6119. < -I|-x)
  6120. < COMPREPLY=( $( compgen -d -P "$prev" -- "$cur" ) )
  6121. < return 0
  6122. < ;;
  6123. < -m|-M)
  6124. < _perlmodules
  6125. < return 0
  6126. < ;;
  6127. < esac
  6128. <
  6129. < # handle case where first parameter is not a dash option
  6130. < if [[ "${COMP_WORDS[COMP_CWORD]}" != -* ]]; then
  6131. < _filedir
  6132. < return 0
  6133. ---
  6134. > # Known hosts files from configs
  6135. > if [ ${#config[@]} -gt 0 ]; then
  6136. > local OIFS=$IFS IFS=$'\n'
  6137. > local -a tmpkh
  6138. > # expand paths (if present) to global and user known hosts files
  6139. > # TODO(?): try to make known hosts files with more than one consecutive
  6140. > # spaces in their name work (watch out for ~ expansion
  6141. > # breakage! Alioth#311595)
  6142. > tmpkh=( $( awk 'sub("^[ \t]*([Gg][Ll][Oo][Bb][Aa][Ll]|[Uu][Ss][Ee][Rr])[Kk][Nn][Oo][Ww][Nn][Hh][Oo][Ss][Tt][Ss][Ff][Ii][Ll][Ee][ \t]+", "") { print $0 }' "${config[@]}" | sort -u ) )
  6143. > for i in "${tmpkh[@]}"; do
  6144. > # Remove possible quotes
  6145. > i=${i//\"}
  6146. > # Eval/expand possible `~' or `~user'
  6147. > __expand_tilde_by_ref i
  6148. > [ -r "$i" ] && kh=( "${kh[@]}" "$i" )
  6149. > done
  6150. > IFS=$OIFS
  6151. 5253,5258c1231,1243
  6152. < # complete using basic options
  6153. < COMPREPLY=( $( compgen -W '-C -s -T -u -U -W -X -h -v -V -c -w -d -D -p \
  6154. < -n -a -F -l -0 -I -m -M -P -S -x -i -e ' -- $cur ) )
  6155. < return 0
  6156. < }
  6157. < complete -F _perl $filenames perl
  6158. ---
  6159. > # Global known_hosts files
  6160. > if [ -z "$configfile" ]; then
  6161. > [ -r /etc/ssh/ssh_known_hosts ] &&
  6162. > kh=( "${kh[@]}" /etc/ssh/ssh_known_hosts )
  6163. > [ -r /etc/ssh/ssh_known_hosts2 ] &&
  6164. > kh=( "${kh[@]}" /etc/ssh/ssh_known_hosts2 )
  6165. > [ -r /etc/known_hosts ] &&
  6166. > kh=( "${kh[@]}" /etc/known_hosts )
  6167. > [ -r /etc/known_hosts2 ] &&
  6168. > kh=( "${kh[@]}" /etc/known_hosts2 )
  6169. > [ -d /etc/ssh2/knownhosts ] &&
  6170. > khd=( "${khd[@]}" /etc/ssh2/knownhosts/*pub )
  6171. > fi
  6172. 5260,5262c1245,1253
  6173. < _perldoc()
  6174. < {
  6175. < local cur prev prefix temp
  6176. ---
  6177. > # User known_hosts files
  6178. > if [ -z "$configfile" ]; then
  6179. > [ -r ~/.ssh/known_hosts ] &&
  6180. > kh=( "${kh[@]}" ~/.ssh/known_hosts )
  6181. > [ -r ~/.ssh/known_hosts2 ] &&
  6182. > kh=( "${kh[@]}" ~/.ssh/known_hosts2 )
  6183. > [ -d ~/.ssh2/hostkeys ] &&
  6184. > khd=( "${khd[@]}" ~/.ssh2/hostkeys/*pub )
  6185. > fi
  6186. 5264,5274c1255,1303
  6187. < COMPREPLY=()
  6188. < cur=`_get_cword`
  6189. < prev=${COMP_WORDS[COMP_CWORD-1]}
  6190. < prefix=""
  6191. <
  6192. < # completing an option (may or may not be separated by a space)
  6193. < if [[ "$cur" == -?* ]]; then
  6194. < temp=$cur
  6195. < prev=${temp:0:2}
  6196. < cur=${temp:2}
  6197. < prefix=$prev
  6198. ---
  6199. > # If we have known_hosts files to use
  6200. > if [[ ${#kh[@]} -gt 0 || ${#khd[@]} -gt 0 ]]; then
  6201. > # Escape slashes and dots in paths for awk
  6202. > awkcur=${cur//\//\\\/}
  6203. > awkcur=${awkcur//\./\\\.}
  6204. > curd=$awkcur
  6205. >
  6206. > if [[ "$awkcur" == [0-9]*.* ]]; then
  6207. > # Digits followed by a dot - just search for that
  6208. > awkcur="^$awkcur.*"
  6209. > elif [[ "$awkcur" == [0-9]* ]]; then
  6210. > # Digits followed by no dot - search for digits followed
  6211. > # by a dot
  6212. > awkcur="^$awkcur.*\."
  6213. > elif [ -z "$awkcur" ]; then
  6214. > # A blank - search for a dot or an alpha character
  6215. > awkcur="[a-z.]"
  6216. > else
  6217. > awkcur="^$awkcur"
  6218. > fi
  6219. >
  6220. > if [ ${#kh[@]} -gt 0 ]; then
  6221. > # FS needs to look for a comma separated list
  6222. > COMPREPLY=( "${COMPREPLY[@]}" $( awk 'BEGIN {FS=","}
  6223. > /^\s*[^|\#]/ {for (i=1; i<=2; ++i) { \
  6224. > gsub(" .*$", "", $i); \
  6225. > gsub("[\\[\\]]", "", $i); \
  6226. > gsub(":[0-9]+$", "", $i); \
  6227. > if ($i ~ /'"$awkcur"'/) {print $i} \
  6228. > }}' "${kh[@]}" 2>/dev/null ) )
  6229. > fi
  6230. > if [ ${#khd[@]} -gt 0 ]; then
  6231. > # Needs to look for files called
  6232. > # .../.ssh2/key_22_<hostname>.pub
  6233. > # dont fork any processes, because in a cluster environment,
  6234. > # there can be hundreds of hostkeys
  6235. > for i in "${khd[@]}" ; do
  6236. > if [[ "$i" == *key_22_$curd*.pub && -r "$i" ]]; then
  6237. > host=${i/#*key_22_/}
  6238. > host=${host/%.pub/}
  6239. > COMPREPLY=( "${COMPREPLY[@]}" $host )
  6240. > fi
  6241. > done
  6242. > fi
  6243. >
  6244. > # apply suffix and prefix
  6245. > for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
  6246. > COMPREPLY[i]=$prefix$user${COMPREPLY[i]}$suffix
  6247. > done
  6248. 5277,6410c1306,1330
  6249. < # complete builtin perl functions
  6250. < case $prev in
  6251. < -f)
  6252. < COMPREPLY=( $( compgen -W 'chomp chop chr crypt hex index lc \
  6253. < lcfirst length oct ord pack q qq reverse rindex sprintf \
  6254. < substr tr uc ucfirst y m pos quotemeta s split study qr abs \
  6255. < atan2 cos exp hex int log oct rand sin sqrt srand pop push \
  6256. < shift splice unshift grep join map qw reverse sort unpack \
  6257. < delete each exists keys values binmode close closedir \
  6258. < dbmclose dbmopen die eof fileno flock format getc print \
  6259. < printf read readdir rewinddir seek seekdir select syscall \
  6260. < sysread sysseek syswrite tell telldir truncate warn write \
  6261. < pack read syscall sysread syswrite unpack vec -X chdir chmod \
  6262. < chown chroot fcntl glob ioctl link lstat mkdir open opendir \
  6263. < readlink rename rmdir stat symlink umask unlink utime caller \
  6264. < continue do dump eval exit goto last next redo return \
  6265. < sub wantarray caller import local my our package use defined \
  6266. < formline reset scalar undef \
  6267. < alarm exec fork getpgrp getppid getpriority kill pipe qx \
  6268. < setpgrp setpriority sleep system times wait waitpid \
  6269. < import no package require use bless dbmclose dbmopen package \
  6270. < ref tie tied untie use accept bind connect getpeername \
  6271. < getsockname getsockopt listen recv send setsockopt shutdown \
  6272. < socket socketpair msgctl msgget msgrcv msgsnd semctl semget \
  6273. < semop shmctl shmget shmread shmwrite endgrent endhostent \
  6274. < endnetent endpwent getgrent getgrgid getgrnam getlogin \
  6275. < getpwent getpwnam getpwuid setgrent setpwent endprotoent \
  6276. < endservent gethostbyaddr gethostbyname gethostent \
  6277. < getnetbyaddr getnetbyname getnetent getprotobyname \
  6278. < getprotobynumber getprotoent getservbyname getservbyport \
  6279. < getservent sethostent setnetent setprotoent setservent \
  6280. < gmtime localtime time times' -- $cur ) )
  6281. < return 0
  6282. < ;;
  6283. < esac
  6284. <
  6285. < case $cur in
  6286. < -*)
  6287. < COMPREPLY=( $( compgen -W '-h -v -t -u -m -l -F -X -f -q' -- $cur ))
  6288. < return 0
  6289. < ;;
  6290. < */*)
  6291. < return 0
  6292. < ;;
  6293. < *)
  6294. < _perlmodules
  6295. < COMPREPLY=( ${COMPREPLY[@]} $( compgen -W '$( PAGER=cat man perl 2>/dev/null | sed -ne "/perl.*Perl overview/,/perlwin32/s/^[^a-z0-9]*\([a-z0-9]*\).*$/\1/p")' -- $cur ) )
  6296. <
  6297. < return 0
  6298. < ;;
  6299. < esac
  6300. < }
  6301. < complete -F _perldoc $default perldoc
  6302. < }
  6303. <
  6304. < # rcs(1) completion
  6305. < #
  6306. < have rcs &&
  6307. < _rcs()
  6308. < {
  6309. < local cur prev file dir i
  6310. <
  6311. < COMPREPLY=()
  6312. < cur=`_get_cword`
  6313. < prev=${COMP_WORDS[COMP_CWORD-1]}
  6314. <
  6315. < file=${cur##*/}
  6316. < dir=${cur%/*}
  6317. <
  6318. < # deal with relative directory
  6319. < [ "$file" = "$dir" ] && dir=.
  6320. <
  6321. < COMPREPLY=( $( compgen -f "$dir/RCS/$file" ) )
  6322. <
  6323. < for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
  6324. < file=${COMPREPLY[$i]##*/}
  6325. < dir=${COMPREPLY[$i]%RCS/*}
  6326. < COMPREPLY[$i]=$dir$file
  6327. < done
  6328. <
  6329. < COMPREPLY=( "${COMPREPLY[@]}" $( compgen -G "$dir/$file*,v" ) )
  6330. <
  6331. < for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
  6332. < COMPREPLY[$i]=${COMPREPLY[$i]%,v}
  6333. < done
  6334. <
  6335. < # default to files if nothing returned and we're checking in.
  6336. < # otherwise, default to directories
  6337. < [ ${#COMPREPLY[@]} -eq 0 -a $1 = ci ] && _filedir || _filedir -d
  6338. < } &&
  6339. < complete -F _rcs $filenames ci co rlog rcs rcsdiff
  6340. <
  6341. < # lilo(8) completion
  6342. < #
  6343. < have lilo && {
  6344. < _lilo_labels()
  6345. < {
  6346. < COMPREPLY=( $( awk -F'=' '/label/ {print $2}' \
  6347. < /etc/lilo.conf | sed -e 's/"//g' | grep "^$cur" ) )
  6348. < }
  6349. <
  6350. < _lilo()
  6351. < {
  6352. < local cur prev
  6353. <
  6354. < COMPREPLY=()
  6355. < cur=`_get_cword`
  6356. < prev=${COMP_WORDS[COMP_CWORD-1]}
  6357. <
  6358. < case $prev in
  6359. < -@(C|i|m|s|S))
  6360. < _filedir
  6361. < return 0
  6362. < ;;
  6363. < -r)
  6364. < _filedir -d
  6365. < return 0
  6366. < ;;
  6367. < -@(I|D|R))
  6368. < # label completion
  6369. < _lilo_labels
  6370. < return 0
  6371. < ;;
  6372. < -@(A|b|M|u|U))
  6373. < # device completion
  6374. < cur=${cur:=/dev/}
  6375. < _filedir
  6376. < return 0
  6377. < ;;
  6378. < -T)
  6379. < # topic completion
  6380. < COMPREPLY=( $( compgen -W 'help ChRul EBDA geom geom= \
  6381. < table= video' -- $cur ) )
  6382. < return 0
  6383. < ;;
  6384. < esac
  6385. <
  6386. < if [[ "$cur" == -* ]]; then
  6387. < # relevant options completion
  6388. < COMPREPLY=( $( compgen -W '-A -b -c -C -d -f -g -i -I -l -L -m \
  6389. < -M -p -P -q -r -R -s -S -t -T -u -U -v -V -w -x -z' -- \
  6390. < $cur ) )
  6391. < fi
  6392. < }
  6393. < complete -F _lilo lilo
  6394. < }
  6395. <
  6396. < # links completion
  6397. < #
  6398. < have links &&
  6399. < _links()
  6400. < {
  6401. < local cur
  6402. <
  6403. < COMPREPLY=()
  6404. < cur=`_get_cword`
  6405. <
  6406. < case "$cur" in
  6407. < --*)
  6408. < COMPREPLY=( $( compgen -W '--help' -- $cur ) )
  6409. < ;;
  6410. < -*)
  6411. < COMPREPLY=( $( compgen -W '-async-dns -max-connections \
  6412. < -max-connections-to-host -retries \
  6413. < -receive-timeout -unrestartable-receive-timeout\
  6414. < -format-cache-size -memory-cache-size \
  6415. < -http-proxy -ftp-proxy -download-dir \
  6416. < -assume-codepage -anonymous -dump -no-connect \
  6417. < -source -version -help' -- $cur ) )
  6418. < ;;
  6419. < *)
  6420. < if [ -r ~/.links/links.his ]; then
  6421. < COMPREPLY=( $( compgen -W '$( < ~/.links/links.his )' \
  6422. < -- $cur ) )
  6423. < fi
  6424. < _filedir '@(htm|html)'
  6425. < return 0
  6426. < ;;
  6427. < esac
  6428. <
  6429. < return 0
  6430. < } &&
  6431. < complete -F _links $filenames links
  6432. <
  6433. < [ $UNAME = FreeBSD ] && {
  6434. < # FreeBSD package management tool completion
  6435. < #
  6436. < _pkg_delete()
  6437. < {
  6438. < local cur pkgdir prev
  6439. <
  6440. < pkgdir=${PKG_DBDIR:-/var/db/pkg}/
  6441. < cur=`_get_cword`
  6442. < prev=${COMP_WORDS[COMP_CWORD-1]}
  6443. <
  6444. < [ "$prev" = "-o" -o "$prev" = "-p" -o "$prev" = "-W" ] && return 0
  6445. <
  6446. < COMPREPLY=( $( compgen -d $pkgdir$cur ) )
  6447. < COMPREPLY=( ${COMPREPLY[@]#$pkgdir} )
  6448. <
  6449. < return 0
  6450. < }
  6451. < complete -F _pkg_delete $dirnames pkg_delete pkg_info
  6452. < have pkg_deinstall && complete -F _pkg_delete $dirnames pkg_deinstall
  6453. <
  6454. < # FreeBSD kernel module commands
  6455. < #
  6456. < _kldload()
  6457. < {
  6458. < local cur moddir
  6459. <
  6460. < moddir=/modules/
  6461. < [ -d $moddir ] || moddir=/boot/kernel/
  6462. < cur=`_get_cword`
  6463. <
  6464. < COMPREPLY=( $( compgen -f $moddir$cur ) )
  6465. < COMPREPLY=( ${COMPREPLY[@]#$moddir} )
  6466. < COMPREPLY=( ${COMPREPLY[@]%.ko} )
  6467. <
  6468. < return 0
  6469. < }
  6470. < complete -F _kldload $filenames kldload
  6471. <
  6472. < _kldunload()
  6473. < {
  6474. < local cur
  6475. < cur=`_get_cword`
  6476. < COMPREPLY=( $(kldstat | sed -ne "s/^.*[ \t]\+\($cur[a-z_]\+\).ko$/\1/p") )
  6477. < }
  6478. < complete -F _kldunload $filenames kldunload
  6479. < }
  6480. <
  6481. < # FreeBSD portupgrade completion
  6482. < #
  6483. < have portupgrade &&
  6484. < _portupgrade()
  6485. < {
  6486. < local cur pkgdir prev
  6487. <
  6488. < pkgdir=${PKG_DBDIR:-/var/db/pkg}/
  6489. < cur=`_get_cword`
  6490. < prev=${COMP_WORDS[COMP_CWORD-1]}
  6491. <
  6492. < [ "$prev" = "-l" -o "$prev" = "-L" -o "$prev" = "-o" ] && return 0
  6493. <
  6494. < COMPREPLY=( $( compgen -d $pkgdir$cur ) )
  6495. < COMPREPLY=( ${COMPREPLY[@]#$pkgdir} )
  6496. < COMPREPLY=( ${COMPREPLY[@]%-*} )
  6497. <
  6498. < return 0
  6499. < } &&
  6500. < complete -F _portupgrade $dirnames portupgrade
  6501. <
  6502. < # FreeBSD portinstall completion
  6503. < #
  6504. < have portinstall &&
  6505. < _portinstall()
  6506. < {
  6507. < local cur portsdir prev indexfile
  6508. < local -a COMPREPLY2
  6509. <
  6510. < portsdir=${PORTSDIR:-/usr/ports}/
  6511. < cur=`_get_cword`
  6512. < prev=${COMP_WORDS[COMP_CWORD-1]}
  6513. < # First try INDEX-5
  6514. < indexfile=$portsdir/INDEX-5
  6515. < # Then INDEX if INDEX-5 does not exist or system is not FreeBSD 5.x
  6516. < [ "${OSTYPE%.*}" = "freebsd5" -a -f $indexfile ] ||
  6517. < indexfile=$portsdir/INDEX
  6518. <
  6519. < [ "$prev" = "-l" -o "$prev" = "-L" -o "$prev" = "-o" ] && return 0
  6520. <
  6521. < COMPREPLY=( $( egrep "^$cur" < $indexfile | cut -d'|' -f1 ) )
  6522. < COMPREPLY2=( $( egrep "^[^\|]+\|$portsdir$cur" < $indexfile | \
  6523. < cut -d'|' -f2 ) )
  6524. < COMPREPLY2=( ${COMPREPLY2[@]#$portsdir} )
  6525. < COMPREPLY=( ${COMPREPLY[@]} ${COMPREPLY2[@]} )
  6526. <
  6527. < return 0
  6528. < } &&
  6529. < complete -F _portinstall $dirnames portinstall
  6530. <
  6531. < # Slackware Linux removepkg completion
  6532. < #
  6533. < have removepkg && [ -f /etc/slackware-version ] &&
  6534. < _removepkg()
  6535. < {
  6536. < local packages cur
  6537. <
  6538. < COMPREPLY=()
  6539. < cur=`_get_cword`
  6540. <
  6541. < COMPREPLY=( $( (cd /var/log/packages; compgen -f -- "$cur") ) )
  6542. < } &&
  6543. < complete -F _removepkg $filenames removepkg &&
  6544. < complete $dirnames -f -X '!*.tgz' installpkg upgradepkg explodepkg
  6545. <
  6546. < # look(1) completion
  6547. < #
  6548. < have look &&
  6549. < _look()
  6550. < {
  6551. < local cur
  6552. <
  6553. < COMPREPLY=()
  6554. < cur=`_get_cword`
  6555. <
  6556. < if [ $COMP_CWORD = 1 ]; then
  6557. < COMPREPLY=( $( compgen -W '$(look $cur)' ) )
  6558. < fi
  6559. < } &&
  6560. < complete -F _look $default look
  6561. <
  6562. < # ypcat(1) and ypmatch(1) completion
  6563. < #
  6564. < have ypmatch &&
  6565. < _ypmatch()
  6566. < {
  6567. < local cur map
  6568. <
  6569. < COMPREPLY=()
  6570. < cur=`_get_cword`
  6571. <
  6572. < [ $1 = ypcat ] && [ $COMP_CWORD -gt 1 ] && return 0
  6573. < [ $1 = ypmatch ] && [ $COMP_CWORD -gt 2 ] && return 0
  6574. <
  6575. < if [ $1 = ypmatch ] && [ $COMP_CWORD -eq 1 ] && \
  6576. < [ ${#COMP_WORDS[@]} -eq 3 ]; then
  6577. < map=${COMP_WORDS[2]}
  6578. < COMPREPLY=( $( compgen -W '$( ypcat $map | \
  6579. < cut -d':' -f 1 )' -- $cur) )
  6580. < else
  6581. < [ $1 = ypmatch ] && [ $COMP_CWORD -ne 2 ] && return 0
  6582. < COMPREPLY=( $( compgen -W \
  6583. < '$( echo $(ypcat -x | cut -d"\"" -f 2))' -- $cur))
  6584. < fi
  6585. <
  6586. < return 0
  6587. < } &&
  6588. < complete -F _ypmatch ypmatch ypcat
  6589. <
  6590. < # mplayer(1) completion
  6591. < #
  6592. < have mplayer && {
  6593. < _mplayer_options_list()
  6594. < {
  6595. < cur=${cur%\\}
  6596. < COMPREPLY=( $( $1 $2 help 2> /dev/null | \
  6597. < sed -e '1,/^Available/d' | awk '{print $1}' | \
  6598. < sed -e 's/:$//' -e 's/^'${2#-}'$//' -e 's/<.*//' | \
  6599. < grep "^$cur" ) )
  6600. < }
  6601. <
  6602. < _mplayer()
  6603. < {
  6604. < local cmd cur prev skinsdir IFS=$' \t\n' i j k=0
  6605. <
  6606. < COMPREPLY=()
  6607. < cmd=${COMP_WORDS[0]}
  6608. < cur=`_get_cword`
  6609. < prev=${COMP_WORDS[COMP_CWORD-1]}
  6610. <
  6611. < case "$prev" in
  6612. < -@(ac|afm|vc|vfm|ao|vo|vop|fstype))
  6613. < _mplayer_options_list mplayer $prev
  6614. < return 0
  6615. < ;;
  6616. < -@(oac|ovc|of))
  6617. < _mplayer_options_list mencoder $prev
  6618. < return 0
  6619. < ;;
  6620. < -audiofile)
  6621. < _filedir '@(mp3|MP3|mpg|MPG|ogg|OGG|wav|WAV|mid|MID|flac|FLAC|mka|MKA)'
  6622. < return 0
  6623. < ;;
  6624. < -font)
  6625. < _filedir '@(desc|ttf)'
  6626. < return 0
  6627. < ;;
  6628. < -sub)
  6629. < _filedir '@(srt|SRT|sub|SUB|txt|TXT|utf|UTF|rar|RAR|mpsub|smi|js)'
  6630. < return 0
  6631. < ;;
  6632. < -vobsub)
  6633. < _filedir '@(idx|IDX|ifo|IFO|sub|SUB)'
  6634. < IFS=$'\t\n'
  6635. < COMPREPLY=( $( for i in ${COMPREPLY[@]}; do
  6636. < if [ -f $i -a -r $i ]; then
  6637. < echo ${i%.*}
  6638. < else
  6639. < echo $i
  6640. < fi
  6641. < done ) )
  6642. < IFS=$' \t\n'
  6643. < return 0
  6644. < ;;
  6645. < -ifo)
  6646. < _filedir '@(ifo|IFO)'
  6647. < return 0
  6648. < ;;
  6649. < -cuefile)
  6650. < _filedir '@(bin|BIN|cue|CUE)'
  6651. < return 0
  6652. < ;;
  6653. < -skin)
  6654. < # if you don't have installed mplayer in /usr/local you
  6655. < # may want to set the MPLAYER_SKINS_DIR global variable
  6656. < if [ -n "$MPLAYER_SKINS_DIR" ]; then
  6657. < skinsdir=$MPLAYER_SKINS_DIR
  6658. < else
  6659. < skinsdir=/usr/local/share/mplayer/Skin
  6660. < fi
  6661. <
  6662. < IFS=$'\t\n'
  6663. < for i in ~/.mplayer/Skin $skinsdir; do
  6664. < if [ -d $i -a -r $i ]; then
  6665. < for j in $( compgen -d $i/$cur ); do
  6666. < COMPREPLY[$k]=${j#$i/}
  6667. < k=$((++k))
  6668. < done
  6669. < fi
  6670. < done
  6671. < IFS=$' \t\n'
  6672. < return 0
  6673. < ;;
  6674. < -@(mixer|@(cdrom|dvd)-device|dvdauth|fb|zrdev))
  6675. < cur=${cur:=/dev/}
  6676. < _filedir
  6677. < return 0
  6678. < ;;
  6679. < -@(edl?(out)|lircconf|menu-cfg|playlist|csslib|dumpfile)| \
  6680. < -@(subfile|vobsub|aofile|fbmodeconfig|include|o|dvdkey)| \
  6681. < -passlogfile)
  6682. < _filedir
  6683. < return 0
  6684. < ;;
  6685. < -@(auto@(q|sync)|loop|menu-root|speed|sstep|aid|alang)| \
  6686. < -@(?(@(audio|sub)-)demuxer|bandwidth|cache|chapter)| \
  6687. < -@(dvd?(angle)|fps|frames|mc|passwd|user|sb|srate|ss|vcd)| \
  6688. < -@(vi?(d|vo)|ffactor|sid|slang|spu@(align|aa|gauss))| \
  6689. < -@(vobsubid|delay|bpp|brightness|contrast|dfbopts|display)| \
  6690. < -@(fbmode|geometry|guiwid|hue|icelayer|screen[wh]|wid)| \
  6691. < -@(monitor@(aspect|-@(dotclock|[hv]freq))|panscan|saturation)| \
  6692. < -@(xineramascreen|zr@(crop|norm|quality|[xy]doff|[vh]dec))| \
  6693. < -@(aspect|pp|x|y|xy|z|stereo|audio-@(density|delay|preload))| \
  6694. < -@(endpos|osdlevel|ffourcc|sws|channels|skiplimit|format)| \
  6695. < -@(ofps|aa@(driver|@(osd|sub)color)|vobsubout?(i@(ndex|d)))| \
  6696. < -sub@(-bg-@(alpha|color)|cp|delay|fps|pos|align|width)| \
  6697. < -sub@(font-@(blur|outline|autoscale|encoding|@(osd|text)-scale)))
  6698. < return 0
  6699. < ;;
  6700. < -lavdopts)
  6701. < COMPREPLY=( $( compgen -W 'ec er= bug= idct= gray' \
  6702. < -- $cur ) )
  6703. < return 0
  6704. < ;;
  6705. < -lavcopts)
  6706. < COMPREPLY=( $( compgen -W 'vcodec= vqmin= vqscale= \
  6707. < vqmax= mbqmin= mbqmax= vqdiff= \
  6708. < vmax_b_frames= vme= vhq v4mv \
  6709. < keyint= vb_strategy= vpass= \
  6710. < aspect= vbitrate= vratetol= \
  6711. < vrc_maxrate= vrc_minrate= \
  6712. < vrc_buf_size= vb_qfactor= vi_qfactor= \
  6713. < vb_qoffset= vi_qoffset= vqblur= \
  6714. < vqcomp= vrc_eq= vrc_override= \
  6715. < vrc_init_cplx= vqsquish= vlelim= \
  6716. < vcelim= vstrict= vdpart vpsize= gray \
  6717. < vfdct= idct= lumi_mask= dark_mask= \
  6718. < tcplx_mask= scplx_mask= naq ildct \
  6719. < format= pred qpel precmp= cmp= \
  6720. < subcmp= predia= dia= trell last_pred= \
  6721. < preme= subq= psnr mpeg_quant aic umv' \
  6722. < -- $cur ) )
  6723. < return 0
  6724. < ;;
  6725. < -ssf)
  6726. < COMPREPLY=( $( compgen -W 'lgb= cgb= ls= cs= chs= \
  6727. < cvs=' -- $cur ) )
  6728. < return 0
  6729. < ;;
  6730. < -jpeg)
  6731. < COMPREPLY=( $( compgen -W 'noprogressive progressive \
  6732. < nobaseline baseline optimize= \
  6733. < smooth= quality= outdir=' -- $cur ) )
  6734. < return 0
  6735. < ;;
  6736. < -xvidopts)
  6737. < COMPREPLY=( $( compgen -W 'dr2 nodr2' -- $cur ) )
  6738. < return 0
  6739. < ;;
  6740. < -xvidencopts)
  6741. < COMPREPLY=( $( compgen -W 'pass= bitrate= \
  6742. < fixed_quant= me_quality= 4mv \
  6743. < rc_reaction_delay_factor= \
  6744. < rc_averaging_period= rc_buffer= \
  6745. < quant_range= min_key_interval= \
  6746. < max_key_interval= mpeg_quant \
  6747. < mod_quant lumi_mask hintedme \
  6748. < hintfile debug keyframe_boost= \
  6749. < kfthreshold= kfreduction=' -- $cur ) )
  6750. < return 0
  6751. < ;;
  6752. < -divx4opts)
  6753. < COMPREPLY=( $( compgen -W 'br= key= deinterlace q= \
  6754. < min_quant= max_quant= rc_period= \
  6755. < rc_reaction_period= crispness= \
  6756. < rc_reaction_ratio= pass= vbrpass= \
  6757. < help' -- $cur ) )
  6758. < return 0
  6759. < ;;
  6760. < -info)
  6761. < COMPREPLY=( $( compgen -W 'name= artist= genre= \
  6762. < subject= copyright= srcform= \
  6763. < comment= help' -- $cur ) )
  6764. < return 0
  6765. < ;;
  6766. < -lameopts)
  6767. < COMPREPLY=( $( compgen -W 'vbr= abr cbr br= q= aq= \
  6768. < ratio= vol= mode= padding= fast \
  6769. < preset= help' -- $cur ) )
  6770. < return 0
  6771. < ;;
  6772. < -rawaudio)
  6773. < COMPREPLY=( $( compgen -W 'on channels= rate= \
  6774. < samplesize= format=' -- $cur ) )
  6775. < return 0
  6776. < ;;
  6777. < -rawvideo)
  6778. < COMPREPLY=( $( compgen -W 'on fps= sqcif qcif cif \
  6779. < 4cif pal ntsc w= h= y420 yv12 yuy2 \
  6780. < y8 format= size=' -- $cur ) )
  6781. < return 0
  6782. < ;;
  6783. < -aop)
  6784. < COMPREPLY=( $( compgen -W 'list= delay= format= fout= \
  6785. < volume= mul= softclip' -- $cur ) )
  6786. < return 0
  6787. < ;;
  6788. < -dxr2)
  6789. < COMPREPLY=( $( compgen -W 'ar-mode= iec958-encoded \
  6790. < iec958-decoded mute ucode= 75ire bw \
  6791. < color interlaced macrovision= norm= \
  6792. < square-pixel ccir601-pixel cr-left= \
  6793. < cr-right= cr-top= cr-bot= ck-rmin= \
  6794. < ck-gmin= ck-bmin= ck-rmax= ck-gmax= \
  6795. < ck-bmax= ck-r= ck-g= ck-b= \
  6796. < ignore-cache= ol-osd= olh-cor= \
  6797. < olw-cor= olx-cor= oly-cor= overlay \
  6798. < overlay-ratio= update-cache' -- $cur ))
  6799. < return 0
  6800. < ;;
  6801. < -tv)
  6802. < COMPREPLY=( $( compgen -W 'on noaudio driver= device= \
  6803. < input= freq= outfmt= width= height= \
  6804. < buffersize= norm= channel= chanlist= \
  6805. < audiorate= forceaudio alsa amode= \
  6806. < forcechan= adevice= audioid= volume= \
  6807. < bass= treble= balance= fps= \
  6808. < channels= immediatemode=' -- $cur ) )
  6809. < return 0
  6810. < ;;
  6811. < -mf)
  6812. < COMPREPLY=( $( compgen -W 'on w= h= fps= type=' \
  6813. < -- $cur ) )
  6814. < return 0
  6815. < ;;
  6816. < -cdda)
  6817. < COMPREPLY=( $( compgen -W 'speed= paranoia= \
  6818. < generic-dev= sector-size= overlap= \
  6819. < toc-bias toc-offset= skip noskip' \
  6820. < -- $cur ) )
  6821. < return 0
  6822. < ;;
  6823. < -input)
  6824. < COMPREPLY=( $( compgen -W 'conf= ar-delay ar-rate \
  6825. < keylist cmdlist js-dev file' -- $cur ) )
  6826. < return 0
  6827. < ;;
  6828. < -af)
  6829. < COMPREPLY=( $( compgen -W 'resample resample= \
  6830. < channels channels= format format= \
  6831. < volume volume= delay delay= pan \
  6832. < pan= sub sub= surround surround=' \
  6833. < -- $cur ) )
  6834. < return 0
  6835. < ;;
  6836. < -af-adv)
  6837. < COMPREPLY=( $( compgen -W 'force= list=' -- $cur ) )
  6838. < return 0
  6839. < ;;
  6840. < esac
  6841. <
  6842. < case "$cur" in
  6843. < -*)
  6844. < COMPREPLY=( $( compgen -W '-aid -alang -audio-demuxer \
  6845. < -audiofile -cdrom-device -cache -cdda \
  6846. < -channels -chapter -csslib -demuxer \
  6847. < -dvd -dvd-device -dvdangle -dvdauth \
  6848. < -dvdkey -dvdnav -forceidx -fps -frames \
  6849. < -hr-mp3-seek -idx -mc -mf -ni -nobps \
  6850. < -passwd -rawaudio -rtsp-stream-over-tcp\
  6851. < -skipopening -sb -srate -ss -tv -user \
  6852. < -vcd -vid -vivo -ifo -ffactor -font \
  6853. < -noautosub -nooverlapsub -sid -slang \
  6854. < -sub -subcc -subcp -sub-demuxer \
  6855. < -subdelay -subfont-autoscale \
  6856. < -subfont-blur -subfont-encoding \
  6857. < -subfont-osd-scale -subfont-outline \
  6858. < -subfont-text-scale -subfps -subfile \
  6859. < -subpos -unicode -utf8 -vobsub \
  6860. < -vobsubid -ac -afm -aspect -flip \
  6861. < -lavdopts -noaspect -nosound -pp -ssf \
  6862. < -stereo -sws -vc -vfm -vop -xvidopts\
  6863. < -xy -zoom -bandwidth -cuefile \
  6864. < -noextbased -rawvideo -overlapsub \
  6865. < -sub-bg-alpha -sub-bg-color -subalign \
  6866. < -subwidth -sub-no-text-pp -spualign \
  6867. < -spuaa -spugauss -pphelp -verbose -v \
  6868. < -noni -noidx -nohr-mp3-seek -extbased \
  6869. < -bps -oldpp -nozoom -noflip -nounicode \
  6870. < -noutf8' -- $cur ) )
  6871. < # add mplayer specific options
  6872. < [[ "$cmd" == @(?(g)mplayer) ]] && COMPREPLY=( ${COMPREPLY[@]} \
  6873. < $(compgen -W '-autoq -autosync -benchmark \
  6874. < -framedrop -h -help -hardframedrop \
  6875. < -identify -input -lircconf -loop \
  6876. < -nojoystick -nolirc -nortc -playlist \
  6877. < -quiet -really-quiet -rnd -sdp -skin \
  6878. < -slave -softsleep -speed -sstep \
  6879. < -use-stdin -dumpaudio -dumpfile \
  6880. < -dumpstream -dumpvideo -dumpmicrodvdsub\
  6881. < -dumpmpsub -dumpsrtsub -dumpjacosub \
  6882. < -dumpsami -dumpsub -osdlevel -af \
  6883. < -af-adv -ao -aofile -aop -delay -mixer \
  6884. < -nowaveheader -bpp -brightness \
  6885. < -contrast -display -double -dr -dxr2 \
  6886. < -fb -fbmode -fbmodeconfig -forcexv -fs \
  6887. < -geometry -hue -icelayer -jpeg \
  6888. < -monitor-dotclock -monitor-hfreq \
  6889. < -monitor-vfreq -monitoraspect \
  6890. < -nograbpointer -noslices -panscan \
  6891. < -rootwin -saturation -screenw -screenh \
  6892. < -stop-xscreensaver -vm -vo -vsync -wid \
  6893. < -xineramascreen -z -zrbw -zrcrop \
  6894. < -zrdev -zrfd -zrhelp -zrnorm -zrquality \
  6895. < -zrvdec -zrhdec -zrxdoff -zrydoff -y \
  6896. < -edl -edlout -enqueue -fixed-vo \
  6897. < -menu -menu-root -menu-cfg -shuffle \
  6898. < -format -aahelp -dfbopts -fstype \
  6899. < -guiwid -nokeepaspect -x --help \
  6900. < -aaosdcolor -aasubcolor -aadriver \
  6901. < -aaextended -aaeight' -- $cur) )
  6902. < # add mencoder specific options
  6903. < [[ "$cmd" = mencoder ]] && COMPREPLY=( ${COMPREPLY[@]} \
  6904. < $(compgen -W '-audio-density -audio-delay \
  6905. < -audio-preload -divx4opts -endpos \
  6906. < -ffourcc -include -info -lameopts \
  6907. < -lavcopts -noskip -o -oac -ofps -ovc \
  6908. < -passlogfile -skiplimit -vobsubout \
  6909. < -vobsuboutindex -vobsuboutid \
  6910. < -xvidencopts -of --verbose' -- $cur) )
  6911. < ;;
  6912. < *)
  6913. < _filedir '@(mp?(e)g|MP?(E)G|wm[av]|WM[AV]|avi|AVI|asf|ASF|vob|VOB|bin|BIN|dat|DAT|vcd|VCD|ps|PS|pes|PES|fli|FLI|viv|VIV|rm?(j)|RM?(J)|ra?(m)|RA?(M)|yuv|YUV|mov|MOV|qt|QT|mp[34]|MP[34]|m4v|M4V|og[gm]|OG[GM]|wav|WAV|dump|DUMP|mk[av]|MK[AV]|m4a|M4A|aac|AAC|m2v|M2V|dv|DV|rmvb|RMVB|mid|MID|ts|TS|3gp|mpc|MPC|flac|FLAC|flv|FLV|divx|DIVX)'
  6914. < ;;
  6915. < esac
  6916. <
  6917. < return 0
  6918. < }
  6919. < complete $filenames -F _mplayer mplayer mencoder gmplayer kplayer
  6920. < }
  6921. <
  6922. < # KDE dcop completion
  6923. < #
  6924. < have dcop &&
  6925. < _dcop()
  6926. < {
  6927. < local cur compstr
  6928. <
  6929. < COMPREPLY=()
  6930. < cur=`_get_cword`
  6931. < if [ -z $cur ]; then
  6932. < compstr=${COMP_WORDS[*]}
  6933. < else
  6934. < compstr=$( command echo ${COMP_WORDS[*]} | sed "s/ $cur$//" )
  6935. < fi
  6936. < COMPREPLY=( $( compgen -W '$( command $compstr | sed s/\(.*\)// )' -- $cur ) )
  6937. < } &&
  6938. < complete -F _dcop dcop
  6939. <
  6940. < # wvdial(1) completion
  6941. < #
  6942. < have wvdial &&
  6943. < _wvdial()
  6944. < {
  6945. < local cur prev config i IFS=$'\t\n'
  6946. <
  6947. < COMPREPLY=()
  6948. < cur=`_get_cword`
  6949. < prev=${COMP_WORDS[COMP_CWORD-1]}
  6950. <
  6951. < case $prev in
  6952. < --config)
  6953. < _filedir
  6954. < return 0
  6955. < ;;
  6956. < esac
  6957. <
  6958. < case $cur in
  6959. < -*)
  6960. < COMPREPLY=( $( compgen -W '--config --chat \
  6961. < --remotename --help --version --no-syslog' \
  6962. < -- $cur ) )
  6963. < ;;
  6964. < *)
  6965. < # start with global and personal config files
  6966. < config="/etc/wvdial.conf"$'\t'"$HOME/.wvdialrc"
  6967. < # replace with command line config file if present
  6968. < for (( i=1; i < COMP_CWORD; i++ )); do
  6969. < if [[ "${COMP_WORDS[i]}" == "--config" ]]; then
  6970. < config=${COMP_WORDS[i+1]}
  6971. < break
  6972. < fi
  6973. < done
  6974. < # parse config files for sections and
  6975. < # remove default section
  6976. < COMPREPLY=( $( sed -ne \
  6977. < "s|^\[Dialer \($cur.*\)\]$|\1|p" \
  6978. < $config 2>/dev/null |grep -v '^Defaults$'))
  6979. < # escape spaces
  6980. < COMPREPLY=${COMPREPLY// /\\ }
  6981. < ;;
  6982. < esac
  6983. <
  6984. < } &&
  6985. < complete -F _wvdial wvdial
  6986. <
  6987. < # gpg(1) completion
  6988. < #
  6989. < have gpg &&
  6990. < _gpg()
  6991. < {
  6992. < local cur prev
  6993. <
  6994. < COMPREPLY=()
  6995. < cur=`_get_cword`
  6996. < prev=${COMP_WORDS[COMP_CWORD-1]}
  6997. <
  6998. < case "$prev" in
  6999. < -@(s|-sign|-clearsign|-decrypt-files|-load-extension))
  7000. < _filedir
  7001. < return 0
  7002. < ;;
  7003. < --@(export|@(?(l|nr|nrl)sign|edit)-key))
  7004. < # return list of public keys
  7005. < COMPREPLY=( $( compgen -W "$( gpg --list-keys 2>/dev/null | sed -ne 's@^pub.*/\([^ ]*\).*\(<\([^>]*\)>\).*$@\1 \3@p')" -- "$cur" ))
  7006. < return 0
  7007. < ;;
  7008. < -@(r|-recipient))
  7009. < COMPREPLY=( $( compgen -W "$( gpg --list-keys 2>/dev/null | sed -ne 's@^pub.*<\([^>]*\)>.*$@\1@p')" -- "$cur" ))
  7010. < if [ -e ~/.gnupg/gpg.conf ]; then
  7011. < COMPREPLY=( ${COMPREPLY[@]} $( compgen -W "$( sed -ne 's@^[ \t]*group[ \t][ \t]*\([^=]*\).*$@\1@p' ~/.gnupg/gpg.conf )" -- "$cur") )
  7012. < fi
  7013. < return 0
  7014. < ;;
  7015. < esac
  7016. <
  7017. < if [[ "$cur" == -* ]]; then
  7018. < COMPREPLY=( $( compgen -W '-s -b -e -f -c -d -a -r -u -Z -o -v\
  7019. < -q -n -N $(gpg --dump-options)' -- $cur ) )
  7020. < fi
  7021. <
  7022. < } &&
  7023. < complete -F _gpg $default gpg
  7024. <
  7025. < # iconv(1) completion
  7026. < #
  7027. < have iconv &&
  7028. < _iconv()
  7029. < {
  7030. < local cur prev
  7031. <
  7032. < COMPREPLY=()
  7033. < cur=`_get_cword`
  7034. < prev=${COMP_WORDS[COMP_CWORD-1]}
  7035. <
  7036. < case "$prev" in
  7037. < -@(f|t|-@(from|to)-code))
  7038. < COMPREPLY=( $( compgen -W \
  7039. < '$( iconv --list | sed -e "s@//@@;" )' -- "$cur" ) )
  7040. < return 0
  7041. < ;;
  7042. < esac
  7043. <
  7044. <
  7045. < if [[ "$cur" = -* ]]; then
  7046. < COMPREPLY=( $( compgen -W '--from-code -f --to-code -t --list
  7047. < --output -o --verbose' -- "$cur" ) )
  7048. < return 0
  7049. < fi
  7050. < } &&
  7051. < complete -F _iconv $default iconv
  7052. <
  7053. < # dict(1) completion
  7054. < #
  7055. < { have dict || have rdict; } && {
  7056. < _dictdata()
  7057. < {
  7058. < dict $host $port $1 2>/dev/null | sed -ne \
  7059. < 's/^['$'\t '']['$'\t '']*\([^'$'\t '']*\).*$/\1/p'
  7060. < }
  7061. <
  7062. < _dict()
  7063. < {
  7064. < local cur prev host port db dictfile
  7065. <
  7066. < COMPREPLY=()
  7067. < cur=`_get_cword`
  7068. < prev=${COMP_WORDS[COMP_CWORD-1]}
  7069. < dictfile=/usr/share/dict/words
  7070. <
  7071. < for (( i=1; i < COMP_CWORD; i++ )); do
  7072. < case "${COMP_WORDS[i]}" in
  7073. < -@(h|--host))
  7074. < host=${COMP_WORDS[i+1]}
  7075. < [ -n "$host" ] && host="-h $host"
  7076. < i=$((++i))
  7077. < ;;
  7078. < -@(p|-port))
  7079. < port=${COMP_WORDS[i+1]}
  7080. < [ -n "$port" ] && port="-p $port"
  7081. < i=$((++i))
  7082. < ;;
  7083. < -@(d|-database))
  7084. < db=${COMP_WORDS[i+1]}
  7085. < [ -n "$db" ] && host="-d $db"
  7086. < i=$((++i))
  7087. < ;;
  7088. < *)
  7089. < ;;
  7090. < esac
  7091. < done
  7092. <
  7093. < if [[ "$cur" = -* ]]; then
  7094. < COMPREPLY=( $( compgen -W '-h --host -p --port -d --database \
  7095. < -m --match -s --strategy -c --config -C \
  7096. < --nocorrect -D --dbs -S --strats -H \
  7097. < --serverhelp -i --info -I --serverinfo \
  7098. < -a --noauth -u --user -k --key -V --version \
  7099. < -L --license --help -v --verbose -r --raw \
  7100. < -P --pager --debug --html --pipesize --client' \
  7101. < -- "$cur" ) )
  7102. < return 0
  7103. < fi
  7104. <
  7105. < case "$prev" in
  7106. < -@(d|-database|i|info))
  7107. < COMPREPLY=( $( compgen -W '$( _dictdata -D )' -- "$cur" ) )
  7108. < return 0
  7109. < ;;
  7110. < -@(s|-strategy))
  7111. < COMPREPLY=( $( compgen -W '$( _dictdata -S )' -- "$cur" ) )
  7112. < return 0
  7113. < ;;
  7114. < *)
  7115. < ;;
  7116. < esac
  7117. <
  7118. < [ -r $dictfile ] && \
  7119. < COMPREPLY=( $( compgen -W '$( cat $dictfile )' -- "$cur" ) )
  7120. < }
  7121. < complete -F _dict $default dict rdict
  7122. < }
  7123. <
  7124. < # cdrecord(1) completion
  7125. < #
  7126. < have cdrecord &&
  7127. < _cdrecord()
  7128. < {
  7129. < local cur prev i generic_options track_options track_mode
  7130. <
  7131. < COMPREPLY=()
  7132. < cur=`_get_cword`
  7133. < prev=${COMP_WORDS[COMP_CWORD-1]}
  7134. <
  7135. < # foo=bar style option
  7136. < if [[ "$cur" == *=* ]]; then
  7137. < prev=${cur/=*/}
  7138. < cur=${cur/*=/}
  7139. < case "$prev" in
  7140. < @(text|cue)file)
  7141. < _filedir
  7142. < return 0
  7143. < ;;
  7144. < blank)
  7145. < COMPREPLY=( $( compgen -W 'help all fast \
  7146. < track unreserve trtail unclose session' \
  7147. < -- $cur ) )
  7148. < return 0
  7149. < ;;
  7150. < driveropts)
  7151. < COMPREPLY=( $( compgen -W 'burnfree noburnfree\
  7152. < varirec= audiomaster forcespeed noforcespeed\
  7153. < speedread nospeedread singlesession \
  7154. < nosinglesession hidecdr nohidecdr tattooinfo\
  7155. < tattoofile=' -- $cur ) )
  7156. < return 0
  7157. < ;;
  7158. < esac
  7159. < fi
  7160. <
  7161. < generic_options=(-version -v -V -d -silent -s -force -immed -dummy \
  7162. < -dao -raw -raw96r -raw96p -raw16 -multi -msinfo -toc \
  7163. < -atip -fix -nofix -waiti -load -lock -eject -format \
  7164. < -setdropts -checkdrive -prcap -inq -scanbus -reset \
  7165. < -abort -overburn -ignsize -useinfo -packet -noclose \
  7166. < -text debug= kdebug= kd= minbuf= speed= blank= fs= \
  7167. < dev= gracetime= timeout= driver= driveropts= \
  7168. < defpregap= pktsize= mcn= textfile= cuefile=)
  7169. < track_options=(-audio -swab -data -mode2 -xa -xa1 -xa2 -xamix -cdi \
  7170. < -isosize -pad padsize= -nopad -shorttrack -noshorttrack\
  7171. < pregap= -preemp -nopreemp -copy -nocopy -scms tcsize= \
  7172. < isrc= index=)
  7173. < # look if previous was either a file or a track option
  7174. < track_mode=0
  7175. < if [ $COMP_CWORD -gt 1 ]; then
  7176. < if [ -f "$prev" ]; then
  7177. < track_mode=1
  7178. < else
  7179. < for (( i=0; i < ${#track_options[@]}; i++ )); do
  7180. < if [[ "${track_options[i]}" == "$prev" ]]; then
  7181. < track_mode=1
  7182. < break
  7183. < fi
  7184. < done
  7185. < fi
  7186. < fi
  7187. <
  7188. < # files are always eligible completion
  7189. < _filedir
  7190. < # track options are always available
  7191. < COMPREPLY=( ${COMPREPLY[@]} $( compgen -W '${track_options[@]}' -- $cur ) )
  7192. < # general options are no more available after file or track option
  7193. < if [ $track_mode -eq 0 ]; then
  7194. < COMPREPLY=( ${COMPREPLY[@]} \
  7195. < $( compgen -W '${generic_options[@]}' -- $cur ) )
  7196. < fi
  7197. <
  7198. < } &&
  7199. < complete -F _cdrecord $filenames cdrecord
  7200. <
  7201. < # mkisofs(8) completion
  7202. < #
  7203. < have mkisofs &&
  7204. < _mkisofs()
  7205. < {
  7206. < local cur prev
  7207. <
  7208. < COMPREPLY=()
  7209. < cur=`_get_cword`
  7210. < prev=${COMP_WORDS[COMP_CWORD-1]}
  7211. <
  7212. < case "$prev" in
  7213. < -@(o|abstract|biblio|check-session|copyright|log-file|root-info|prep-boot|*-list))
  7214. < _filedir
  7215. < return 0
  7216. < ;;
  7217. < -*-charset)
  7218. < COMPREPLY=( $( mkisofs -input-charset help 2>&1 | \
  7219. < tail +3 | grep "^$cur") )
  7220. < return 0
  7221. < ;;
  7222. < -uid)
  7223. < _uids
  7224. < return 0
  7225. < ;;
  7226. < -gid)
  7227. < _gids
  7228. < return 0
  7229. < ;;
  7230. < esac
  7231. <
  7232. < if [[ "$cur" == -* ]]; then
  7233. < COMPREPLY=( $( compgen -W '-abstract -A -allow-lowercase \
  7234. < -allow-multidot -biblio -cache-inodes \
  7235. < -no-cache-inodes -b -eltorito-alt-boot -B -G \
  7236. < -hard-disk-boot -no-emul-boot -no-boot \
  7237. < -boot-load-seg -boot-load-size \
  7238. < -boot-info-table -C -c -check-oldname \
  7239. < -check-session -copyright -d -D -dir-mode \
  7240. < -dvd-video -f -file-mode -gid -gui \
  7241. < -graft-points -hide -hide-list -hidden \
  7242. < -hidden-list -hide-joliet -hide-joliet-list \
  7243. < -hide-joliet-trans-tbl -hide-rr-moved \
  7244. < -input-charset -output-charset -iso-level -J \
  7245. < -joliet-long -jcharset -l -L -log-file -m \
  7246. < -exclude-list -max-iso9660-filenames -M -N \
  7247. < -new-dir-mode -nobak -no-bak -force-rr -no-rr \
  7248. < -no-split-symlink-components \
  7249. < -no-split-symlink-fields -o -pad -no-pad \
  7250. < -path-list -P -p -print-size -quiet -R -r \
  7251. < -relaxed-filenames -sort -split-output \
  7252. < -stream-media-size -stream-file-name -sysid -T\
  7253. < -table-name -ucs-level -udf -uid \
  7254. < -use-fileversion -U -no-iso-translate -V \
  7255. < -volset -volset-size -volset-seqno -v -x -z \
  7256. < -hfs -apple -map -magic -hfs-creator \
  7257. < -hfs-type -probe -no-desktop -mac-name \
  7258. < -boot-hfs-file -part -auto -cluster-size \
  7259. < -hide-hfs -hide-hfs-list -hfs-volid \
  7260. < -icon-position -root-info -prep-boot \
  7261. < -input-hfs-charset -output-hfs-charset \
  7262. < -hfs-unlock -hfs-bless -hfs-parms --cap \
  7263. < --netatalk --double --ethershare --ushare \
  7264. < --exchange --sgi --xinet --macbin --single \
  7265. < --dave --sfm --osx-double --osx-hfs' -- $cur ))
  7266. < else
  7267. < _filedir
  7268. < fi
  7269. <
  7270. < } &&
  7271. < complete -F _mkisofs $filenames mkisofs
  7272. <
  7273. < # mc(1) completion
  7274. < #
  7275. < have mc &&
  7276. < _mc()
  7277. < {
  7278. < local cur prev
  7279. <
  7280. < COMPREPLY=()
  7281. < cur=`_get_cword`
  7282. < prev=${COMP_WORDS[COMP_CWORD-1]}
  7283. <
  7284. < # -name value style option
  7285. < case "$prev" in
  7286. < -@(e|v|l|P))
  7287. < _filedir
  7288. < return 0
  7289. < ;;
  7290. < esac
  7291. <
  7292. < # --name=value style option
  7293. < if [[ "$cur" == *=* ]]; then
  7294. < prev=${cur/=*/}
  7295. < cur=${cur/*=/}
  7296. < case "$prev" in
  7297. < --@(edit|view|ftplog|printwd))
  7298. < _filedir
  7299. < return 0
  7300. < ;;
  7301. < esac
  7302. < fi
  7303. <
  7304. < if [[ "$cur" == -* ]]; then
  7305. < COMPREPLY=( $( compgen -W '-a --stickchars -b --nocolor -c \
  7306. < --color -C --colors= -d --nomouse -e --edit= -f \
  7307. < --datadir -k --resetsoft -l --ftplog= -P --printwd= \
  7308. < -s --slow -t --termcap -u --nosubshell -U --subshell \
  7309. < -v --view= -V --version -x --xterm -h --help' -- $cur ) )
  7310. < else
  7311. < _filedir -d
  7312. < fi
  7313. < } &&
  7314. < complete -F _mc $filenames mc
  7315. <
  7316. < # yum(8) completion
  7317. < #
  7318. < have yum && {
  7319. < _yum()
  7320. < {
  7321. < local cur prev special
  7322. <
  7323. < COMPREPLY=()
  7324. < cur=`_get_cword`
  7325. < prev=${COMP_WORDS[COMP_CWORD-1]}
  7326. <
  7327. < for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  7328. < if [[ ${COMP_WORDS[i]} == @(install|update|upgrade|remove|erase|deplist) ]]; then
  7329. < special=${COMP_WORDS[i]}
  7330. < fi
  7331. < done
  7332. <
  7333. < if [ -n "$special" ]; then
  7334. < case $special in
  7335. < install|deplist)
  7336. < COMPREPLY=( $( compgen -W '$( yum -C list | cut -d" " -f1 )' -- $cur ) )
  7337. < return 0
  7338. < ;;
  7339. < *)
  7340. < _rpm_installed_packages
  7341. < return 0
  7342. < ;;
  7343. < esac
  7344. < fi
  7345. <
  7346. < case $cur in
  7347. < --*)
  7348. < COMPREPLY=( $( compgen -W '--installroot --version --help --enablerepo --disablerepo --exclude --obsoletes --noplugins' -- $cur ) )
  7349. < return 0
  7350. < ;;
  7351. < -*)
  7352. < COMPREPLY=( $( compgen -W '-c -e -d -y -t -R -C -h' -- $cur ) )
  7353. < return 0
  7354. < ;;
  7355. < esac
  7356. <
  7357. < case $prev in
  7358. < list)
  7359. < COMPREPLY=( $( compgen -W 'all available updates installed extras obsoletes recent' -- $cur ) )
  7360. < ;;
  7361. < clean)
  7362. < COMPREPLY=( $( compgen -W 'packages headers metadata cache dbcache all' -- $cur ) )
  7363. < ;;
  7364. < localinstall)
  7365. < _filedir rpm
  7366. < ;;
  7367. < -c)
  7368. < _filedir
  7369. < ;;
  7370. < --installroot)
  7371. < _filedir -d
  7372. < ;;
  7373. < *)
  7374. < COMPREPLY=( $( compgen -W 'install update check-update upgrade remove list \
  7375. < search info provides clean groupinstall groupupdate \
  7376. < grouplist deplist erase groupinfo groupremove \
  7377. < localinstall localupdate makecache resolvedep \
  7378. < shell whatprovides' -- $cur ) )
  7379. < ;;
  7380. < esac
  7381. < }
  7382. < complete -F _yum $filenames yum
  7383. ---
  7384. > # append any available aliases from config files
  7385. > if [[ ${#config[@]} -gt 0 && -n "$aliases" ]]; then
  7386. > local hosts=$( sed -ne 's/^[ \t]*[Hh][Oo][Ss][Tt]\([Nn][Aa][Mm][Ee]\)\{0,1\}['"$'\t '"']\{1,\}\([^#*?]*\)\(#.*\)\{0,1\}$/\2/p' "${config[@]}" )
  7387. > COMPREPLY=( "${COMPREPLY[@]}" $( compgen -P "$prefix$user" \
  7388. > -S "$suffix" -W "$hosts" -- "$cur" ) )
  7389. > fi
  7390. >
  7391. > # Add hosts reported by avahi-browse, if it's available.
  7392. > # The original call to avahi-browse also had "-k", to avoid lookups into
  7393. > # avahi's services DB. We don't need the name of the service, and if it
  7394. > # contains ";", it may mistify the result. But on Gentoo (at least),
  7395. > # -k isn't available (even if mentioned in the manpage), so...
  7396. > if type avahi-browse >&/dev/null; then
  7397. > COMPREPLY=( "${COMPREPLY[@]}" $( \
  7398. > compgen -P "$prefix$user" -S "$suffix" -W \
  7399. > "$( avahi-browse -cpr _workstation._tcp 2>/dev/null | \
  7400. > awk -F';' '/^=/ { print $7 }' | sort -u )" -- "$cur" ) )
  7401. > fi
  7402. >
  7403. > # Add results of normal hostname completion, unless
  7404. > # `COMP_KNOWN_HOSTS_WITH_HOSTFILE' is set to an empty value.
  7405. > if [ -n "${COMP_KNOWN_HOSTS_WITH_HOSTFILE-1}" ]; then
  7406. > COMPREPLY=( "${COMPREPLY[@]}"
  7407. > $( compgen -A hostname -P "$prefix$user" -S "$suffix" -- "$cur" ) )
  7408. > fi
  7409. 6412c1332,1341
  7410. < # yum-arch(8) completion
  7411. ---
  7412. > __ltrim_colon_completions "$prefix$user$cur"
  7413. >
  7414. > return 0
  7415. > } # _known_hosts_real()
  7416. > complete -F _known_hosts traceroute traceroute6 tracepath tracepath6 ping \
  7417. > ping6 fping fping6 telnet host nslookup rsh rlogin ftp dig mtr \
  7418. > ssh-installkeys showmount
  7419. >
  7420. > # This meta-cd function observes the CDPATH variable, so that cd additionally
  7421. > # completes on directories under those specified in CDPATH.
  7422. 6414c1343
  7423. < _yum_arch()
  7424. ---
  7425. > _cd()
  7426. 6416,6418c1345,1346
  7427. < local cur
  7428. < COMPREPLY=()
  7429. < cur=`_get_cword`
  7430. ---
  7431. > local cur IFS=$'\t\n' i j k
  7432. > _get_comp_words_by_ref cur
  7433. 6420,6427c1348,1352
  7434. < case "$cur" in
  7435. < -*)
  7436. < COMPREPLY=( $( compgen -W '-d -v -vv -n -c -z -s -l -q' -- $cur ) )
  7437. < ;;
  7438. < *)
  7439. < _filedir -d
  7440. < ;;
  7441. < esac
  7442. ---
  7443. > # try to allow variable completion
  7444. > if [[ "$cur" == ?(\\)\$* ]]; then
  7445. > COMPREPLY=( $( compgen -v -P '$' -- "${cur#?(\\)$}" ) )
  7446. > return 0
  7447. > fi
  7448. 6429c1354,1386
  7449. < return 0
  7450. ---
  7451. > # Enable -o filenames option, see Debian bug #272660
  7452. > compgen -f /non-existing-dir/ >/dev/null
  7453. >
  7454. > # Use standard dir completion if no CDPATH or parameter starts with /,
  7455. > # ./ or ../
  7456. > if [[ -z "${CDPATH:-}" || "$cur" == ?(.)?(.)/* ]]; then
  7457. > _filedir -d
  7458. > return 0
  7459. > fi
  7460. >
  7461. > local -r mark_dirs=$(_rl_enabled mark-directories && echo y)
  7462. > local -r mark_symdirs=$(_rl_enabled mark-symlinked-directories && echo y)
  7463. >
  7464. > # we have a CDPATH, so loop on its contents
  7465. > for i in ${CDPATH//:/$'\t'}; do
  7466. > # create an array of matched subdirs
  7467. > k="${#COMPREPLY[@]}"
  7468. > for j in $( compgen -d $i/$cur ); do
  7469. > if [[ ( $mark_symdirs && -h $j || $mark_dirs && ! -h $j ) && ! -d ${j#$i/} ]]; then
  7470. > j="${j}/"
  7471. > fi
  7472. > COMPREPLY[k++]=${j#$i/}
  7473. > done
  7474. > done
  7475. >
  7476. > _filedir -d
  7477. >
  7478. > if [[ ${#COMPREPLY[@]} -eq 1 ]]; then
  7479. > i=${COMPREPLY[0]}
  7480. > if [[ "$i" == "$cur" && $i != "*/" ]]; then
  7481. > COMPREPLY[0]="${i}/"
  7482. > fi
  7483. > fi
  7484. 6430a1388
  7485. > return 0
  7486. 6432c1390,1409
  7487. < complete -F _yum_arch $filenames yum-arch
  7488. ---
  7489. > if shopt -q cdable_vars; then
  7490. > complete -v -F _cd -o nospace cd
  7491. > else
  7492. > complete -F _cd -o nospace cd
  7493. > fi
  7494. >
  7495. > # a wrapper method for the next one, when the offset is unknown
  7496. > _command()
  7497. > {
  7498. > local offset i
  7499. >
  7500. > # find actual offset, as position of the first non-option
  7501. > offset=1
  7502. > for (( i=1; i <= COMP_CWORD; i++ )); do
  7503. > if [[ "${COMP_WORDS[i]}" != -* ]]; then
  7504. > offset=$i
  7505. > break
  7506. > fi
  7507. > done
  7508. > _command_offset $offset
  7509. 6435c1412,1415
  7510. < # ImageMagick completion
  7511. ---
  7512. > # A meta-command completion function for commands like sudo(8), which need to
  7513. > # first complete on a command, then complete according to that command's own
  7514. > # completion definition - currently not quite foolproof (e.g. mount and umount
  7515. > # don't work properly), but still quite useful.
  7516. 6437,6438c1417
  7517. < have convert && {
  7518. < _ImageMagick()
  7519. ---
  7520. > _command_offset()
  7521. 6440,8777c1419,1420
  7522. < local prev
  7523. < prev=${COMP_WORDS[COMP_CWORD-1]}
  7524. <
  7525. < case "$prev" in
  7526. < -channel)
  7527. < COMPREPLY=( $( compgen -W 'Red Green Blue Opacity \
  7528. < Matte Cyan Magenta Yellow Black' -- $cur ) )
  7529. < return 0
  7530. < ;;
  7531. < -colormap)
  7532. < COMPREPLY=( $( compgen -W 'shared private' -- $cur ) )
  7533. < return 0
  7534. < ;;
  7535. < -colorspace)
  7536. < COMPREPLY=( $( compgen -W 'GRAY OHTA RGB Transparent \
  7537. < XYZ YCbCr YIQ YPbPr YUV CMYK' -- $cur ) )
  7538. < return 0
  7539. < ;;
  7540. < -compose)
  7541. < COMPREPLY=( $( compgen -W 'Over In Out Atop Xor Plus \
  7542. < Minus Add Subtract Difference Multiply Bumpmap\
  7543. < Copy CopyRed CopyGreen CopyBlue CopyOpacity' \
  7544. < -- $cur ) )
  7545. < return 0
  7546. < ;;
  7547. < -compress)
  7548. < COMPREPLY=( $( compgen -W 'None BZip Fax Group4 JPEG \
  7549. < Lossless LZW RLE Zip' -- $cur ) )
  7550. < return 0
  7551. < ;;
  7552. < -dispose)
  7553. < COMPREPLY=( $( compgen -W 'Undefined None Background \
  7554. < Previous' -- $cur ) )
  7555. < return 0
  7556. < ;;
  7557. < -encoding)
  7558. < COMPREPLY=( $( compgen -W 'AdobeCustom AdobeExpert \
  7559. < AdobeStandard AppleRoman BIG5 GB2312 Latin2 \
  7560. < None SJIScode Symbol Unicode Wansung' -- $cur))
  7561. < return 0
  7562. < ;;
  7563. < -endian)
  7564. < COMPREPLY=( $( compgen -W 'MSB LSB' -- $cur ) )
  7565. < return 0
  7566. < ;;
  7567. < -filter)
  7568. < COMPREPLY=( $( compgen -W 'Point Box Triangle Hermite \
  7569. < Hanning Hamming Blackman Gaussian Quadratic \
  7570. < Cubic Catrom Mitchell Lanczos Bessel Sinc' \
  7571. < -- $cur ) )
  7572. < return 0
  7573. < ;;
  7574. < -format)
  7575. < COMPREPLY=( $( convert -list format | \
  7576. < awk '/ [r-][w-][+-] / {print $1}' | \
  7577. < tr -d '*' | tr [:upper:] [:lower:] | \
  7578. < grep "^$cur" ) )
  7579. < return 0
  7580. < ;;
  7581. < -gravity)
  7582. < COMPREPLY=( $( compgen -W 'Northwest North NorthEast \
  7583. < West Center East SouthWest South SouthEast' \
  7584. < -- $cur ) )
  7585. < return 0
  7586. < ;;
  7587. < -intent)
  7588. < COMPREPLY=( $( compgen -W 'Absolute Perceptual \
  7589. < Relative Saturation' -- $cur ) )
  7590. < return 0
  7591. < ;;
  7592. < -interlace)
  7593. < COMPREPLY=( $( compgen -W 'None Line Plane Partition' \
  7594. < -- $cur ) )
  7595. < return 0
  7596. < ;;
  7597. < -limit)
  7598. < COMPREPLY=( $( compgen -W 'Disk File Map Memory' \
  7599. < -- $cur ) )
  7600. < return 0
  7601. < ;;
  7602. < -list)
  7603. < COMPREPLY=( $( compgen -W 'Delegate Format Magic \
  7604. < Module Resource Type' -- $cur ) )
  7605. < return 0
  7606. < ;;
  7607. < -map)
  7608. < COMPREPLY=( $( compgen -W 'best default gray red \
  7609. < green blue' -- $cur ) )
  7610. < _filedir
  7611. < return 0
  7612. < ;;
  7613. < -noise)
  7614. < COMPREPLY=( $( compgen -W 'Uniform Gaussian \
  7615. < Multiplicative \
  7616. < Impulse Laplacian Poisson' -- $cur ) )
  7617. < return 0
  7618. < ;;
  7619. < -preview)
  7620. < COMPREPLY=( $( compgen -W 'Rotate Shear Roll Hue \
  7621. < Saturation Brightness Gamma Spiff \
  7622. < Dull Grayscale Quantize Despeckle \
  7623. < ReduceNoise AddNoise Sharpen Blur \
  7624. < Treshold EdgeDetect Spread Shade \
  7625. < Raise Segment Solarize Swirl Implode \
  7626. < Wave OilPaint CharcoalDrawing JPEG' \
  7627. < -- $cur ) )
  7628. < return 0
  7629. < ;;
  7630. < -@(mask|profile|texture|tile|write))
  7631. < _filedir
  7632. < return 0
  7633. < ;;
  7634. < -type)
  7635. < COMPREPLY=( $( compgen -W 'Bilevel Grayscale Palette \
  7636. < PaletteMatte TrueColor TrueColorMatte \
  7637. < ColorSeparation ColorSeparationlMatte \
  7638. < Optimize' -- $cur ) )
  7639. < return 0
  7640. < ;;
  7641. < -units)
  7642. < COMPREPLY=( $( compgen -W 'Undefined PixelsPerInch \
  7643. < PixelsPerCentimeter' -- $cur ) )
  7644. < return 0
  7645. < ;;
  7646. < -virtual-pixel)
  7647. < COMPREPLY=( $( compgen -W 'Constant Edge mirror tile' \
  7648. < -- $cur ) )
  7649. < return 0
  7650. < ;;
  7651. < -visual)
  7652. < COMPREPLY=( $( compgen -W 'StaticGray GrayScale \
  7653. < StaticColor PseudoColor TrueColor \
  7654. < DirectColor defaut visualid' -- $cur ))
  7655. < return 0
  7656. < ;;
  7657. < esac
  7658. < }
  7659. <
  7660. < _convert()
  7661. < {
  7662. < local cur
  7663. <
  7664. < COMPREPLY=()
  7665. < cur=`_get_cword`
  7666. <
  7667. < _ImageMagick
  7668. <
  7669. < if [[ "$cur" == -* ]]; then
  7670. < COMPREPLY=( $( compgen -W '-adjoin -affine -antialias -append \
  7671. < -authenticate -average -background -black-threshold \
  7672. < -blue-primary -blur -border -bordercolor -channel \
  7673. < -charcoal -chop -clip -coalesce -colorize -colors \
  7674. < -colorspace -comment -compress -contrast -convolve \
  7675. < -crop -cycle -debug -deconstruct -delay -density \
  7676. < -depth -despeckle -display -dispose -dither -draw \
  7677. < -edge -emboss -encoding -endian -enhance -equalize \
  7678. < -extract -fill -filter -flatten -flip -flop -font \
  7679. < -frame -fuzz -gamma -gaussian -geometry \
  7680. < -green-primary -gravity -help -implode -intent \
  7681. < -interlace -label -lat -level -limit -list -log -loop \
  7682. < -map -mask -matte -median -modulate -monochrome \
  7683. < -morph -mosaic -negate -noop -noise -normalize \
  7684. < -opaque -ordered-dither -page -paint -ping -pointsize \
  7685. < -preview -profile -quality -raise -random-threshold \
  7686. < -region -raise -red-primary -render -resize -resample \
  7687. < -roll -rotate -sample -sampling-factor -scale -scene \
  7688. < -seed -segment -shade -sharpen -shave -shear -size \
  7689. < -solarize -spread -stroke -strokewidth -swirl \
  7690. < -texture -threshold -thumbnail -tile -transform \
  7691. < -transparent -treedepth -trim -type -undercolor \
  7692. < -units -unsharp -verbose -version -view \
  7693. < -virtual-pixel -wave -white-point -white-threshold \
  7694. < -write' -- $cur ) )
  7695. < elif [[ "$cur" == +* ]]; then
  7696. < COMPREPLY=( $( compgen -W '+adjoin +append +compress \
  7697. < +contrast +debug +dither +endian +gamma +label +map \
  7698. < +mask +matte +negate +noise +page +raise +render \
  7699. < +write' -- $cur ) )
  7700. < else
  7701. < _filedir
  7702. < fi
  7703. < }
  7704. < complete -F _convert $filenames convert
  7705. <
  7706. < _mogrify()
  7707. < {
  7708. < local cur
  7709. <
  7710. < COMPREPLY=()
  7711. < cur=`_get_cword`
  7712. <
  7713. < _ImageMagick
  7714. <
  7715. < if [[ "$cur" == -* ]]; then
  7716. < COMPREPLY=( $( compgen -W '-affine -antialias -authenticate \
  7717. < -background -black-threshold -blue-primary -blur \
  7718. < -border -bordercolor -channel -charcoal -chop \
  7719. < -colorize -colors -colorspace -comment -compress \
  7720. < -contrast -convolve -crop -cycle -debug -delay \
  7721. < -density -depth -despeckle -display -dispose -dither \
  7722. < -draw -edge -emboss -encoding -endian -enhance \
  7723. < -equalize -extract -fill -filter -flip -flop -font \
  7724. < -format -frame -fuzz -gamma -gaussian -geometry \
  7725. < -green-primary -implode -interlace -help -label -lat \
  7726. < -level -limit -list -log -loop -map -mask -matte \
  7727. < -median -modulate -monochrome -negate -noop \
  7728. < -normalize -opaque -page -paint -fill -ordered-dither \
  7729. < -pointsize -profile -quality -raise -random-threshold \
  7730. < -red-primary -region -resample -resize -roll -rotate \
  7731. < -sample -sampling-factor -scale -scene -seed -segment \
  7732. < -shade -sharpen -shear -size -solarize -spread \
  7733. < -stroke -strokewidth -swirl -texture -threshold \
  7734. < -thumbnail -tile -transform -transparent -treedepth \
  7735. < -trim -type -undercolor -units -unsharp -verbose \
  7736. < -version -view -virtual-pixel -wave -white-point \
  7737. < -white-threshold' -- $cur ) )
  7738. < elif [[ "$cur" == +* ]]; then
  7739. < COMPREPLY=( $( compgen -W '+compress +contrast +debug +dither \
  7740. < +endian +gamma +label +map +mask +matte +negate +page \
  7741. < +raise' -- $cur ) )
  7742. < else
  7743. < _filedir
  7744. < fi
  7745. < }
  7746. < complete -F _mogrify $filenames mogrify
  7747. <
  7748. < _display()
  7749. < {
  7750. < local cur
  7751. <
  7752. < COMPREPLY=()
  7753. < cur=`_get_cword`
  7754. <
  7755. < _ImageMagick
  7756. <
  7757. < if [[ "$cur" == -* ]]; then
  7758. < COMPREPLY=( $( compgen -W '-authenticate -backdrop -border \
  7759. < -colormap -colors -colorspace -comment -compress \
  7760. < -contrast -crop -debug -delay -density -depth \
  7761. < -despeckle -display -dispose -dither -edge -endian \
  7762. < -enhance -extract -filter -flip -flop -frame -gamma \
  7763. < -geometry -help -immutable -interlace -label -limit \
  7764. < -log -map -matte -monochrome -negate -noop -page \
  7765. < -quality -raise -remote -roll -rotate -sample \
  7766. < -sampling-factor -scene -segment -sharpen -size \
  7767. < -texture -treedepth -trim -update -verbose -version \
  7768. < -virtual-pixel -window -window_group -write' -- $cur))
  7769. < elif [[ "$cur" == +* ]]; then
  7770. < COMPREPLY=( $( compgen -W '+compress +contrast +debug +dither \
  7771. < +endian +gamma +label +map +matte +negate +page \
  7772. < +raise +write' -- $cur ) )
  7773. < else
  7774. < _filedir
  7775. < fi
  7776. < }
  7777. < complete -F _display $filenames display
  7778. <
  7779. < _animate()
  7780. < {
  7781. < local cur
  7782. <
  7783. < COMPREPLY=()
  7784. < cur=`_get_cword`
  7785. <
  7786. < _ImageMagick
  7787. <
  7788. < if [[ "$cur" == -* ]]; then
  7789. < COMPREPLY=( $( compgen -W '-authenticate -backdrop -colormap \
  7790. < -colors -colorspace -crop -debug -delay -density \
  7791. < -depth -display -dither -extract -gamma -geometry \
  7792. < -help -interlace -limit -log -matte -map -monochrome \
  7793. < -noop -pause -remote -rotate -sampling-factor -scene \
  7794. < -size -treedepth -trim -verbose -version -visual \
  7795. < -virtual-pixel -window' -- $cur ) )
  7796. < elif [[ "$cur" == +* ]]; then
  7797. < COMPREPLY=( $( compgen -W '+debug +dither +gamma +map +matte' -- $cur ) )
  7798. < else
  7799. < _filedir
  7800. < fi
  7801. < }
  7802. < complete -F _animate $filenames animate
  7803. <
  7804. < _identify()
  7805. < {
  7806. < local cur
  7807. <
  7808. < COMPREPLY=()
  7809. < cur=`_get_cword`
  7810. <
  7811. < _ImageMagick
  7812. <
  7813. < if [[ "$cur" == -* ]]; then
  7814. < COMPREPLY=( $( compgen -W '-authenticate -debug -density \
  7815. < -depth -extract -format -help -interlace -limit -list \
  7816. < -log -size -sampling-factor -verbose -version \
  7817. < -virtual-pixel' -- $cur ) )
  7818. < elif [[ "$cur" == +* ]]; then
  7819. < COMPREPLY=( $( compgen -W '+debug ' -- $cur ) )
  7820. < else
  7821. < _filedir
  7822. < fi
  7823. < }
  7824. < complete -F _identify $filenames identify
  7825. <
  7826. < _montage()
  7827. < {
  7828. < local cur
  7829. <
  7830. < COMPREPLY=()
  7831. < cur=`_get_cword`
  7832. <
  7833. < _ImageMagick
  7834. <
  7835. < if [[ "$cur" == -* ]]; then
  7836. < COMPREPLY=( $( compgen -W '-adjoin -affine -authenticate \
  7837. < -blue-primary -blur -colors -colorspace -comment \
  7838. < -compose -compress -crop -debug -density -depth \
  7839. < -display -dispose -dither -draw -encoding -endian \
  7840. < -extract -fill -filter -flip -flop -frame -gamma \
  7841. < -geometry -gravity -green-primary -interlace -help \
  7842. < -label -limit -log -matte -mode -monochrome -noop \
  7843. < -page -pointsize -quality -red-primary -resize \
  7844. < -rotate -sampling-factor -scene -shadow -size \
  7845. < -stroke -texture -thumbnail -tile -transform \
  7846. < -transparent -treedepth -trim -type -verbose \
  7847. < -version -virtual-pixel -white-point' -- $cur ) )
  7848. < elif [[ "$cur" == +* ]]; then
  7849. < COMPREPLY=( $( compgen -W '+adjoin +compress +debug +dither \
  7850. < +endian +gamma +label +matte +page' -- $cur ) )
  7851. < else
  7852. < _filedir
  7853. < fi
  7854. < }
  7855. < complete -F _montage $filenames montage
  7856. <
  7857. < _composite()
  7858. < {
  7859. < local cur
  7860. <
  7861. < COMPREPLY=()
  7862. < cur=`_get_cword`
  7863. <
  7864. < _ImageMagick
  7865. <
  7866. < if [[ "$cur" == -* ]]; then
  7867. < COMPREPLY=( $( compgen -W '-affine -authenticate \
  7868. < -blue-primary -colors -colorspace -comment -compose \
  7869. < -compress -debug -density -depth -displace -display \
  7870. < -dispose -dissolve -dither -encoding -endian -extract \
  7871. < -filter -font -geometry -gravity -green-primary -help \
  7872. < -interlace -label -limit -log -matte -monochrome \
  7873. < -negate -page -profile -quality -red-primary -rotate \
  7874. < -resize -sampling-factor -scene -sharpen -size \
  7875. < -stegano -stereo -thumbnail -tile -transform \
  7876. < -treedepth -type -units -unsharp -verbose -version \
  7877. < -virtual-pixel -watermark -white-point -write' \
  7878. < -- $cur ) )
  7879. < elif [[ "$cur" == +* ]]; then
  7880. < COMPREPLY=( $( compgen -W '+compress +debug +dither +endian +label \
  7881. < +matte +negate +page +write' -- $cur ) )
  7882. < else
  7883. < _filedir
  7884. < fi
  7885. < }
  7886. < complete -F _composite $filenames composite
  7887. < }
  7888. <
  7889. < # dd(1) completion
  7890. < #
  7891. < have dd &&
  7892. < _dd()
  7893. < {
  7894. < local cur
  7895. <
  7896. < COMPREPLY=()
  7897. < cur=`_get_cword`
  7898. <
  7899. < case "$cur" in
  7900. < if=*|of=*)
  7901. < cur=${cur#*=}
  7902. < _filedir
  7903. < return 0
  7904. < ;;
  7905. < conv=*)
  7906. < cur=${cur#*=}
  7907. < COMPREPLY=( $( compgen -W 'ascii ebcdic ibm block unblock \
  7908. < lcase notrunc ucase swab noerror sync' \
  7909. < -- $cur ) )
  7910. < return 0
  7911. < ;;
  7912. < esac
  7913. <
  7914. < _expand || return 0
  7915. <
  7916. < COMPREPLY=( $( compgen -W '--help --version' -- $cur ) \
  7917. < $( compgen -W 'bs cbs conv count ibs if obs of seek skip'\
  7918. < -S '=' -- $cur ) )
  7919. < } &&
  7920. < complete -F _dd $nospace $filenames dd
  7921. <
  7922. < # CUPS cancel(1) completion
  7923. < #
  7924. < have cancel &&
  7925. < _cancel()
  7926. < {
  7927. < local cur
  7928. <
  7929. < COMPREPLY=()
  7930. < cur=`_get_cword`
  7931. <
  7932. < COMPREPLY=( $( lpstat | cut -d' ' -f1 | grep "^$cur" ) )
  7933. < } &&
  7934. < complete -F _cancel $filenames cancel
  7935. <
  7936. < # aspell(1) completion
  7937. < #
  7938. < have aspell && {
  7939. < _aspell_dictionary()
  7940. < {
  7941. < local datadir
  7942. < datadir=/usr/lib/aspell
  7943. < COMPREPLY=( $( command ls $datadir/*.@(multi|alias) ) )
  7944. < COMPREPLY=( ${COMPREPLY[@]%.@(multi|alias)} )
  7945. < COMPREPLY=( $( compgen -W '${COMPREPLY[@]#$datadir/}' -- $cur ) )
  7946. < }
  7947. <
  7948. < _aspell()
  7949. < {
  7950. < local cur prev
  7951. <
  7952. < COMPREPLY=()
  7953. < cur=`_get_cword`
  7954. < prev=${COMP_WORDS[COMP_CWORD-1]}
  7955. <
  7956. < # --name value style option
  7957. < case "$prev" in
  7958. < @(-c|-p|check))
  7959. < _filedir
  7960. < return 0
  7961. < ;;
  7962. < @(dump|create|merge))
  7963. < COMPREPLY=( $( compgen -W 'master personal repl' -- $cur ) )
  7964. < return 0
  7965. < ;;
  7966. < -d)
  7967. < _aspell_dictionary
  7968. < return 0
  7969. < ;;
  7970. < esac
  7971. <
  7972. < # --name=value style option
  7973. < if [[ "$cur" == *=* ]]; then
  7974. < prev=${cur/=*/}
  7975. < cur=${cur/*=/}
  7976. < case "$prev" in
  7977. < --@(conf|personal|repl|per-conf))
  7978. < _filedir
  7979. < return 0
  7980. < ;;
  7981. < --@(conf-dir|data-dir|dict-dir|home-dir|local-data-dir|prefix))
  7982. < _filedir -d
  7983. < return 0
  7984. < ;;
  7985. < --master)
  7986. < _aspell_dictionary
  7987. < return 0
  7988. < ;;
  7989. < --mode)
  7990. < COMPREPLY=( $( compgen -W 'none url email sgml tex' -- $cur ) )
  7991. < return 0
  7992. < ;;
  7993. < --sug-mode)
  7994. < COMPREPLY=( $( compgen -W 'ultra fast normal bad-speller' -- $cur ) )
  7995. < return 0
  7996. < ;;
  7997. < --keymapping)
  7998. < COMPREPLY=( $( compgen -W 'aspell ispell' -- $cur ) )
  7999. < return 0
  8000. < ;;
  8001. < esac
  8002. < fi
  8003. <
  8004. < if [[ "$cur" == -* ]]; then
  8005. < COMPREPLY=( $( compgen -W '--conf= --conf-dir= --data-dir= --dict-dir= \
  8006. < --encoding= --add-filter= --rem-filter= --mode= -e \
  8007. < -H -t --add-extra-dicts= --rem-extra-dicts= \
  8008. < --home-dir= -W --ignore= --ignore-accents \
  8009. < --dont-ignore-accents --ignore-case --dont-ignore-case \
  8010. < --ignore-repl --dont-ignore-repl --jargon= --keyboard= \
  8011. < --lang= --language-tag= --local-data-dir= -d --master= \
  8012. < --module= --add-module-search-order= \
  8013. < --rem-module-search-order= --per-conf= -p --personal= \
  8014. < --prefix= --repl= -C -B --run-together --dont-run-together \
  8015. < --run-together-limit= --run-together-min= --save-repl \
  8016. < --dont-save-repl --set-prefix --dont-set-prefix --size= \
  8017. < --spelling= --strip-accents --dont-strip-accents \
  8018. < --sug-mode= --add-word-list-path= --rem-word-list-path= \
  8019. < -b -x --backup -b|-x --dont-backup --reverse --dont-reverse \
  8020. < --time --dont-time --keymapping= --add-email-quote= \
  8021. < --rem-email-quote= --email-margin= --add-tex-command= \
  8022. < --rem-tex-command= --tex-check-comments \
  8023. < --dont-tex-check-comments --add-tex-extension= \
  8024. < --rem-tex-extension= --add-sgml-check= --rem-sgml-check= \
  8025. < --add-sgml-extension= --rem-sgml-extension=' -- $cur ) )
  8026. < else
  8027. < COMPREPLY=( $( compgen -W '-? help -c check -a pipe -l list \
  8028. < config config soundslike filter -v version dump \
  8029. < create merge' -- $cur ) )
  8030. < fi
  8031. <
  8032. < }
  8033. < complete -F _aspell $default aspell
  8034. < }
  8035. <
  8036. < # xmms(1) completion
  8037. < #
  8038. < have xmms &&
  8039. < _xmms()
  8040. < {
  8041. < local cur
  8042. <
  8043. < COMPREPLY=()
  8044. < cur=`_get_cword`
  8045. <
  8046. < if [[ "$cur" == -* ]]; then
  8047. < COMPREPLY=( $( compgen -W '-h --help -r --rew -p --play \
  8048. < -u --pause -s --stop -t --play-pause -f --fwd -e \
  8049. < --enqueue -m --show-main-window -i --sm-client-id \
  8050. < -v --version' -- $cur ) )
  8051. < else
  8052. < _filedir '@(mp[23]|MP[23]|ogg|OGG|wav|WAV|pls|m3u|xm|mod|s[3t]m|it|mtm|ult|flac)'
  8053. <
  8054. < fi
  8055. <
  8056. < } &&
  8057. < complete -F _xmms $filenames xmms
  8058. <
  8059. < # info(1) completion
  8060. < #
  8061. < have info &&
  8062. < _info()
  8063. < {
  8064. < local cur infopath UNAME
  8065. <
  8066. < COMPREPLY=()
  8067. < cur=`_get_cword`
  8068. <
  8069. < _expand || return 0
  8070. <
  8071. < # default completion if parameter contains /
  8072. < if [[ "$cur" == */* ]]; then
  8073. < _filedir
  8074. < return 0
  8075. < fi
  8076. <
  8077. < infopath='/usr/share/info'
  8078. <
  8079. < if [ "${INFOPATH: -1:1}" == ':' ]; then
  8080. < infopath=${INFOPATH}${infopath}
  8081. < elif [ ${INFOPATH:+set} ]; then
  8082. < infopath=$INFOPATH
  8083. < fi
  8084. <
  8085. < infopath=$infopath:
  8086. < if [ -n "$cur" ]; then
  8087. < infopath="${infopath//://$cur* }"
  8088. < else
  8089. < infopath="${infopath//:// }"
  8090. < fi
  8091. <
  8092. < # redirect stderr for when path doesn't exist
  8093. < COMPREPLY=( $( eval command ls "$infopath" 2>/dev/null ) )
  8094. < # weed out directory path names and paths to info pages
  8095. < COMPREPLY=( ${COMPREPLY[@]##*/?(:)} )
  8096. < # weed out info dir file
  8097. < for (( i=0 ; i < ${#COMPREPLY[@]} ; ++i )); do
  8098. < if [ "${COMPREPLY[$i]}" == 'dir' ]; then
  8099. < unset COMPREPLY[$i];
  8100. < fi;
  8101. < done
  8102. < # strip suffix from info pages
  8103. < COMPREPLY=( ${COMPREPLY[@]%.@(gz|bz2)} )
  8104. < COMPREPLY=( $( compgen -W '${COMPREPLY[@]%.*}' -- "${cur//\\\\/}" ) )
  8105. <
  8106. < return 0
  8107. < } &&
  8108. < complete -F _info $filenames info
  8109. <
  8110. < # dhclient(1) completion
  8111. < #
  8112. < have dhclient && _dhclient()
  8113. < {
  8114. < local cur prev
  8115. <
  8116. < COMPREPLY=()
  8117. < cur=`_get_cword`
  8118. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8119. <
  8120. < case "$prev" in
  8121. < -@(cf|lf|pf|sf))
  8122. < _filedir
  8123. < return 0
  8124. < ;;
  8125. < -s)
  8126. < _known_hosts
  8127. < return 0
  8128. < ;;
  8129. < esac
  8130. <
  8131. < if [[ "$cur" == -* ]]; then
  8132. < COMPREPLY=( $( compgen -W '-p -d -q -1 -r -lf -pf \
  8133. < -cf -sf -s -g -n -nw -w' -- $cur ) )
  8134. < else
  8135. < _available_interfaces
  8136. < fi
  8137. < } &&
  8138. < complete -F _dhclient dhclient
  8139. <
  8140. < # lvm(8) completion
  8141. < #
  8142. < have lvm && {
  8143. < _volumegroups()
  8144. < {
  8145. < COMPREPLY=( $(compgen -W "$( vgscan 2>/dev/null | \
  8146. < sed -n -e 's|.*Found.*"\(.*\)".*$|\1|p' )" -- $cur ) )
  8147. < }
  8148. <
  8149. < _physicalvolumes()
  8150. < {
  8151. < COMPREPLY=( $(compgen -W "$( pvscan 2>/dev/null | \
  8152. < sed -n -e 's|^.*PV \(.*\) VG.*$|\1|p' )" -- $cur ) )
  8153. < }
  8154. <
  8155. < _logicalvolumes()
  8156. < {
  8157. < COMPREPLY=( $(compgen -W "$( lvscan 2>/dev/null | \
  8158. < sed -n -e "s|^.*'\(.*\)'.*$|\1|p" )" -- $cur ) )
  8159. < }
  8160. <
  8161. < _units()
  8162. < {
  8163. < COMPREPLY=( $( compgen -W 'h s b k m g t H K M G T' -- $cur ) )
  8164. < }
  8165. <
  8166. < _sizes()
  8167. < {
  8168. < COMPREPLY=( $( compgen -W 'k K m M g G t T' -- $cur ) )
  8169. < }
  8170. <
  8171. < _args()
  8172. < {
  8173. < args=0
  8174. < if [[ "${COMP_WORDS[0]}" == lvm ]]; then
  8175. < offset=2
  8176. < else
  8177. < offset=1
  8178. < fi
  8179. < for (( i=$offset; i < COMP_CWORD; i++ )); do
  8180. < if [[ "${COMP_WORDS[i]}" != -* ]]; then
  8181. < args=$(($args + 1))
  8182. < fi
  8183. < done
  8184. < }
  8185. <
  8186. < _lvmdiskscan()
  8187. < {
  8188. < local cur
  8189. <
  8190. < COMPREPLY=()
  8191. < cur=`_get_cword`
  8192. <
  8193. < if [[ "$cur" == -* ]]; then
  8194. < COMPREPLY=( $( compgen -W '-d --debug -h -? --help -l \
  8195. < --lvmpartition -v --verbose --version' -- $cur ) )
  8196. < fi
  8197. < }
  8198. < complete -F _lvmdiskscan lvmdiskscan
  8199. <
  8200. < _pvscan()
  8201. < {
  8202. < local cur
  8203. <
  8204. < COMPREPLY=()
  8205. < cur=`_get_cword`
  8206. <
  8207. < if [[ "$cur" == -* ]]; then
  8208. < COMPREPLY=( $( compgen -W '-d --debug -e \
  8209. < --exported -n --novolumegroup -h -? \
  8210. < --help --ignorelockingfailure -P \
  8211. < --partial -s --short -u --uuid -v \
  8212. < --verbose --version' -- $cur ) )
  8213. < fi
  8214. < }
  8215. < complete -F _pvscan pvscan
  8216. <
  8217. < _pvs()
  8218. < {
  8219. < local cur prev
  8220. <
  8221. < COMPREPLY=()
  8222. < cur=`_get_cword`
  8223. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8224. <
  8225. < case "$prev" in
  8226. < -@(o|O|-options|-sort))
  8227. < COMPREPLY=( $( compgen -W 'pv_fmt pv_uuid \
  8228. < pv_size pv_free pv_used pv_name \
  8229. < pv_attr pv_pe_count \
  8230. < pv_pe_alloc_count' -- $cur ) )
  8231. < return 0
  8232. < ;;
  8233. < --units)
  8234. < _units
  8235. < return 0
  8236. < ;;
  8237. < esac
  8238. <
  8239. < if [[ "$cur" == -* ]]; then
  8240. < COMPREPLY=( $( compgen -W '--aligned -a --all -d --debug \
  8241. < -h -? --help --ignorelockingfailure --noheadings \
  8242. < --nosuffix -o --options -O --sort \
  8243. < --separator --unbuffered --units \
  8244. < -v --verbose --version' -- $cur ) )
  8245. < else
  8246. < _physicalvolumes
  8247. < fi
  8248. < }
  8249. < complete -F _pvs pvs
  8250. <
  8251. < _pvdisplay()
  8252. < {
  8253. < local cur prev
  8254. <
  8255. < COMPREPLY=()
  8256. < cur=`_get_cword`
  8257. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8258. <
  8259. < case "$prev" in
  8260. < --units)
  8261. < _units
  8262. < return 0
  8263. < ;;
  8264. < esac
  8265. <
  8266. < if [[ "$cur" == -* ]]; then
  8267. < COMPREPLY=( $( compgen -W '-c --colon -C --columns --units \
  8268. < -v --verbose -d --debug -h --help --version' -- $cur ) )
  8269. < else
  8270. < _physicalvolumes
  8271. < fi
  8272. < }
  8273. < complete -F _pvdisplay pvdisplay
  8274. <
  8275. < _pvchange()
  8276. < {
  8277. < local cur prev
  8278. <
  8279. < COMPREPLY=()
  8280. < cur=`_get_cword`
  8281. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8282. <
  8283. < case "$prev" in
  8284. < -@(A|x|-autobackup|--allocatable))
  8285. < COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8286. < return 0
  8287. < ;;
  8288. < esac
  8289. <
  8290. < if [[ "$cur" == -* ]]; then
  8291. < COMPREPLY=( $( compgen -W '-a --all -A --autobackup \
  8292. < -d --debug -h --help -t --test -u --uuid -x \
  8293. < --allocatable -v --verbose --addtag --deltag \
  8294. < --version' -- $cur ) )
  8295. < else
  8296. < _physicalvolumes
  8297. < fi
  8298. < }
  8299. < complete -F _pvchange pvchange
  8300. <
  8301. < _pvcreate()
  8302. < {
  8303. < local cur prev
  8304. <
  8305. < COMPREPLY=()
  8306. < cur=`_get_cword`
  8307. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8308. <
  8309. < case "$prev" in
  8310. < --restorefile)
  8311. < _filedir
  8312. < return 0
  8313. < ;;
  8314. < -@(M|-metadatatype))
  8315. < COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
  8316. < return 0
  8317. < ;;
  8318. < --metadatacopies)
  8319. < COMPREPLY=( $( compgen -W '0 1 2' -- $cur ) )
  8320. < return 0
  8321. < ;;
  8322. < --@(metadatasize|setphysicalvolumesize))
  8323. < _sizes
  8324. < return 0
  8325. < ;;
  8326. < esac
  8327. <
  8328. < if [[ "$cur" == -* ]]; then
  8329. < COMPREPLY=( $( compgen -W '--restorefile -d --debug -f \
  8330. < --force -h -? --help --labelsector -M --metadatatype \
  8331. < --metadatacopies --metadatasize \
  8332. < --setphysicalvolumesize -t --test -u --uuid uuid -v \
  8333. < --verbose -y --yes --version' -- $cur ) )
  8334. < else
  8335. < _physicalvolumes
  8336. < fi
  8337. < }
  8338. < complete -F _pvcreate pvcreate
  8339. <
  8340. < _pvmove()
  8341. < {
  8342. < local cur prev
  8343. <
  8344. < COMPREPLY=()
  8345. < cur=`_get_cword`
  8346. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8347. <
  8348. < case "$prev" in
  8349. < -@(A|-autobackup))
  8350. < COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8351. < return 0
  8352. < ;;
  8353. < -@(n|-name))
  8354. < _logicalvolumes
  8355. < return 0
  8356. < esac
  8357. <
  8358. < if [[ "$cur" == -* ]]; then
  8359. < COMPREPLY=( $( compgen -W '--abort -A --autobackup \
  8360. < -b --background -d --debug -f --force -h -? \
  8361. < --help -i --interval -t --test -v --verbose \
  8362. < --version -n --name' -- $cur ) )
  8363. < else
  8364. < _physicalvolumes
  8365. < fi
  8366. < }
  8367. < complete -F _pvmove pvmove
  8368. <
  8369. < _pvremove()
  8370. < {
  8371. < local cur
  8372. <
  8373. < COMPREPLY=()
  8374. < cur=`_get_cword`
  8375. <
  8376. < if [[ "$cur" == -* ]]; then
  8377. < COMPREPLY=( $( compgen -W '-d --debug -f --force -h -? \
  8378. < --help -y --yes -t --test -v --verbose \
  8379. < --version' -- $cur ) )
  8380. < else
  8381. < _physicalvolumes
  8382. < fi
  8383. < }
  8384. < complete -F _pvremove pvremove
  8385. <
  8386. < _vgscan()
  8387. < {
  8388. < local cur
  8389. <
  8390. < COMPREPLY=()
  8391. < cur=`_get_cword`
  8392. <
  8393. < if [[ "$cur" == -* ]]; then
  8394. < COMPREPLY=( $( compgen -W '-d --debug -h --help \
  8395. < --ignorelockingfailure --mknodes -P \
  8396. < --partial -v --verbose --version' -- $cur ) )
  8397. < fi
  8398. < }
  8399. < complete -F _vgscan vgscan
  8400. <
  8401. < _vgs()
  8402. < {
  8403. < local cur prev
  8404. <
  8405. < COMPREPLY=()
  8406. < cur=`_get_cword`
  8407. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8408. <
  8409. < case "$prev" in
  8410. < -@(o|O|-options|-sort))
  8411. < COMPREPLY=( $( compgen -W 'vg_fmt vg_uuid vg_name \
  8412. < vg_attr vg_size vg_free vg_sysid \
  8413. < vg_extent_size vg_extent_count vg_free_count \
  8414. < max_lv max_pv pv_count lv_count snap_count \
  8415. < vg_seqno' -- $cur ) )
  8416. < return 0
  8417. < ;;
  8418. < --units)
  8419. < _units
  8420. < return 0
  8421. < ;;
  8422. < esac
  8423. <
  8424. < if [[ "$cur" == -* ]]; then
  8425. < COMPREPLY=( $( compgen -W '--aligned -d --debug \
  8426. < -h --help --ignorelockingfailure --noheadings \
  8427. < --nosuffix -o --options -O --sort -P --partial \
  8428. < --separator --unbuffered --units \
  8429. < -v --verbose --version' -- $cur ) )
  8430. < else
  8431. < _volumegroups
  8432. < fi
  8433. < }
  8434. < complete -F _vgs vgs
  8435. <
  8436. < _vgdisplay()
  8437. < {
  8438. < local cur prev
  8439. <
  8440. < COMPREPLY=()
  8441. < cur=`_get_cword`
  8442. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8443. <
  8444. < case "$prev" in
  8445. < --units)
  8446. < _units
  8447. < return 0
  8448. < ;;
  8449. < esac
  8450. <
  8451. < if [[ "$cur" == -* ]]; then
  8452. < COMPREPLY=( $( compgen -W '-c --colon -C --columns --units \
  8453. < -P --partial -A --activevolumegroups -v --verbose \
  8454. < -d --debug -h --help --version' -- $cur ) )
  8455. < else
  8456. < _volumegroups
  8457. < fi
  8458. < }
  8459. < complete -F _vgdisplay vgdisplay
  8460. <
  8461. < _vgchange()
  8462. < {
  8463. < local cur prev
  8464. <
  8465. < COMPREPLY=()
  8466. < cur=`_get_cword`
  8467. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8468. <
  8469. < case "$prev" in
  8470. < -@(a|A|x|-available|-autobackup|-resizeable))
  8471. < COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8472. < return 0
  8473. < ;;
  8474. < esac
  8475. <
  8476. < if [[ "$cur" == -* ]]; then
  8477. < COMPREPLY=( $( compgen -W '-A --autobackup --alloc -P \
  8478. < --partial -d --debug -h --help --ignorelockingfailure \
  8479. < -t --test -u --uuid -v --verbose --version -a \
  8480. < --available -x --resizeable -l --logicalvolume \
  8481. < --addtag --deltag' -- $cur ) )
  8482. < else
  8483. < _volumegroups
  8484. < fi
  8485. < }
  8486. < complete -F _vgchange vgchange
  8487. <
  8488. < _vgcreate()
  8489. < {
  8490. < local cur prev
  8491. <
  8492. < COMPREPLY=()
  8493. < cur=`_get_cword`
  8494. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8495. <
  8496. < case "$prev" in
  8497. < -@(A|-autobackup))
  8498. < COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8499. < return 0
  8500. < ;;
  8501. < -@(M|-metadatatype))
  8502. < COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
  8503. < return 0
  8504. < ;;
  8505. < -@(s|-physicalextentsize))
  8506. < _sizes
  8507. < return 0
  8508. < ;;
  8509. < esac
  8510. <
  8511. < if [[ "$cur" == -* ]]; then
  8512. < COMPREPLY=( $( compgen -W '-A --autobackup --addtag \
  8513. < --alloc -d --debug -h --help -l --maxlogicalvolumes \
  8514. < -M --metadatatype -p --maxphysicalvolumes -s \
  8515. < --physicalextentsize -t --test -v --verbose \
  8516. < --version' -- $cur ) )
  8517. < else
  8518. < _args
  8519. < if [ $args -eq 0 ]; then
  8520. < _volumegroups
  8521. < else
  8522. < _physicalvolumes
  8523. < fi
  8524. < fi
  8525. < }
  8526. < complete -F _vgcreate vgcreate
  8527. <
  8528. < _vgremove()
  8529. < {
  8530. < local cur
  8531. <
  8532. < COMPREPLY=()
  8533. < cur=`_get_cword`
  8534. <
  8535. < if [[ "$cur" == -* ]]; then
  8536. < COMPREPLY=( $( compgen -W '-d --debug -h --help -t --test \
  8537. < -v --verbose --version' -- $cur ) )
  8538. < else
  8539. < _volumegroups
  8540. < fi
  8541. < }
  8542. < complete -F _vgremove vgremove
  8543. <
  8544. < _vgrename()
  8545. < {
  8546. < local cur prev
  8547. <
  8548. < COMPREPLY=()
  8549. < cur=`_get_cword`
  8550. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8551. <
  8552. < case "$prev" in
  8553. < -@(A|-autobackup))
  8554. < COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8555. < return 0
  8556. < ;;
  8557. < esac
  8558. <
  8559. < if [[ "$cur" == -* ]]; then
  8560. < COMPREPLY=( $( compgen -W '-A --autobackup -d --debug -h \
  8561. < -? --help -t --test -v --verbose --version' -- $cur ) )
  8562. < else
  8563. < _volumegroups
  8564. < fi
  8565. < }
  8566. < complete -F _vgrename vgrename
  8567. <
  8568. < _vgreduce()
  8569. < {
  8570. < local cur prev
  8571. <
  8572. < COMPREPLY=()
  8573. < cur=`_get_cword`
  8574. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8575. <
  8576. < case "$prev" in
  8577. < -@(A|-autobackup))
  8578. < COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8579. < return 0
  8580. < ;;
  8581. < esac
  8582. <
  8583. < if [[ "$cur" == -* ]]; then
  8584. < COMPREPLY=( $( compgen -W '-a --all -A --autobackup -d \
  8585. < --debug -h --help --removemissing -t --test -v \
  8586. < --verbose --version' -- $cur ) )
  8587. <
  8588. < else
  8589. < _args
  8590. < if [ $args -eq 0 ]; then
  8591. < _volumegroups
  8592. < else
  8593. < _physicalvolumes
  8594. < fi
  8595. < fi
  8596. < }
  8597. < complete -F _vgreduce vgreduce
  8598. <
  8599. < _vgextend()
  8600. < {
  8601. < local cur prev
  8602. <
  8603. < COMPREPLY=()
  8604. < cur=`_get_cword`
  8605. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8606. <
  8607. < case "$prev" in
  8608. < -@(A|-autobackup))
  8609. < COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8610. < return 0
  8611. < ;;
  8612. < -@(L|-size))
  8613. < _sizes
  8614. < return 0
  8615. < ;;
  8616. < esac
  8617. <
  8618. < if [[ "$cur" == -* ]]; then
  8619. < COMPREPLY=( $( compgen -W '-A --autobackup -d --debug -h \
  8620. < -? --help -t --test -v --verbose --version' -- $cur ) )
  8621. < else
  8622. < _args
  8623. < if [ $args -eq 0 ]; then
  8624. < _volumegroups
  8625. < else
  8626. < _physicalvolumes
  8627. < fi
  8628. < fi
  8629. < }
  8630. < complete -F _vgextend vgextend
  8631. <
  8632. < _vgport()
  8633. < {
  8634. < local cur prev
  8635. <
  8636. < COMPREPLY=()
  8637. < cur=`_get_cword`
  8638. <
  8639. < if [[ "$cur" == -* ]]; then
  8640. < COMPREPLY=( $( compgen -W '-a --all -d --debug -h \
  8641. < -? --help -v --verbose --version' -- $cur ) )
  8642. < else
  8643. < _volumegroups
  8644. < fi
  8645. < }
  8646. < complete -F _vgport vgimport vgexport
  8647. <
  8648. < _vgck()
  8649. < {
  8650. < local cur prev
  8651. <
  8652. < COMPREPLY=()
  8653. < cur=`_get_cword`
  8654. <
  8655. < if [[ "$cur" == -* ]]; then
  8656. < COMPREPLY=( $( compgen -W '-d --debug -h \
  8657. < -? --help -v --verbose --version' -- $cur ) )
  8658. < else
  8659. < _volumegroups
  8660. < fi
  8661. < }
  8662. < complete -F _vgck vgck
  8663. <
  8664. < _vgconvert()
  8665. < {
  8666. < local cur prev
  8667. <
  8668. < COMPREPLY=()
  8669. < cur=`_get_cword`
  8670. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8671. <
  8672. < case "$prev" in
  8673. < -@(M|-metadatatype))
  8674. < COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
  8675. < return 0
  8676. < ;;
  8677. < --metadatacopies)
  8678. < COMPREPLY=( $( compgen -W '0 1 2' -- $cur ) )
  8679. < return 0
  8680. < ;;
  8681. < --metadatasize)
  8682. < _sizes
  8683. < return 0
  8684. < ;;
  8685. < esac
  8686. <
  8687. < if [[ "$cur" == -* ]]; then
  8688. < COMPREPLY=( $( compgen -W '-d --debug -h --help --labelsector \
  8689. < -M --metadatatype --metadatacopies --metadatasize \
  8690. < -t --test -v --verbose --version' -- $cur ) )
  8691. < else
  8692. < _volumegroups
  8693. < fi
  8694. < }
  8695. < complete -F _vgconvert vgconvert
  8696. <
  8697. < _vgcfgbackup()
  8698. < {
  8699. < local cur prev
  8700. <
  8701. < COMPREPLY=()
  8702. < cur=`_get_cword`
  8703. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8704. <
  8705. < case "$prev" in
  8706. < -@(f|-file))
  8707. < _filedir
  8708. < return 0
  8709. < ;;
  8710. < esac
  8711. <
  8712. < if [[ "$cur" == -* ]]; then
  8713. < COMPREPLY=( $( compgen -W '-d --debug -f --file -h --help \
  8714. < --ignorelockingfailure -P --partial -v --verbose \
  8715. < --version' -- $cur ) )
  8716. < else
  8717. < _volumegroups
  8718. < fi
  8719. < }
  8720. < complete -F _vgcfgbackup vgcfgbackup
  8721. <
  8722. < _vgcfgrestore()
  8723. < {
  8724. < local cur prev
  8725. <
  8726. < COMPREPLY=()
  8727. < cur=`_get_cword`
  8728. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8729. <
  8730. < case "$prev" in
  8731. < -@(f|-file))
  8732. < _filedir
  8733. < return 0
  8734. < ;;
  8735. < -@(M|-metadatatype))
  8736. < COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
  8737. < return 0
  8738. < ;;
  8739. < -@(n|-name))
  8740. < _volumegroups
  8741. < return 0
  8742. < ;;
  8743. < esac
  8744. <
  8745. < if [[ "$cur" == -* ]]; then
  8746. < COMPREPLY=( $( compgen -W '-d --debug -f --file -l --list \
  8747. < -h --help -M --Metadatatype -n --name -t --test \
  8748. < -v --verbose --version' -- $cur ) )
  8749. < else
  8750. < _volumegroups
  8751. < fi
  8752. < }
  8753. < complete -F _vgcfgrestore vgcfgrestore
  8754. <
  8755. < _vgmerge()
  8756. < {
  8757. < local cur prev
  8758. <
  8759. < COMPREPLY=()
  8760. < cur=`_get_cword`
  8761. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8762. <
  8763. < case "$prev" in
  8764. < -@(A|-autobackup))
  8765. < COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8766. < return 0
  8767. < ;;
  8768. < esac
  8769. <
  8770. < if [[ "$cur" == -* ]]; then
  8771. < COMPREPLY=( $( compgen -W '-A --autobackup -d --debug \
  8772. < -h --help -l --list -t --test -v --verbose \
  8773. < --version' -- $cur ) )
  8774. < else
  8775. < _volumegroups
  8776. < fi
  8777. < }
  8778. < complete -F _vgmerge vgmerge
  8779. <
  8780. < _vgsplit()
  8781. < {
  8782. < local cur prev
  8783. <
  8784. < COMPREPLY=()
  8785. < cur=`_get_cword`
  8786. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8787. <
  8788. < case "$prev" in
  8789. < -@(A|-autobackup))
  8790. < COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8791. < return 0
  8792. < ;;
  8793. < -@(M|-metadatatype))
  8794. < COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
  8795. < return 0
  8796. < ;;
  8797. < esac
  8798. <
  8799. < if [[ "$cur" == -* ]]; then
  8800. < COMPREPLY=( $( compgen -W '-A --autobackup -d --debug \
  8801. < -h --help -l --list -M --metadatatype -t --test \
  8802. < -v --verbose --version' -- $cur ) )
  8803. < else
  8804. < _args
  8805. < if [ $args -eq 0 -o $args -eq 1 ]; then
  8806. < _volumegroups
  8807. < else
  8808. < _physicalvolumes
  8809. < fi
  8810. < fi
  8811. < }
  8812. < complete -F _vgsplit vgsplit
  8813. <
  8814. < _vgmknodes()
  8815. < {
  8816. < local cur
  8817. <
  8818. < COMPREPLY=()
  8819. < cur=`_get_cword`
  8820. <
  8821. < if [[ "$cur" == -* ]]; then
  8822. < COMPREPLY=( $( compgen -W '-d --debug -h --help -v --verbose \
  8823. < --version' -- $cur ) )
  8824. < else
  8825. < _volumegroups
  8826. < fi
  8827. < }
  8828. < complete -F _vgmknodes vgmknodes
  8829. <
  8830. < _lvscan()
  8831. < {
  8832. < local cur
  8833. <
  8834. < COMPREPLY=()
  8835. < cur=`_get_cword`
  8836. <
  8837. < if [[ "$cur" == -* ]]; then
  8838. < COMPREPLY=( $( compgen -W '-b --blockdevice -d --debug \
  8839. < -h -? --help --ignorelockingfailure -P \
  8840. < --partial -v --verbose --version' -- $cur ) )
  8841. < fi
  8842. < }
  8843. < complete -F _lvscan lvscan
  8844. <
  8845. < _lvs()
  8846. < {
  8847. < local cur prev
  8848. <
  8849. < COMPREPLY=()
  8850. < cur=`_get_cword`
  8851. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8852. <
  8853. < case "$prev" in
  8854. < -@(o|O|-options|-sort))
  8855. < COMPREPLY=( $( compgen -W 'lv_uuid lv_name \
  8856. < lv_attr lv_minor lv_size seg_count \
  8857. < origin snap_percent segtype stripes \
  8858. < stripesize chunksize seg_start \
  8859. < seg_size' -- $cur ) )
  8860. < return 0
  8861. < ;;
  8862. < --units)
  8863. < _units
  8864. < return 0
  8865. < ;;
  8866. < esac
  8867. <
  8868. < if [[ "$cur" == -* ]]; then
  8869. < COMPREPLY=( $( compgen -W '--aligned -d --debug \
  8870. < -h --help --ignorelockingfailure --noheadings \
  8871. < --nosuffix -o --options -O --sort -P --partial \
  8872. < --segments --separator --unbuffered --units \
  8873. < -v --verbose --version' -- $cur ) )
  8874. < else
  8875. < _logicalvolumes
  8876. < fi
  8877. < }
  8878. < complete -F _lvs lvs
  8879. <
  8880. < _lvdisplay()
  8881. < {
  8882. < local cur prev
  8883. <
  8884. < COMPREPLY=()
  8885. < cur=`_get_cword`
  8886. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8887. <
  8888. < case "$prev" in
  8889. < --units)
  8890. < _units
  8891. < return 0
  8892. < ;;
  8893. < esac
  8894. <
  8895. < if [[ "$cur" == -* ]]; then
  8896. < COMPREPLY=( $( compgen -W '-c --colon -C --columns --units \
  8897. < -P --partial -m --maps -v --verbose -d --debug -h \
  8898. < --help --version' -- $cur ) )
  8899. < else
  8900. < _logicalvolumes
  8901. < fi
  8902. < }
  8903. < complete -F _lvdisplay lvdisplay
  8904. <
  8905. < _lvchange()
  8906. < {
  8907. < local cur prev
  8908. <
  8909. < COMPREPLY=()
  8910. < cur=`_get_cword`
  8911. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8912. <
  8913. < case "$prev" in
  8914. < -@(a|A|C|M|-available|-autobackup|-continguous|-persistent))
  8915. < COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8916. < return 0
  8917. < ;;
  8918. < -@(p|-permission))
  8919. < COMPREPLY=( $( compgen -W 'r rw' -- $cur ) )
  8920. < return 0
  8921. < ;;
  8922. < esac
  8923. <
  8924. < if [[ "$cur" == -* ]]; then
  8925. < COMPREPLY=( $( compgen -W '-A --autobackup -a --available \
  8926. < --addtag --alloc -C --contiguous -d --debug --deltag \
  8927. < -f --force -h --help --ignorelockingfailure -M \
  8928. < --persistent --major major --minor minor -P --partial \
  8929. < -p --permission -r --readahead --refresh -t --test \
  8930. < -v --verbose --version' -- $cur ) )
  8931. < else
  8932. < _logicalvolumes
  8933. < fi
  8934. < }
  8935. < complete -F _lvchange lvchange
  8936. <
  8937. < _lvcreate()
  8938. < {
  8939. < local cur prev
  8940. <
  8941. < COMPREPLY=()
  8942. < cur=`_get_cword`
  8943. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8944. <
  8945. < case "$prev" in
  8946. < -@(A|C|M|Z|-autobackup|-continguous|-persistent|-zero))
  8947. < COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8948. < return 0
  8949. < ;;
  8950. < -@(L|-size))
  8951. < _sizes
  8952. < return 0
  8953. < ;;
  8954. < -@(p|-permission))
  8955. < COMPREPLY=( $( compgen -W 'r rw' -- $cur ) )
  8956. < return 0
  8957. < ;;
  8958. < -@(n|-name))
  8959. < _logicalvolumes
  8960. < return 0
  8961. < ;;
  8962. < esac
  8963. <
  8964. < if [[ "$cur" == -* ]]; then
  8965. < COMPREPLY=( $( compgen -W '-A --autobackup --addtag --alloc \
  8966. < -C --contiguous -d --debug -h -? --help -i --stripes \
  8967. < -I --stripesize -l --extents -L --size -M --persistent \
  8968. < --major --minor -n --name -p --permission -r \
  8969. < --readahead -t --test --type -v --verbose -Z --zero \
  8970. < --version' -- $cur ) )
  8971. < else
  8972. < _args
  8973. < if [ $args -eq 0 ]; then
  8974. < _volumegroups
  8975. < else
  8976. < _physicalvolumes
  8977. < fi
  8978. < fi
  8979. < }
  8980. < complete -F _lvcreate lvcreate
  8981. <
  8982. < _lvremove()
  8983. < {
  8984. < local cur prev
  8985. <
  8986. < COMPREPLY=()
  8987. < cur=`_get_cword`
  8988. < prev=${COMP_WORDS[COMP_CWORD-1]}
  8989. <
  8990. < case "$prev" in
  8991. < -@(A|-autobackup))
  8992. < COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8993. < return 0
  8994. < ;;
  8995. < esac
  8996. <
  8997. < if [[ "$cur" == -* ]]; then
  8998. < COMPREPLY=( $( compgen -W '-A --autobackup -d --debug -f \
  8999. < --force -h -? --help -t --test -v --verbose \
  9000. < --version' -- $cur ) )
  9001. < else
  9002. < _logicalvolumes
  9003. < fi
  9004. < }
  9005. < complete -F _lvremove lvremove
  9006. <
  9007. < _lvrename()
  9008. < {
  9009. < local cur prev
  9010. <
  9011. < COMPREPLY=()
  9012. < cur=`_get_cword`
  9013. < prev=${COMP_WORDS[COMP_CWORD-1]}
  9014. <
  9015. < case "$prev" in
  9016. < -@(A|-autobackup))
  9017. < COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  9018. < return 0
  9019. < ;;
  9020. < esac
  9021. <
  9022. < if [[ "$cur" == -* ]]; then
  9023. < COMPREPLY=( $( compgen -W '-A --autobackup -d --debug -h \
  9024. < -? --help -t --test -v --verbose --version' -- $cur ) )
  9025. < else
  9026. < _logicalvolumes
  9027. < fi
  9028. < }
  9029. < complete -F _lvrename lvrename
  9030. <
  9031. < _lvreduce()
  9032. < {
  9033. < local cur prev
  9034. <
  9035. < COMPREPLY=()
  9036. < cur=`_get_cword`
  9037. < prev=${COMP_WORDS[COMP_CWORD-1]}
  9038. <
  9039. < case "$prev" in
  9040. < -@(A|-autobackup))
  9041. < COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  9042. < return 0
  9043. < ;;
  9044. < -@(L|-size))
  9045. < _sizes
  9046. < return 0
  9047. < ;;
  9048. < esac
  9049. <
  9050. < if [[ "$cur" == -* ]]; then
  9051. < COMPREPLY=( $( compgen -W '-A --autobackup -d \
  9052. < --debug -f --force -h --help -l --extents \
  9053. < -L --size -n --nofsck -r --resizefs -t --test \
  9054. < -v --verbose --version' -- $cur ) )
  9055. < else
  9056. < _logicalvolumes
  9057. < fi
  9058. < }
  9059. < complete -F _lvreduce lvreduce
  9060. <
  9061. < _lvresize()
  9062. < {
  9063. < local cur prev
  9064. <
  9065. < COMPREPLY=()
  9066. < cur=`_get_cword`
  9067. < prev=${COMP_WORDS[COMP_CWORD-1]}
  9068. <
  9069. < case "$prev" in
  9070. < -@(A|-autobackup))
  9071. < COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  9072. < return 0
  9073. < ;;
  9074. < -@(L|-size))
  9075. < _sizes
  9076. < return 0
  9077. < ;;
  9078. < esac
  9079. <
  9080. < if [[ "$cur" == -* ]]; then
  9081. < COMPREPLY=( $( compgen -W '-A --autobackup --alloc -d \
  9082. < --debug -h --help -i --stripes -I --stripesize \
  9083. < -l --extents -L --size -n --nofsck -r --resizefs \
  9084. < -t --test --type -v --verbose --version' -- $cur ) )
  9085. < else
  9086. < _args
  9087. < if [ $args -eq 0 ]; then
  9088. < _logicalvolumes
  9089. < else
  9090. < _physicalvolumes
  9091. < fi
  9092. < fi
  9093. < }
  9094. < complete -F _lvresize lvresize
  9095. <
  9096. < _lvextend()
  9097. < {
  9098. < local cur prev
  9099. <
  9100. < COMPREPLY=()
  9101. < cur=`_get_cword`
  9102. < prev=${COMP_WORDS[COMP_CWORD-1]}
  9103. <
  9104. < case "$prev" in
  9105. < -@(A|-autobackup))
  9106. < COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  9107. < return 0
  9108. < ;;
  9109. < -@(L|-size))
  9110. < _sizes
  9111. < return 0
  9112. < ;;
  9113. < esac
  9114. <
  9115. < if [[ "$cur" == -* ]]; then
  9116. < COMPREPLY=( $( compgen -W '-A --autobackup --alloc -d \
  9117. < --debug -h --help -i --stripes -I --stripesize \
  9118. < -l --extents -L --size -n --nofsck -r --resizefs \
  9119. < -t --test --type -v --verbose --version' -- $cur ) )
  9120. < else
  9121. < _args
  9122. < if [ $args -eq 0 ]; then
  9123. < _logicalvolumes
  9124. < else
  9125. < _physicalvolumes
  9126. < fi
  9127. < fi
  9128. < }
  9129. < complete -F _lvextend lvextend
  9130. <
  9131. < _lvm()
  9132. < {
  9133. < local prev
  9134. <
  9135. < COMPREPLY=()
  9136. < cur=`_get_cword`
  9137. <
  9138. < if [ $COMP_CWORD -eq 1 ]; then
  9139. < COMPREPLY=( $( compgen -W 'dumpconfig help lvchange \
  9140. < lvcreate lvdisplay lvextend lvmchange \
  9141. < lvmdiskscan lvmsadc lvmsar lvreduce \
  9142. < lvremove lvrename lvresize lvs lvscan \
  9143. < pvchange pvcreate pvdata pvdisplay pvmove \
  9144. < pvremove pvresize pvs pvscan vgcfgbackup \
  9145. < vgcfgrestore vgchange vgck vgconvert \
  9146. < vgcreate vgdisplay vgexport vgextend \
  9147. < vgimport vgmerge vgmknodes vgreduce \
  9148. < vgremove vgrename vgs vgscan vgsplit \
  9149. < version' -- $cur ) )
  9150. < else
  9151. < case ${COMP_WORDS[1]} in
  9152. < pvchange)
  9153. < _pvchange
  9154. < ;;
  9155. < pvcreate)
  9156. < _pvcreate
  9157. < ;;
  9158. < pvdisplay)
  9159. < _pvdisplay
  9160. < ;;
  9161. < pvmove)
  9162. < _pvmove
  9163. < ;;
  9164. < pvremove)
  9165. < _pvremove
  9166. < ;;
  9167. < pvresize)
  9168. < _pvresize
  9169. < ;;
  9170. < pvs)
  9171. < _pvs
  9172. < ;;
  9173. < pvscan)
  9174. < _pvscan
  9175. < ;;
  9176. < vgcfgbackup)
  9177. < _vgcfgbackup
  9178. < ;;
  9179. < vgcfgrestore)
  9180. < _vgcfgrestore
  9181. < ;;
  9182. < vgchange)
  9183. < _vgchange
  9184. < ;;
  9185. < vgck)
  9186. < _vgck
  9187. < ;;
  9188. < vgconvert)
  9189. < _vgconvert
  9190. < ;;
  9191. < vgcreate)
  9192. < _vgcreate
  9193. < ;;
  9194. < vgdisplay)
  9195. < _vgdisplay
  9196. < ;;
  9197. < vgexport)
  9198. < _vgexport
  9199. < ;;
  9200. < vgextend)
  9201. < _vgextend
  9202. < ;;
  9203. < vgimport)
  9204. < _vgimport
  9205. < ;;
  9206. < vgmerge)
  9207. < _vgmerge
  9208. < ;;
  9209. < vgmknodes)
  9210. < _vgmknodes
  9211. < ;;
  9212. < vgreduce)
  9213. < _vgreduce
  9214. < ;;
  9215. < vgremove)
  9216. < _vgremove
  9217. < ;;
  9218. < vgrename)
  9219. < _vgrename
  9220. < ;;
  9221. < vgs)
  9222. < _vgs
  9223. < ;;
  9224. < vgscan)
  9225. < _vgscan
  9226. < ;;
  9227. < vgsplit)
  9228. < _vgsplit
  9229. < ;;
  9230. < lvchange)
  9231. < _lvchange
  9232. < ;;
  9233. < lvcreate)
  9234. < _lvcreate
  9235. < ;;
  9236. < lvdisplay)
  9237. < _lvdisplay
  9238. < ;;
  9239. < lvextend)
  9240. < _lvextend
  9241. < ;;
  9242. < lvreduce)
  9243. < _lvreduce
  9244. < ;;
  9245. < lvremove)
  9246. < _lvremove
  9247. < ;;
  9248. < lvrename)
  9249. < _lvrename
  9250. < ;;
  9251. < lvresize)
  9252. < _lvresize
  9253. < ;;
  9254. < lvs)
  9255. < _lvs
  9256. < ;;
  9257. < lvscan)
  9258. < _lvscan
  9259. < ;;
  9260. < esac
  9261. < fi
  9262. < }
  9263. < complete -F _lvm lvm
  9264. < }
  9265. <
  9266. < # mkinitrd(8) completion
  9267. < #
  9268. < have mkinitrd &&
  9269. < _mkinitrd()
  9270. < {
  9271. < local cur args
  9272. <
  9273. < COMPREPLY=()
  9274. < cur=`_get_cword`
  9275. < prev=${COMP_WORDS[COMP_CWORD-1]}
  9276. <
  9277. < # --name value style option
  9278. < case "$prev" in
  9279. < --preload)
  9280. < _modules
  9281. < return 0
  9282. < ;;
  9283. < esac
  9284. <
  9285. < # --name=value style option
  9286. < if [[ "$cur" == *=* ]]; then
  9287. < prev=${cur/=*/}
  9288. < cur=${cur/*=/}
  9289. < case "$prev" in
  9290. < --@(with|builtin))
  9291. < _modules
  9292. < return 0
  9293. < ;;
  9294. < --@(fstab|dsdt))
  9295. < _filedir
  9296. < return 0
  9297. < ;;
  9298. < --tmpdir)
  9299. < _filedir -d
  9300. < return 0
  9301. < ;;
  9302. < esac
  9303. < fi
  9304. <
  9305. <
  9306. < if [[ "$cur" == -* ]]; then
  9307. < COMPREPLY=( $( compgen -W '--version -v -f --preload \
  9308. < --with= --omit-scsi-modules --omit-raid-modules \
  9309. < --images-version --fstab= --nocompress --builtin= \
  9310. < --nopivot --noudev --allow-missing --tmpdir= \
  9311. < --initrdfs= --dsdt= --lvm-version= --froce-usb' \
  9312. < -- $cur ) )
  9313. < else
  9314. < _count_args
  9315. <
  9316. < case $args in
  9317. < 1)
  9318. < _filedir
  9319. < ;;
  9320. < 2)
  9321. < COMPREPLY=( $( command ls /lib/modules | grep "^$cur" ) )
  9322. < ;;
  9323. < esac
  9324. < fi
  9325. <
  9326. < } &&
  9327. < complete -F _mkinitrd mkinitrd
  9328. <
  9329. < # pkgconfig(1) completion
  9330. < #
  9331. < have pkg-config &&
  9332. < _pkg_config()
  9333. < {
  9334. < local cur
  9335. <
  9336. < COMPREPLY=()
  9337. < cur=`_get_cword`
  9338. <
  9339. < if [[ "$cur" == -* ]]; then
  9340. < # return list of available options
  9341. < COMPREPLY=( $( compgen -W '-version --modversion \
  9342. < --atleast-pkgconfig-version= --libs --libs-only-l \
  9343. < --libs-only-other --libs-only-L --cflags \
  9344. < --cflags-only-I --cflags-only-other --variable= \
  9345. < --define-variable= --exists --uninstalled \
  9346. < --atleast-version= --exact-version= --max-version= \
  9347. < --list-all --debug --print-errors --silence-errors \
  9348. < --errors-to-stdout -? --help --usage' -- $cur))
  9349. < else
  9350. < COMPREPLY=( $( pkg-config --list-all 2>/dev/null | \
  9351. < awk '{print $1}' | grep "^$cur" ) )
  9352. < fi
  9353. < } &&
  9354. < complete -F _pkg_config pkg-config
  9355. <
  9356. <
  9357. < # cpio(1) completion
  9358. < #
  9359. < have cpio && {
  9360. < _cpio_format()
  9361. < {
  9362. < COMPREPLY=( $( compgen -W 'bin odc newc crc tar ustar hpbin hpodc' -- $cur ) )
  9363. < }
  9364. <
  9365. < _cpio()
  9366. < {
  9367. < local cur
  9368. <
  9369. < COMPREPLY=()
  9370. < cur=`_get_cword`
  9371. < prev=${COMP_WORDS[COMP_CWORD-1]}
  9372. <
  9373. < # --name value style option
  9374. < case $prev in
  9375. < -H)
  9376. < _cpio_format
  9377. < return 0
  9378. < ;;
  9379. < -@(E|F|I))
  9380. < _filedir
  9381. < return 0
  9382. < ;;
  9383. < -R)
  9384. < _usergroup
  9385. < return 0
  9386. < ;;
  9387. < esac
  9388. <
  9389. < # --name=value style option
  9390. < if [[ "$cur" == *=* ]]; then
  9391. < prev=${cur/=*/}
  9392. < cur=${cur/*=/}
  9393. < case $prev in
  9394. < --format)
  9395. < _cpio_format
  9396. < return 0
  9397. < ;;
  9398. < --@(file|pattern-file))
  9399. < _filedir
  9400. < return 0
  9401. < ;;
  9402. < --owner)
  9403. < _usergroup
  9404. < return 0
  9405. < ;;
  9406. < --rsh-command)
  9407. < COMPREPLY=( $( compgen -c -- $cur ) )
  9408. < return 0
  9409. < ;;
  9410. < esac
  9411. < fi
  9412. <
  9413. < if [ $COMP_CWORD -eq 1 ]; then
  9414. < COMPREPLY=( $( compgen -W '-o --create -i --extract -p --pass-through' -- $cur) )
  9415. < else
  9416. < case ${COMP_WORDS[1]} in
  9417. < -@(o|-create))
  9418. < if [[ "$cur" == -* ]]; then
  9419. < COMPREPLY=( $( compgen -W '-0 -a -c -v -A -B\
  9420. < -L -V -C -H -M -O -F --file= --format=\
  9421. < --message= --null --reset-access-time\
  9422. < --verbose --dot --append --block-size=\
  9423. < --dereference --io-size= --quiet\
  9424. < --force-local --rsh-command= --help\
  9425. < --version' -- $cur ) )
  9426. < fi
  9427. < ;;
  9428. < -@(i|-extract))
  9429. < if [[ "$cur" == -* ]]; then
  9430. < COMPREPLY=( $( compgen -W '-b -c -d -f -m -n -r\
  9431. < -t -s -u -v -B -S -V -C -E -H -M -R -I\
  9432. < -F --file= --make-directories\
  9433. < --nonmatching\
  9434. < --preserve-modification-time\
  9435. < --numeric-uid-gid --rename -t --list\
  9436. < --swap-bytes --swap --dot\
  9437. < --unconditional --verbose --block-size=\
  9438. < --swap-halfwords --io-size=\
  9439. < --pattern-file= --format= --owner=\
  9440. < --no-preserve-owner --message=\
  9441. < --force-local --no-absolute-filenames\
  9442. < --sparse --only-verify-crc --quiet\
  9443. < --rsh-command= --help\
  9444. < --version' -- $cur ) )
  9445. < fi
  9446. < ;;
  9447. < -@(p|-pass-through))
  9448. < if [[ "$cur" == -* ]]; then
  9449. < COMPREPLY=( $( compgen -W '-0 -a -d -l -m -u -v\
  9450. < -L -V -R --null --reset-access-time\
  9451. < --make-directories --link --quiet\
  9452. < --preserve-modification-time\
  9453. < --unconditional --verbose --dot\
  9454. < --dereference --owner=\
  9455. < --no-preserve-owner --sparse --help\
  9456. < --version' -- $cur ) )
  9457. < else
  9458. < _filedir -d
  9459. < fi
  9460. < ;;
  9461. < esac
  9462. < fi
  9463. < }
  9464. < complete -F _cpio cpio
  9465. < }
  9466. <
  9467. < # id(1) completion
  9468. < #
  9469. < have id &&
  9470. < _id()
  9471. < {
  9472. < local cur
  9473. <
  9474. < COMPREPLY=()
  9475. < cur=`_get_cword`
  9476. <
  9477. < if [[ "$cur" == -* ]]; then
  9478. < COMPREPLY=( $( compgen -W '-a -g --group -G --groups -n --name\
  9479. < -r --real -u --user --help --version' -- $cur ) )
  9480. < else
  9481. < COMPREPLY=( $( compgen -u $cur ) )
  9482. < fi
  9483. < } &&
  9484. < complete -F _id id
  9485. <
  9486. < # getent(1) completion
  9487. < #
  9488. < have getent &&
  9489. < _getent()
  9490. < {
  9491. < local cur prev
  9492. <
  9493. < COMPREPLY=()
  9494. < cur=`_get_cword`
  9495. < prev=${COMP_WORDS[COMP_CWORD-1]}
  9496. <
  9497. < case $prev in
  9498. < passwd)
  9499. < COMPREPLY=( $( compgen -u $cur ) )
  9500. < return 0
  9501. < ;;
  9502. < group)
  9503. < COMPREPLY=( $( compgen -g $cur ) )
  9504. < return 0
  9505. < ;;
  9506. < services)
  9507. < COMPREPLY=( $( compgen -s $cur ) )
  9508. < return 0
  9509. < ;;
  9510. < hosts)
  9511. < COMPREPLY=( $( compgen -A hostname $cur ) )
  9512. < return 0
  9513. < ;;
  9514. < protocols)
  9515. < COMPREPLY=( $( getent protocols | awk '{print $1}' | grep "^$cur" ) )
  9516. < return 0
  9517. < ;;
  9518. < networks)
  9519. < COMPREPLY=( $( getent networks | awk '{print $1}' | grep "^$cur" ) )
  9520. < return 0
  9521. < ;;
  9522. < esac
  9523. <
  9524. <
  9525. < if [ $COMP_CWORD -eq 1 ]; then
  9526. < COMPREPLY=( $( compgen -W 'passwd group hosts services protocols networks' -- $cur ) )
  9527. < fi
  9528. < } &&
  9529. < complete -F _getent getent
  9530. <
  9531. < # ntpdate(1) completion
  9532. < #
  9533. < have ntpdate &&
  9534. < _ntpdate()
  9535. < {
  9536. < local cur prev
  9537. <
  9538. < COMPREPLY=()
  9539. < cur=`_get_cword`
  9540. < prev=${COMP_WORDS[COMP_CWORD-1]}
  9541. <
  9542. < case $prev in
  9543. < -k)
  9544. < _filedir
  9545. < return 0
  9546. < ;;
  9547. < -U)
  9548. < COMPREPLY=( $( compgen -u $cur ) )
  9549. < return 0
  9550. < ;;
  9551. < esac
  9552. <
  9553. < if [[ "$cur" == -* ]]; then
  9554. < COMPREPLY=( $( compgen -W '-4 -6 -b -B -d -Q -q -s -u -v -a\
  9555. < -e -k -p -o -r -t' -- $cur ) )
  9556. < else
  9557. < _known_hosts
  9558. < fi
  9559. < } &&
  9560. < complete -F _ntpdate ntpdate
  9561. <
  9562. < # smartctl(8) completion
  9563. < #
  9564. < have smartctl && {
  9565. < _smartctl_quietmode()
  9566. < {
  9567. < COMPREPLY=( $( compgen -W 'errorsonly silent' -- $cur ) )
  9568. < }
  9569. < _smartctl_device()
  9570. < {
  9571. < COMPREPLY=( $( compgen -W 'ata scsi 3ware' -- $cur ) )
  9572. < }
  9573. < _smartctl_tolerance()
  9574. < {
  9575. < COMPREPLY=( $( compgen -W 'warn exit ignore' -- $cur ) )
  9576. < }
  9577. < _smartctl_badsum()
  9578. < {
  9579. < COMPREPLY=( $( compgen -W 'normal conservative permissive verypermissive' -- $cur ) )
  9580. < }
  9581. < _smartctl_report()
  9582. < {
  9583. < COMPREPLY=( $( compgen -W 'ioctl ataioctl scsiioctl' -- $cur ) )
  9584. < }
  9585. < _smartctl_feature()
  9586. < {
  9587. < COMPREPLY=( $( compgen -W 'on off' -- $cur ) )
  9588. < }
  9589. < _smartctl_log()
  9590. < {
  9591. < COMPREPLY=( $( compgen -W 'error selftest selective directory' -- $cur ) )
  9592. < }
  9593. < _smartctl_vendorattribute()
  9594. < {
  9595. < COMPREPLY=( $( compgen -W 'help 9,minutes 9,seconds 9,halfminutes \
  9596. < 9,temp 192,emergencyretractcyclect 193,loadunload \
  9597. < 194,10xCelsius 194,unknown 198,offlinescanuncsectorct \
  9598. < 200,writeerrorcount 201,detectedtacount 220,temp' -- $cur ) )
  9599. < }
  9600. < _smartctl_firmwarebug()
  9601. < {
  9602. < COMPREPLY=( $( compgen -W 'none samsung samsung2' -- $cur ) )
  9603. < }
  9604. < _smartctl_presets()
  9605. < {
  9606. < COMPREPLY=( $( compgen -W 'use ignore show showall' -- $cur ) )
  9607. < }
  9608. < _smartctl_test()
  9609. < {
  9610. < COMPREPLY=( $( compgen -W 'offline short long conveyance select afterselect,on afterselect,off pending' -- $cur ) )
  9611. < }
  9612. <
  9613. < _smartctl()
  9614. < {
  9615. < local cur prev
  9616. <
  9617. < COMPREPLY=()
  9618. < cur=`_get_cword`
  9619. < prev=${COMP_WORDS[COMP_CWORD-1]}
  9620. <
  9621. < # --name value style option
  9622. < case "$prev" in
  9623. < -q)
  9624. < _smartctl_quietmode
  9625. < ;;
  9626. < -d)
  9627. < _smartctl_device
  9628. < return 0
  9629. < ;;
  9630. < -t)
  9631. < _smartctl_tolerance
  9632. < return 0
  9633. < ;;
  9634. < -b)
  9635. < _smartctl_badsum
  9636. < return 0
  9637. < ;;
  9638. < -r)
  9639. < _smartctl_report
  9640. < return 0
  9641. < ;;
  9642. < -s)
  9643. < _smartctl_feature
  9644. < return 0
  9645. < ;;
  9646. < -o)
  9647. < _smartctl_feature
  9648. < return 0
  9649. < ;;
  9650. < -S)
  9651. < _smartctl_feature
  9652. < return 0
  9653. < ;;
  9654. < -l)
  9655. < _smartctl_log
  9656. < return 0
  9657. < ;;
  9658. < -v)
  9659. < _smartctl_vendorattribute
  9660. < return 0
  9661. < ;;
  9662. < -F)
  9663. < _smartctl_firmwarebug
  9664. < return 0
  9665. < ;;
  9666. < -P)
  9667. < _smartctl_presets
  9668. < return 0
  9669. < ;;
  9670. < -t)
  9671. < _smartctl_test
  9672. < return 0
  9673. < ;;
  9674. < esac
  9675. <
  9676. < # --name=value style option
  9677. < if [[ "$cur" == *=* ]]; then
  9678. < prev=${cur/=*/}
  9679. < cur=${cur/*=/}
  9680. < case "$prev" in
  9681. < --quietmode)
  9682. < _smartctl_quietmode
  9683. < return 0
  9684. < ;;
  9685. < --device)
  9686. < _smartctl_device
  9687. < return 0
  9688. < ;;
  9689. < --tolerance)
  9690. < _smartctl_tolerance
  9691. < return 0
  9692. < ;;
  9693. < --badsum)
  9694. < _smartctl_badsum
  9695. < return 0
  9696. < ;;
  9697. < --report)
  9698. < _smartctl_report
  9699. < return 0
  9700. < ;;
  9701. < --smart)
  9702. < _smartctl_feature
  9703. < return 0
  9704. < ;;
  9705. < --offlineauto)
  9706. < _smartctl_feature
  9707. < return 0
  9708. < ;;
  9709. < --saveauto)
  9710. < _smartctl_feature
  9711. < return 0
  9712. < ;;
  9713. < --log)
  9714. < _smartctl_log
  9715. < return 0
  9716. < ;;
  9717. < --vendorattribute)
  9718. < _smartctl_vendorattribute
  9719. < return 0
  9720. < ;;
  9721. < --firmwarebug)
  9722. < _smartctl_firmwarebug
  9723. < return 0
  9724. < ;;
  9725. < --presets)
  9726. < _smartctl_presets
  9727. < return 0
  9728. < ;;
  9729. < --test)
  9730. < _smartctl_test
  9731. < return 0
  9732. < ;;
  9733. < esac
  9734. < fi
  9735. <
  9736. <
  9737. < if [[ "$cur" == -* ]]; then
  9738. < COMPREPLY=( $( compgen -W '-h --help --usage -V --version \
  9739. < --copyright --license-i --info -a --all -q \
  9740. < --quietmode= -d --device= -T --tolerance= -b --badsum= \
  9741. < -r --report= -s --smart= -o --offlineauto= -S \
  9742. < --saveauto= -H --health -c --capabilities -A \
  9743. < --attributes -l --log= -v --vendorattribute= -F \
  9744. < --firmwarebug= -P --presets= -t --test= -C \
  9745. < --captive -X --abort' -- $cur ) )
  9746. < else
  9747. < cur=${cur:=/dev/}
  9748. < _filedir
  9749. < fi
  9750. < }
  9751. < complete -F _smartctl smartctl
  9752. < }
  9753. <
  9754. < # vncviewer(1) completion
  9755. < #
  9756. < have vncviewer &&
  9757. < _vncviewer()
  9758. < {
  9759. < local cur prev
  9760. < local -a config
  9761. <
  9762. < COMPREPLY=()
  9763. < cur=`_get_cword`
  9764. < prev=${COMP_WORDS[COMP_CWORD-1]}
  9765. <
  9766. < case "$prev" in
  9767. < -via)
  9768. < _known_hosts -a
  9769. < ;;
  9770. < *)
  9771. < # ssh into the the server, find and ping the broadcast address, then
  9772. < # sort and show the results.
  9773. < COMPREPLY=( $( ssh -o 'Batchmode yes' $prev \
  9774. < "ping -bnc 4 255.255.255.255" 2>/dev/null | \
  9775. < awk -F ' ' '{print $4}' | \
  9776. < sort -n | uniq | egrep '[0-9]+\.[0-9]+\.' 2>/dev/null ) )
  9777. < esac
  9778. <
  9779. < return 0
  9780. < } &&
  9781. < complete -F _vncviewer vncviewer
  9782. <
  9783. < # sysctl(8) completion
  9784. < #
  9785. < have sysctl &&
  9786. < _sysctl()
  9787. < {
  9788. < local cur
  9789. <
  9790. < COMPREPLY=()
  9791. < cur=`_get_cword`
  9792. <
  9793. < COMPREPLY=( $( compgen -W "$(sysctl -N -a 2>/dev/null)" -- $cur ) )
  9794. <
  9795. < return 0
  9796. < } &&
  9797. < complete -F _sysctl sysctl
  9798. <
  9799. < # update-rc.d(8) completion
  9800. < #
  9801. < # Copyright (C) 2004 Servilio Afre Puentes <[email protected]>
  9802. < #
  9803. < have update-rc.d &&
  9804. < _update_rc_d()
  9805. < {
  9806. < local cur prev sysvdir services options valid_options
  9807. <
  9808. < cur=`_get_cword`
  9809. < prev=${COMP_WORDS[COMP_CWORD-1]}
  9810. <
  9811. < [ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d \
  9812. < || sysvdir=/etc/init.d
  9813. <
  9814. < services=( $(echo $sysvdir/!(README*|*.sh|*.dpkg*|*.rpm*)) )
  9815. < services=( ${services[@]#$sysvdir/} )
  9816. < options=( -f -n )
  9817. <
  9818. < if [[ $COMP_CWORD -eq 1 || "$prev" == -* ]]; then
  9819. < valid_options=( $( \
  9820. < echo "${COMP_WORDS[@]} ${options[@]}" \
  9821. < | tr " " "\n" \
  9822. < | sed -ne "/$( echo "${options[@]}" | sed "s/ /\\|/g" )/p" \
  9823. < | sort | uniq -u \
  9824. < ) )
  9825. < COMPREPLY=( $( compgen -W '${options[@]} ${services[@]}' \
  9826. < -X '$( echo ${COMP_WORDS[@]} | tr " " "|" )' -- $cur ) )
  9827. < elif [[ "$prev" == ?($( echo ${services[@]} | tr " " "|" )) ]]; then
  9828. < COMPREPLY=( $( compgen -W 'remove defaults start stop' -- $cur ) )
  9829. < elif [[ "$prev" == defaults && "$cur" == [0-9] ]]; then
  9830. < COMPREPLY=( 0 1 2 3 4 5 6 7 8 9 )
  9831. < elif [[ "$prev" == defaults && "$cur" == [sk]?([0-9]) ]]; then
  9832. < COMPREPLY=( 0 1 2 3 4 5 6 7 8 9 )
  9833. < elif [[ "$prev" == defaults && -z "$cur" ]]; then
  9834. < COMPREPLY=( 0 1 2 3 4 5 6 7 8 9 s k )
  9835. < elif [[ "$prev" == ?(start|stop) ]]; then
  9836. < if [[ "$cur" == [0-9] || -z "$cur" ]]; then
  9837. < COMPREPLY=( 0 1 2 3 4 5 6 7 8 9 )
  9838. < elif [[ "$cur" == [0-9][0-9] ]]; then
  9839. < COMPREPLY=( $cur )
  9840. < else
  9841. < COMPREPLY=()
  9842. < fi
  9843. < elif [[ "$prev" == ?([0-9][0-9]|[0-6S]) ]]; then
  9844. < if [[ -z "$cur" ]]; then
  9845. < if [[ $prev == [0-9][0-9] ]]; then
  9846. < COMPREPLY=( 0 1 2 3 4 5 6 S )
  9847. < else
  9848. < COMPREPLY=( 0 1 2 3 4 5 6 S . )
  9849. < fi
  9850. < elif [[ "$cur" == [0-6S.] ]]; then
  9851. < COMPREPLY=( $cur )
  9852. < else
  9853. < COMPREPLY=()
  9854. < fi
  9855. < elif [[ "$prev" == "." ]]; then
  9856. < COMPREPLY=( $(compgen -W "start stop" -- $cur) )
  9857. < else
  9858. < COMPREPLY=()
  9859. < fi
  9860. ---
  9861. > local cur func cline cspec noglob cmd i char_offset word_offset \
  9862. > _COMMAND_FUNC _COMMAND_FUNC_ARGS
  9863. 8779,8781c1422
  9864. < return 0
  9865. < } &&
  9866. < complete -F _update_rc_d update-rc.d
  9867. ---
  9868. > word_offset=$1
  9869. 8783,8815c1424,1452
  9870. < # invoke-rc.d(8) completion
  9871. < #
  9872. < # Copyright (C) 2004 Servilio Afre Puentes <[email protected]>
  9873. < #
  9874. < have invoke-rc.d &&
  9875. < _invoke_rc_d()
  9876. < {
  9877. < local cur prev sysvdir services options valid_options
  9878. <
  9879. < cur=`_get_cword`
  9880. < prev=${COMP_WORDS[COMP_CWORD-1]}
  9881. <
  9882. < [ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d \
  9883. < || sysvdir=/etc/init.d
  9884. <
  9885. < services=( $(echo $sysvdir/!(README*|*.sh|*.dpkg*|*.rpm*)) )
  9886. < services=( ${services[@]#$sysvdir/} )
  9887. < options=( --help --quiet --force --try-anyway --disclose-deny --query --no-fallback )
  9888. <
  9889. < if [[ ($COMP_CWORD -eq 1) || ("$prev" == --* ) ]]; then
  9890. < valid_options=( $( \
  9891. < echo ${COMP_WORDS[@]} ${options[@]} \
  9892. < | tr " " "\n" \
  9893. < | sed -ne "/$( echo ${options[@]} | sed "s/ /\\\\|/g" )/p" \
  9894. < | sort | uniq -u \
  9895. < ) )
  9896. < COMPREPLY=( $( compgen -W '${valid_options[@]} ${services[@]}' -- \
  9897. < $cur ) )
  9898. < elif [ -x $sysvdir/$prev ]; then
  9899. < COMPREPLY=( $( compgen -W '`sed -ne "y/|/ /; \
  9900. < s/^.*Usage:[ ]*[^ ]*[ ]*{*\([^}\"]*\).*$/\1/p" \
  9901. < $sysvdir/$prev`' -- \
  9902. < $cur ) )
  9903. ---
  9904. > # rewrite current completion context before invoking
  9905. > # actual command completion
  9906. >
  9907. > # find new first word position, then
  9908. > # rewrite COMP_LINE and adjust COMP_POINT
  9909. > local first_word=${COMP_WORDS[$word_offset]}
  9910. > for (( i=0; i <= ${#COMP_LINE}; i++ )); do
  9911. > if [[ "${COMP_LINE:$i:${#first_word}}" == "$first_word" ]]; then
  9912. > char_offset=$i
  9913. > break
  9914. > fi
  9915. > done
  9916. > COMP_LINE=${COMP_LINE:$char_offset}
  9917. > COMP_POINT=$(( COMP_POINT - $char_offset ))
  9918. >
  9919. > # shift COMP_WORDS elements and adjust COMP_CWORD
  9920. > for (( i=0; i <= COMP_CWORD - $word_offset; i++ )); do
  9921. > COMP_WORDS[i]=${COMP_WORDS[i+$word_offset]}
  9922. > done
  9923. > for (( i; i <= COMP_CWORD; i++ )); do
  9924. > unset COMP_WORDS[i];
  9925. > done
  9926. > COMP_CWORD=$(( $COMP_CWORD - $word_offset ))
  9927. >
  9928. > COMPREPLY=()
  9929. > _get_comp_words_by_ref cur
  9930. >
  9931. > if [[ $COMP_CWORD -eq 0 ]]; then
  9932. > COMPREPLY=( $( compgen -c -- "$cur" ) )
  9933. 8817c1454,1485
  9934. < COMPREPLY=()
  9935. ---
  9936. > cmd=${COMP_WORDS[0]}
  9937. > if complete -p $cmd &>/dev/null; then
  9938. > cspec=$( complete -p $cmd )
  9939. > if [ "${cspec#* -F }" != "$cspec" ]; then
  9940. > # complete -F <function>
  9941. >
  9942. > # get function name
  9943. > func=${cspec#*-F }
  9944. > func=${func%% *}
  9945. >
  9946. > if [[ ${#COMP_WORDS[@]} -ge 2 ]]; then
  9947. > $func $cmd "${COMP_WORDS[${#COMP_WORDS[@]}-1]}" "${COMP_WORDS[${#COMP_WORDS[@]}-2]}"
  9948. > else
  9949. > $func $cmd "${COMP_WORDS[${#COMP_WORDS[@]}-1]}"
  9950. > fi
  9951. >
  9952. > # remove any \: generated by a command that doesn't
  9953. > # default to filenames or dirnames (e.g. sudo chown)
  9954. > # FIXME: I'm pretty sure this does not work!
  9955. > if [ "${cspec#*-o }" != "$cspec" ]; then
  9956. > cspec=${cspec#*-o }
  9957. > cspec=${cspec%% *}
  9958. > if [[ "$cspec" != @(dir|file)names ]]; then
  9959. > COMPREPLY=("${COMPREPLY[@]//\\\\:/:}")
  9960. > fi
  9961. > fi
  9962. > elif [ -n "$cspec" ]; then
  9963. > cspec=${cspec#complete};
  9964. > cspec=${cspec%%$cmd};
  9965. > COMPREPLY=( $( eval compgen "$cspec" -- "$cur" ) );
  9966. > fi
  9967. > fi
  9968. 8820,8822c1488,1491
  9969. < return 0
  9970. < } &&
  9971. < complete -F _invoke_rc_d invoke-rc.d
  9972. ---
  9973. > [ ${#COMPREPLY[@]} -eq 0 ] && _filedir
  9974. > }
  9975. > complete -F _command -o filenames nohup exec nice eval time ltrace then \
  9976. > else do vsound command xargs tsocks aoss padsp
  9977. 8824,8827c1493
  9978. < # minicom(1) completion
  9979. < #
  9980. < have minicom &&
  9981. < _minicom()
  9982. ---
  9983. > _root_command()
  9984. 8829,9280c1495,1496
  9985. < local cur prev
  9986. <
  9987. < COMPREPLY=()
  9988. < cur=`_get_cword`
  9989. < prev=${COMP_WORDS[COMP_CWORD-1]}
  9990. <
  9991. < case $prev in
  9992. < -@(a|c))
  9993. < COMPREPLY=( $( compgen -W 'on off' -- $cur ) )
  9994. < return 0
  9995. < ;;
  9996. < -@(S|C))
  9997. < _filedir
  9998. < return 0
  9999. < ;;
  10000. < -P)
  10001. < COMPREPLY=( $( command ls /dev/tty* ) )
  10002. < COMPREPLY=( $( compgen -W '${COMPREPLY[@]} ${COMPREPLY[@]#/dev/}' -- $cur ) )
  10003. < return 0
  10004. < ;;
  10005. < esac
  10006. <
  10007. <
  10008. < if [[ "$cur" == -* ]]; then
  10009. < COMPREPLY=( $( compgen -W '-s -o -m -M -z -l -L -w -a -t \
  10010. < -c -S -d -p -C -T -8' -- $cur ) )
  10011. < else
  10012. < COMPREPLY=( $( command ls /etc/minicom/minirc.* 2>/dev/null | sed -e 's|/etc/minicom/minirc.||' | grep "^$cur" ) )
  10013. < fi
  10014. < } &&
  10015. < complete -F _minicom minicom
  10016. <
  10017. < # svn completion
  10018. < #
  10019. < have svn &&
  10020. < {
  10021. < _svn()
  10022. < {
  10023. < local cur prev commands options command
  10024. <
  10025. < COMPREPLY=()
  10026. < cur=`_get_cword`
  10027. <
  10028. < commands='add blame praise annotate ann cat checkout co cleanup commit \
  10029. < ci copy cp delete del remove rm diff di export help ? h import \
  10030. < info list ls lock log merge mkdir move mv rename ren \
  10031. < propdel pdel pd propedit pedit pe propget pget pg \
  10032. < proplist plist pl propset pset ps resolved revert \
  10033. < status stat st switch sw unlock update up'
  10034. <
  10035. < if [[ $COMP_CWORD -eq 1 ]] ; then
  10036. < if [[ "$cur" == -* ]]; then
  10037. < COMPREPLY=( $( compgen -W '--version' -- $cur ) )
  10038. < else
  10039. < COMPREPLY=( $( compgen -W "$commands" -- $cur ) )
  10040. < fi
  10041. < else
  10042. <
  10043. < prev=${COMP_WORDS[COMP_CWORD-1]}
  10044. < case $prev in
  10045. < --config-dir)
  10046. < _filedir -d
  10047. < return 0;
  10048. < ;;
  10049. < -@(F|-file|-targets))
  10050. < _filedir
  10051. < return 0;
  10052. < ;;
  10053. < --encoding)
  10054. < COMPREPLY=( $( compgen -W \
  10055. < '$( iconv --list | sed -e "s@//@@;" )' \
  10056. < -- "$cur" ) )
  10057. < return 0;
  10058. < ;;
  10059. < --@(editor|diff|diff3)-cmd)
  10060. < COMP_WORDS=(COMP_WORDS[0] $cur)
  10061. < COMP_CWORD=1
  10062. < _command
  10063. < return 0;
  10064. < ;;
  10065. < esac
  10066. <
  10067. < command=${COMP_WORDS[1]}
  10068. <
  10069. < if [[ "$cur" == -* ]]; then
  10070. < # possible options for the command
  10071. < case $command in
  10072. < add)
  10073. < options='--auto-props --no-auto-props \
  10074. < --force --targets --no-ignore \
  10075. < --non-recursive -N -q --quiet'
  10076. < ;;
  10077. < @(blame|annotate|ann|praise))
  10078. < options='-r --revisions --username \
  10079. < --password --no-auth-cache \
  10080. < --non-interactive -v \
  10081. < --verbose --incremental --xml'
  10082. < ;;
  10083. < cat)
  10084. < options='-r --revision --username \
  10085. < --password --no-auth-cache \
  10086. < --non-interactive'
  10087. < ;;
  10088. < @(checkout|co))
  10089. < options='-r --revision -q --quiet -N \
  10090. < --non-recursive --username \
  10091. < --password --no-auth-cache \
  10092. < --non-interactive \
  10093. < --ignore-externals'
  10094. < ;;
  10095. < cleanup)
  10096. < options='--diff3-cmd'
  10097. < ;;
  10098. < @(commit|ci))
  10099. < options='-m --message -F --file \
  10100. < --encoding --force-log -q \
  10101. < --quiet --non-recursive -N \
  10102. < --targets --editor-cmd \
  10103. < --username --password \
  10104. < --no-auth-cache \
  10105. < --non-interactive --no-unlock'
  10106. < ;;
  10107. < @(copy|cp))
  10108. < options='-m --message -F --file \
  10109. < --encoding --force-log -r \
  10110. < --revision -q --quiet \
  10111. < --editor-cmd -username \
  10112. < --password --no-auth-cache \
  10113. < --non-interactive'
  10114. < ;;
  10115. < @(delete|del|remove|rm))
  10116. < options='--force -m --message -F \
  10117. < --file --encoding --force-log \
  10118. < -q --quiet --targets \
  10119. < --editor-cmd -username \
  10120. < --password --no-auth-cache \
  10121. < --non-interactive'
  10122. < ;;
  10123. < @(diff|di))
  10124. < options='-r --revision -x --extensions \
  10125. < --diff-cmd --no-diff-deleted \
  10126. < -N --non-recursive --username \
  10127. < --password --no-auth-cache \
  10128. < --non-interactive --force \
  10129. < --old --new --notice-ancestry'
  10130. < ;;
  10131. < export)
  10132. < options='-r --revision -q --quiet \
  10133. < --username --password \
  10134. < --no-auth-cache \
  10135. < --non-interactive -N \
  10136. < --non-recursive --force \
  10137. < --native-eol --ignore-externals'
  10138. < ;;
  10139. < import)
  10140. < options='--auto-props --no-auto-props \
  10141. < -m --message -F --file \
  10142. < --encoding --force-log -q \
  10143. < --quiet --non-recursive \
  10144. < --no-ignore --editor-cmd \
  10145. < --username --password \
  10146. < --no-auth-cache \
  10147. < --non-interactive'
  10148. < ;;
  10149. < info)
  10150. < options='--username --password \
  10151. < --no-auth-cache \
  10152. < --non-interactive -r \
  10153. < --revision --xml --targets \
  10154. < -R --recursive --incremental'
  10155. < ;;
  10156. < @(list|ls))
  10157. < options='-r --revision -v --verbose -R \
  10158. < --recursive --username \
  10159. < --password --no-auth-cache \
  10160. < --non-interactive \
  10161. < --incremental --xml'
  10162. < ;;
  10163. < lock)
  10164. < options='-m --message -F --file \
  10165. < --encoding --force-log \
  10166. < --targets --force --username \
  10167. < --password --no-auth-cache \
  10168. < --non-interactive'
  10169. < ;;
  10170. < log)
  10171. < options='-r --revision -v --verbose \
  10172. < --targets --username \
  10173. < --password --no-auth-cache \
  10174. < --non-interactive \
  10175. < --stop-on-copy --incremental \
  10176. < --xml -q --quiet --limit'
  10177. < ;;
  10178. < merge)
  10179. < options='-r --revision -N \
  10180. < --non-recursive -q --quiet \
  10181. < --force --dry-run --diff3-cmd \
  10182. < --username --password \
  10183. < --no-auth-cache \
  10184. < --non-interactive \
  10185. < --ignore-ancestry'
  10186. < ;;
  10187. < mkdir)
  10188. < options='-m --message -F --file \
  10189. < --encoding --force-log -q \
  10190. < --quiet --editor-cmd \
  10191. < --username --password \
  10192. < --no-auth-cache \
  10193. < --non-interactive'
  10194. < ;;
  10195. < @(move|mv|rename|ren))
  10196. < options='-m --message -F --file \
  10197. < --encoding --force-log -r \
  10198. < --revision -q --quiet \
  10199. < --force --editor-cmd \
  10200. < --username --password \
  10201. < --no-auth-cache \
  10202. < --non-interactive'
  10203. < ;;
  10204. < @(propdel|pdel|pd))
  10205. < options='-q --quiet -R --recursive -r \
  10206. < --revision --revprop \
  10207. < --username --password \
  10208. < --no-auth-cache \
  10209. < --non-interactive'
  10210. < ;;
  10211. < @(propedit|pedit|pe))
  10212. < options='-r --revision --revprop \
  10213. < --encoding --editor-cmd \
  10214. < --username --password \
  10215. < --no-auth-cache \
  10216. < --non-interactive --force'
  10217. < ;;
  10218. < @(propget|pget|pg))
  10219. < options='-R --recursive -r --revision \
  10220. < --revprop --strict --username \
  10221. < --password --no-auth-cache \
  10222. < --non-interactive'
  10223. < ;;
  10224. < @(proplist|plist|pl))
  10225. < options='-v --verbose -R --recursive \
  10226. < -r --revision --revprop -q \
  10227. < --quiet --username --password \
  10228. < --no-auth-cache \
  10229. < --non-interactive'
  10230. < ;;
  10231. < @(propset|pset|ps))
  10232. < options='-F --file -q --quiet \
  10233. < --targets -R --recursive \
  10234. < --revprop --encoding \
  10235. < --username --password \
  10236. < --no-auth-cache \
  10237. < --non-interactive -r \
  10238. < --revision --force'
  10239. < ;;
  10240. < resolved)
  10241. < options='--targets -R --recursive -q \
  10242. < --quiet'
  10243. < ;;
  10244. < revert)
  10245. < options='--targets -R --recursive -q \
  10246. < --quiet'
  10247. < ;;
  10248. < @(status|stat|st))
  10249. < options='-u --show-updates -v \
  10250. < --verbose -N --non-recursive \
  10251. < -q --quiet --username \
  10252. < --password --no-auth-cache \
  10253. < --non-interactive --no-ignore \
  10254. < --ignore-externals \
  10255. < --incremental --xml'
  10256. < ;;
  10257. < @(switch|sw))
  10258. < options='--relocate -r --revision -N \
  10259. < --non-recursive -q --quiet \
  10260. < --username --password \
  10261. < --no-auth-cache \
  10262. < --non-interactive --diff3-cmd'
  10263. < ;;
  10264. < unlock)
  10265. < options='--targets --force --username \
  10266. < --password --no-auth-cache \
  10267. < --non-interactive'
  10268. < ;;
  10269. < @(update|up))
  10270. < options='-r --revision -N \
  10271. < --non-recursive -q --quiet \
  10272. < --username --password \
  10273. < --no-auth-cache \
  10274. < --non-interactive \
  10275. < --diff3-cmd --ignore-externals'
  10276. < ;;
  10277. < esac
  10278. < options="$options --help -h --config-dir"
  10279. <
  10280. < COMPREPLY=( $( compgen -W "$options" -- $cur ) )
  10281. < else
  10282. < if [[ "$command" == @(help|h|\?) ]]; then
  10283. < COMPREPLY=( $( compgen -W "$commands" -- $cur ) )
  10284. < else
  10285. < _filedir
  10286. < fi
  10287. < fi
  10288. < fi
  10289. <
  10290. < return 0
  10291. < }
  10292. < complete -F _svn $default svn
  10293. <
  10294. < _svnadmin()
  10295. < {
  10296. < local cur prev commands options mode
  10297. <
  10298. < COMPREPLY=()
  10299. < cur=`_get_cword`
  10300. <
  10301. < commands='create deltify dump help ? hotcopy list-dblogs \
  10302. < list-unused-dblogs load lslocks lstxns recover rmlocks \
  10303. < rmtxns setlog verify'
  10304. <
  10305. < if [[ $COMP_CWORD -eq 1 ]] ; then
  10306. < if [[ "$cur" == -* ]]; then
  10307. < COMPREPLY=( $( compgen -W '--version' -- $cur ) )
  10308. < else
  10309. < COMPREPLY=( $( compgen -W "$commands" -- $cur ) )
  10310. < fi
  10311. < else
  10312. < prev=${COMP_WORDS[COMP_CWORD-1]}
  10313. < case $prev in
  10314. < --config-dir)
  10315. < _filedir -d
  10316. < return 0;
  10317. < ;;
  10318. < --fs-type)
  10319. < COMPREPLY=( $( compgen -W 'fsfs bdb' -- $cur ) )
  10320. < return 0;
  10321. < ;;
  10322. < esac
  10323. <
  10324. < command=${COMP_WORDS[1]}
  10325. <
  10326. < if [[ "$cur" == -* ]]; then
  10327. < # possible options for the command
  10328. < case $command in
  10329. < create)
  10330. < options='--bdb-txn-nosync \
  10331. < --bdb-log-keep --config-dir \
  10332. < --fs-type'
  10333. < ;;
  10334. < deltify)
  10335. < options='-r --revision -q --quiet'
  10336. < ;;
  10337. < dump)
  10338. < options='-r --revision --incremental \
  10339. < -q --quiet --deltas'
  10340. < ;;
  10341. < hotcopy)
  10342. < options='--clean-logs'
  10343. < ;;
  10344. < load)
  10345. < options='--ignore-uuid --force-uuid \
  10346. < --parent-dir -q --quiet \
  10347. < --use-pre-commit-hook \
  10348. < --use-post-commit-hook'
  10349. < ;;
  10350. < rmtxns)
  10351. < options='-q --quiet'
  10352. < ;;
  10353. < setlog)
  10354. < options='-r --revision --bypass-hooks'
  10355. < ;;
  10356. < esac
  10357. <
  10358. < options="$options --help -h"
  10359. < COMPREPLY=( $( compgen -W "$options" -- $cur ) )
  10360. < else
  10361. < if [[ "$command" == @(help|h|\?) ]]; then
  10362. < COMPREPLY=( $( compgen -W "$commands" -- $cur ) )
  10363. < else
  10364. < _filedir
  10365. < fi
  10366. < fi
  10367. < fi
  10368. <
  10369. < return 0
  10370. < }
  10371. < complete -F _svnadmin $default svnadmin
  10372. <
  10373. < _svnlook()
  10374. < {
  10375. < local cur prev commands options mode
  10376. <
  10377. < COMPREPLY=()
  10378. < cur=`_get_cword`
  10379. <
  10380. < commands='author cat changed date diff dirs-changed help ? h history \
  10381. < info lock log propget pget pg proplist plist pl tree uuid \
  10382. < youngest'
  10383. <
  10384. < if [[ $COMP_CWORD -eq 1 ]] ; then
  10385. < if [[ "$cur" == -* ]]; then
  10386. < COMPREPLY=( $( compgen -W '--version' -- $cur ) )
  10387. < else
  10388. < COMPREPLY=( $( compgen -W "$commands" -- $cur ) )
  10389. < fi
  10390. < else
  10391. < command=${COMP_WORDS[1]}
  10392. <
  10393. < if [[ "$cur" == -* ]]; then
  10394. < # possible options for the command
  10395. < case $command in
  10396. < @(author|cat|date|dirs-changed|info|log))
  10397. < options='-r --revision -t \
  10398. < --transaction'
  10399. < ;;
  10400. < changed)
  10401. < options='-r --revision -t \
  10402. < --transaction --copy-info'
  10403. < ;;
  10404. < diff)
  10405. < options='-r --revision -t \
  10406. < --transaction \
  10407. < --no-diff-deleted \
  10408. < --no-diff-added \
  10409. < --diff-copy-from'
  10410. < ;;
  10411. < history)
  10412. < options='-r --revision --show-ids'
  10413. < ;;
  10414. < prop@(get|list))
  10415. < options='-r --revision -t \
  10416. < --transaction --revprop'
  10417. < ;;
  10418. < tree)
  10419. < options='-r --revision -t \
  10420. < --transaction --show-ids \
  10421. < --full-paths'
  10422. < ;;
  10423. < esac
  10424. <
  10425. < options="$options --help -h"
  10426. < COMPREPLY=( $( compgen -W "$options" -- $cur ) )
  10427. < else
  10428. < if [[ "$command" == @(help|h|\?) ]]; then
  10429. < COMPREPLY=( $( compgen -W "$commands" -- $cur ) )
  10430. < else
  10431. < _filedir
  10432. < fi
  10433. < fi
  10434. < fi
  10435. <
  10436. < return 0
  10437. ---
  10438. > local PATH=$PATH:/sbin:/usr/sbin:/usr/local/sbin
  10439. > _command $1 $2 $3
  10440. 9282c1498,1526
  10441. < complete -F _svnlook $default svnlook
  10442. ---
  10443. > complete -F _root_command -o filenames sudo fakeroot really gksudo gksu kdesudo
  10444. >
  10445. > _longopt()
  10446. > {
  10447. > local cur prev
  10448. >
  10449. > _get_comp_words_by_ref cur prev
  10450. >
  10451. > if _split_longopt; then
  10452. > case "$prev" in
  10453. > *[Dd][Ii][Rr]*)
  10454. > _filedir -d
  10455. > ;;
  10456. > *[Ff][Ii][Ll][Ee]*)
  10457. > _filedir
  10458. > ;;
  10459. > esac
  10460. > return 0
  10461. > fi
  10462. >
  10463. > if [[ "$cur" == -* ]]; then
  10464. > COMPREPLY=( $( compgen -W "$( $1 --help 2>&1 | \
  10465. > sed -ne 's/.*\(--[-A-Za-z0-9]\{1,\}\).*/\1/p' | sort -u )" \
  10466. > -- "$cur" ) )
  10467. > elif [[ "$1" == rmdir ]]; then
  10468. > _filedir -d
  10469. > else
  10470. > _filedir
  10471. > fi
  10472. 9283a1528,1542
  10473. > # makeinfo and texi2dvi are defined elsewhere.
  10474. > for i in a2ps autoconf automake bc gprof ld nm objcopy objdump readelf strip \
  10475. > bison colordiff diff patch enscript cp df dir du ln ls mkfifo mknod mv rm \
  10476. > touch vdir awk gperf grep grub indent less m4 sed shar date \
  10477. > tee who texindex cat csplit cut expand fmt fold head \
  10478. > md5sum nl od paste pr ptx sha1sum sort split tac tail tr unexpand \
  10479. > uniq wc ldd bash id irb mkdir rmdir wget curl; do
  10480. > have $i && complete -F _longopt -o filenames $i
  10481. > done
  10482. >
  10483. > # These commands do not use filenames, so '-o filenames' is not needed.
  10484. > for i in env netstat seq uname units; do
  10485. > have $i && complete -F _longopt -o default $i
  10486. > done
  10487. > unset i
  10488. 9287c1546,1550
  10489. < local IFS cur xspec
  10490. ---
  10491. > local IFS cur xspec
  10492. >
  10493. > IFS=$'\t\n'
  10494. > COMPREPLY=()
  10495. > _get_comp_words_by_ref cur
  10496. 9289,9321c1552,1597
  10497. < IFS=$'\t\n'
  10498. < COMPREPLY=()
  10499. < cur=`_get_cword`
  10500. <
  10501. < _expand || return 0
  10502. <
  10503. < # get first exclusion compspec that matches this command
  10504. < xspec=$( sed -ne $'/^complete .*[ \t]'${1##*/}$'\([ \t]\|$\)/{p;q;}' \
  10505. < $BASH_COMPLETION )
  10506. < # prune to leave nothing but the -X spec
  10507. < xspec=${xspec#*-X }
  10508. < xspec=${xspec%% *}
  10509. <
  10510. < COMPREPLY=( $( eval compgen -f -X "$xspec" -- \
  10511. < \"${cur#[\`\"\']}\" 2>/dev/null ) \
  10512. < $( compgen -d -- $cur ) )
  10513. < }
  10514. < list=( $( sed -ne '/^# START exclude/,/^# FINISH exclude/p' \
  10515. < $BASH_COMPLETION | \
  10516. < # read exclusion compspecs
  10517. < (
  10518. < while read line
  10519. < do
  10520. < # ignore compspecs that are commented out
  10521. < if [ "${line#\#}" != "$line" ]; then continue; fi
  10522. < line=${line%# START exclude*}
  10523. < line=${line%# FINISH exclude*}
  10524. < line=${line##*\'}
  10525. < list=( ${list[@]:-} $line )
  10526. < done
  10527. < echo ${list[@]}
  10528. < )
  10529. < ) )
  10530. ---
  10531. > _expand || return 0
  10532. >
  10533. > # get first exclusion compspec that matches this command
  10534. > xspec=$( awk "/^complete[ \t]+.*[ \t]${1##*/}([ \t]|\$)/ { print \$0; exit }" \
  10535. > "$BASH_COMPLETION" )
  10536. > # prune to leave nothing but the -X spec
  10537. > xspec=${xspec#*-X }
  10538. > xspec=${xspec%% *}
  10539. >
  10540. > local -a toks
  10541. > local tmp
  10542. >
  10543. > toks=( ${toks[@]-} $(
  10544. > compgen -d -- "$(quote_readline "$cur")" | {
  10545. > while read -r tmp; do
  10546. > # see long TODO comment in _filedir() --David
  10547. > printf '%s\n' $tmp
  10548. > done
  10549. > }
  10550. > ))
  10551. >
  10552. > toks=( ${toks[@]-} $(
  10553. > eval compgen -f -X "$xspec" -- "\$(quote_readline "\$cur")" | {
  10554. > while read -r tmp; do
  10555. > [ -n $tmp ] && printf '%s\n' $tmp
  10556. > done
  10557. > }
  10558. > ))
  10559. >
  10560. > COMPREPLY=( "${toks[@]}" )
  10561. > }
  10562. > list=( $( sed -ne '/^# START exclude/,/^# FINISH exclude/p' "$BASH_COMPLETION" | \
  10563. > # read exclusion compspecs
  10564. > (
  10565. > while read line
  10566. > do
  10567. > # ignore compspecs that are commented out
  10568. > if [ "${line#\#}" != "$line" ]; then continue; fi
  10569. > line=${line%# START exclude*}
  10570. > line=${line%# FINISH exclude*}
  10571. > line=${line##*\'}
  10572. > list=( "${list[@]}" $line )
  10573. > done
  10574. > printf '%s ' "${list[@]}"
  10575. > )
  10576. > ) )
  10577. 9326c1602
  10578. < eval complete -F _filedir_xspec $filenames ${list[@]}
  10579. ---
  10580. > eval complete -F _filedir_xspec -o filenames "${list[@]}"
  10581. 9331,9336c1607,1622
  10582. < if [ -d $BASH_COMPLETION_DIR -a -r $BASH_COMPLETION_DIR -a \
  10583. < -x $BASH_COMPLETION_DIR ]; then
  10584. < for i in $BASH_COMPLETION_DIR/*; do
  10585. < [[ ${i##*/} != @(*~|*.bak|*.swp|\#*\#|*.dpkg*|.rpm*) ]] &&
  10586. < [ \( -f $i -o -h $i \) -a -r $i ] && . $i
  10587. < done
  10588. ---
  10589. > if [[ -d $BASH_COMPLETION_COMPAT_DIR && -r $BASH_COMPLETION_COMPAT_DIR && \
  10590. > -x $BASH_COMPLETION_COMPAT_DIR ]]; then
  10591. > for i in $(LC_ALL=C command ls "$BASH_COMPLETION_COMPAT_DIR"); do
  10592. > i=$BASH_COMPLETION_COMPAT_DIR/$i
  10593. > [[ ${i##*/} != @(*~|*.bak|*.swp|\#*\#|*.dpkg*|*.rpm@(orig|new|save)) \
  10594. > && ( -f $i || -h $i ) && -r $i ]] && . "$i"
  10595. > done
  10596. > fi
  10597. > if [[ $BASH_COMPLETION_DIR != $BASH_COMPLETION_COMPAT_DIR && \
  10598. > -d $BASH_COMPLETION_DIR && -r $BASH_COMPLETION_DIR && \
  10599. > -x $BASH_COMPLETION_DIR ]]; then
  10600. > for i in $(LC_ALL=C command ls "$BASH_COMPLETION_DIR"); do
  10601. > i=$BASH_COMPLETION_DIR/$i
  10602. > [[ ${i##*/} != @(*~|*.bak|*.swp|\#*\#|*.dpkg*|*.rpm@(orig|new|save)) \
  10603. > && ( -f $i || -h $i ) && -r $i ]] && . "$i"
  10604. > done
  10605. 9341,9342c1627,1628
  10606. < [ $BASH_COMPLETION != ~/.bash_completion -a -r ~/.bash_completion ] \
  10607. < && . ~/.bash_completion
  10608. ---
  10609. > [[ $BASH_COMPLETION != ~/.bash_completion && -r ~/.bash_completion ]] \
  10610. > && . ~/.bash_completion
  10611. 9344,9345c1630,1633
  10612. < unset UNAME RELEASE default dirnames filenames have nospace bashdefault \
  10613. < plusdirs
  10614. ---
  10615. > unset UNAME USERLAND have
  10616. >
  10617. > set $BASH_COMPLETION_ORIGINAL_V_VALUE
  10618. > unset BASH_COMPLETION_ORIGINAL_V_VALUE
  10619. 9347,9349c1635,1641
  10620. < ### Local Variables:
  10621. < ### mode: shell-script
  10622. < ### End:
  10623. ---
  10624. > # Local variables:
  10625. > # mode: shell-script
  10626. > # sh-basic-offset: 4
  10627. > # sh-indent-comment: t
  10628. > # indent-tabs-mode: nil
  10629. > # End:
  10630. > # ex: ts=4 sw=4 et filetype=sh
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!