| 1 | #
|
|---|
| 2 | # Completion examples
|
|---|
| 3 | #
|
|---|
| 4 |
|
|---|
| 5 | #
|
|---|
| 6 | # This encapsulates the default bash completion code
|
|---|
| 7 | # call with the word to be completed as $1
|
|---|
| 8 | #
|
|---|
| 9 | # Since programmable completion does not use the bash default completions
|
|---|
| 10 | # or the readline default of filename completion when the compspec does
|
|---|
| 11 | # not generate any matches, this may be used as a `last resort' in a
|
|---|
| 12 | # completion function to mimic the default bash completion behavior.
|
|---|
| 13 | #
|
|---|
| 14 | _bash_def_completion ()
|
|---|
| 15 | {
|
|---|
| 16 | local h t
|
|---|
| 17 | COMPREPLY=()
|
|---|
| 18 |
|
|---|
| 19 | # command substitution
|
|---|
| 20 | if [[ "$1" == \$\(* ]]; then
|
|---|
| 21 | t=${1#??}
|
|---|
| 22 | COMPREPLY=( $(compgen -c -P '$(' $t) )
|
|---|
| 23 | fi
|
|---|
| 24 | # variables with a leading `${'
|
|---|
| 25 | if [ ${#COMPREPLY[@]} -eq 0 ] && [[ "$1" == \$\{* ]]; then
|
|---|
| 26 | t=${1#??}
|
|---|
| 27 | COMPREPLY=( $(compgen -v -P '${' -S '}' $t) )
|
|---|
| 28 | fi
|
|---|
| 29 | # variables with a leading `$'
|
|---|
| 30 | if [ ${#COMPREPLY[@]} -eq 0 ] && [[ "$1" == \$* ]]; then
|
|---|
| 31 | t=${1#?}
|
|---|
| 32 | COMPREPLY=( $(compgen -v -P '$' $t ) )
|
|---|
| 33 | fi
|
|---|
| 34 | # username expansion
|
|---|
| 35 | if [ ${#COMPREPLY[@]} -eq 0 ] && [[ "$1" == ~* ]] && [[ "$1" != */* ]]; then
|
|---|
| 36 | t=${1#?}
|
|---|
| 37 | COMPREPLY=( $( compgen -u -P '~' $t ) )
|
|---|
| 38 | fi
|
|---|
| 39 | # hostname
|
|---|
| 40 | if [ ${#COMPREPLY[@]} -eq 0 ] && [[ "$1" == *@* ]]; then
|
|---|
| 41 | h=${1%%@*}
|
|---|
| 42 | t=${1#*@}
|
|---|
| 43 | COMPREPLY=( $( compgen -A hostname -P "${h}@" $t ) )
|
|---|
| 44 | fi
|
|---|
| 45 | # glob pattern
|
|---|
| 46 | if [ ${#COMPREPLY[@]} -eq 0 ]; then
|
|---|
| 47 | # sh-style glob pattern
|
|---|
| 48 | if [[ $1 == *[*?[]* ]]; then
|
|---|
| 49 | COMPREPLY=( $( compgen -G "$1" ) )
|
|---|
| 50 | # ksh-style extended glob pattern - must be complete
|
|---|
| 51 | elif shopt -q extglob && [[ $1 == *[?*+\!@]\(*\)* ]]; then
|
|---|
| 52 | COMPREPLY=( $( compgen -G "$1" ) )
|
|---|
| 53 | fi
|
|---|
| 54 | fi
|
|---|
| 55 |
|
|---|
| 56 | # final default is filename completion
|
|---|
| 57 | if [ ${#COMPREPLY[@]} -eq 0 ]; then
|
|---|
| 58 | COMPREPLY=( $(compgen -f "$1" ) )
|
|---|
| 59 | fi
|
|---|
| 60 | }
|
|---|
| 61 |
|
|---|
| 62 | #
|
|---|
| 63 | # Return 1 if $1 appears to contain a redirection operator. Handles backslash
|
|---|
| 64 | # quoting (barely).
|
|---|
| 65 | #
|
|---|
| 66 | _redir_op()
|
|---|
| 67 | {
|
|---|
| 68 | case "$1" in
|
|---|
| 69 | *\\'[\<\>]'*) return 1;;
|
|---|
| 70 | *[\<\>]*) return 0;;
|
|---|
| 71 | *) return 1;;
|
|---|
| 72 | esac
|
|---|
| 73 | }
|
|---|
| 74 |
|
|---|
| 75 |
|
|---|
| 76 | # _redir_test tests the current word ($1) and the previous word ($2) for
|
|---|
| 77 | # redirection operators and does filename completion on the current word
|
|---|
| 78 | # if either one contains a redirection operator
|
|---|
| 79 | _redir_test()
|
|---|
| 80 | {
|
|---|
| 81 | if _redir_op "$1" ; then
|
|---|
| 82 | COMPREPLY=( $( compgen -f "$1" ) )
|
|---|
| 83 | return 0
|
|---|
| 84 | elif _redir_op "$2" ; then
|
|---|
| 85 | COMPREPLY=( $( compgen -f "$1" ) )
|
|---|
| 86 | return 0
|
|---|
| 87 | fi
|
|---|
| 88 | return 1
|
|---|
| 89 | }
|
|---|
| 90 |
|
|---|
| 91 | # optional, but without this you can't use extended glob patterns
|
|---|
| 92 | shopt -s extglob
|
|---|
| 93 |
|
|---|
| 94 | #
|
|---|
| 95 | # Easy ones for the shell builtins
|
|---|
| 96 | #
|
|---|
| 97 | # nothing for: alias, break, continue, dirs, echo, eval, exit, getopts,
|
|---|
| 98 | # let, logout, popd, printf, pwd, return, shift, suspend, test, times,
|
|---|
| 99 | # umask
|
|---|
| 100 | #
|
|---|
| 101 |
|
|---|
| 102 | complete -f -- . source
|
|---|
| 103 | complete -A enabled builtin
|
|---|
| 104 | complete -d cd
|
|---|
| 105 |
|
|---|
| 106 | # this isn't exactly right yet -- needs to skip shell functions and
|
|---|
| 107 | # do $PATH lookup (or do compgen -c and filter out matches that also
|
|---|
| 108 | # appear in compgen -A function)
|
|---|
| 109 | complete -c command
|
|---|
| 110 |
|
|---|
| 111 | # could add -S '=', but that currently screws up because readline appends
|
|---|
| 112 | # a space unconditionally
|
|---|
| 113 |
|
|---|
| 114 | complete -v export local readonly
|
|---|
| 115 | complete -A helptopic help # currently same as builtins
|
|---|
| 116 |
|
|---|
| 117 | complete -d pushd
|
|---|
| 118 |
|
|---|
| 119 | complete -A shopt shopt
|
|---|
| 120 |
|
|---|
| 121 | complete -c type
|
|---|
| 122 |
|
|---|
| 123 | complete -a unalias
|
|---|
| 124 | complete -v unset
|
|---|
| 125 |
|
|---|
| 126 | #
|
|---|
| 127 | # Job control builtins: fg, bg, disown, kill, wait
|
|---|
| 128 | # kill not done yet
|
|---|
| 129 | #
|
|---|
| 130 |
|
|---|
| 131 | complete -A stopped -P '%' bg
|
|---|
| 132 | complete -j -P '%' fg jobs disown
|
|---|
| 133 |
|
|---|
| 134 | # this is not quite right at this point
|
|---|
| 135 |
|
|---|
| 136 | _wait_func ()
|
|---|
| 137 | {
|
|---|
| 138 | local cur
|
|---|
| 139 | cur=${COMP_WORDS[COMP_CWORD]}
|
|---|
| 140 |
|
|---|
| 141 | case "$cur" in
|
|---|
| 142 | %*) COMPREPLY=( $(compgen -A running -P '%' ${cur#?} ) ) ;;
|
|---|
| 143 | [0-9]*) COMPREPLY=( $(jobs -p | grep ^${cur}) ) ;;
|
|---|
| 144 | *) COMPREPLY=( $(compgen -A running -P '%') $(jobs -p) )
|
|---|
| 145 | ;;
|
|---|
| 146 | esac
|
|---|
| 147 | }
|
|---|
| 148 | complete -F _wait_func wait
|
|---|
| 149 |
|
|---|
| 150 | #
|
|---|
| 151 | # more complicated things, several as yet unimplemented
|
|---|
| 152 | #
|
|---|
| 153 |
|
|---|
| 154 | #complete -F _bind_func bind
|
|---|
| 155 |
|
|---|
| 156 | _declare_func()
|
|---|
| 157 | {
|
|---|
| 158 | local cur prev nflag opts
|
|---|
| 159 |
|
|---|
| 160 | cur=${COMP_WORDS[COMP_CWORD]}
|
|---|
| 161 | prev=${COMP_WORDS[COMP_CWORD-1]}
|
|---|
| 162 |
|
|---|
| 163 | COMPREPLY=()
|
|---|
| 164 | if (( $COMP_CWORD <= 1 )) || [[ $cur == '-' ]]; then
|
|---|
| 165 | COMPREPLY=(-a -f -F -i -p -r -t -x)
|
|---|
| 166 | return 0;
|
|---|
| 167 | fi
|
|---|
| 168 | if [[ $cur == '+' ]]; then
|
|---|
| 169 | COMPREPLY=(+i +t +x)
|
|---|
| 170 | return 0;
|
|---|
| 171 | fi
|
|---|
| 172 | if [[ $prev == '-p' ]]; then
|
|---|
| 173 | COMPREPLY=( $(compgen -v $cur) )
|
|---|
| 174 | return 0;
|
|---|
| 175 | fi
|
|---|
| 176 | return 1
|
|---|
| 177 | }
|
|---|
| 178 | complete -F _declare_func declare typeset
|
|---|
| 179 |
|
|---|
| 180 | _enable_func()
|
|---|
| 181 | {
|
|---|
| 182 | local cur prev nflag opts
|
|---|
| 183 |
|
|---|
| 184 | cur=${COMP_WORDS[COMP_CWORD]}
|
|---|
| 185 | prev=${COMP_WORDS[COMP_CWORD-1]}
|
|---|
| 186 |
|
|---|
| 187 | COMPREPLY=()
|
|---|
| 188 | if (( $COMP_CWORD <= 1 )) || [[ $cur == '-' ]]; then
|
|---|
| 189 | COMPREPLY=(-a -d -f -n -p -s)
|
|---|
| 190 | return 0;
|
|---|
| 191 | fi
|
|---|
| 192 | if [[ $prev == '-f' ]]; then
|
|---|
| 193 | COMPREPLY=( $( compgen -f $cur ) )
|
|---|
| 194 | return 0;
|
|---|
| 195 | fi
|
|---|
| 196 | for opts in "${COMP_WORDS[@]}" ; do
|
|---|
| 197 | if [[ $opts == -*n* ]]; then nflag=1; fi
|
|---|
| 198 | done
|
|---|
| 199 |
|
|---|
| 200 | if [ -z "$nflag" ] ; then
|
|---|
| 201 | COMPREPLY=( $( compgen -A enabled $cur ) )
|
|---|
| 202 | else
|
|---|
| 203 | COMPREPLY=( $( compgen -A disabled $cur ) )
|
|---|
| 204 | fi
|
|---|
| 205 | return 0;
|
|---|
| 206 | }
|
|---|
| 207 | complete -F _enable_func enable
|
|---|
| 208 |
|
|---|
| 209 | _exec_func()
|
|---|
| 210 | {
|
|---|
| 211 | local cur prev
|
|---|
| 212 |
|
|---|
| 213 | cur=${COMP_WORDS[COMP_CWORD]}
|
|---|
| 214 | prev=${COMP_WORDS[COMP_CWORD-1]}
|
|---|
| 215 |
|
|---|
| 216 | if (( $COMP_CWORD <= 1 )) || [[ $cur == '-' ]]; then
|
|---|
| 217 | COMPREPLY=(-a -c -l)
|
|---|
| 218 | return 0;
|
|---|
| 219 | fi
|
|---|
| 220 | if [[ $prev != -*a* ]]; then
|
|---|
| 221 | COMPREPLY=( $( compgen -c $cur ) )
|
|---|
| 222 | return 0
|
|---|
| 223 | fi
|
|---|
| 224 | return 1;
|
|---|
| 225 | }
|
|---|
| 226 | complete -F _exec_func exec
|
|---|
| 227 |
|
|---|
| 228 | _fc_func()
|
|---|
| 229 | {
|
|---|
| 230 | local cur prev
|
|---|
| 231 |
|
|---|
| 232 | cur=${COMP_WORDS[COMP_CWORD]}
|
|---|
| 233 | prev=${COMP_WORDS[COMP_CWORD-1]}
|
|---|
| 234 |
|
|---|
| 235 | if (( $COMP_CWORD <= 1 )) || [[ $cur == '-' ]]; then
|
|---|
| 236 | COMPREPLY=(-e -n -l -r -s)
|
|---|
| 237 | return 0;
|
|---|
| 238 | fi
|
|---|
| 239 | if [[ $prev == -*e ]]; then
|
|---|
| 240 | COMPREPLY=( $(compgen -c $cur) )
|
|---|
| 241 | return 0
|
|---|
| 242 | fi
|
|---|
| 243 | return 1
|
|---|
| 244 | }
|
|---|
| 245 | complete -F _fc_func fc
|
|---|
| 246 |
|
|---|
| 247 | _hash_func()
|
|---|
| 248 | {
|
|---|
| 249 | local cur prev
|
|---|
| 250 |
|
|---|
| 251 | cur=${COMP_WORDS[COMP_CWORD]}
|
|---|
| 252 | prev=${COMP_WORDS[COMP_CWORD-1]}
|
|---|
| 253 |
|
|---|
| 254 | if (( $COMP_CWORD <= 1 )) || [[ $cur == '-' ]]; then
|
|---|
| 255 | COMPREPLY=(-p -r -t)
|
|---|
| 256 | return 0;
|
|---|
| 257 | fi
|
|---|
| 258 |
|
|---|
| 259 | if [[ $prev == '-p' ]]; then
|
|---|
| 260 | COMPREPLY=( $( compgen -f $cur ) )
|
|---|
| 261 | return 0;
|
|---|
| 262 | fi
|
|---|
| 263 | COMPREPLY=( $( compgen -c $cur ) )
|
|---|
| 264 | return 0
|
|---|
| 265 | }
|
|---|
| 266 | complete -F _hash_func hash
|
|---|
| 267 |
|
|---|
| 268 | _history_func()
|
|---|
| 269 | {
|
|---|
| 270 | local cur prev
|
|---|
| 271 |
|
|---|
| 272 | cur=${COMP_WORDS[COMP_CWORD]}
|
|---|
| 273 | prev=${COMP_WORDS[COMP_CWORD-1]}
|
|---|
| 274 |
|
|---|
| 275 | COMPREPLY=()
|
|---|
| 276 | if (( $COMP_CWORD <= 1 )) || [[ $cur == '-' ]]; then
|
|---|
| 277 | COMPREPLY=(-a -c -d -n -r -w -p -s)
|
|---|
| 278 | return 0;
|
|---|
| 279 | fi
|
|---|
| 280 | if [[ $prev == -[anrw] ]]; then
|
|---|
| 281 | COMPREPLY=( $( compgen -f $cur ) )
|
|---|
| 282 | fi
|
|---|
| 283 | return 0
|
|---|
| 284 | }
|
|---|
| 285 | complete -F _history_func history
|
|---|
| 286 |
|
|---|
| 287 | #complete -F _read_func read
|
|---|
| 288 |
|
|---|
| 289 | _set_func ()
|
|---|
| 290 | {
|
|---|
| 291 | local cur prev
|
|---|
| 292 |
|
|---|
| 293 | cur=${COMP_WORDS[COMP_CWORD]}
|
|---|
| 294 | prev=${COMP_WORDS[COMP_CWORD-1]}
|
|---|
| 295 |
|
|---|
| 296 | COMPREPLY=()
|
|---|
| 297 |
|
|---|
| 298 | _redir_test "$cur" "$prev" && return 0;
|
|---|
| 299 |
|
|---|
| 300 | if (( $COMP_CWORD <= 1 )) || [[ $cur == '-' ]]; then
|
|---|
| 301 | COMPREPLY=(-a -b -e -f -k -m -n -o -p -t -u -v -x -B -C -H -P --)
|
|---|
| 302 | return 0;
|
|---|
| 303 | fi
|
|---|
| 304 | if [[ $cur == '+' ]]; then
|
|---|
| 305 | COMPREPLY=(+a +b +e +f +k +m +n +o +p +t +u +v +x +B +C +H +P)
|
|---|
| 306 | return 0;
|
|---|
| 307 | fi
|
|---|
| 308 | if [[ $prev == [+-]o ]]; then
|
|---|
| 309 | COMPREPLY=( $(compgen -A setopt $cur) )
|
|---|
| 310 | return 0;
|
|---|
| 311 | fi
|
|---|
| 312 | return 1;
|
|---|
| 313 | }
|
|---|
| 314 | complete -F _set_func set
|
|---|
| 315 |
|
|---|
| 316 | _trap_func ()
|
|---|
| 317 | {
|
|---|
| 318 | local cur
|
|---|
| 319 | cur=${COMP_WORDS[COMP_CWORD]}
|
|---|
| 320 |
|
|---|
| 321 | if (( $COMP_CWORD <= 1 )) || [[ $cur == '-' ]]; then
|
|---|
| 322 | COMPREPLY=(-l -p)
|
|---|
| 323 | return 0;
|
|---|
| 324 | fi
|
|---|
| 325 | COMPREPLY=( $( compgen -A signal ${cur}) )
|
|---|
| 326 | return 0
|
|---|
| 327 | }
|
|---|
| 328 | complete -F _trap_func trap
|
|---|
| 329 |
|
|---|
| 330 | #
|
|---|
| 331 | # meta-completion (completion for complete/compgen)
|
|---|
| 332 | #
|
|---|
| 333 | _complete_meta_func()
|
|---|
| 334 | {
|
|---|
| 335 | local cur prev cmd
|
|---|
| 336 | COMPREPLY=()
|
|---|
| 337 |
|
|---|
| 338 | cmd=$1
|
|---|
| 339 |
|
|---|
| 340 | cur=${COMP_WORDS[COMP_CWORD]}
|
|---|
| 341 | prev=${COMP_WORDS[COMP_CWORD-1]}
|
|---|
| 342 |
|
|---|
| 343 | _redir_test "$cur" "$prev" && return 0;
|
|---|
| 344 |
|
|---|
| 345 | if (( $COMP_CWORD <= 1 )) || [[ "$cur" == '-' ]]; then
|
|---|
| 346 | case "$cmd" in
|
|---|
| 347 | complete) COMPREPLY=(-a -b -c -d -e -f -j -k -s -v -u -r -p -A -G -W -P -S -X -F -C);;
|
|---|
| 348 | compgen) COMPREPLY=(-a -b -c -d -e -f -j -k -s -v -u -A -G -W -P -S -X -F -C);;
|
|---|
| 349 | esac
|
|---|
| 350 | return 0
|
|---|
| 351 | fi
|
|---|
| 352 |
|
|---|
| 353 | if [[ $prev == -A ]]; then
|
|---|
| 354 | COMPREPLY=(alias arrayvar binding builtin command directory \
|
|---|
| 355 | disabled enabled export file 'function' helptopic hostname job keyword \
|
|---|
| 356 | running service setopt shopt signal stopped variable)
|
|---|
| 357 | return 0
|
|---|
| 358 | elif [[ $prev == -F ]]; then
|
|---|
| 359 | COMPREPLY=( $( compgen -A function $cur ) )
|
|---|
| 360 | elif [[ $prev == -C ]]; then
|
|---|
| 361 | COMPREPLY=( $( compgen -c $cur ) )
|
|---|
| 362 | else
|
|---|
| 363 | COMPREPLY=( $( compgen -c $cur ) )
|
|---|
| 364 | fi
|
|---|
| 365 | return 0
|
|---|
| 366 | }
|
|---|
| 367 | complete -F _complete_meta_func complete compgen
|
|---|
| 368 |
|
|---|
| 369 | #
|
|---|
| 370 | # some completions for shell reserved words
|
|---|
| 371 | #
|
|---|
| 372 | #complete -c -k time do if then else elif '{'
|
|---|
| 373 |
|
|---|
| 374 | #
|
|---|
| 375 | # external commands
|
|---|
| 376 | #
|
|---|
| 377 |
|
|---|
| 378 | complete -e printenv
|
|---|
| 379 |
|
|---|
| 380 | complete -c nohup exec nice eval trace truss strace sotruss gdb
|
|---|
| 381 |
|
|---|
| 382 | _make_targets ()
|
|---|
| 383 | {
|
|---|
| 384 | local mdef makef gcmd cur prev i
|
|---|
| 385 |
|
|---|
| 386 | COMPREPLY=()
|
|---|
| 387 | cur=${COMP_WORDS[COMP_CWORD]}
|
|---|
| 388 | prev=${COMP_WORDS[COMP_CWORD-1]}
|
|---|
| 389 |
|
|---|
| 390 | # if prev argument is -f, return possible filename completions.
|
|---|
| 391 | # we could be a little smarter here and return matches against
|
|---|
| 392 | # `makefile Makefile *.mk', whatever exists
|
|---|
| 393 | case "$prev" in
|
|---|
| 394 | -*f) COMPREPLY=( $(compgen -f $cur ) ); return 0;;
|
|---|
| 395 | esac
|
|---|
| 396 |
|
|---|
| 397 | # if we want an option, return the possible posix options
|
|---|
| 398 | case "$cur" in
|
|---|
| 399 | -) COMPREPLY=(-e -f -i -k -n -p -q -r -S -s -t); return 0;;
|
|---|
| 400 | esac
|
|---|
| 401 |
|
|---|
| 402 | # make reads `makefile' before `Makefile'
|
|---|
| 403 | # GNU make reads `GNUmakefile' before all other makefiles, but we
|
|---|
| 404 | # check that we're completing `gmake' before checking for it
|
|---|
| 405 | if [ -f GNUmakefile ] && [ ${COMP_WORDS[0]} == gmake ]; then
|
|---|
| 406 | mdef=GNUmakefile
|
|---|
| 407 | elif [ -f makefile ]; then
|
|---|
| 408 | mdef=makefile
|
|---|
| 409 | elif [ -f Makefile ]; then
|
|---|
| 410 | mdef=Makefile
|
|---|
| 411 | else
|
|---|
| 412 | mdef=*.mk # local convention
|
|---|
| 413 | fi
|
|---|
| 414 |
|
|---|
| 415 | # before we scan for targets, see if a makefile name was specified
|
|---|
| 416 | # with -f
|
|---|
| 417 | for (( i=0; i < ${#COMP_WORDS[@]}; i++ )); do
|
|---|
| 418 | if [[ ${COMP_WORDS[i]} == -*f ]]; then
|
|---|
| 419 | eval makef=${COMP_WORDS[i+1]} # eval for tilde expansion
|
|---|
| 420 | break
|
|---|
| 421 | fi
|
|---|
| 422 | done
|
|---|
| 423 |
|
|---|
| 424 | [ -z "$makef" ] && makef=$mdef
|
|---|
| 425 |
|
|---|
| 426 | # if we have a partial word to complete, restrict completions to
|
|---|
| 427 | # matches of that word
|
|---|
| 428 | if [ -n "$2" ]; then gcmd='grep "^$2"' ; else gcmd=cat ; fi
|
|---|
| 429 |
|
|---|
| 430 | # if we don't want to use *.mk, we can take out the cat and use
|
|---|
| 431 | # test -f $makef and input redirection
|
|---|
| 432 | COMPREPLY=( $(cat $makef 2>/dev/null | awk 'BEGIN {FS=":"} /^[^.# ][^=]*:/ {print $1}' | tr -s ' ' '\012' | sort -u | eval $gcmd ) )
|
|---|
| 433 | }
|
|---|
| 434 | complete -F _make_targets -X '+($*|*.[cho])' make gmake pmake
|
|---|
| 435 |
|
|---|
| 436 | _umount_func ()
|
|---|
| 437 | {
|
|---|
| 438 | COMPREPLY=( $(mount | awk '{print $1}') )
|
|---|
| 439 | }
|
|---|
| 440 | complete -F _umount_func umount
|
|---|
| 441 |
|
|---|
| 442 | _configure_func ()
|
|---|
| 443 | {
|
|---|
| 444 | case "$2" in
|
|---|
| 445 | -*) ;;
|
|---|
| 446 | *) return ;;
|
|---|
| 447 | esac
|
|---|
| 448 |
|
|---|
| 449 | case "$1" in
|
|---|
| 450 | \~*) eval cmd=$1 ;;
|
|---|
| 451 | *) cmd="$1" ;;
|
|---|
| 452 | esac
|
|---|
| 453 |
|
|---|
| 454 | COMPREPLY=( $("$cmd" --help | awk '{if ($1 ~ /--.*/) print $1}' | grep ^"$2" | sort -u) )
|
|---|
| 455 | }
|
|---|
| 456 | complete -F _configure_func configure
|
|---|
| 457 |
|
|---|
| 458 | complete -W '"${GROUPS[@]}"' newgrp
|
|---|
| 459 |
|
|---|
| 460 | complete -f chown ln more cat
|
|---|
| 461 | complete -d mkdir rmdir
|
|---|
| 462 | complete -f strip
|
|---|
| 463 |
|
|---|
| 464 | complete -f -X '*.gz' gzip
|
|---|
| 465 | complete -f -X '*.bz2' bzip2
|
|---|
| 466 | complete -f -X '*.Z' compress
|
|---|
| 467 | complete -f -X '!*.+(gz|tgz|Gz)' gunzip gzcat zcat zmore
|
|---|
| 468 | complete -f -X '!*.Z' uncompress zmore zcat
|
|---|
| 469 | complete -f -X '!*.bz2' bunzip2 bzcat
|
|---|
| 470 | complete -f -X '!*.zip' unzip
|
|---|
| 471 | complete -f -X '!*.+(gif|jpg|jpeg|GIF|JPG|JPEG|bmp)' xv
|
|---|
| 472 |
|
|---|
| 473 | complete -f -X '!*.pl' perl perl5
|
|---|
| 474 |
|
|---|
| 475 | complete -A hostname rsh telnet rlogin ftp ping xping host traceroute nslookup
|
|---|
| 476 | complete -A hostname rxterm rxterm3 rxvt2
|
|---|
| 477 |
|
|---|
| 478 | complete -u su
|
|---|
| 479 | complete -g newgrp groupdel groupmod
|
|---|
| 480 |
|
|---|
| 481 | complete -f -X '!*.+(ps|PS)' gs gv ghostview psselect pswrap
|
|---|
| 482 | complete -f -X '!*.+(dvi|DVI)' dvips xdvi dviselect dvitype catdvi
|
|---|
| 483 | complete -f -X '!*.+(pdf|PDF)' acroread4
|
|---|
| 484 | complete -f -X '!*.texi*' makeinfo texi2dvi texi2html
|
|---|
| 485 | complete -f -X '!*.+(tex|TEX)' tex latex slitex
|
|---|
| 486 |
|
|---|
| 487 | complete -f -X '!*.+(mp3|MP3)' mpg123
|
|---|
| 488 | complete -f -X '!*.+(htm|html)' links w3m lynx
|
|---|
| 489 |
|
|---|
| 490 | #
|
|---|
| 491 | # other possibilities, left as exercises
|
|---|
| 492 | #
|
|---|
| 493 | #complete -F _find_func find
|
|---|
| 494 | #complete -F _man_func man
|
|---|
| 495 | #complete -F _stty_func stty
|
|---|
