4315 lines
100 KiB
Bash
4315 lines
100 KiB
Bash
# bash_completion - some programmable completion functions for bash 2.05b
|
|
#
|
|
# $Id: bash_completion,v 1.492 2002/12/19 21:57:36 ianmacd Exp $
|
|
#
|
|
# Copyright (C) Ian Macdonald <ian@caliban.org>
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2, or (at your option)
|
|
# any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software Foundation,
|
|
# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
# RELEASE: 20021217
|
|
|
|
[ -n "${DEBUG:-}" ] && set -v || set +v
|
|
|
|
# Alter the following to reflect the location of this file
|
|
#
|
|
declare -r BASH_COMPLETION=${BASH_COMPLETION:-/etc/bash_completion} 2>/dev/null
|
|
declare -r BASH_COMPLETION_DIR=${BASH_COMPLETION_DIR:=/etc/bash_completion.d} 2>/dev/null
|
|
|
|
# Set a couple of useful vars
|
|
#
|
|
UNAME=$( uname -s )
|
|
RELEASE=$( uname -r )
|
|
if [ ${BASH_VERSINFO[1]} '>' 04 ]; then
|
|
default="-o default"
|
|
dirnames="-o dirnames"
|
|
filenames="-o filenames"
|
|
fi
|
|
[ ${BASH_VERSINFO[1]} = "05b" ] && nospace="-o nospace" || nospace=""
|
|
|
|
# Turn on extended globbing and programmable completion
|
|
shopt -s extglob progcomp
|
|
|
|
# A lot of the following one-liners were taken directly from the
|
|
# completion examples provided with the bash 2.04 source distribution
|
|
|
|
# Make directory commands see only directories
|
|
complete -d pushd
|
|
|
|
# The following section lists completions that are redefined later
|
|
# Do NOT break these over multiple lines.
|
|
#
|
|
# START exclude -- do NOT remove this line
|
|
complete -f -X '!*.?(t)bz2' bunzip2 bzcat bzcmp bzdiff bzegrep bzfgrep bzgrep
|
|
complete -f -X '!*.@(zip|ZIP|jar|JAR|exe|EXE|pk3|war|wsz|ear|zargo)' unzip zipinfo
|
|
complete -f -X '*.Z' compress znew
|
|
complete -f -X '!*.@(Z|gz|tgz|Gz|dz)' gunzip zcmp zdiff zcat zegrep zfgrep zgrep zless zmore
|
|
complete -f -X '!*.Z' uncompress
|
|
complete -f -X '!*.@(gif|jp?(e)g|tif?(f)|pn[gm]|p[bgp]m|bmp|xpm|ico|xwd|GIF|JPG|JP?(E)G|TIF?(F)|PN[GM]|P[BGP]M|BMP|XPM|ICO|XWD)' ee display
|
|
complete -f -X '!*.@(gif|jp?(e)g|tif?(f)|png|p[bgp]m|bmp|x[bp]m|rle|rgb|pcx|fits|pm|GIF|JPG|JP?(E)G|TIF?(F)|PNG|P[BGP]M|BMP|X[BP]M|RLE|RGB|PCX|FITS|PM)' xv qiv
|
|
complete -f -X '!*.@(@(?(e)ps|?(E)PS|pdf|PDF)?(.gz|.GZ|.Z))' gv ggv
|
|
complete -f -X '!*.@(dvi|DVI)?(.@(gz|Z|bz2))' xdvi
|
|
complete -f -X '!*.@(dvi|DVI)' dvips dviselect dvitype
|
|
complete -f -X '!*.@(pdf|PDF)' acroread xpdf
|
|
complete -f -X '!*.texi*' makeinfo texi2html
|
|
complete -f -X '!*.@(?(la)tex|?(LA)TEX|texi|TEXI|dtx|DTX|ins|INS)' tex latex slitex jadetex pdfjadetex pdftex pdflatex texi2dvi
|
|
complete -f -X '!*.@(mp3|MP3)' mpg123 mpg321
|
|
complete -f -X '!*.@(mpg|mpeg|MPG|MPEG|wma|avi|AVI|asf|vob|bin|vcd|ps|pes|fli|viv|rm|ram|yuv|mov|wmv|mp3|MP3|ogg|OGG|ogm|OGM|mp4|MP4)' xine
|
|
complete -f -X '!*.@(avi|asf|wmv)' aviplay
|
|
complete -f -X '!*.@(rm|ram|smi?(l))' realplay
|
|
complete -f -X '!*.@(mpg|mpeg|avi|mov)' xanim
|
|
complete -f -X '!*.@(ogg|OGG)' ogg123
|
|
complete -f -X '!*.@(mp3|MP3|ogg|OGG|pls|m3u)' gqmpeg freeamp
|
|
complete -f -X '!*.@(mp3|MP3|ogg|OGG|wav|WAV|pls|m3u|xm|mod|s[3t]m|it|mtm|ult|flac)' xmms
|
|
complete -f -X '!*.fig' xfig
|
|
complete -f -X '!*.@(mid?(i))' timidity playmidi
|
|
complete -f -X '*.@(o|so|so.*|a|tar|tgz|tbz2|rpm|zip|ZIP|gif|GIF|jp?(e)g|JP?(E)G|mp3|MP3|mpg|MPG|avi|AVI|asf|ASF|ogg|OGG)' vi vim gvim emacs
|
|
complete -f -X '!*.@(exe|EXE|com|COM|scr|SCR)' wine
|
|
complete -f -X '!*.@(zip|ZIP|z|Z|gz|GZ|tgz|TGZ)' bzme
|
|
complete -f -X '!*.@(?(x)htm?(l))' netscape mozilla lynx opera w3m galeon curl dillo elinks
|
|
# FINISH exclude -- do not remove this line
|
|
|
|
# start of section containing compspecs that can be handled within bash
|
|
|
|
# user commands see only users
|
|
complete -u su usermod userdel passwd chage write chfn
|
|
|
|
# group commands see only groups
|
|
[ ${BASH_VERSINFO[1]} '>' 04 ] &&
|
|
complete -g groupmod groupdel newgrp 2>/dev/null
|
|
|
|
# bg completes with stopped jobs
|
|
complete -A stopped -P '%' bg
|
|
|
|
# other job commands
|
|
complete -j -P '%' fg jobs disown
|
|
|
|
# readonly and unset complete with shell variables
|
|
complete -v readonly unset
|
|
|
|
# set completes with set options
|
|
complete -A setopt set
|
|
|
|
# shopt completes with shopt options
|
|
complete -A shopt shopt
|
|
|
|
# helptopics
|
|
complete -A helptopic help
|
|
|
|
# unalias completes with aliases
|
|
complete -a unalias
|
|
|
|
# bind completes with readline bindings (make this more intelligent)
|
|
complete -A binding bind
|
|
|
|
# type and which complete on commands
|
|
complete -c command type which
|
|
|
|
# start of section containing completion functions called by other functions
|
|
|
|
# This function checks whether we have a given programs on the system.
|
|
# No need for bulky functions in memory if we don't.
|
|
#
|
|
have()
|
|
{
|
|
unset -v have
|
|
type $1 &> /dev/null
|
|
[ $? -eq 0 ] && have="yes"
|
|
}
|
|
|
|
# use GNU sed if we have it, since its extensions are still used in our code
|
|
#
|
|
[ $UNAME != Linux ] && have gsed && alias sed=gsed
|
|
|
|
# This function performs file and directory completion. It's better than
|
|
# simply using 'compgen -f', because it honours spaces in filenames.
|
|
# If passed -d, it completes only on directories. If passed anything else,
|
|
# it's assumed to be a file glob to complete on.
|
|
#
|
|
_filedir()
|
|
{
|
|
local IFS=$'\t\n' xspec
|
|
|
|
_expand || return 0
|
|
|
|
if [ "${1:-}" = -d ]; then
|
|
COMPREPLY=( ${COMPREPLY[@]:-} $( compgen -d -- $cur ) )
|
|
return 0
|
|
fi
|
|
|
|
xspec=${1:+"!*.$1"} # set only if glob passed in as $1
|
|
COMPREPLY=( ${COMPREPLY[@]:-} $( compgen -f -X "$xspec" -- "$cur" )
|
|
$( compgen -d -- "$cur" ) )
|
|
}
|
|
|
|
# This function completes on signal names
|
|
#
|
|
_signals()
|
|
{
|
|
local i
|
|
|
|
# standard signal completion is rather braindead, so we need
|
|
# to hack around to get what we want here, which is to
|
|
# complete on a dash, followed by the signal name minus
|
|
# the SIG prefix
|
|
COMPREPLY=( $( compgen -A signal SIG${cur#-} ))
|
|
for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
|
|
COMPREPLY[i]=-${COMPREPLY[i]#SIG}
|
|
done
|
|
}
|
|
|
|
# This function expands tildes in pathnames
|
|
#
|
|
_expand()
|
|
{
|
|
[ "$cur" != "${cur%\\}" ] && cur="$cur\\"
|
|
|
|
# expand ~username type directory specifications
|
|
if [[ "$cur" == \~*/* ]]; then
|
|
: eval cur=$cur
|
|
|
|
elif [[ "$cur" == \~* ]]; then
|
|
cur=${cur#\~}
|
|
COMPREPLY=( $( compgen -P '~' -u $cur ) )
|
|
return ${#COMPREPLY[@]}
|
|
fi
|
|
}
|
|
|
|
# This function completes on process IDs
|
|
#
|
|
_pids()
|
|
{
|
|
COMPREPLY=( $( compgen -W '$( command ps axo pid | sed 1d )' -- $cur ) )
|
|
}
|
|
|
|
# This function completes on process group IDs
|
|
#
|
|
_pgids()
|
|
{
|
|
COMPREPLY=( $( compgen -W '$( command ps axo pgid | sed 1d )' -- $cur ))
|
|
}
|
|
|
|
# Linux ifconfig(8) and iwconfig(8) helper function
|
|
#
|
|
[ $UNAME = Linux ] && ( have ifconfig || have iwconfig ) &&
|
|
_ifwconfig()
|
|
{
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
case "${COMP_WORDS[1]}" in
|
|
-|*[0-9]*)
|
|
#COMPREPLY=( $( compgen -W '${keywords[@]}' ) )
|
|
COMPREPLY=( ${keywords[@]} )
|
|
COMPREPLY=( $( echo " ${COMP_WORDS[@]}" | \
|
|
(while read -d ' ' i; do
|
|
[ "$i" == "" ] && continue
|
|
# flatten array with spaces on either side,
|
|
# otherwise we cannot grep on word
|
|
# boundaries of first and last word
|
|
COMPREPLY=" ${COMPREPLY[@]} "
|
|
# remove word from list of completions
|
|
COMPREPLY=( ${COMPREPLY/ $i / } )
|
|
done
|
|
echo ${COMPREPLY[@]})
|
|
) )
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
COMPREPLY=( $( eval "$@" 2>/dev/null | \
|
|
sed -ne 's|^\('$cur'[^ ]*\).*$|\1|p' ) )
|
|
}
|
|
|
|
# start of section containing completion functions for bash built-ins
|
|
|
|
# bash alias completion
|
|
#
|
|
_alias()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[$COMP_CWORD]}
|
|
|
|
case "$COMP_LINE" in
|
|
*[^=])
|
|
COMPREPLY=( $( compgen -A alias -S '=' -- $cur ) )
|
|
;;
|
|
*=)
|
|
COMPREPLY=( "$( alias ${cur%=} 2>/dev/null | \
|
|
sed -e 's|^alias '$cur'\(.*\)$|\1|' )" )
|
|
;;
|
|
esac
|
|
}
|
|
complete -F _alias alias
|
|
|
|
# bash export completion
|
|
#
|
|
_export()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[$COMP_CWORD]}
|
|
|
|
case "$COMP_LINE" in
|
|
*=\$*)
|
|
COMPREPLY=( $( compgen -v -P '$' -- ${cur#*=\$} ) )
|
|
;;
|
|
*[^=])
|
|
COMPREPLY=( $( compgen -v -S '=' -- $cur ) )
|
|
;;
|
|
*=)
|
|
COMPREPLY=( $( eval echo $`echo ${cur%=}` ) )
|
|
;;
|
|
esac
|
|
}
|
|
complete -F _export $default $nospace export
|
|
|
|
# bash shell function completion
|
|
#
|
|
_function()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
if [[ $1 == @(declare|typeset) ]]; then
|
|
if [ "$prev" = -f ]; then
|
|
COMPREPLY=( $( compgen -A function -- $cur ) )
|
|
elif [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( compgen -W '-a -f -F -i -r -x -p' -- \
|
|
$cur ) )
|
|
fi
|
|
elif [ $COMP_CWORD -eq 1 ]; then
|
|
COMPREPLY=( $( compgen -A function -- $cur ) )
|
|
else
|
|
COMPREPLY=( "() $( type -- ${COMP_WORDS[1]} | sed -e 1,2d )" )
|
|
fi
|
|
}
|
|
complete -F _function function declare typeset
|
|
|
|
# bash complete completion
|
|
#
|
|
_complete()
|
|
{
|
|
local cur prev options
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
case $prev in
|
|
-o)
|
|
options="default dirnames filenames"
|
|
[ ${BASH_VERSINFO[1]} = "05b" ] && options="$options nospace"
|
|
COMPREPLY=( $( compgen -W "$options" -- $cur ) )
|
|
return 0
|
|
;;
|
|
|
|
-A)
|
|
COMPREPLY=( $( compgen -W 'alias arrayvar binding \
|
|
builtin command directory disabled enabled \
|
|
export file function group helptopic hostname \
|
|
job keyword running service setopt shopt \
|
|
signal stopped user variable' -- $cur ) )
|
|
return 0
|
|
;;
|
|
|
|
-C)
|
|
COMPREPLY=( $( compgen -A command -- $cur ) )
|
|
return 0
|
|
;;
|
|
-F)
|
|
COMPREPLY=( $( compgen -A function -- $cur ) )
|
|
return 0
|
|
;;
|
|
-@(p|r))
|
|
COMPREPLY=( $( complete -p | sed -e 's|.* ||' | \
|
|
grep "^$cur" ) )
|
|
return 0
|
|
;;
|
|
|
|
esac
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
# relevant options completion
|
|
options="-a -b -c -d -e -f -g -j -k -s -v -u -A -G -W -P -S -X -F -C"
|
|
[ ${BASH_VERSINFO[1]} '>' 04 ] && options="$options -o"
|
|
COMPREPLY=( $( compgen -W "$options" -- $cur ) )
|
|
else
|
|
COMPREPLY=( $( compgen -A command -- $cur ) )
|
|
fi
|
|
}
|
|
complete -F _complete complete
|
|
|
|
# start of section containing completion functions for external programs
|
|
|
|
# chown(1) completion
|
|
#
|
|
_chown()
|
|
{
|
|
local cur prev user group i
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
# options completion
|
|
if [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( compgen -W '-c -h -f -R -v --changes \
|
|
--dereference --no-dereference --from= --silent --quiet \
|
|
--reference= --recursive --verbose --help --version' -- $cur ) )
|
|
return 0
|
|
fi
|
|
|
|
# first parameter on line or first since an option?
|
|
if [ $COMP_CWORD -eq 1 ] || [[ "$prev" == -* ]]; then
|
|
if [[ "$cur" == [a-zA-Z]*[.:]* ]] && \
|
|
[ ${BASH_VERSINFO[1]} '>' 04 ]; then
|
|
user=${cur%%?(\\)[.:]*}
|
|
group=${cur#*[.:]}
|
|
COMPREPLY=( $( compgen -P $user':' \
|
|
-g -- $group 2>/dev/null) )
|
|
else
|
|
COMPREPLY=( $( compgen -S ':' -u $cur ) )
|
|
fi
|
|
else
|
|
_filedir
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
complete -F _chown $filenames chown
|
|
|
|
# chgrp(1) completion
|
|
#
|
|
_chgrp()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
# options completion
|
|
if [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( compgen -W '-c -h -f -R -v --changes \
|
|
--dereference --no-dereference --silent --quiet \
|
|
--reference= --recursive --verbose --help --version' -- $cur ) )
|
|
return 0
|
|
fi
|
|
|
|
# first parameter on line or first since an option?
|
|
if [ $COMP_CWORD -eq 1 ] && [[ "$cur" != -* ]] || \
|
|
[[ "$prev" == -* ]]; then
|
|
[ ${BASH_VERSINFO[1]} '>' 04 ] && \
|
|
COMPREPLY=( $( compgen -g $cur 2>/dev/null) )
|
|
else
|
|
_expand || return 0
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
complete -F _chgrp $default chgrp
|
|
|
|
# umount(8) completion. This relies on the mount point being the third
|
|
# space-delimited field in the output of mount(8)
|
|
#
|
|
_umount()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
COMPREPLY=( $( compgen -W '$( mount | cut -d" " -f 3 )' -- $cur ) )
|
|
|
|
return 0
|
|
}
|
|
complete -F _umount $dirnames umount
|
|
|
|
# mount(8) completion. This will pull a list of possible mounts out of
|
|
# /etc/fstab, unless the word being completed contains a ':', which
|
|
# would indicate the specification of an NFS server. In that case, we
|
|
# query the server for a list of all available exports and complete on
|
|
# that instead.
|
|
#
|
|
_mount()
|
|
{ local cur i sm host
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
[[ "$cur" == \\ ]] && cur="/"
|
|
|
|
for i in {,/usr}/{,s}bin/showmount; do [ -x $i ] && sm=$i && break; done
|
|
|
|
if [ -n "$sm" ] && [[ "$cur" == *:* ]]; then
|
|
COMPREPLY=( $( $sm -e ${cur%%:*} | sed 1d | \
|
|
grep ^${cur#*:} | awk '{print $1}' ) )
|
|
elif [[ "$cur" == //* ]]; then
|
|
host=${cur#//}
|
|
host=${host%%/*}
|
|
if [ -n $host ]; then
|
|
COMPREPLY=( $( compgen -W "$( echo $( smbclient -d 0 -NL $host |
|
|
sed -ne '/^['$'\t '']*Sharename/,/^$/p' |
|
|
sed -ne '3,$s|^[^A-Za-z]*\([^'$'\t '']*\).*$|//'$host'/\1|p' ) )" -- "$cur" ) )
|
|
fi
|
|
else
|
|
COMPREPLY=( $( awk '! /^[ \t]*#/ {if ($2 ~ /\//) print $2}' /etc/fstab | \
|
|
grep "^$cur" ) )
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
complete -F _mount $default mount
|
|
|
|
# Linux rmmod(8) completion. This completes on a list of all currently
|
|
# installed kernel modules.
|
|
#
|
|
have rmmod && {
|
|
_rmmod()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
COMPREPLY=( $( /sbin/lsmod | \
|
|
awk '{if (NR != 1 && $1 ~ /^'$cur'/) print $1}' 2>/dev/null ))
|
|
return 0
|
|
}
|
|
complete -F _rmmod rmmod
|
|
|
|
# Linux insmod(8) & modprobe(8) completion. This completes on a list of all
|
|
# available modules for the version of the kernel currently running.
|
|
#
|
|
_insmod()
|
|
{
|
|
local cur prev modpath
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
modpath=/lib/modules/`uname -r`
|
|
|
|
# behave like lsmod for modprobe -r
|
|
if [ $1 = "modprobe" ] &&
|
|
[ "${COMP_WORDS[1]}" = "-r" ]; then
|
|
COMPREPLY=( $( /sbin/lsmod | \
|
|
awk '{if (NR != 1 && $1 ~ /^'$cur'/) print $1}' ) )
|
|
return 0
|
|
fi
|
|
|
|
# do filename completion if we're giving a path to a module
|
|
if [[ "$cur" == ?(.|..)/* ]]; then
|
|
_filedir
|
|
return 0
|
|
fi
|
|
|
|
if [ $COMP_CWORD -gt 1 ]; then
|
|
# do module parameter completion
|
|
COMPREPLY=( $( /sbin/modinfo -p ${COMP_WORDS[1]} 2>/dev/null | \
|
|
awk '{if ($1 ~ /^parm:/ && $2 ~ /^'$cur'/) { print $2 } \
|
|
else if ($1 !~ /:/ && $1 ~ /^'$cur'/) { print $1 }}' ) )
|
|
elif [ -r $modpath -a -x $modpath ]; then
|
|
# do module name completion
|
|
COMPREPLY=( $( command ls -R $modpath | \
|
|
sed -ne 's/^\('$cur'.*\)\.o\(\|.gz\)$/\1/p') )
|
|
else
|
|
_filedir
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
complete -F _insmod $filenames insmod modprobe
|
|
}
|
|
|
|
# man(1) completion. This is GNU, GNU/Linux and Darwin specific, in that
|
|
# 'man <section> <page>' is the expected syntax.
|
|
#
|
|
[ $UNAME = GNU -o $UNAME = Linux -o $UNAME = Darwin -o $UNAME = FreeBSD ] &&
|
|
_man()
|
|
{
|
|
local cur prev sect manpath UNAME
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
_expand || return 0
|
|
|
|
# default completion if parameter contains /
|
|
if [[ "$cur" == */* ]]; then
|
|
_filedir
|
|
return 0
|
|
fi
|
|
|
|
UNAME=$( uname -s )
|
|
if [ $UNAME = GNU -o $UNAME = Linux -o $UNAME = FreeBSD ]; then
|
|
manpath=$( manpath 2>/dev/null || command man --path )
|
|
else
|
|
manpath=$MANPATH
|
|
fi
|
|
|
|
if [ -z "$manpath" ]; then
|
|
COMPREPLY=( $( compgen -c -- $cur ) )
|
|
return 0
|
|
fi
|
|
|
|
# determine manual section to search
|
|
[[ "$prev" == [0-9ln] ]] && sect=$prev || sect='?'
|
|
|
|
manpath=$manpath:
|
|
if [ -n "$cur" ]; then
|
|
manpath="${manpath//://man$sect/$cur* }"
|
|
else
|
|
manpath="${manpath//://man$sect/ }"
|
|
fi
|
|
|
|
# redirect stderr for when path doesn't exist
|
|
COMPREPLY=( $( eval command ls "$manpath" 2>/dev/null ) )
|
|
# weed out directory path names and paths to man pages
|
|
COMPREPLY=( ${COMPREPLY[@]##*/?(:)} )
|
|
# strip suffix from man pages
|
|
COMPREPLY=( ${COMPREPLY[@]%.@(gz|bz2)} )
|
|
COMPREPLY=( $( compgen -W '${COMPREPLY[@]%.*}' -- "${cur//\\\\/}" ) )
|
|
|
|
[[ "$prev" != [0-9ln] ]] && _filedir '[0-9ln]'
|
|
|
|
return 0
|
|
}
|
|
[ $UNAME = GNU -o $UNAME = Linux -o $UNAME = Darwin -o $UNAME = FreeBSD ] &&
|
|
complete -F _man $filenames man
|
|
|
|
# renice(8) completion
|
|
#
|
|
_renice()
|
|
{
|
|
local command cur curopt i
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
command=$1
|
|
|
|
i=0
|
|
# walk back throuh command line and find last option
|
|
while [ $i -le $COMP_CWORD -a ${#COMPREPLY[@]} -eq 0 ]; do
|
|
curopt=${COMP_WORDS[COMP_CWORD-$i]}
|
|
case "$curopt" in
|
|
-u)
|
|
COMPREPLY=( $( compgen -u -- $cur ) )
|
|
;;
|
|
-g)
|
|
_pgids
|
|
;;
|
|
-p|$command)
|
|
_pids
|
|
;;
|
|
esac
|
|
i=$(( ++i ))
|
|
done
|
|
}
|
|
complete -F _renice renice
|
|
|
|
# kill(1) completion
|
|
#
|
|
_kill()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
if [ $COMP_CWORD -eq 1 ] && [[ "$cur" == -* ]]; then
|
|
# return list of available signals
|
|
_signals
|
|
else
|
|
# return list of available PIDs
|
|
_pids
|
|
fi
|
|
}
|
|
complete -F _kill kill
|
|
|
|
# Linux and FreeBSD killall(1) completion.
|
|
#
|
|
[ $UNAME = Linux -o $UNAME = FreeBSD ] &&
|
|
_killall()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
if [ $COMP_CWORD -eq 1 ] && [[ "$cur" == -* ]]; then
|
|
_signals
|
|
else
|
|
COMPREPLY=( $( compgen -W '$( command ps axo ucomm | sed 1d )' \
|
|
-- $cur ) )
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
[ $UNAME = Linux -o $UNAME = FreeBSD ] && complete -F _killall killall
|
|
|
|
# GNU find(1) completion. This makes heavy use of ksh style extended
|
|
# globs and contains Linux specific code for completing the parameter
|
|
# to the -fstype option.
|
|
#
|
|
_find()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
case "$prev" in
|
|
-@(max|min)depth)
|
|
COMPREPLY=( $( compgen -W '0 1 2 3 4 5 6 7 8 9' -- $cur ) )
|
|
return 0
|
|
;;
|
|
-?(a)newer|-fls|-fprint?(0|f)|-?(i)?(l)name)
|
|
_filedir
|
|
return 0
|
|
;;
|
|
-fstype)
|
|
# this is highly non-portable
|
|
COMPREPLY=( $( cut -d$'\t' -f 2 /proc/filesystems | \
|
|
grep "^$cur" ) )
|
|
return 0
|
|
;;
|
|
-gid)
|
|
COMPREPLY=( $( awk 'BEGIN {FS=":"} \
|
|
{if ($3 ~ /^'$ncur'/) print $3}' /etc/group ) )
|
|
return 0
|
|
;;
|
|
-group)
|
|
[ ${BASH_VERSINFO[1]} '>' 04 ] && \
|
|
COMPREPLY=( $( compgen -g -- $cur 2>/dev/null) )
|
|
return 0
|
|
;;
|
|
-?(x)type)
|
|
COMPREPLY=( $( compgen -W 'b c d p f l s' -- $cur ) )
|
|
return 0
|
|
;;
|
|
-uid)
|
|
COMPREPLY=( $( awk 'BEGIN {FS=":"} \
|
|
{if ($3 ~ /^'$ncur'/) print $3}' /etc/passwd ) )
|
|
return 0
|
|
;;
|
|
-user)
|
|
COMPREPLY=( $( compgen -u -- $cur ) )
|
|
return 0
|
|
;;
|
|
-[acm]min|-[acm]time|-?(i)?(l)name|-inum|-?(i)path|-?(i)regex| \
|
|
-links|-perm|-size|-used|-exec|-ok|-printf)
|
|
# do nothing, just wait for a parameter to be given
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
_expand || return 0
|
|
|
|
# handle case where first parameter is not a dash option
|
|
if [ $COMP_CWORD -eq 1 ] && [[ "$cur" != -* ]]; then
|
|
_filedir -d
|
|
return 0
|
|
fi
|
|
|
|
# complete using basic options
|
|
COMPREPLY=( $( compgen -W '-daystart -depth -follow -help -maxdepth \
|
|
-mindepth -mount -noleaf -version -xdev -amin -anewer \
|
|
-atime -cmin -cnewer -ctime -empty -false -fstype \
|
|
-gid -group -ilname -iname -inum -ipath -iregex \
|
|
-links -lname -mmin -mtime -name -newer -nouser \
|
|
-nogroup -perm -regex -size -true -type -uid -used \
|
|
-user -xtype -exec -fls -fprint -fprint0 -fprintf -ok \
|
|
-print -print0 -printf -prune -ls' -- $cur ) )
|
|
|
|
# this removes any options from the list of completions that have
|
|
# already been specified somewhere on the command line.
|
|
COMPREPLY=( $( echo "${COMP_WORDS[@]}" | \
|
|
(while read -d ' ' i; do
|
|
[ "$i" == "" ] && continue
|
|
# flatten array with spaces on either side,
|
|
# otherwise we cannot grep on word boundaries of
|
|
# first and last word
|
|
COMPREPLY=" ${COMPREPLY[@]} "
|
|
# remove word from list of completions
|
|
COMPREPLY=( ${COMPREPLY/ ${i%% *} / } )
|
|
done
|
|
echo ${COMPREPLY[@]})
|
|
) )
|
|
|
|
return 0
|
|
}
|
|
complete -F _find $filenames find
|
|
|
|
# Linux ifconfig(8) completion
|
|
#
|
|
[ $UNAME = Linux ] && have ifconfig &&
|
|
_ifconfig()
|
|
{
|
|
local cur
|
|
local -a keywords=( -a up down arp promisc allmulti metric mtu dstaddr \
|
|
netmask add del tunnel irq io_addr mem_start media \
|
|
broadcast pointopoint hw multicast address txqueuelen )
|
|
|
|
_ifwconfig ifconfig -a
|
|
|
|
COMPREPLY=( $( compgen -W '${COMPREPLY[@]}' -- $cur ) )
|
|
}
|
|
[ $UNAME = Linux ] && have ifconfig && complete -F _ifconfig ifconfig
|
|
|
|
# Linux iwconfig(8) completion
|
|
#
|
|
[ $UNAME = Linux ] && have iwconfig &&
|
|
_iwconfig()
|
|
{
|
|
local -a keywords=( essid nwid domain freq channel sens mode ap nick \
|
|
rate bit rts frag key enc power )
|
|
|
|
_ifwconfig iwconfig
|
|
|
|
COMPREPLY=( $( compgen -W '${COMPREPLY[@]}' -- $cur ) )
|
|
}
|
|
[ $UNAME = Linux ] && complete -F _iwconfig iwconfig
|
|
|
|
# RedHat & Debian GNU/Linux if{up,down} completion
|
|
#
|
|
[ $UNAME = Linux ] && ( have ifup || have ifdown ) &&
|
|
_ifupdown()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
if [ $COMP_CWORD -eq 1 ]; then
|
|
if [ -f /etc/debian_version ]; then
|
|
# Debian system
|
|
COMPREPLY=( $( sed -ne 's|^iface \([^ ]\+\).*$|\1|p' \
|
|
/etc/network/interfaces ) )
|
|
else
|
|
# Assume Red Hat
|
|
COMPREPLY=( $( command ls \
|
|
/etc/sysconfig/network-scripts/ifcfg-* | \
|
|
sed -ne 's|.*ifcfg-\('$cur'.*\)|\1|p' ) )
|
|
fi
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
[ $UNAME = Linux ] && have ifup && complete -F _ifupdown ifup ifdown
|
|
|
|
# Linux ipsec(8) completion (for FreeS/WAN)
|
|
#
|
|
[ $UNAME = Linux ] && have ipsec &&
|
|
_ipsec()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
|
|
if [ $COMP_CWORD -eq 1 ]; then
|
|
COMPREPLY=( $( compgen -W 'auto barf eroute klipsdebug look \
|
|
manual pluto ranbits rsasigkey \
|
|
setup showdefaults showhostkey spi \
|
|
spigrp tncfg whack' $cur ) )
|
|
return 0
|
|
fi
|
|
|
|
case ${COMP_WORDS[1]} in
|
|
auto)
|
|
COMPREPLY=( $( compgen -W '--asynchronous --up --add --delete \
|
|
--replace --down --route --unroute \
|
|
--ready --status --rereadsecrets' \
|
|
$cur ) )
|
|
;;
|
|
manual)
|
|
COMPREPLY=( $( compgen -W '--up --down --route --unroute \
|
|
--union' $cur ) )
|
|
;;
|
|
ranbits)
|
|
COMPREPLY=( $( compgen -W '--quick --continuous --bytes' $cur ) )
|
|
;;
|
|
setup)
|
|
COMPREPLY=( $( compgen -W '--start --stop --restart' $cur ) )
|
|
;;
|
|
|
|
*)
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
[ $UNAME = Linux ] && [ -n "${have:-}" ] && complete -F _ipsec ipsec
|
|
|
|
# Postfix completion.
|
|
#
|
|
have postfix && {
|
|
# postfix(1)
|
|
#
|
|
_postfix()
|
|
{
|
|
COMPREPLY=( $( compgen -W 'start stop reload abort flush check' -- \
|
|
"${COMP_WORDS[COMP_CWORD]}" ) )
|
|
}
|
|
complete -F _postfix postfix
|
|
|
|
# postalias(1) and postmap(1)
|
|
#
|
|
_postmap()
|
|
{
|
|
local cur prev len idx
|
|
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
if [[ $cur == '-' ]]; then
|
|
COMPREPLY=(-N -f -i -n -o -r -v -w -c -d -q)
|
|
return 0
|
|
fi
|
|
if [[ $prev == '-c' ]]; then
|
|
_filedir -d
|
|
return 0
|
|
fi
|
|
if [[ $prev == -[dq] ]]; then
|
|
return 0
|
|
fi
|
|
|
|
if [[ "$cur" == *:* ]]; then
|
|
COMPREPLY=( $( compgen -f -- ${cur#*:} ) )
|
|
else
|
|
len=${#cur}
|
|
idx=0
|
|
for pval in $( postconf -m ); do
|
|
if [[ "$cur" == "${pval:0:$len}" ]]; then
|
|
COMPREPLY[$idx]="$pval:"
|
|
idx=$(($idx+1))
|
|
fi
|
|
done
|
|
if [[ $idx -eq 0 ]]; then
|
|
COMPREPLY=( $( compgen -f -- "$cur" ) )
|
|
fi
|
|
fi
|
|
return 0
|
|
}
|
|
complete -F _postmap postmap postalias
|
|
|
|
# postconf(1)
|
|
#
|
|
_postconf()
|
|
{
|
|
local cur prev len idx eqext
|
|
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
if [[ $cur == '-' ]]; then
|
|
COMPREPLY=(-c -d -e -h -m -l -n -v)
|
|
return 0
|
|
fi
|
|
if [[ $prev == '-c' ]]; then
|
|
_filedir -d
|
|
return 0
|
|
fi
|
|
if [[ $prev == '-e' ]]; then
|
|
cur=${cur#[\"\']}
|
|
eqext='='
|
|
fi
|
|
len=${#cur}
|
|
idx=0
|
|
for pval in $( postconf | cut -d ' ' -f 1 ); do
|
|
if [[ "$cur" == "${pval:0:$len}" ]]; then
|
|
COMPREPLY[$idx]="$pval$eqext"
|
|
idx=$(($idx+1))
|
|
fi
|
|
done
|
|
return 0
|
|
}
|
|
complete -F _postconf postconf
|
|
|
|
# postsuper(1)
|
|
#
|
|
_postsuper()
|
|
{
|
|
local cur prev len idx
|
|
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
if [[ $cur == '-' ]]; then
|
|
COMPREPLY=(-d -p -r -s -v)
|
|
return 0
|
|
fi
|
|
if [[ $prev == -[dr] ]]; then
|
|
len=${#cur}
|
|
idx=0
|
|
for pval in $( mailq | \
|
|
sed -e '1d; $d; /^[^0-9A-Z]\|^$/d; s/[* ].*$//' ); do
|
|
if [[ "$cur" == "${pval:0:$len}" ]]; then
|
|
COMPREPLY[$idx]=$pval
|
|
idx=$(($idx+1))
|
|
fi
|
|
done
|
|
return 0
|
|
fi
|
|
_filedir -d
|
|
return 0
|
|
}
|
|
complete -F _postsuper postsuper
|
|
}
|
|
|
|
# cvs(1) completion
|
|
#
|
|
have cvs && {
|
|
set_prefix()
|
|
{
|
|
[ -z ${prefix:-} ] || prefix=${cur%/*}/
|
|
[ -r ${prefix:-}CVS/Entries ] || prefix=""
|
|
}
|
|
|
|
get_entries()
|
|
{
|
|
[ -r ${prefix:-}CVS/Entries ] && \
|
|
entries=( $( compgen -W \
|
|
"$( echo $( cut -d/ -f2 -s ${prefix}CVS/Entries ) )" -- $cur ) )
|
|
}
|
|
|
|
get_modules()
|
|
{
|
|
if [ -n "$prefix" ]; then
|
|
COMPREPLY=( $( command ls -d ${cvsroot}/${prefix}/!(CVSROOT) ) )
|
|
else
|
|
COMPREPLY=( $( command ls -d ${cvsroot}/!(CVSROOT) ) )
|
|
fi
|
|
}
|
|
|
|
_cvs()
|
|
{
|
|
local cur count mode i cvsroot pwd
|
|
local -a flags miss files entries changed newremoved
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
count=0
|
|
for i in ${COMP_WORDS[@]}; do
|
|
[ $count -eq $COMP_CWORD ] && break
|
|
if [ -z "$mode" ]; then
|
|
case $i in
|
|
-d)
|
|
cvsroot=${COMP_WORDS[((count+1))]}
|
|
;;
|
|
@(add|new))
|
|
mode=add
|
|
;;
|
|
@(admin|rcs))
|
|
mode=admin
|
|
;;
|
|
@(checkout|co|get))
|
|
mode=checkout
|
|
;;
|
|
@(commit|ci))
|
|
mode=commit
|
|
;;
|
|
@(annotate|diff|@(ex|im)port|history|release|status|update|edit|unedit))
|
|
mode=$i
|
|
;;
|
|
?(r)log)
|
|
mode=log
|
|
;;
|
|
@(rdiff|patch))
|
|
mode=rdiff
|
|
;;
|
|
@(remove|rm|delete))
|
|
mode=remove
|
|
;;
|
|
@(rtag|rfreeze))
|
|
mode=rtag
|
|
;;
|
|
@(tag|freeze))
|
|
mode=tag
|
|
;;
|
|
*)
|
|
;;
|
|
esac
|
|
elif [[ "$i" = -* ]]; then
|
|
flags=( ${flags[@]} $i )
|
|
fi
|
|
count=$((++count))
|
|
done
|
|
|
|
case "$mode" in
|
|
add)
|
|
if [[ "$cur" != -* ]]; then
|
|
set_prefix
|
|
if [ $COMP_CWORD -gt 1 -a -r ${prefix}CVS/Entries ]; then
|
|
get_entries
|
|
[ -z "$cur" ] && \
|
|
files=$( command ls -Ad !(CVS) ) || \
|
|
files=$( command ls -d ${cur}* 2>/dev/null )
|
|
for i in ${entries[@]}; do
|
|
files=( ${files[@]/#$i//} )
|
|
done
|
|
COMPREPLY=( $( compgen -W '${files[@]}' -- \
|
|
$cur ) )
|
|
fi
|
|
else
|
|
COMPREPLY=( $( compgen -W '-k -m' -- $cur ) )
|
|
fi
|
|
;;
|
|
admin)
|
|
if [[ "$cur" = -* ]]; then
|
|
COMPREPLY=( $( compgen -W '-i -a -A -e -b -c -k -l -u \
|
|
-L -U -m -M -n -N -o -q -I \
|
|
-s -t -t- -T -V -x -z' -- \
|
|
$cur ) )
|
|
fi
|
|
;;
|
|
checkout)
|
|
if [[ "$cur" != -* ]]; then
|
|
[ -z "$cvsroot" ] && cvsroot=$CVSROOT
|
|
COMPREPLY=( $( cvs -d "$cvsroot" co -c | awk '{print $1}' ) )
|
|
COMPREPLY=( $( compgen -W '${COMPREPLY[@]}' -- $cur ) )
|
|
else
|
|
COMPREPLY=( $( compgen -W '-A -N -P -R -c -f -l -n -p \
|
|
-s -r -D -d -k -j' -- $cur ) )
|
|
fi
|
|
;;
|
|
commit)
|
|
set_prefix
|
|
|
|
if [[ "$cur" != -* ]] && [ -r ${prefix}CVS/Entries ]; then
|
|
# if $COMP_CVS_REMOTE is not null, 'cvs commit' will
|
|
# complete on remotely checked-out files (requires
|
|
# passwordless access to the remote repository
|
|
if [ -n "$COMP_CVS_REMOTE" ]; then
|
|
# this is the least computationally intensive
|
|
# way found so far, but other changes
|
|
# (something other than changed/removed/new)
|
|
# may be missing
|
|
changed=( $( cvs diff --brief 2>&1 | \
|
|
sed -ne 's/^Files [^ ]* and \([^ ]*\) differ$/\1/p' ) )
|
|
newremoved=( $( cvs diff --brief 2>&1 | \
|
|
sed -ne 's/^cvs diff: \([^ ]*\) .*, no comparison available$/\1/p' ) )
|
|
COMPREPLY=( $( compgen -W '${changed[@]} \
|
|
${newremoved[@]}' -- $cur ) )
|
|
else
|
|
COMPREPLY=( $( compgen -f -- $cur ) )
|
|
fi
|
|
else
|
|
COMPREPLY=( $( compgen -W '-n -R -l -f -F -m -r' -- \
|
|
$cur ) )
|
|
fi
|
|
;;
|
|
diff)
|
|
if [[ "$cur" == -* ]]; then
|
|
_longopt diff
|
|
else
|
|
get_entries
|
|
COMPREPLY=( ${entries[@]:-} )
|
|
fi
|
|
;;
|
|
remove)
|
|
if [[ "$cur" != -* ]]; then
|
|
set_prefix
|
|
if [ $COMP_CWORD -gt 1 -a -r ${prefix}CVS/Entries ]; then
|
|
get_entries
|
|
# find out what files are missing
|
|
for i in ${entries[@]}; do
|
|
[ ! -r "$i" ] && miss=( ${miss[@]} $i )
|
|
done
|
|
COMPREPLY=( $(compgen -W '${miss[@]}' -- $cur) )
|
|
fi
|
|
else
|
|
COMPREPLY=( $( compgen -W '-f -l -R' -- $cur ) )
|
|
fi
|
|
;;
|
|
import)
|
|
if [[ "$cur" != -* ]]; then
|
|
# starts with same algorithm as checkout
|
|
[ -z "$cvsroot" ] && cvsroot=$CVSROOT
|
|
prefix=${cur%/*}
|
|
if [ -r ${cvsroot}/${prefix} ]; then
|
|
get_modules
|
|
COMPREPLY=( ${COMPREPLY[@]#$cvsroot} )
|
|
COMPREPLY=( ${COMPREPLY[@]#\/} )
|
|
fi
|
|
pwd=$( pwd )
|
|
pwd=${pwd##*/}
|
|
COMPREPLY=( $( compgen -W '${COMPREPLY[@]} $pwd' -- \
|
|
$cur ) )
|
|
else
|
|
COMPREPLY=( $( compgen -W '-d -k -I -b -m -W' -- $cur ))
|
|
fi
|
|
;;
|
|
"")
|
|
COMPREPLY=( $( compgen -W 'add admin annotate checkout ci co \
|
|
commit diff delete edit export \
|
|
freeze get history import log new \
|
|
patch rcs rdiff release remove \
|
|
rfreeze rlog rm rtag status tag \
|
|
unedit update -H -Q -q -b -d -e -f \
|
|
-l -n -t -r -v -w -x -z --help \
|
|
--version' -- $cur ) )
|
|
;;
|
|
*)
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -F _cvs $default cvs
|
|
}
|
|
|
|
have rpm && {
|
|
# helper functions for rpm completion
|
|
#
|
|
_rpm_installed_packages()
|
|
{
|
|
local i
|
|
|
|
if [ -r /var/log/rpmpkgs -a \
|
|
/var/log/rpmpkgs -nt /var/lib/rpm/Packages ]; then
|
|
# using RHL 7.2 - this is quicker than querying the DB
|
|
COMPREPLY=( $( sed -ne \
|
|
's|^\('$cur'.*\)-[0-9a-zA-Z._]\+-[0-9a-z.@]\+.*\.rpm$|\1|p' \
|
|
/var/log/rpmpkgs ) )
|
|
else
|
|
COMPREPLY=( $( rpm -qa | sed -ne \
|
|
's|^\('$cur'.*\)-[0-9a-zA-Z._]\+-[0-9a-z.@]\+$|\1|p' ) )
|
|
fi
|
|
}
|
|
|
|
_rpm_groups()
|
|
{
|
|
local IFS=$'\t'
|
|
# remove trailing backslash, or grep will complain
|
|
cur=${cur%"\\"}
|
|
COMPREPLY=( $( rpm -qa --queryformat '%{group}\n' | grep "^$cur" ) )
|
|
# backslash escape spaces and translate newlines to tabs
|
|
COMPREPLY=( $( echo ${COMPREPLY[@]} | sed 's/ /\\ /g' | tr '\n' '\t' ) )
|
|
}
|
|
|
|
# rpm(8) completion
|
|
#
|
|
_rpm()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
if [ $COMP_CWORD -eq 1 ]; then
|
|
# first parameter on line
|
|
case "$cur" in
|
|
-b*)
|
|
COMPREPLY=( $( compgen -W '-ba -bb -bc -bi -bl -bp -bs'\
|
|
-- $cur ) )
|
|
;;
|
|
-t*)
|
|
COMPREPLY=( $( compgen -W '-ta -tb -tc -ti -tl -tp -ts'\
|
|
-- $cur ) )
|
|
;;
|
|
--*)
|
|
COMPREPLY=( $( compgen -W '--help --version --initdb \
|
|
--checksig --recompile --rebuild --resign --addsign \
|
|
--rebuilddb --showrc --setperms --setugids --tarbuild \
|
|
--eval --install --upgrade --query --freshen --erase \
|
|
--verify --querytags --rmsource --rmspec --clean \
|
|
--import' -- $cur ) )
|
|
;;
|
|
*)
|
|
COMPREPLY=( $( compgen -W '-b -e -F -i -q -t -U -V' \
|
|
-- $cur ) )
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
fi
|
|
|
|
case "$prev" in
|
|
--@(@(db|exclude)path|prefix|relocate|root))
|
|
_filedir -d
|
|
return 0
|
|
;;
|
|
--eval)
|
|
# get a list of macros
|
|
COMPREPLY=( $( sed -ne 's|^\(%'${cur#\%}'[^ '$'\t'']*\).*$|\1|p' \
|
|
/usr/lib/rpm/macros ) )
|
|
return 0
|
|
;;
|
|
--pipe)
|
|
COMPREPLY=( $( compgen -c -- $cur ) )
|
|
return 0
|
|
;;
|
|
--rcfile)
|
|
_filedir
|
|
return 0
|
|
;;
|
|
--specfile)
|
|
# complete on .spec files
|
|
_filedir spec
|
|
return 0
|
|
;;
|
|
--whatprovides)
|
|
if [[ "$cur" == */* ]]; then
|
|
_filedir
|
|
else
|
|
# complete on capabilities
|
|
COMPREPLY=( $( rpm -qa --queryformat \
|
|
'%{providename}\n' | grep "^$cur" ) )
|
|
fi
|
|
return 0
|
|
;;
|
|
--whatrequires)
|
|
# complete on capabilities
|
|
COMPREPLY=( $( rpm -qa --queryformat '%{requirename}\n' | \
|
|
grep "^$cur" ) )
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
case "${COMP_WORDS[1]}" in
|
|
-@([iFU]*|-install|-freshen|-upgrade))
|
|
if [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( compgen -W '--percent --force --test \
|
|
--replacepkgs --replacefiles --root --excludedocs \
|
|
--includedocs --noscripts --rcfile --ignorearch \
|
|
--dbpath --prefix --ignoreos --nodeps --allfiles \
|
|
--ftpproxy --ftpport --justdb --httpproxy --httpport \
|
|
--noorder --relocate --badreloc --notriggers \
|
|
--excludepath --ignoresize --oldpackage --define \
|
|
--eval --pipe --queryformat --repackage --nosuggests \
|
|
--nodigest --nosignature' -- $cur ) )
|
|
else
|
|
_filedir 'rpm'
|
|
fi
|
|
;;
|
|
-@(e|-erase))
|
|
if [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( compgen -W '--allmatches --noscripts \
|
|
--notriggers --nodeps --test --repackage' -- $cur ) )
|
|
else
|
|
_rpm_installed_packages
|
|
fi
|
|
;;
|
|
-@(q*|-query))
|
|
# check whether we're doing file completion
|
|
if [ "${COMP_LINE#* -*([^ -])f}" != "$COMP_LINE" ]; then
|
|
_filedir
|
|
elif [ "${COMP_LINE#* -*([^ -])g}" != "$COMP_LINE" ]; then
|
|
_rpm_groups
|
|
elif [ "${COMP_LINE#* -*([^ -])p}" != "$COMP_LINE" ]; then
|
|
# uninstalled package completion
|
|
if [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( compgen -W '--scripts --root \
|
|
--rcfile --whatprovides --whatrequires \
|
|
--requires --triggeredby --ftpport --ftpproxy \
|
|
--httpproxy --httpport --provides --triggers \
|
|
--dump --changelog --dbpath --filesbypkg \
|
|
--define --eval --pipe --showrc --info --list \
|
|
--state --docfiles --configfiles --queryformat \
|
|
--conflicts --obsoletes --nodigest \
|
|
--nosignature' -- $cur ) )
|
|
else
|
|
_filedir 'rpm'
|
|
fi
|
|
else
|
|
# installed package completion
|
|
if [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( compgen -W '--scripts --root \
|
|
--rcfile --whatprovides --whatrequires \
|
|
--requires --triggeredby --ftpport --ftpproxy \
|
|
--httpproxy --httpport --provides --triggers \
|
|
--dump --changelog --dbpath --specfile \
|
|
--querybynumber --last --filesbypkg --define \
|
|
--eval --pipe --showrc --info --list --state \
|
|
--docfiles --configfiles --queryformat \
|
|
--conflicts --obsoletes --pkgid --hdrid \
|
|
--fileid --tid --nodigest --nosignature' \
|
|
-- $cur ) )
|
|
elif [ "${COMP_LINE#* -*([^ -])a}" == "$COMP_LINE" ]; then
|
|
_rpm_installed_packages
|
|
fi
|
|
fi
|
|
;;
|
|
-@(K*|-checksig))
|
|
if [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( compgen -W '--nopgp --nogpg --nomd5 \
|
|
--nodigest --nosignature' -- $cur ) )
|
|
else
|
|
_filedir 'rpm'
|
|
fi
|
|
;;
|
|
-@([Vy]*|-verify))
|
|
if [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( compgen -W '--root --rcfile --dbpath \
|
|
--nodeps --nofiles --noscripts --nomd5 --querytags \
|
|
--specfile --whatrequires --whatprovides --nodigest \
|
|
--nosignature' -- $cur ) )
|
|
# check whether we're doing file completion
|
|
elif [ "${COMP_LINE#* -*([^ -])f}" != "$COMP_LINE" ]; then
|
|
_filedir
|
|
elif [ "${COMP_LINE#* -*([^ -])g}" != "$COMP_LINE" ]; then
|
|
_rpm_groups
|
|
elif [ "${COMP_LINE#* -*([^ -])p}" != "$COMP_LINE" ]; then
|
|
_filedir 'rpm'
|
|
else
|
|
_rpm_installed_packages
|
|
fi
|
|
;;
|
|
-[bt]*)
|
|
if [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( compgen -W '--short-circuit --timecheck \
|
|
--clean --rmsource --rmspec --test --sign --buildroot \
|
|
--targetbuildarch --buildos --nobuild --nodeps \
|
|
--nodirtokens' -- $cur ) )
|
|
elif [[ ${COMP_WORDS[1]} == -b* ]]; then
|
|
_filedir 'spec'
|
|
else
|
|
_filedir '@(tgz|tar.@(gz|bz2))'
|
|
fi
|
|
;;
|
|
--re@(build|compile))
|
|
if [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( compgen -W '--nodeps --rmsource \
|
|
--rmspec --sign --nodirtokens' -- $cur ) )
|
|
else
|
|
_filedir 'src.rpm'
|
|
fi
|
|
;;
|
|
--tarbuild)
|
|
_filedir '@(tgz|tar.@(gz|bz2))'
|
|
;;
|
|
--@(re|add)sign)
|
|
_filedir 'rpm'
|
|
;;
|
|
--set@(perms|gids))
|
|
_rpm_installed_packages
|
|
;;
|
|
--@(clean|rms@(ource|pec)))
|
|
if [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( compgen -W '--clean --rmsource \
|
|
--rmspec' -- $cur ) )
|
|
else
|
|
_filedir 'spec'
|
|
fi
|
|
;;
|
|
--@(import|dbpath|root))
|
|
if [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( compgen -W '--import --dbpath --root' \
|
|
-- $cur ) )
|
|
else
|
|
_filedir
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -F _rpm $filenames rpm rpmbuild
|
|
}
|
|
|
|
# Debian apt-get(8) completion.
|
|
#
|
|
have apt-get &&
|
|
_apt_get()
|
|
{
|
|
local cur prev special i
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
for (( i=0; i < ${#COMP_WORDS}-1; i++ )); do
|
|
if [[ ${COMP_WORDS[i]} == @(install|remove|source|build-dep) ]]; then
|
|
special=${COMP_WORDS[i]}
|
|
fi
|
|
done
|
|
|
|
if [ -n "$special" ]; then
|
|
case $special in
|
|
remove)
|
|
if [ -f /etc/debian_version ]; then
|
|
# Debian system
|
|
COMPREPLY=( $( _comp-dpkg-installed-packages \
|
|
$cur ) )
|
|
else
|
|
# assume RPM based
|
|
_rpm_installed_packages
|
|
fi
|
|
return 0
|
|
;;
|
|
*)
|
|
COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
|
|
return 0
|
|
;;
|
|
|
|
esac
|
|
fi
|
|
|
|
case "$prev" in
|
|
-@(c|-config-file))
|
|
_filedir
|
|
return 0
|
|
;;
|
|
|
|
-@(t|-target-release|-default-release))
|
|
COMPREPLY=( $( apt-cache policy | \
|
|
grep "release.o=Debian,a=$cur" | \
|
|
sed -e "s/.*a=\(\w*\).*/\1/" | uniq ) )
|
|
return 0
|
|
;;
|
|
|
|
esac
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
|
|
COMPREPLY=( $( compgen -W '-d -f -h -v -m -q -s -y \
|
|
-u -t -b -c -o --download-only --fix-broken \
|
|
--help --version --ignore-missing \
|
|
--fix-missing --no-download --quiet --simulate \
|
|
--just-print --dry-run --recon --no-act --yes \
|
|
--assume-yes --show-upgraded --only-source \
|
|
--compile --build --ignore-hold \
|
|
--target-release --no-upgrade --force-yes \
|
|
--print-uris --purge --reinstall \
|
|
--list-cleanup --default-release \
|
|
--trivial-only --no-remove --diff-only \
|
|
--tar-only --config-file --option' -- $cur ) )
|
|
else
|
|
|
|
COMPREPLY=( $( compgen -W 'update upgrade dselect-upgrade \
|
|
dist-upgrade install remove source build-dep \
|
|
check clean autoclean' -- $cur ) )
|
|
|
|
fi
|
|
|
|
|
|
return 0
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _apt_get $filenames apt-get
|
|
|
|
# Debian apt-cache(8) completion.
|
|
#
|
|
have apt-cache &&
|
|
_apt_cache()
|
|
{
|
|
local cur prev special i
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
|
|
if [ "$cur" != show ]; then
|
|
for (( i=0; i < ${#COMP_WORDS}-1; i++ )); do
|
|
if [[ ${COMP_WORDS[i]} == @(add|depends|dotty|policy|show?(pkg)) ]]; then
|
|
special=${COMP_WORDS[i]}
|
|
fi
|
|
done
|
|
fi
|
|
|
|
|
|
if [ -n "$special" ]; then
|
|
case $special in
|
|
add)
|
|
_filedir
|
|
return 0
|
|
;;
|
|
|
|
*)
|
|
COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
|
|
return 0
|
|
;;
|
|
|
|
esac
|
|
fi
|
|
|
|
|
|
case "$prev" in
|
|
-@(c|p|s|-config-file|-@(pkg|src)-cache))
|
|
_filedir
|
|
return 0
|
|
;;
|
|
search)
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
|
|
COMPREPLY=( $( compgen -W '-h -v -p -s -q -i -f -a -g -c \
|
|
-o --help --version --pkg-cache --src-cache \
|
|
--quiet --important --full --all-versions \
|
|
--generate --no-generate --names-only \
|
|
--all-names --config-file --option \
|
|
--recurse' -- $cur ) )
|
|
else
|
|
|
|
COMPREPLY=( $( compgen -W 'add gencaches showpkg show stats \
|
|
dumpavail unmet check search dump dotty policy \
|
|
depends pkgnames' -- $cur ) )
|
|
|
|
fi
|
|
|
|
|
|
return 0
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _apt_cache $filenames apt-cache
|
|
|
|
|
|
# Debian aptitude(1) completion
|
|
#
|
|
have aptitude && {
|
|
_comp-dpkg-hold-packages()
|
|
{
|
|
grep -B 2 'hold' /var/lib/dpkg/status | grep "Package: $1" \
|
|
| cut -d\ -f2
|
|
}
|
|
|
|
_aptitude()
|
|
{
|
|
local cur dashoptions prev special i
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
|
|
dashoptions='-S -u -i -h --help --version -s --simulate -d \
|
|
--download-only -P --prompt -y --assume-yes -F \
|
|
--display-format -w --width -f --with-recommends \
|
|
--with-suggests --without-recommends --without-suggests'
|
|
|
|
for (( i=0; i < ${#COMP_WORDS}-1; i++ )); do
|
|
if [[ ${COMP_WORDS[i]} == @(install|hold|unhold|markauto|unmarkauto|dist-upgrade|download|purge|remove) ]]; then
|
|
special=${COMP_WORDS[i]}
|
|
fi
|
|
#exclude some mutually exclusive options
|
|
[[ ${COMP_WORDS[i]} == '-u' ]] && dashoptions=${dashoptions/-i}
|
|
[[ ${COMP_WORDS[i]} == '-i' ]] && dashoptions=${dashoptions/-u}
|
|
done
|
|
|
|
if [[ -n "$special" ]]; then
|
|
case $special in
|
|
@(install|hold|markauto|unmarkauto|dist-upgrade|download))
|
|
COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
|
|
return 0
|
|
;;
|
|
@(purge|remove))
|
|
COMPREPLY=( $( _comp-dpkg-installed-packages $cur ) )
|
|
return 0
|
|
;;
|
|
unhold)
|
|
COMPREPLY=( $( _comp-dpkg-hold-packages $cur ) )
|
|
return 0
|
|
;;
|
|
|
|
esac
|
|
fi
|
|
|
|
case $prev in
|
|
# don't complete anything if these options are found
|
|
@(autoclean|clean|forget-new|search|upgrade|update))
|
|
return 0
|
|
;;
|
|
-S)
|
|
_filedir
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( compgen -W "$dashoptions" -- $cur ) )
|
|
else
|
|
COMPREPLY=( $( compgen -W 'update upgrade forget-new clean \
|
|
autoclean install remove hold unhold \
|
|
purge markauto unmarkauto dist-upgrade \
|
|
download search' -- $cur ) )
|
|
fi
|
|
|
|
|
|
return 0
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _aptitude $default aptitude
|
|
}
|
|
|
|
# Debian apt-build(1) completion.
|
|
#
|
|
have apt-build &&
|
|
_apt_build()
|
|
{
|
|
local cur prev special i
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
for (( i=0; i < ${#COMP_WORDS}-1; i++ )); do
|
|
if [[ ${COMP_WORDS[i]} == @(install|remove|source|info|clean) ]]; then
|
|
special=${COMP_WORDS[i]}
|
|
fi
|
|
done
|
|
|
|
if [ -n "$special" ]; then
|
|
case $special in
|
|
@(install|source|info))
|
|
COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
|
|
return 0
|
|
;;
|
|
remove)
|
|
COMPREPLY=( $( _comp-dpkg-installed-packages \
|
|
$cur ) )
|
|
return 0
|
|
;;
|
|
*)
|
|
return 0
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
case "$prev" in
|
|
|
|
--@(patch|build-dir|repository-dir))
|
|
_filedir
|
|
return 0
|
|
;;
|
|
|
|
-@(h|-help))
|
|
return 0
|
|
;;
|
|
|
|
esac
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( compgen -W '--help --show-upgraded -u --build-dir \
|
|
--repository-dir --build-only \
|
|
--build-command --reinstall --rebuild \
|
|
--remove-builddep --no-wrapper --purge \
|
|
--patch --patch-strip -p --yes -y \
|
|
--version -v --no-source' -- $cur ) )
|
|
|
|
else
|
|
COMPREPLY=( $( compgen -W 'update upgrade install remove \
|
|
source dist-upgrade world clean info \
|
|
clean-build update-repository ' -- $cur ) )
|
|
fi
|
|
|
|
|
|
return 0
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _apt_build $filenames apt-build
|
|
|
|
# chsh(1) completion
|
|
#
|
|
_chsh()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
if [ "$prev" = "-s" ]; then
|
|
COMPREPLY=( $( chsh -l | grep "^$cur" ) )
|
|
else
|
|
COMPREPLY=( $( compgen -u -- $cur ) )
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
complete -F _chsh chsh
|
|
|
|
# chkconfig(8) completion
|
|
#
|
|
have chkconfig &&
|
|
_chkconfig()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
if [ $COMP_CWORD -eq 1 ]; then
|
|
COMPREPLY=( $( compgen -W '--list --add --del --level' -- \
|
|
$cur ) )
|
|
return 0
|
|
fi
|
|
|
|
if [ $COMP_CWORD -eq 4 ]; then
|
|
COMPREPLY=( $( compgen -W 'on off reset' -- $cur ) )
|
|
return 0
|
|
fi
|
|
|
|
case "$prev" in
|
|
@([1-6]|--@(list|add|del)))
|
|
COMPREPLY=( $( compgen -W "`(cd /etc/rc.d/init.d; echo *)`" \
|
|
-- $cur) )
|
|
return 0
|
|
;;
|
|
--level)
|
|
COMPREPLY=( $( compgen -W '1 2 3 4 5 6' -- $cur ) )
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _chkconfig chkconfig
|
|
|
|
# This function provides simple user@host completion
|
|
#
|
|
_user_at_host() {
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
if [[ $cur == *@* ]]; then
|
|
_known_hosts
|
|
else
|
|
COMPREPLY=( $( compgen -S '@' -u -- "$cur" ) )
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
shopt -u hostcomplete && complete -F _user_at_host $nospace talk ytalk finger
|
|
|
|
# This function performs host completion based on ssh's known_hosts files,
|
|
# defaulting to standard host completion if they don't exist.
|
|
#
|
|
_known_hosts()
|
|
{
|
|
local cur ocur user suffix aliases global_kh user_kh hosts
|
|
local -a kh config
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
ocur=$cur
|
|
|
|
[ "$1" = -a ] || [ "$2" = -a ] && aliases='yes'
|
|
[ "$1" = -c ] || [ "$2" = -c ] && suffix=':'
|
|
[[ $cur == *@* ]] && user=${cur%@*}@ && cur=${cur#*@}
|
|
kh=()
|
|
|
|
# ssh config files
|
|
[ -r /etc/ssh/ssh_config ] && config[0]=/etc/ssh/ssh_config
|
|
[ -r ~/.ssh/config ] && config[1]=~/.ssh/config
|
|
|
|
if [ ${#config[@]} -gt 0 ]; then
|
|
# expand path (if present) to global known hosts file
|
|
global_kh=$( eval echo $( sed -ne 's/^[Gg][Ll][Oo][Bb][Aa][Ll][Kk][Nn][Oo][Ww][Nn][Hh][Oo][Ss][Tt][Ss][Ff][Ii][Ll][Ee]['$'\t '']*\(.*\)$/\1/p' ${config[@]} ) )
|
|
# expand path (if present) to user known hosts file
|
|
user_kh=$( eval echo $( sed -ne 's/^[Uu][Ss][Ee][Rr][Kk][Nn][Oo][Ww][Nn][Hh][Oo][Ss][Tt][Ss][Ff][Ii][Ll][Ee]['$'\t '']*\(.*\)$/\1/p' ${config[@]} ) )
|
|
fi
|
|
|
|
# choose which global known hosts file to use
|
|
if [ -r "$global_kh" ]; then
|
|
kh=( "$global_kh" )
|
|
else
|
|
[ -r /etc/known_hosts ] && kh[0]=/etc/known_hosts
|
|
[ -r /etc/known_hosts2 ] && kh[1]=/etc/known_hosts2
|
|
fi
|
|
|
|
# choose which user known hosts file to use
|
|
if [ -r "$user_kh" ]; then
|
|
kh=( ${kh[@]} "$user_kh" )
|
|
else
|
|
[ -r ~/.ssh/known_hosts ] && kh=( ${kh[@]} ~/.ssh/known_hosts )
|
|
[ -r ~/.ssh/known_hosts2 ] && kh=( ${kh[@]} ~/.ssh/known_hosts2 )
|
|
fi
|
|
|
|
# If we have known_hosts files to use
|
|
if [ ${#kh[@]} -gt 0 ]; then
|
|
# Escape slashes and dots in paths for awk
|
|
cur=${cur//\//\\\/}
|
|
cur=${cur//\./\\\.}
|
|
|
|
if [[ "$cur" == [0-9]*.* ]]; then
|
|
# Digits followed by a dot - just search for that
|
|
cur="^$cur.*"
|
|
elif [[ "$cur" == [0-9]* ]]; then
|
|
# Digits followed by no dot - search for digits followed
|
|
# by a dot
|
|
cur="^$cur.*\."
|
|
elif [ -z "$cur" ]; then
|
|
# A blank - search for a dot or an alpha character
|
|
cur="[a-z.]"
|
|
else
|
|
cur="^$cur"
|
|
fi
|
|
|
|
# FS needs to look for a comma separated list
|
|
COMPREPLY=( $( awk 'BEGIN {FS=","}
|
|
{for (i=1; i<=2; ++i) { \
|
|
gsub(" .*$", "", $i); \
|
|
if ($i ~ /'$cur'/) {print $i} \
|
|
}}' ${kh[@]} ) )
|
|
|
|
# append any available aliases from config files
|
|
if [ ${#config[@]} -gt 0 ] && [ -n "$aliases" ]; then
|
|
hosts=$( compgen -W "$( echo $( sed -ne "s/^[Hh][Oo][Ss][Tt]["$'\t '"]*\([^*?]*\)$/\1/p" ${config[@]} ) )" -- $ocur )
|
|
COMPREPLY=( ${COMPREPLY[@]} $hosts )
|
|
fi
|
|
|
|
# apply suffix
|
|
for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
|
|
COMPREPLY[i]=$user${COMPREPLY[i]}$suffix
|
|
done
|
|
else
|
|
# Just do normal hostname completion
|
|
COMPREPLY=( $( compgen -A hostname -S "$suffix" -- $cur ) )
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
complete -F _known_hosts traceroute traceroute6 tracepath tracepath6 \
|
|
ping fping telnet host nslookup rsh rlogin ftp
|
|
|
|
# ssh(1) completion
|
|
#
|
|
have ssh && {
|
|
_ssh()
|
|
{
|
|
local cur prev
|
|
local -a config
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
case "$prev" in
|
|
-*c)
|
|
COMPREPLY=( $( compgen -W 'blowfish 3des 3des-cbc blowfish-cbc \
|
|
arcfour cast128-cbc' -- $cur ) )
|
|
;;
|
|
-*i)
|
|
_filedir
|
|
;;
|
|
-*l)
|
|
COMPREPLY=( $( compgen -u -- $cur ) )
|
|
;;
|
|
*)
|
|
_known_hosts -a
|
|
|
|
[ $COMP_CWORD -eq 1 ] || \
|
|
COMPREPLY=( ${COMPREPLY[@]} $( compgen -c -- $cur ) )
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
shopt -u hostcomplete && complete -F _ssh ssh slogin sftp
|
|
|
|
# scp(1) completion
|
|
#
|
|
_scp()
|
|
{
|
|
local cur userhost path
|
|
|
|
local IFS=$'\t\n'
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
_expand || return 0
|
|
|
|
if [[ "$cur" == *:* ]]; then
|
|
# remove backslash escape from :
|
|
cur=${cur/\\:/:}
|
|
userhost=${cur%%?(\\):*}
|
|
path=${cur#*:}
|
|
# unescape spaces
|
|
path=${path//\\\\\\\\ / }
|
|
if [ -z "$path" ]; then
|
|
# default to home dir of specified user on remote host
|
|
path=$(ssh -o 'Batchmode yes' $userhost pwd 2>/dev/null)
|
|
fi
|
|
# escape spaces; remove executables, aliases, pipes and sockets;
|
|
# add space at end of file names
|
|
COMPREPLY=( $( ssh -o 'Batchmode yes' $userhost \
|
|
command ls -aF1d "$path*" 2>/dev/null | \
|
|
sed -e 's/ /\\\\\\\ /g' -e 's/[*@|=]$//g' \
|
|
-e 's/[^\/]$/& /g' ) )
|
|
return 0
|
|
fi
|
|
|
|
[[ "$cur" == */* ]] || _known_hosts -c -a
|
|
COMPREPLY=( ${COMPREPLY[@]} $( command ls -aF1d "$cur"* \
|
|
2>/dev/null | sed -e 's/ /\\ /g' -e 's/[*@|=]$//g' \
|
|
-e 's/[^\/]$/& /g' ) )
|
|
|
|
|
|
|
|
return 0
|
|
}
|
|
complete -F _scp $nospace scp
|
|
}
|
|
|
|
# Linux route(8) completion
|
|
#
|
|
[ $UNAME = Linux ] &&
|
|
_route()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
if [ "$prev" = dev ]; then
|
|
COMPREPLY=( $( ifconfig -a | sed -ne 's|^\('$cur'[^ ]*\).*$|\1|p' ))
|
|
return 0
|
|
fi
|
|
|
|
COMPREPLY=( $( compgen -W 'add del -host -net netmask metric mss \
|
|
window irtt reject mod dyn reinstate dev \
|
|
default gw' -- $cur ) )
|
|
|
|
COMPREPLY=( $( echo " ${COMP_WORDS[@]}" | \
|
|
(while read -d ' ' i; do
|
|
[ "$i" == "" ] && continue
|
|
# flatten array with spaces on either side,
|
|
# otherwise we cannot grep on word
|
|
# boundaries of first and last word
|
|
COMPREPLY=" ${COMPREPLY[@]} "
|
|
# remove word from list of completions
|
|
COMPREPLY=( ${COMPREPLY/ $i / } )
|
|
done
|
|
echo ${COMPREPLY[@]})
|
|
) )
|
|
return 0
|
|
}
|
|
[ $UNAME = Linux ] && complete -F _route route
|
|
|
|
# GNU make(1) completion (adapted from the example supplied with the bash 2.04
|
|
# source code)
|
|
#
|
|
have make &&
|
|
_make()
|
|
{
|
|
local mdef makef gcmd cur prev i
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
# if prev argument is -f, return possible filename completions.
|
|
# we could be a little smarter here and return matches against
|
|
# `makefile Makefile *.mk', whatever exists
|
|
if [[ "$prev" == -*f ]]; then
|
|
_filedir
|
|
return 0
|
|
fi
|
|
|
|
# check for a long option
|
|
if [[ "$cur" == --* ]]; then
|
|
_longopt $1
|
|
return 0
|
|
fi
|
|
|
|
# if we want an option, return the possible posix options
|
|
if [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( compgen -W '-e -f -i -k -n -p -q -r -S -s -t' \
|
|
-- $cur ) )
|
|
return 0
|
|
fi
|
|
|
|
# make reads `makefile' before `Makefile'
|
|
if [ -f makefile ]; then
|
|
mdef=makefile
|
|
elif [ -f Makefile ]; then
|
|
mdef=Makefile
|
|
else
|
|
mdef=*.mk # local convention
|
|
fi
|
|
|
|
# before we scan for targets, see if a makefile name was specified
|
|
# with -f
|
|
for (( i=0; i < ${#COMP_WORDS[@]}; i++ )); do
|
|
if [[ ${COMP_WORDS[i]} == -*f ]]; then
|
|
eval makef=${COMP_WORDS[i+1]} # eval for tilde expansion
|
|
break
|
|
fi
|
|
done
|
|
|
|
[ -z "$makef" ] && makef=$mdef
|
|
|
|
# if we have a partial word to complete, restrict completions to
|
|
# matches of that word
|
|
[ -n "$2" ] && gcmd='grep "^$2"' || gcmd=cat
|
|
|
|
COMPREPLY=( $( grep -v '^\w\w*[[:space:]]*:=' $makef 2>/dev/null | \
|
|
awk 'BEGIN {FS=":"} /^[^.#'$'\t''][^=]*:/ {print $1}' | \
|
|
eval $gcmd ) )
|
|
|
|
# default to filename completion if all else failed
|
|
[ ${#COMPREPLY[@]} -eq 0 ] && _filedir
|
|
|
|
return 0
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _make -X '+($*|*.[ch])' $filenames make gmake pmake
|
|
|
|
# Red Hat Linux service completion. This completes on a list of all available
|
|
# service scripts in the SysV init.d directory, followed by that script's
|
|
# available commands
|
|
#
|
|
have service &&
|
|
_service()
|
|
{
|
|
local cur sysvdir
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
[ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d \
|
|
|| sysvdir=/etc/init.d
|
|
|
|
#[[ "$cur" == -* ]] && return 0
|
|
if [ $COMP_CWORD -eq 1 ]; then
|
|
COMPREPLY=( $( compgen -W '`echo $sysvdir/!(*.rpmsave|*.rpmorig)`' ) )
|
|
COMPREPLY=( $( compgen -W '${COMPREPLY[@]#$sysvdir/}' -- \
|
|
$cur ) )
|
|
else
|
|
COMPREPLY=( $( compgen -W '`sed -ne "y/|/ /; \
|
|
s/^.*Usage.*{\(.*\)}.*$/\1/p" \
|
|
$sysvdir/${COMP_WORDS[1]}`' -- \
|
|
$cur ) )
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _service service
|
|
|
|
# GNU tar(1) completion
|
|
#
|
|
_tar()
|
|
{
|
|
local cur ext regex tar untar
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
if [ $COMP_CWORD -eq 1 ]; then
|
|
COMPREPLY=( $( compgen -W 'c t x u r d A' -- $cur ) )
|
|
return 0
|
|
fi
|
|
|
|
case "${COMP_WORDS[1]}" in
|
|
?(-)c*f)
|
|
_filedir
|
|
return 0
|
|
;;
|
|
+([^Izjy])f)
|
|
ext='tar'
|
|
regex=$ext
|
|
;;
|
|
*z*f)
|
|
ext='t?(ar.)@(gz|Z)'
|
|
regex='t\(ar\.\)\(gz\|Z\)'
|
|
;;
|
|
*[Ijy]*f)
|
|
ext='t?(ar.)bz?(2)'
|
|
regex='t\(ar\.\)bz2\?'
|
|
;;
|
|
*)
|
|
_filedir
|
|
return 0
|
|
;;
|
|
|
|
esac
|
|
|
|
if [[ "$COMP_LINE" == *$ext' ' ]]; then
|
|
# complete on files in tar file
|
|
#
|
|
# get name of tar file from command line
|
|
tar=$( echo "$COMP_LINE" | \
|
|
sed -e 's|^.* \([^ ]*'$regex'\) .*$|\1|' )
|
|
# devise how to untar and list it
|
|
untar=t${COMP_WORDS[1]//[^Izjyf]/}
|
|
|
|
COMPREPLY=( $( compgen -W "$( echo $( tar $untar $tar \
|
|
2>/dev/null ) )" -- "$cur" ) )
|
|
return 0
|
|
fi
|
|
|
|
# file completion on relevant files
|
|
_filedir $ext
|
|
|
|
return 0
|
|
}
|
|
[ -n "${COMP_TAR_INTERNAL_PATHS:-}" ] && complete -F _tar $dirnames tar ||
|
|
complete -F _tar $filenames tar
|
|
|
|
# jar(1) completion
|
|
#
|
|
have jar &&
|
|
_jar()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
if [ $COMP_CWORD = 1 ]; then
|
|
COMPREPLY=( $( compgen -W 'c t x u' -- $cur ) )
|
|
return 0
|
|
fi
|
|
|
|
case "${COMP_WORDS[1]}" in
|
|
*c*f)
|
|
_filedir
|
|
;;
|
|
*f)
|
|
_filedir 'jar'
|
|
;;
|
|
*)
|
|
_filedir
|
|
;;
|
|
esac
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _jar $filenames jar
|
|
|
|
# Linux iptables(8) completion
|
|
#
|
|
have iptables &&
|
|
_iptables()
|
|
{
|
|
local cur prev table chain
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
chain='s/^Chain \([^ ]\+\).*$/\1/p'
|
|
|
|
if [[ $COMP_LINE == *-t\ *filter* ]]; then
|
|
table="-t filter"
|
|
elif [[ $COMP_LINE == *-t\ *nat* ]]; then
|
|
table="-t nat"
|
|
elif [[ $COMP_LINE == *-t\ *mangle* ]]; then
|
|
table="-t mangle"
|
|
fi
|
|
|
|
case "$prev" in
|
|
-*[AIDPFXL])
|
|
COMPREPLY=( $( compgen -W '`iptables $table -nL | \
|
|
sed -ne "s/^Chain \([^ ]\+\).*$/\1/p"`' -- $cur ) )
|
|
;;
|
|
-*t)
|
|
COMPREPLY=( $( compgen -W 'nat filter mangle' -- $cur ) )
|
|
;;
|
|
-j)
|
|
if [ "$table" = "-t filter" -o "$table" = "" ]; then
|
|
COMPREPLY=( $( compgen -W 'ACCEPT DROP LOG ULOG REJECT \
|
|
`iptables $table -nL | sed -ne "$chain" \
|
|
-e "s/INPUT|OUTPUT|FORWARD|PREROUTING|POSTROUTING//"`' -- \
|
|
$cur ) )
|
|
elif [ "$table" = "-t nat" ]; then
|
|
COMPREPLY=( $( compgen -W 'ACCEPT DROP LOG ULOG REJECT \
|
|
MIRROR SNAT DNAT MASQUERADE `iptables $table -nL | \
|
|
sed -ne "$chain" -e "s/OUTPUT|PREROUTING|POSTROUTING//"`' \
|
|
-- $cur ) )
|
|
elif [ "$table" = "-t mangle" ]; then
|
|
COMPREPLY=( $( compgen -W 'ACCEPT DROP LOG ULOG REJECT \
|
|
MARK TOS `iptables $table -nL | sed -ne "$chain" \
|
|
-e "s/INPUT|OUTPUT|FORWARD|PREROUTING|POSTROUTING//"`' -- \
|
|
$cur ) )
|
|
fi
|
|
;;
|
|
*)
|
|
;;
|
|
esac
|
|
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _iptables iptables
|
|
|
|
# tcpdump(8) completion
|
|
#
|
|
have tcpdump &&
|
|
_tcpdump()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
COMPREPLY=( $( compgen -W 'host net port src dst ether gateway \
|
|
less greater' -- $cur ) )
|
|
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _tcpdump tcpdump
|
|
|
|
# autorpm(8) completion
|
|
#
|
|
have autorpm &&
|
|
_autorpm()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
COMPREPLY=( $( compgen -W '--notty --debug --help --version \
|
|
auto add fullinfo info help install list \
|
|
remove set' -- $cur ) )
|
|
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _autorpm autorpm
|
|
|
|
# This meta-cd function observes the CDPATH variable, so that cd additionally
|
|
# completes on directories under those specified in CDPATH.
|
|
#
|
|
_cd()
|
|
{
|
|
local IFS=$'\t\n' cur=${COMP_WORDS[COMP_CWORD]} i j k
|
|
|
|
# Use standard dir completion if no CDPATH or parameter starts with /,
|
|
# ./ or ../
|
|
if [ -z "${CDPATH:-}" ] || [[ "$cur" == ?(.)?(.)/* ]]; then
|
|
_filedir -d
|
|
return 0
|
|
fi
|
|
|
|
IFS=$'\t\n'
|
|
# we have a CDPATH, so loop on its contents
|
|
for i in ${CDPATH//:/$'\t'}; do
|
|
# create an array of matched subdirs
|
|
k=${#COMPREPLY[@]}
|
|
for j in $( compgen -d $i/$cur ); do
|
|
COMPREPLY[$k]=${j#$i/}
|
|
k=$((++k))
|
|
done
|
|
done
|
|
|
|
_filedir -d
|
|
|
|
return 0
|
|
}
|
|
complete -F _cd $nospace $filenames cd
|
|
|
|
# A meta-command completion function for commands like sudo(8), which need to
|
|
# first complete on a command, then complete according to that command's own
|
|
# completion definition - currently not quite foolproof (e.g. mount and umount
|
|
# don't work properly), but still quite useful
|
|
#
|
|
_command()
|
|
{
|
|
local cur func cline cspec
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
if [ $COMP_CWORD -eq 1 ]; then
|
|
COMPREPLY=( $( compgen -c -- $cur ) )
|
|
elif complete -p ${COMP_WORDS[1]} &>/dev/null; then
|
|
cspec=$( complete -p ${COMP_WORDS[1]} )
|
|
if [ "${cspec#*-F }" != "$cspec" ]; then
|
|
# complete -F <function>
|
|
#
|
|
# COMP_CWORD and COMP_WORDS() are not read-only,
|
|
# so we can set them before handing off to regular
|
|
# completion routine
|
|
|
|
# set current token number to 1 less than now
|
|
COMP_CWORD=$(( $COMP_CWORD - 1 ))
|
|
# get function name
|
|
func=${cspec#*-F }
|
|
func=${func%% *}
|
|
# get current command line minus initial command
|
|
cline="${COMP_LINE#$1 }"
|
|
# split current command line tokens into array
|
|
COMP_WORDS=( $cline )
|
|
$func $cline
|
|
# remove any \: generated by a command that doesn't
|
|
# default to filenames or dirnames (e.g. sudo chown)
|
|
if [ "${cspec#*-o }" != "$cspec" ]; then
|
|
cspec=${cspec#*-o }
|
|
cspec=${cspec%% *}
|
|
if [[ "$cspec" != @(dir|file)names ]]; then
|
|
COMPREPLY=( "${COMPREPLY[@]//\\\\:/:}" )
|
|
fi
|
|
fi
|
|
elif [ "${cspec#*-[abcdefgjkvu]}" != "$cspec" ]; then
|
|
# complete -[abcdefgjkvu]
|
|
func=$( echo $cspec | \
|
|
sed -e 's/^.*\(-[abcdefgjkvu]\).*$/\1/' )
|
|
COMPREPLY=( $( compgen $func -- $cur ) )
|
|
elif [ "${cspec#*-A}" != "$cspec" ]; then
|
|
# complete -A <type>
|
|
func=${cspec#*-A }
|
|
func=${func%% *}
|
|
COMPREPLY=( $( compgen -A $func -- $cur ) )
|
|
fi
|
|
fi
|
|
|
|
[ ${#COMPREPLY[@]} -eq 0 ] && _filedir
|
|
}
|
|
complete -F _command $filenames nohup exec nice eval strace time ltrace then \
|
|
else do
|
|
|
|
_root_command()
|
|
{
|
|
PATH=$PATH:/sbin:/usr/sbin:/usr/local/sbin _command $1
|
|
}
|
|
complete -F _root_command $filenames sudo fakeroot
|
|
|
|
# ant(1) completion
|
|
#
|
|
have ant &&
|
|
_ant()
|
|
{
|
|
local cur prev buildfile i
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
case "$prev" in
|
|
-buildfile)
|
|
_filedir 'xml'
|
|
return 0
|
|
;;
|
|
-logfile)
|
|
_filedir
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
# relevant options completion
|
|
COMPREPLY=( $( compgen -W '-help -projecthelp -version -quiet \
|
|
-verbose -debug -emacs -logfile -logger \
|
|
-listener -buildfile -D -find' -- $cur ) )
|
|
else
|
|
# available targets completion
|
|
# find which buildfile to use
|
|
buildfile=build.xml
|
|
for (( i=1; i < COMP_CWORD; i++ )); do
|
|
if [[ "${COMP_WORDS[i]}" == -buildfile ]]; then
|
|
buildfile=${COMP_WORDS[i+1]}
|
|
break
|
|
fi
|
|
done
|
|
[ ! -f $buildfile ] && return 0
|
|
|
|
# parse buildfile for targets
|
|
COMPREPLY=( $( awk -F'"' '/<target name="/ {print $2}' \
|
|
$buildfile | grep "^$cur" ) )
|
|
fi
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _ant $filenames ant
|
|
|
|
have nslookup &&
|
|
_nslookup()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]#-}
|
|
|
|
COMPREPLY=( $( compgen -P '-' -W 'all class= debug d2 domain= \
|
|
srchlist= defname search port= querytype= \
|
|
type= recurse retry root timeout vc \
|
|
ignoretc' -- $cur ) )
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _nslookup nslookup
|
|
|
|
# mysqladmin(1) completion
|
|
#
|
|
have mysqladmin &&
|
|
_mysqladmin()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
case "$prev" in
|
|
-u)
|
|
COMPREPLY=( $( compgen -u -- $cur ) )
|
|
return 0
|
|
;;
|
|
*)
|
|
;;
|
|
esac
|
|
|
|
COMPREPLY=( $( compgen -W '-# -f -? -C -h -p -P -i -r -E -s -S -t -u \
|
|
-v -V -w' -- $cur ) )
|
|
|
|
COMPREPLY=( ${COMPREPLY[@]} \
|
|
$( compgen -W 'create drop extended-status flush-hosts \
|
|
flush-logs flush-status flush-tables \
|
|
flush-threads flush-privileges kill \
|
|
password ping processlist reload refresh \
|
|
shutdown status variables version' \
|
|
-- $cur ) )
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _mysqladmin mysqladmin
|
|
|
|
# gzip(1) and bzip2(1) completion
|
|
#
|
|
have gzip &&
|
|
_zip()
|
|
{
|
|
local IFS cur prev xspec
|
|
|
|
IFS=$'\t\n'
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
[ $1 = "gzip" ] && xspec="*.?(t)gz"
|
|
[ $1 = "bzip2" ] && xspec="*.bz2"
|
|
[[ "$prev" == -*[dt]* ]] && xspec="!"$xspec
|
|
|
|
_expand || return 0
|
|
|
|
COMPREPLY=( $( compgen -f -X "$xspec" -- $cur ) \
|
|
$( compgen -d -- $cur ) )
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _zip $filenames gzip bzip2
|
|
|
|
# openssl(1) completion
|
|
#
|
|
have openssl &&
|
|
_openssl()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
if [ $COMP_CWORD -eq 1 ]; then
|
|
COMPREPLY=( $( compgen -W 'asn1parse ca ciphers crl crl2pkcs7 \
|
|
dgst dh dhparam dsa dsaparam enc errstr gendh gendsa \
|
|
genrsa nseq passwd pkcs12 pkcs7 pkcs8 rand req rsa \
|
|
rsautl s_client s_server s_time sess_id smime speed \
|
|
spkac verify version x509 md2 md4 md5 mdc2 rmd160 sha \
|
|
sha1 base64 bf bf-cbc bf-cfb bf-ecb bf-ofb cast \
|
|
cast-cbc cast5-cbc cast5-cfb cast5-ecb cast5-ofb des \
|
|
des-cbc des-cfb des-ecb des-ede des-ede-cbc \
|
|
des-ede-cfb des-ede-ofb des-ede3 des-ede3-cbc \
|
|
des-ede3-cfb des-ede3-ofb des-ofb des3 desx rc2 \
|
|
rc2-40-cbc rc2-64-cbc rc2-cbc rc2-cfb rc2-ecb rc2-ofb \
|
|
rc4 rc4-40' -- $cur ) )
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _openssl $default openssl
|
|
|
|
# screen(1) completion
|
|
#
|
|
have screen &&
|
|
_screen()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
test "$COMP_CWORD" -ge 2 && preprev=${COMP_WORDS[COMP_CWORD-2]} || unset preprev
|
|
|
|
if test "$preprev" = "-d" -o "$preprev" = "-D" -a "$prev" = "-r" -o "$prev" = "-R"; then
|
|
# list all
|
|
COMPREPLY=( $( command screen -ls | \
|
|
sed -ne 's|^['$'\t'']\+[0-9]\+\.\('$cur'[^'$'\t'']\+\).*$|\1|p' ) )
|
|
else
|
|
case "$prev" in
|
|
-[rR])
|
|
# list detached
|
|
COMPREPLY=( $( command screen -ls | \
|
|
sed -ne 's|^['$'\t'']\+[0-9]\+\.\('$cur'[^'$'\t'']\+\).*Detached.*$|\1|p' ) )
|
|
;;
|
|
-[dDx])
|
|
# list attached
|
|
COMPREPLY=( $( command screen -ls | \
|
|
sed -ne 's|^['$'\t'']\+[0-9]\+\.\('$cur'[^'$'\t'']\+\).*Attached.*$|\1|p' ) )
|
|
;;
|
|
-s)
|
|
# shells
|
|
COMPREPLY=( $( grep ^${cur:-[^#]} /etc/shells ) )
|
|
;;
|
|
*)
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _screen $default screen
|
|
|
|
# lftp(1) bookmark completion
|
|
#
|
|
have lftp &&
|
|
_lftp()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
if [ $COMP_CWORD -eq 1 ] && [ -f ~/.lftp/bookmarks ]; then
|
|
COMPREPLY=( $( compgen -W '$( sed -ne "s/^\(.*\)'$'\t''.*$/\1/p" \
|
|
~/.lftp/bookmarks )' -- $cur ) )
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _lftp $default lftp
|
|
|
|
# ncftp(1) bookmark completion
|
|
#
|
|
have ncftp &&
|
|
_ncftp()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
if [ $COMP_CWORD -eq 1 ] && [ -f ~/.ncftp/bookmarks ]; then
|
|
COMPREPLY=( $( compgen -W '$( sed -ne "s/^\([^,]\{1,\}\),.*$/\1/p" \
|
|
~/.ncftp/bookmarks )' -- $cur ) )
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _ncftp $default ncftp
|
|
|
|
# gdb(1) completion
|
|
#
|
|
have gdb &&
|
|
_gdb()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
if [ $COMP_CWORD -eq 1 ]; then
|
|
COMPREPLY=( $( compgen -c -- $cur ) )
|
|
elif [ $COMP_CWORD -eq 2 ]; then
|
|
prev=${prev##*/}
|
|
COMPREPLY=( $( compgen -W "$( compgen -f core* \
|
|
$( command ps axo comm,pid |
|
|
awk '{if ($1 ~ /^'$prev'/) print $2}' ) )" \
|
|
-- "$cur" ) )
|
|
fi
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _gdb $filenames gdb
|
|
|
|
# Postgresql completion
|
|
#
|
|
have psql && {
|
|
_pg_databases()
|
|
{
|
|
COMPREPLY=( $( psql -l 2>/dev/null | \
|
|
sed -ne 's|^ \('$cur'[^ ]*\).*$|\1|p' ) )
|
|
}
|
|
|
|
_pg_users()
|
|
{
|
|
COMPREPLY=( $( psql -qtc 'select usename from pg_user' 2>/dev/null | \
|
|
grep "^ $cur" ) )
|
|
[ ${#COMPREPLY[@]} -eq 0 ] && COMPREPLY=( $( compgen -u -- $cur ) )
|
|
}
|
|
|
|
# psql(1) completion
|
|
#
|
|
_psql()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
case "$prev" in
|
|
-h|--host)
|
|
_known_hosts
|
|
return 0
|
|
;;
|
|
-U|--username)
|
|
_pg_users
|
|
return 0
|
|
;;
|
|
-d|--dbname)
|
|
_pg_databases
|
|
return 0
|
|
;;
|
|
-@(o|f)|--output|--file)
|
|
_filedir
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
# return list of available options
|
|
COMPREPLY=( $( compgen -W '-a --echo-all -A --no-align \
|
|
-c --command -d --dbname -e --echo-queries \
|
|
-E --echo-hidden -f --file -F --filed-separator \
|
|
-h --host -H --html -l --list -n -o --output \
|
|
-p --port -P --pset -q -R --record-separator \
|
|
-s --single-step -S --single-line -t --tuples-only \
|
|
-T --table-attr -U --username -v --variable \
|
|
-V --version -W --password -x --expanded -X --nopsqlrc \
|
|
-? --help ' -- $cur ) )
|
|
else
|
|
# return list of available databases
|
|
_pg_databases
|
|
fi
|
|
}
|
|
complete -F _psql $default psql
|
|
|
|
# createdb(1) completion
|
|
#
|
|
_createdb()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
case "$prev" in
|
|
-@(h|-host=))
|
|
_known_hosts
|
|
return 0
|
|
;;
|
|
-@(U|-username=))
|
|
_pg_users
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( compgen -W '-D -T -E -h -p -U -W -e -q \
|
|
--location= --template= --encoding= --host= --port= \
|
|
--username= --password --echo --quiet --help' -- $cur ))
|
|
else
|
|
_pg_databases
|
|
fi
|
|
}
|
|
complete -F _createdb $default createdb
|
|
|
|
# dropdb(1) completion
|
|
#
|
|
_dropdb()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
case "$prev" in
|
|
-@(h|-host=))
|
|
_known_hosts
|
|
return 0
|
|
;;
|
|
-@(U|-username=))
|
|
_pg_users
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( compgen -W '-h -p -U -W -e -q \
|
|
--host= --port= --username= --password \
|
|
--interactive --echo --quiet --help' -- $cur ) )
|
|
else
|
|
_pg_databases
|
|
fi
|
|
}
|
|
complete -F _dropdb $default dropdb
|
|
}
|
|
|
|
_longopt()
|
|
{
|
|
local cur opt
|
|
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
if [[ "$cur" == --*=* ]]; then
|
|
opt=${cur%%=*}
|
|
# cut backlash that gets inserted before '=' sign
|
|
opt=${opt%\\*}
|
|
cur=${cur#*=}
|
|
_filedir
|
|
COMPREPLY=( $( compgen -P "$opt=" -W '${COMPREPLY[@]}' -- $cur))
|
|
return 0
|
|
fi
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( $1 --help 2>&1 | sed -e '/--/!d' \
|
|
-e 's/.*\(--[-A-Za-z0-9]\+=\?\).*/\1/' | \
|
|
grep "^$cur" | sort -u ) )
|
|
elif [[ "$1" == @(mk|rm)dir ]]; then
|
|
_filedir -d
|
|
else
|
|
_filedir
|
|
fi
|
|
}
|
|
# makeinfo and texi2dvi are defined elsewhere
|
|
for i in a2ps autoconf automake bc gprof ld nm objcopy objdump readelf strip \
|
|
bison cpio diff patch enscript cp df dir du ln ls mkfifo mknod mv rm \
|
|
touch vdir xargs awk gperf grep gpg grub indent less m4 sed shar date \
|
|
env seq su tee uname who texindex cat csplit cut expand fmt fold head \
|
|
md5sum nl od paste pr ptx sha1sum sort split tac tail tr unexpand \
|
|
uniq wc units wget rsync ldd bash id info irb mkdir rmdir netstat; do
|
|
have $i && complete -F _longopt $filenames $i
|
|
done
|
|
unset i
|
|
|
|
# gcc(1) completion
|
|
#
|
|
# The only unusual feature is that we don't parse "gcc --help -v" output
|
|
# directly, because that would include the options of all the other backend
|
|
# tools (linker, assembler, preprocessor, etc) without any indication that
|
|
# you cannot feed such options to the gcc driver directly. (For example, the
|
|
# linker takes a -z option, but you must type -Wl,-z for gcc.) Instead, we
|
|
# ask the driver ("g++") for the name of the compiler ("cc1"), and parse the
|
|
# --help output of the compiler.
|
|
#
|
|
have gcc &&
|
|
_gcc()
|
|
{
|
|
local cur cc backend
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
_expand || return 0
|
|
|
|
case "$1" in
|
|
gcj)
|
|
backend=jc1
|
|
;;
|
|
gpc)
|
|
backend=gpc1
|
|
;;
|
|
*77)
|
|
backend=f771
|
|
;;
|
|
*)
|
|
backend=cc1 # (near-)universal backend
|
|
;;
|
|
esac
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
cc=$( $1 -print-prog-name=$backend )
|
|
# sink stderr:
|
|
# for C/C++/ObjectiveC it's useless
|
|
# for FORTRAN/Java it's an error
|
|
COMPREPLY=( $( $cc --help 2>/dev/null | tr '\t' ' ' | \
|
|
sed -e '/^ *-/!d' -e 's/ *-\([^ ]*\).*/-\1/' | \
|
|
grep "^$cur" | sort -u ) )
|
|
else
|
|
_filedir
|
|
fi
|
|
}
|
|
[ -n "${have:-}" ] && complete $filenames -F _gcc gcc g++ c++ g77 gcj gpc
|
|
[ $UNAME = GNU -o $UNAME = Linux ] && complete $filenames -F _gcc cc
|
|
|
|
# Linux cardctl(8) completion
|
|
#
|
|
have cardctl &&
|
|
_cardctl()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
if [ $COMP_CWORD -eq 1 ]; then
|
|
COMPREPLY=( $( compgen -W 'status config ident suspend \
|
|
resume reset eject insert scheme' \
|
|
-- $cur ) )
|
|
fi
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _cardctl cardctl
|
|
|
|
# This function is required by _dpkg() and _dpkg-reconfigure()
|
|
#
|
|
have dpkg && {
|
|
_comp-dpkg-installed-packages()
|
|
{
|
|
grep -B 2 'ok installed' /var/lib/dpkg/status | grep "Package: $1" | \
|
|
cut -d\ -f2
|
|
|
|
}
|
|
|
|
# Debian dpkg(8) completion
|
|
#
|
|
_dpkg()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
_expand || return 0
|
|
|
|
# find the last option flag
|
|
if [[ $cur != -* ]]; then
|
|
while [[ $prev != -* && $COMP_CWORD != 1 ]]; do
|
|
COMP_CWORD=$((COMP_CWORD-1))
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
done
|
|
fi
|
|
|
|
case "$prev" in
|
|
-@(c|i|A|I|f|e|X|-@(install|unpack|record-avail|contents|info| \
|
|
fsys-tarfile|field|control|extract)))
|
|
_filedir '?(u)deb'
|
|
return 0
|
|
;;
|
|
-@(b|-build))
|
|
_filedir -d
|
|
return 0
|
|
;;
|
|
-@(s|p|l|-@(status|print-avail|list)))
|
|
COMPREPLY=( $( apt-cache pkgnames $cur 2>/dev/null ) )
|
|
return 0
|
|
;;
|
|
-@(S|-search))
|
|
_filedir
|
|
return 0
|
|
;;
|
|
-@(r|L|-@(remove|purge|listfiles)))
|
|
COMPREPLY=( $( _comp-dpkg-installed-packages $cur ) )
|
|
return 0
|
|
;;
|
|
*)
|
|
|
|
COMPREPLY=( $( compgen -W '-i --install --unpack -A --record-avail \
|
|
--configure -r --remove --purge --get-selections \
|
|
--set-selections --update-avail --merge-avail \
|
|
--clear-avail --command-fd --forget-old-unavail -s \
|
|
--status -p --print-avail -L --listfiles -l --list \
|
|
-S --search -C --audit --print-architecture \
|
|
--print-gnu-build-architecture \
|
|
--print-installation-architecture \
|
|
--compare-versions --help --version --force-help \
|
|
--force-all --force-auto-select --force-downgrade \
|
|
--force-configure-any --force-hold --force-bad-path \
|
|
--force-not-root --force-overwrite \
|
|
--force-overwrite-diverted --force-bad-verify \
|
|
--force-depends-version --force-depends \
|
|
--force-confnew --force-confold --force-confdef \
|
|
--force-confmiss --force-conflicts --force-architecture\
|
|
--force-overwrite-dir --force-remove-reinstreq \
|
|
--force-remove-essential -Dh \
|
|
--debug=help --licence --admindir= --root= --instdir= \
|
|
-O --selected-only -E --skip-same-version \
|
|
-G --refuse-downgrade -B --auto-deconfigure \
|
|
--no-debsig --no-act -D --debug= --status-fd \
|
|
-b --build -I --info -f --field -c --contents \
|
|
-x --extract -X --vextract --fsys-tarfile -e --control \
|
|
--ignore-depends= --abort-after' -- $cur ) )
|
|
;;
|
|
esac
|
|
|
|
|
|
}
|
|
complete -F _dpkg $filenames dpkg dpkg-deb
|
|
}
|
|
|
|
# Debian GNU dpkg-reconfigure(8) completion
|
|
#
|
|
have dpkg-reconfigure &&
|
|
_dpkg_reconfigure()
|
|
{
|
|
local cur prev opt
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
|
|
case "$prev" in
|
|
-@(f|-frontend))
|
|
opt=( $( echo /usr/share/perl5/Debconf/FrontEnd/* ) )
|
|
opt=( ${opt[@]##*/} )
|
|
opt=( ${opt[@]%.pm} )
|
|
COMPREPLY=( $( compgen -W '${opt[@]}' -- $cur ) )
|
|
return 0
|
|
;;
|
|
-@(p|-priority))
|
|
COMPREPLY=( $( compgen -W 'low medium high critical' -- $cur ) )
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( compgen -W '-f --frontend -p --priority -a --all \
|
|
-u --unseen-only -h --help -s --showold \
|
|
--force --terse' -- $cur ) )
|
|
else
|
|
COMPREPLY=( $( _comp-dpkg-installed-packages $cur ) )
|
|
fi
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _dpkg_reconfigure $default dpkg-reconfigure
|
|
|
|
# Debian Linux dselect(8) completion.
|
|
#
|
|
have dselect &&
|
|
_dselect()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
case "$prev" in
|
|
--admindir)
|
|
_filedir -d
|
|
;;
|
|
|
|
-@(D|debug))
|
|
_filedir
|
|
;;
|
|
|
|
esac
|
|
COMPREPLY=( $( compgen -W -- $cur ) )
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
COMPREPLY=( $( compgen -W '--admindir --help --version --licence \
|
|
--license --expert --debug' -- $cur ) )
|
|
else
|
|
COMPREPLY=( $( compgen -W 'access update select install config \
|
|
remove quit' -- $cur ) )
|
|
fi
|
|
|
|
|
|
return 0
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _dselect $filenames dselect
|
|
|
|
# Java completion
|
|
#
|
|
|
|
# available path elements completion
|
|
have java && {
|
|
_java_path()
|
|
{
|
|
cur=${cur##*:}
|
|
_filedir '@(jar|zip)'
|
|
}
|
|
|
|
# exact classpath determination
|
|
_java_find_classpath()
|
|
{
|
|
local i
|
|
|
|
# search first in current options
|
|
for (( i=1; i < COMP_CWORD; i++ )); do
|
|
if [[ "${COMP_WORDS[i]}" == -@(cp|classpath) ]]; then
|
|
classpath=${COMP_WORDS[i+1]}
|
|
break
|
|
fi
|
|
done
|
|
|
|
# default to environment
|
|
[ -z "$classpath" ] && classpath=$CLASSPATH
|
|
|
|
# default to current directory
|
|
[ -z "$classpath" ] && classpath=.
|
|
}
|
|
|
|
# exact sourcepath determination
|
|
_java_find_sourcepath()
|
|
{
|
|
local i
|
|
|
|
# search first in current options
|
|
for (( i=1; i < COMP_CWORD; i++ )); do
|
|
if [[ "${COMP_WORDS[i]}" == -sourcepath ]]; then
|
|
sourcepath=${COMP_WORDS[i+1]}
|
|
break
|
|
fi
|
|
done
|
|
|
|
# default to classpath
|
|
[ -z "$sourcepath" ] && _java_find_classpath
|
|
sourcepath=$classpath
|
|
}
|
|
|
|
# available classes completion
|
|
_java_classes()
|
|
{
|
|
local classpath i
|
|
|
|
# find wich classpath to use
|
|
_java_find_classpath
|
|
|
|
# convert package syntax to path syntax
|
|
cur=${cur//.//}
|
|
# parse each classpath element for classes
|
|
for i in ${classpath//:/ }; do
|
|
if [ -r $i ] && [[ "$i" == *.@(jar|zip) ]]; then
|
|
COMPREPLY=( ${COMPREPLY[@]} $( jar tf $i $cur | grep -v\
|
|
"META-INF" | sed -e 's|\('$cur'[^/]*/\).*|\1|' \
|
|
| sort | uniq ) )
|
|
elif [ -d $i ]; then
|
|
COMPREPLY=( ${COMPREPLY[@]} $( command ls -F -d \
|
|
$i/$cur* 2>/dev/null | sed -e 's|^'$i'/||' ) )
|
|
fi
|
|
done
|
|
# keep only packages and classes
|
|
COMPREPLY=(
|
|
$( echo ${COMPREPLY[@]} | tr " " "\n" | grep "/$")
|
|
$( echo ${COMPREPLY[@]} | tr " " "\n" | grep "\.class$" | \
|
|
grep -v "\\$" )
|
|
)
|
|
# remove class extension
|
|
COMPREPLY=( ${COMPREPLY[@]%.class} )
|
|
# convert path syntax to package syntax
|
|
COMPREPLY=( ${COMPREPLY[@]//\//.} )
|
|
}
|
|
|
|
# available packages completion
|
|
_java_packages()
|
|
{
|
|
local sourcepath i
|
|
|
|
# find wich sourcepath to use
|
|
_java_find_sourcepath
|
|
|
|
# convert package syntax to path syntax
|
|
cur=${cur//.//}
|
|
# parse each sourcepath element for packages
|
|
for i in ${sourcepath//:/ }; do
|
|
if [ -d $i ]; then
|
|
COMPREPLY=( ${COMPREPLY[@]} $( command ls -F -d \
|
|
$i/$cur* 2>/dev/null | sed -e 's|^'$i'/||' ) )
|
|
fi
|
|
done
|
|
# keep only packages
|
|
COMPREPLY=( $( echo ${COMPREPLY[@]} | tr " " "\n" | grep "/$" ) )
|
|
# remove packages extension
|
|
COMPREPLY=( ${COMPREPLY[@]%/} )
|
|
# convert path syntax to package syntax
|
|
cur=${COMPREPLY[@]//\//.}
|
|
}
|
|
|
|
# java completion
|
|
#
|
|
_java()
|
|
{
|
|
local cur prev i
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
for ((i=1; i < $COMP_CWORD; i++)); do
|
|
case ${COMP_WORDS[$i]} in
|
|
-cp|-classpath)
|
|
i++ # skip the classpath string.
|
|
;;
|
|
-*)
|
|
# this is an option, not a class/jarfile name.
|
|
;;
|
|
*)
|
|
# once we've seen a class, just do filename completion
|
|
_filedir
|
|
return 0
|
|
;;
|
|
esac
|
|
done
|
|
|
|
case $prev in
|
|
-@(cp|classpath))
|
|
_java_path
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
# relevant options completion
|
|
COMPREPLY=( $( compgen -W '-client -hotspot -server -classic \
|
|
-cp -classpath -D -verbose -verbose:class \
|
|
-verbose:gc -version:jni -version \
|
|
-showversion -? -help -X -jar \
|
|
-ea -enableassertions -da -disableassertions \
|
|
-esa -enablesystemassertions \
|
|
-dsa -disablesystemassertions ' -- $cur ) )
|
|
else
|
|
if [[ "$prev" == -jar ]]; then
|
|
# jar file completion
|
|
_filedir jar
|
|
else
|
|
# classes completion
|
|
_java_classes
|
|
fi
|
|
fi
|
|
}
|
|
complete -F _java $filenames java
|
|
}
|
|
|
|
# javadoc completion
|
|
#
|
|
have javadoc &&
|
|
_javadoc()
|
|
{
|
|
COMPREPLY=()
|
|
local cur prev
|
|
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
case $prev in
|
|
-@(overview|helpfile|stylesheetfile))
|
|
_filedir
|
|
return 0
|
|
;;
|
|
-d)
|
|
_filedir -d
|
|
return 0
|
|
;;
|
|
-@(classpath|bootclasspath|docletpath|sourcepath|extdirs))
|
|
_java_path
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
# relevant options completion
|
|
COMPREPLY=( $( compgen -W '-overview -public -protected \
|
|
-package -private -help -doclet -docletpath \
|
|
-sourcepath -classpath -exclude -subpackages \
|
|
-breakiterator -bootclasspath -source -extdirs \
|
|
-verbose -locale -encoding -J -d -use -version \
|
|
-author -docfilessubdirs -splitindex \
|
|
-windowtitle -doctitle -header -footer -bottom \
|
|
-link -linkoffline -excludedocfilessubdir \
|
|
-group -nocomment -nodeprecated -noqualifier \
|
|
-nosince -nodeprecatedlist -notree -noindex \
|
|
-nohelp -nonavbar -quiet -serialwarn -tag \
|
|
-taglet -tagletpath -charset -helpfile \
|
|
-linksource -stylesheetfile -docencoding' -- \
|
|
$cur ) )
|
|
else
|
|
# source files completion
|
|
_filedir java
|
|
# packages completion
|
|
_java_packages
|
|
fi
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _javadoc $filenames javadoc
|
|
|
|
# javac completion
|
|
#
|
|
have javac &&
|
|
_javac()
|
|
{
|
|
COMPREPLY=()
|
|
local cur prev
|
|
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
case $prev in
|
|
-d)
|
|
_filedir -d
|
|
return 0
|
|
;;
|
|
-@(classpath|bootclasspath|sourcepath|extdirs))
|
|
_java_path
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
# relevant options completion
|
|
COMPREPLY=( $( compgen -W '-g -g:none -g:lines -g:vars\
|
|
-g:source -O -nowarn -verbose -deprecation -classpath\
|
|
-sourcepath -bootclasspath -extdirs -d -encoding -source\
|
|
-target -help' -- $cur ) )
|
|
else
|
|
# source files completion
|
|
_filedir java
|
|
fi
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _javac $filenames javac
|
|
|
|
# PINE address-book completion
|
|
#
|
|
have pine &&
|
|
_pineaddr()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
COMPREPLY=( $( compgen -W '$( awk "{print \$1}" ~/.addressbook 2>/dev/null)' \
|
|
-- $cur ) )
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _pineaddr $default pine
|
|
|
|
_configure_func()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
# if $COMP_CONFIGURE_HINTS is not null, then completions of the form
|
|
# --option=SETTING will include 'SETTING' as a contextual hint
|
|
[[ "$cur" != -* ]] && return 0
|
|
|
|
if [ -n "$COMP_CONFIGURE_HINTS" ]; then
|
|
COMPREPLY=( $( $1 --help | awk '/^ --[A-Za-z]/ { print $1; if ($2 ~ /--[A-Za-z]/) print $2 }' | sed -e 's/[,[].*//g' | grep ^$cur ) )
|
|
|
|
else
|
|
COMPREPLY=( $( $1 --help | awk '/^ --[A-Za-z]/ { print $1; if ($2 ~ /--[A-Za-z]/) print $2 }' | sed -e 's/[,=[].*//g' | grep ^$cur ) )
|
|
fi
|
|
}
|
|
complete -F _configure_func $default configure
|
|
|
|
# urpmi media function required by other urpmi functions
|
|
#
|
|
have urpmq && {
|
|
_urpmi_media()
|
|
{
|
|
local media
|
|
# first try new urpmq option to get media list
|
|
media=$( urpmq --list-media 2>/dev/null )
|
|
# default to old manual media extraction
|
|
[ -z "$media" ] && media=( $( sed -ne "s/^\(.\+\) \(\(file\|removable\|ftp\|http\):\/\/.*\)\? {$/\1/p" /etc/urpmi/urpmi.cfg | grep "^${cur//\\\\/\\\\}" ) )
|
|
# return list of available media
|
|
COMPREPLY=( $( echo $media | tr " " "\n" | grep "^$cur" ) )
|
|
}
|
|
|
|
_urpmi_packages()
|
|
{
|
|
local packages media
|
|
# find if a particular media has been specified
|
|
for (( i=1; i < COMP_CWORD; i++ )); do
|
|
if [[ "${COMP_WORDS[i]}" == --media ]]; then
|
|
media=${COMP_WORDS[i+1]}
|
|
break
|
|
fi
|
|
done
|
|
|
|
# first try new urpmq option to get package list
|
|
packages=$( urpmq --media $media --list 2>/dev/null )
|
|
# default to old manual database extraction
|
|
[ -z "$packages" ] && packages=$( gzip -dc /var/lib/urpmi/synthesis.hdlist.$media* | awk -F'@' '/info/ {print $1}' )
|
|
# return list of available packages
|
|
COMPREPLY=( $( echo $packages | tr " " "\n" | grep "^$cur" ) )
|
|
}
|
|
|
|
_urpmi_aliases()
|
|
{
|
|
# return list of available nodes
|
|
COMPREPLY=( $( urpmq --list-aliases 2>/dev/null | grep "^$cur" ) )
|
|
}
|
|
}
|
|
|
|
# Mandrake urpmi completion
|
|
#
|
|
have urpmi &&
|
|
_urpmi()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
case "$prev" in
|
|
--media)
|
|
_urpmi_media
|
|
return 0
|
|
;;
|
|
--parallel)
|
|
_urpmi_aliases
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
# return list of available options
|
|
COMPREPLY=( $( compgen -W '-a -p -P -y -s -q -v --help \
|
|
--update --media --synthesis --auto --auto-select \
|
|
--fuzzy --src --clean --noclean --force --allow-nodeps \
|
|
--allow-force --parallel --wget --curl --proxy \
|
|
--proxy-user --bug --env --X --best-output \
|
|
--verify-rpm --test' -- $cur ) )
|
|
else
|
|
# return rpm files and available packages
|
|
_urpmi_packages
|
|
_filedir rpm
|
|
fi
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _urpmi urpmi
|
|
|
|
# Mandrake urpmq completion
|
|
#
|
|
have urpmq &&
|
|
_urpmq()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
case "$prev" in
|
|
--media)
|
|
_urpmi_media
|
|
return 0
|
|
;;
|
|
--parallel)
|
|
_urpmi_nodes
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
# return list of available options
|
|
COMPREPLY=( $( compgen -W '-h -v -d -u -c -P -y -s -g -r -f \
|
|
--help --update --media --synthesis --auto-select \
|
|
--fuzzy --all --list --list-media --list-nodes \
|
|
--list-aliases --src --headers --sources --force \
|
|
--parallel --wget --curl --proxy --proxy-user' -- $cur))
|
|
else
|
|
# return rpm files and available packages
|
|
_urpmi_packages
|
|
_filedir rpm
|
|
fi
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _urpmq urpmq
|
|
|
|
# Mandrake urpme completion
|
|
#
|
|
have urpme &&
|
|
_urpme()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
# return list of available options
|
|
COMPREPLY=( $( compgen -W '-a --help --auto' -- $cur ) )
|
|
else
|
|
# return list of available packages
|
|
_rpm_installed_packages
|
|
fi
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _urpme urpme
|
|
|
|
# Mandrake urpmf completion
|
|
#
|
|
have urpmf &&
|
|
_urpmf()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
# return list of available options
|
|
COMPREPLY=( $( compgen -W '--help --quiet --all --name \
|
|
--group --size --serial --summary --description \
|
|
--provides --requires --files --conflicts --obsoletes \
|
|
--prereqs' -- $cur ) )
|
|
else
|
|
# return available files
|
|
_filedir
|
|
fi
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _urpmf urpmf
|
|
|
|
# Mandrake urpmi.update completion
|
|
#
|
|
have urpmi.update &&
|
|
_urpmi_update()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
# return list of available options
|
|
COMPREPLY=( $( compgen -W '-a -c -d -f --help --curl --wget \
|
|
--proxy --proxy-user' -- $cur))
|
|
else
|
|
# return list of available media
|
|
_urpmi_media
|
|
fi
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _urpmi_update urpmi.update
|
|
|
|
# Mandrake urpmi.addmedia completion
|
|
#
|
|
have urpmi.addmedia &&
|
|
_urpmi_addmedia()
|
|
{
|
|
local cur i args
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
# return list of available options
|
|
COMPREPLY=( $( compgen -W '-c -h -f --help --wget --curl \
|
|
--proxy --proxy-user --update --distrib' -- $cur ) )
|
|
else
|
|
# count number of mandatory args given sofar
|
|
args=$COMP_CWORD
|
|
for (( i=1; i < COMP_CWORD; i++ )); do
|
|
if [[ "${COMP_WORDS[i]}" == -* ]]; then
|
|
args=$(($args-1))
|
|
fi
|
|
done
|
|
case $args in
|
|
1)
|
|
# return list of available media
|
|
_urpmi_media
|
|
;;
|
|
2)
|
|
# return list of available protocols
|
|
COMPREPLY=( $( compgen -W 'file:// http:// \
|
|
ftp:// removable://' -- $cur ) )
|
|
;;
|
|
3)
|
|
# return word "with"
|
|
COMPREPLY=( 'with' )
|
|
;;
|
|
esac
|
|
fi
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _urpmi_addmedia urpmi.addmedia
|
|
|
|
# Mandrake urpmi.removemedia completion
|
|
#
|
|
have urpmi.removemedia &&
|
|
_urpmi_removemedia()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
# if word begins with a dash, return list of available options
|
|
COMPREPLY=( $( compgen -W '-a -c --help' -- $cur ) )
|
|
else
|
|
# elsewhere, return list of available media
|
|
_urpmi_media
|
|
fi
|
|
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _urpmi_removemedia urpmi.removemedia
|
|
|
|
# Debian reportbug(1) completion
|
|
#
|
|
have reportbug &&
|
|
_reportbug()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
case "$prev" in
|
|
-f|--filename|-i|--include|--mta|-o|--output)
|
|
_filedir
|
|
return 0
|
|
;;
|
|
-B|--bts)
|
|
COMPREPLY=( $( compgen -W "debian guug kde mandrake help" -- \
|
|
$cur ))
|
|
return 0
|
|
;;
|
|
-e|--editor|--mua)
|
|
COMP_WORDS=(COMP_WORDS[0] $cur)
|
|
COMP_CWORD=1
|
|
_command
|
|
return 0
|
|
;;
|
|
--mode)
|
|
COMPREPLY=( $( compgen -W "novice standard expert" -- $cur ) )
|
|
return 0
|
|
;;
|
|
-S|--severity)
|
|
COMPREPLY=( $( compgen -W "grave serious important normal \
|
|
minor wishlist" -- $cur ) )
|
|
return 0
|
|
;;
|
|
-u|--ui|--interface)
|
|
COMPREPLY=( $( compgen -W "newt text gnome" -- $cur ) )
|
|
return 0
|
|
;;
|
|
-t|--type)
|
|
COMPREPLY=( $( compgen -W "gnats debbugs" -- $cur ) )
|
|
return 0
|
|
;;
|
|
-T|--tags)
|
|
COMPREPLY=( $( compgen -W "none patch security upstream sid \
|
|
woody potato sarge fixed" -- $cur ) )
|
|
return 0
|
|
;;
|
|
*)
|
|
;;
|
|
esac
|
|
|
|
COMPREPLY=($( compgen -W '-h --help -v --version -a --af -b \
|
|
--no-query-bts --query-bts -B --bts -c --configure \
|
|
--no-config-files --check-available -d --debug \
|
|
--no-check-available -e --editor --email -f \
|
|
--filename -g --gnupg -H --header -i --include -j \
|
|
--justification -l --ldap --no-ldap -L --list-cc -m \
|
|
--maintonly --mode --mua --mta --mutt -n --mh --nmh \
|
|
-o --output -p --print -P --pgp --proxy --http_proxy\
|
|
-q --quiet -Q --query-only --realname --report-quiet \
|
|
--reply-to --replyto -s --subject -S --severity \
|
|
--smtphost -t --type -T --tags --template -V -x \
|
|
--no-cc --package-version -z --no-compress \
|
|
--ui --interface -u \
|
|
wnpp boot-floppies kernel-image' -- $cur ) \
|
|
$( apt-cache pkgnames -- $cur ) )
|
|
_filedir
|
|
return 0
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _reportbug $filenames reportbug
|
|
|
|
# Debian querybts(1) completion
|
|
#
|
|
have querybts &&
|
|
_querybts()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
case "$prev" in
|
|
-B|--bts)
|
|
COMPREPLY=( $( compgen -W "debian guug kde mandrake help" -- \
|
|
$cur ))
|
|
return 0
|
|
;;
|
|
-u|--ui|--interface)
|
|
COMPREPLY=($( compgen -W "newt text gnome" -- $cur ))
|
|
return 0
|
|
;;
|
|
*)
|
|
;;
|
|
esac
|
|
|
|
COMPREPLY=($( compgen -W '-h --help -v --version -A --archive \
|
|
-B --bts -l --ldap --no-ldap --proxy= --http_proxy= \
|
|
-s --source -w --web -u --ui --interface \
|
|
wnpp boot-floppies' -- $cur ) \
|
|
$( apt-cache pkgnames -- $cur ) )
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _querybts $filenames querybts
|
|
|
|
# update-alternatives completion
|
|
#
|
|
have update-alternatives &&
|
|
_update_alternatives()
|
|
{
|
|
installed_alternatives()
|
|
{
|
|
local admindir
|
|
# find wich admin dir to use
|
|
if [ -f /etc/debian_version ]; then
|
|
admindir=/var/lib/dpkg/alternatives
|
|
else
|
|
admindir=/var/lib/rpm/alternatives
|
|
fi
|
|
for (( i=1; i < COMP_CWORD; i++ )); do
|
|
if [[ "${COMP_WORDS[i]}" == --admindir ]]; then
|
|
admindir=${COMP_WORDS[i+1]}
|
|
break
|
|
fi
|
|
done
|
|
COMPREPLY=( $( command ls $admindir | grep "^$cur" ) )
|
|
}
|
|
|
|
local cur prev mode args
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
case "$prev" in
|
|
--@(altdir|admindir))
|
|
_filedir -d
|
|
return 0
|
|
;;
|
|
--@(help|version))
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
# find wich mode to use and how many real args used so far
|
|
for (( i=1; i < COMP_CWORD; i++ )); do
|
|
if [[ "${COMP_WORDS[i]}" == --@(install|remove|auto|display|config) ]]; then
|
|
mode=${COMP_WORDS[i]}
|
|
args=$(($COMP_CWORD - i))
|
|
break
|
|
fi
|
|
done
|
|
|
|
case $mode in
|
|
--install)
|
|
case $args in
|
|
1)
|
|
_filedir
|
|
;;
|
|
2)
|
|
installed_alternatives
|
|
;;
|
|
3)
|
|
_filedir
|
|
;;
|
|
esac
|
|
;;
|
|
--remove)
|
|
case $args in
|
|
1)
|
|
installed_alternatives
|
|
;;
|
|
2)
|
|
_filedir
|
|
;;
|
|
esac
|
|
;;
|
|
--auto)
|
|
installed_alternatives
|
|
;;
|
|
--display)
|
|
installed_alternatives
|
|
;;
|
|
--config)
|
|
installed_alternatives
|
|
;;
|
|
*)
|
|
COMPREPLY=( $( compgen -W '--verbose --quiet --help --version \
|
|
--altdir --admindir' -- $cur ) \
|
|
$( compgen -W '--install --remove --auto --display \
|
|
--config' -- $cur ) )
|
|
esac
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _update_alternatives update-alternatives
|
|
|
|
# Python completion
|
|
#
|
|
have python &&
|
|
_python()
|
|
{
|
|
local prev cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
case "$prev" in
|
|
-Q)
|
|
COMPREPLY=( $( compgen -W "old new warn warnall" -- $cur ) )
|
|
return 0
|
|
;;
|
|
-W)
|
|
COMPREPLY=( $( compgen -W "ignore default all module once error" -- $cur ) )
|
|
return 0
|
|
;;
|
|
-c)
|
|
_filedir '@(py|pyc|pyo)'
|
|
return 0
|
|
;;
|
|
!(python|-?))
|
|
[[ ${COMP_WORDS[COMP_CWORD-2]} != -@(Q|W) ]] && _filedir
|
|
;;
|
|
esac
|
|
|
|
|
|
# if '-c' is already given, complete all kind of files.
|
|
for (( i=0; i < ${#COMP_WORDS}-1; i++ )); do
|
|
if [[ ${COMP_WORDS[i]} == -c ]]; then
|
|
_filedir
|
|
fi
|
|
done
|
|
|
|
|
|
if [[ "$cur" != -* ]]; then
|
|
_filedir '@(py|pyc|pyo)'
|
|
else
|
|
COMPREPLY=( $( compgen -W "- -d -E -h -i -O -Q -S -t -u \
|
|
-U -v -V -W -x -c" -- $cur ) )
|
|
fi
|
|
|
|
|
|
|
|
return 0
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _python $filenames python
|
|
|
|
# Perl completion
|
|
#
|
|
have perl &&
|
|
{
|
|
_perlmodules()
|
|
{
|
|
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 ) )
|
|
}
|
|
|
|
_perl()
|
|
{
|
|
local cur prev prefix temp
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
prefix=""
|
|
|
|
# completing an option (may or may not be separated by a space)
|
|
if [[ "$cur" == -?* ]]; then
|
|
temp=$cur
|
|
prev=${temp:0:2}
|
|
cur=${temp:2}
|
|
prefix=$prev
|
|
fi
|
|
|
|
# only handle module completion for now
|
|
case "$prev" in
|
|
-m|-M)
|
|
_perlmodules
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
# handle case where first parameter is not a dash option
|
|
if [ $COMP_CWORD -eq 1 ] && [[ "$cur" != -* ]]; then
|
|
_filedir -d
|
|
return 0
|
|
fi
|
|
|
|
# complete using basic options
|
|
COMPREPLY=( $( compgen -W '-C -s -T -u -U -W -X -h -v -V -c -w -d -D -p \
|
|
-n -a -F -l -0 -I -m -M -P -S -x -i -e ' -- $cur ) )
|
|
return 0
|
|
}
|
|
complete -F _perl $default perl
|
|
|
|
_perldoc()
|
|
{
|
|
local cur prev prefix temp
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
prefix=""
|
|
|
|
# completing an option (may or may not be separated by a space)
|
|
if [[ "$cur" == -?* ]]; then
|
|
temp=$cur
|
|
prev=${temp:0:2}
|
|
cur=${temp:2}
|
|
prefix=$prev
|
|
fi
|
|
|
|
# complete builtin perl functions
|
|
case $prev in
|
|
-f)
|
|
COMPREPLY=( $( compgen -W 'chomp chop chr crypt hex index lc \
|
|
lcfirst length oct ord pack q qq reverse rindex sprintf \
|
|
substr tr uc ucfirst y m pos quotemeta s split study qr abs \
|
|
atan2 cos exp hex int log oct rand sin sqrt srand pop push \
|
|
shift splice unshift grep join map qw reverse sort unpack \
|
|
delete each exists keys values binmode close closedir \
|
|
dbmclose dbmopen die eof fileno flock format getc print \
|
|
printf read readdir rewinddir seek seekdir select syscall \
|
|
sysread sysseek syswrite tell telldir truncate warn write \
|
|
pack read syscall sysread syswrite unpack vec -X chdir chmod \
|
|
chown chroot fcntl glob ioctl link lstat mkdir open opendir \
|
|
readlink rename rmdir stat symlink umask unlink utime caller \
|
|
continue die do dump eval exit goto last next redo return \
|
|
sub wantarray caller import local my our package use defined \
|
|
dump eval formline local my our reset scalar undef wantarray \
|
|
alarm exec fork getpgrp getppid getpriority kill pipe qx \
|
|
setpgrp setpriority sleep system times wait waitpid do \
|
|
import no package require use bless dbmclose dbmopen package \
|
|
ref tie tied untie use accept bind connect getpeername \
|
|
getsockname getsockopt listen recv send setsockopt shutdown \
|
|
socket socketpair msgctl msgget msgrcv msgsnd semctl semget \
|
|
semop shmctl shmget shmread shmwrite endgrent endhostent \
|
|
endnetent endpwent getgrent getgrgid getgrnam getlogin \
|
|
getpwent getpwnam getpwuid setgrent setpwent endprotoent \
|
|
endservent gethostbyaddr gethostbyname gethostent \
|
|
getnetbyaddr getnetbyname getnetent getprotobyname \
|
|
getprotobynumber getprotoent getservbyname getservbyport \
|
|
getservent sethostent setnetent setprotoent setservent \
|
|
gmtime localtime time times' -- $cur ) )
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
case $cur in
|
|
-*)
|
|
COMPREPLY=( $( compgen -W '-h -v -t -u -m -l -F -X -f -q' -- $cur ))
|
|
return 0
|
|
;;
|
|
*)
|
|
_perlmodules
|
|
COMPREPLY=( ${COMPREPLY[@]} $( compgen -W '$( PAGER=cat man perl | sed -ne "/perl.*Perl overview/,/perlwin32/s/^[^a-z0-9]*\([a-z0-9]*\).*$/\1/p")' -- $cur ) )
|
|
|
|
return 0
|
|
;;
|
|
esac
|
|
}
|
|
complete -F _perldoc $default perldoc
|
|
}
|
|
|
|
# rcs(1) completion
|
|
#
|
|
have rcs &&
|
|
_rcs()
|
|
{
|
|
local cur prev file dir
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
file=${cur##*/}
|
|
dir=${cur%/*}
|
|
|
|
# deal with relative directory
|
|
[ "$file" = "$dir" ] && dir=.
|
|
|
|
COMPREPLY=( $( compgen -f "$dir/RCS/$file" ) )
|
|
|
|
for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
|
|
file=${COMPREPLY[$i]##*/}
|
|
file=${file%,v}
|
|
dir=${COMPREPLY[$i]%RCS/*}
|
|
COMPREPLY[$i]=$dir$file
|
|
done
|
|
|
|
# default to files if nothing returned and we're checking in.
|
|
# otherwise, default to directories
|
|
[ ${#COMPREPLY[@]} -eq 0 -a $1 = ci ] && _filedir || _filedir -d
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _rcs $filenames ci co rlog rcs rcsdiff
|
|
|
|
# lilo(8) completion
|
|
#
|
|
have lilo &&
|
|
_lilo()
|
|
{
|
|
local cur prev
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
case $prev in
|
|
-@(C|i|m|s|S))
|
|
_filedir
|
|
return 0
|
|
;;
|
|
-r)
|
|
_filedir -d
|
|
return 0
|
|
;;
|
|
-@(I|D|R))
|
|
# label completion
|
|
COMPREPLY=( $( awk -F'=' '/label/ {print $2}' \
|
|
/etc/lilo.conf | grep "^$cur" ) )
|
|
return 0
|
|
;;
|
|
-@(A|b|M|u|U))
|
|
# device completion
|
|
cur=${cur:=/dev/}
|
|
_filedir
|
|
return 0
|
|
;;
|
|
-T)
|
|
# topic completion
|
|
COMPREPLY=( $( compgen -W 'help ChRul EBDA geom geom= \
|
|
table= video' -- $cur ) )
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
if [[ "$cur" == -* ]]; then
|
|
# relevant options completion
|
|
COMPREPLY=( $( compgen -W '-A -b -c -C -d -f -g -i -I -l -L -m \
|
|
-M -p -P -q -r -R -s -S -t -T -u -U -v -V -w -x -z' -- \
|
|
$cur ) )
|
|
fi
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _lilo lilo
|
|
|
|
# links completion
|
|
#
|
|
have links &&
|
|
_links()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
case "$cur" in
|
|
--*)
|
|
COMPREPLY=( $( compgen -W '--help' -- $cur ) )
|
|
;;
|
|
-*)
|
|
COMPREPLY=( $( compgen -W '-async-dns -max-connections \
|
|
-max-connections-to-host -retries \
|
|
-receive-timeout -unrestartable-receive-timeout\
|
|
-format-cache-size -memory-cache-size \
|
|
-http-proxy -ftp-proxy -download-dir \
|
|
-assume-codepage -anonymous -dump -no-connect \
|
|
-source -version -help' -- $cur ) )
|
|
;;
|
|
*)
|
|
if [ -r ~/.links/links.his ]; then
|
|
COMPREPLY=( $( compgen -W '$( < ~/.links/links.his )' \
|
|
-- $cur ) )
|
|
fi
|
|
_filedir '@(htm|html)'
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _links $filenames links
|
|
|
|
[ $UNAME = FreeBSD ] && {
|
|
# FreeBSD package management tool completion
|
|
#
|
|
_pkg_delete()
|
|
{
|
|
local cur pkgdir prev
|
|
|
|
pkgdir=${PKG_DBDIR:-/var/db/pkg/}
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
test "$prev" = "-o" -o "$prev" = "-p" -o "$prev" = "-W" && return 0
|
|
|
|
COMPREPLY=( $( compgen -d $pkgdir$cur ) )
|
|
COMPREPLY=( ${COMPREPLY[@]#$pkgdir} )
|
|
|
|
return 0
|
|
}
|
|
complete -F _pkg_delete $dirnames pkg_delete pkg_info
|
|
|
|
# FreeBSD kernel module commands
|
|
#
|
|
_kldload()
|
|
{
|
|
local cur moddir
|
|
|
|
moddir=/modules/
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
COMPREPLY=( $( compgen -f $moddir$cur ) )
|
|
COMPREPLY=( ${COMPREPLY[@]#$moddir} )
|
|
COMPREPLY=( ${COMPREPLY[@]%.ko} )
|
|
|
|
return 0
|
|
}
|
|
complete -F _kldload $filenames kldload
|
|
|
|
_kldunload()
|
|
{
|
|
local cur
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
COMPREPLY=( $(kldstat | sed -ne "s/^.*[ \t]\+\($cur[a-z_]\+\).ko$/\1/p") )
|
|
}
|
|
complete -F _kldunload $filenames kldunload
|
|
}
|
|
|
|
# FreeBSD portupgrade completion
|
|
#
|
|
have portupgrade &&
|
|
_portupgrade()
|
|
{
|
|
local cur pkgdir prev
|
|
|
|
pkgdir=${PKG_DBDIR:-/var/db/pkg/}
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
test "$prev" = "-l" -o "$prev" = "-L" -o "$prev" = "-o" && return 0
|
|
|
|
COMPREPLY=( $( compgen -d $pkgdir$cur ) )
|
|
COMPREPLY=( ${COMPREPLY[@]#$pkgdir} )
|
|
COMPREPLY=( ${COMPREPLY[@]%-*} )
|
|
|
|
return 0
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _portupgrade $dirnames portupgrade
|
|
|
|
# Slackware Linux removepkg completion
|
|
#
|
|
have removepkg && [ -f /etc/slackware-version ] &&
|
|
_removepkg()
|
|
{
|
|
local packages cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
COMPREPLY=( $( (cd /var/log/packages; compgen -f -- "$cur") ) )
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _removepkg $filenames removepkg &&
|
|
complete $dirnames -f -X '!*.tgz' installpkg upgradepkg explodepkg
|
|
|
|
# look(1) completion
|
|
#
|
|
have look &&
|
|
_look()
|
|
{
|
|
local cur
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
if [ $COMP_CWORD = 1 ]; then
|
|
COMPREPLY=( $( compgen -W '$(look $cur)' ) )
|
|
fi
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _look $default look
|
|
|
|
# ypcat(1) and ypmatch(1) completion
|
|
#
|
|
have ypmatch &&
|
|
_ypmatch()
|
|
{
|
|
local cur map
|
|
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
[ $1 = ypcat ] && [ $COMP_CWORD -gt 1 ] && return 0
|
|
[ $1 = ypmatch ] && [ $COMP_CWORD -gt 2 ] && return 0
|
|
|
|
if [ $1 = ypmatch ] && [ $COMP_CWORD -eq 1 ] && \
|
|
[ ${#COMP_WORDS[@]} -eq 3 ]; then
|
|
map=${COMP_WORDS[2]}
|
|
COMPREPLY=( $( compgen -W '$( ypcat $map | \
|
|
cut -d':' -f 1 )' -- $cur) )
|
|
else
|
|
[ $1 = ypmatch ] && [ $COMP_CWORD -ne 2 ] && return 0
|
|
COMPREPLY=( $( compgen -W \
|
|
'$( echo $(ypcat -x | cut -d"\"" -f 2))' -- $cur))
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
[ -n "${have:-}" ] && complete -F _ypmatch ypmatch ypcat
|
|
|
|
# mplayer completion by Peter Valach <pvalach@gmx.net>
|
|
#
|
|
have mplayer &&
|
|
_mplayer()
|
|
{
|
|
local incmd cur prev ext mhelp mhsed mwords
|
|
|
|
COMPREPLY=()
|
|
incmd=${COMP_WORDS[0]}
|
|
ext=""
|
|
mhelp=""
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
prev=${COMP_WORDS[COMP_CWORD-1]}
|
|
|
|
case "$cur" in
|
|
--*)
|
|
COMPREPLY=( $( compgen -W '--help --verbose' -- $cur ) )
|
|
;;
|
|
-*)
|
|
COMPREPLY=( $( compgen -W ' \
|
|
-aid -alang -audio-demuxer -audiofile -cdrom-device
|
|
-cache -cdda -channels -chapter -csslib -demuxer -dvd \
|
|
-dvd-device -dvdangle -dvdauth -dvdkey -dvdnav \
|
|
-forceidx -fps -frames -hr-mp3-seek -idx -mc -mf -ni \
|
|
-nobps -passwd -rawaudio -rtsp-stream-over-tcp \
|
|
-skipopening -sb -srate -ss -tv -user -vcd -vid -vivo \
|
|
-ifo -ffactor -font -noautosub -nooverlapsub -sid \
|
|
-slang -sub -subcc -subcp -sub-demuxer -subdelay \
|
|
-subfont-autoscale -subfont-blur -subfont-encoding \
|
|
-subfont-osd-scale -subfont-outline \
|
|
-subfont-text-scale -subfps -subfile -subpos -unicode \
|
|
-utf8 -vobsub -vobsubid \
|
|
-ac -afm -aspect -flip -lavdopts -noaspect -nosound \
|
|
-pp -ssf -stereo -sws -vc -vfm -vop -x -xvidopts -xy \
|
|
-zoom' -- $cur ) )
|
|
# add mplayer specific options
|
|
[[ "$incmd" == @(mplayer|gmplayer) ]] && COMPREPLY=( $COMPREPLY \
|
|
$(compgen -W '-autoq -autosync -benchmark \
|
|
-framedrop -h -help -hardframedrop -identify -input \
|
|
-lircconf -loop -nojoystick -nolirc --nortc -playlist \
|
|
-quiet -really-quiet -rnd -sdp -skin -slave -softsleep \
|
|
-speed -sstep -use-stdin \
|
|
-dumpaudio -dumpfile -dumpstream \
|
|
-dumpvideo -dumpmicrodvdsub -dumpmpsub -dumpsrtsub \
|
|
-dumpjacosub -dumpsami -dumpsub -osdlevel \
|
|
-af -af-adv -ao -aofile -aop -delay -mixer \
|
|
-nowaveheader \
|
|
-bpp -brightness -contrast -display -double -dr \
|
|
-dxr2 -fb -fbmode -fbmodeconfig -forcexv -fs \
|
|
-geometry -hue -icelayer -jpeg -monitor_dotclock \
|
|
-monitor_hfreq -monitor_vfreq -monitoraspect \
|
|
-nograbpointer -noslices -panscan -rootwin \
|
|
-saturation -screenw -screenh -stop_xscreensaver \
|
|
-vm -vo -vsync -wid -xineramascreen -z -zrbw -zrcrop \
|
|
-zrcrop -zrdev -zrfd -zrhelp -zrnorm -zrquality \
|
|
-zrvdec -zrhdec -zrxdoff -zrydoff \
|
|
-y' -- $cur) )
|
|
# add mencoder specific options
|
|
[[ "$incmd" = "mencoder" ]] && COMPREPLY=( $COMPREPLY \
|
|
$(compgen -W '-audio-density -audio-delay \
|
|
-audio-preload -divx4opts -endpos -ffourcc -include \
|
|
-info -lameopts -lavcopts -noskip -o -oac -ofps -ovc \
|
|
-passlogfile -skiplimit -vobsubout -vobsuboutindex \
|
|
-vobsuboutid -xvidencopts' -- $cur) )
|
|
;;
|
|
*)
|
|
# autocomplete values of switches
|
|
case "$prev" in
|
|
# -ac, -afm, -vc and -vfm don't use tab-indented values;
|
|
# they are not that much used anyway...
|
|
-audiofile)
|
|
ext='@(mp3|MP3|mpg|MPG|ogg|OGG|wav|WAV)'
|
|
;;
|
|
-oac)
|
|
[ "$incmd" = "mencoder" ] && mhelp='mencoder -oac help'
|
|
;;
|
|
-ovc)
|
|
[ "$incmd" = "mencoder" ] && mhelp='mencoder -ovc help'
|
|
;;
|
|
-sub)
|
|
ext='@(srt|SRT|sub|SUB|txt|TXT|utf|UTF)'
|
|
;;
|
|
-vo)
|
|
mhelp='mplayer -vo help'
|
|
;;
|
|
-vop)
|
|
mhelp='mplayer -vop help'
|
|
;;
|
|
*)
|
|
ext='@(mpg|mpeg|MPG|MPEG|wma|avi|AVI|asf|vob|bin|vcd|ps|pes|fli|viv|rm|ram|yuv|mov|wmv|mp3|MP3|ogg|OGG|ogm|OGM|mp4|MP4|wav|WAV)'
|
|
;;
|
|
esac
|
|
|
|
# do what's needed
|
|
if [ "$ext" != "" ] ; then
|
|
_filedir "$ext"
|
|
elif [ "$mhelp" != "" ] ; then
|
|
mwords=$( $mhelp 2> /dev/null | sed -n 's/^['$'\t '']\+\([a-zA-Z0-9_-]*\).*$/\1/p' )
|
|
COMPREPLY=( $( compgen -W "$mwords" -- $cur) )
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
[ -n "${have:-}" ] && complete $filenames -F _mplayer mplayer mencoder gmplayer
|
|
|
|
_filedir_xspec()
|
|
{
|
|
local IFS cur xspec
|
|
|
|
IFS=$'\t\n'
|
|
COMPREPLY=()
|
|
cur=${COMP_WORDS[COMP_CWORD]}
|
|
|
|
_expand || return 0
|
|
|
|
# get first exclusion compspec that matches this command
|
|
xspec=$( sed -ne '/ '${1##*/}'/{p;q;}' $BASH_COMPLETION )
|
|
# prune to leave nothing but the -X spec
|
|
xspec=${xspec#*-X }
|
|
xspec=${xspec%% *}
|
|
|
|
COMPREPLY=( $( eval compgen -f -X "$xspec" -- \
|
|
\"${cur#[\`\"\']}\" 2>/dev/null ) \
|
|
$( compgen -d -- $cur ) )
|
|
}
|
|
list=( $( sed -ne '/^# START exclude/,/^# FINISH exclude/p' \
|
|
$BASH_COMPLETION | \
|
|
# read exclusion compspecs
|
|
(
|
|
while read line
|
|
do
|
|
# ignore compspecs that are commented out
|
|
if [ "${line#\#}" != "$line" ]; then continue; fi
|
|
line=${line%# START exclude*}
|
|
line=${line%# FINISH exclude*}
|
|
line=${line##*\'}
|
|
list=( ${list[@]:-} $line )
|
|
done
|
|
echo ${list[@]}
|
|
)
|
|
) )
|
|
# remove previous compspecs
|
|
if [ ${#list[@]} -gt 0 ]; then
|
|
eval complete -r ${list[@]}
|
|
# install new compspecs
|
|
eval complete -F _filedir_xspec $filenames ${list[@]}
|
|
fi
|
|
unset list[@]
|
|
|
|
# source completion directory definitions
|
|
if [ -d $BASH_COMPLETION_DIR -a -r $BASH_COMPLETION_DIR -a \
|
|
-x $BASH_COMPLETION_DIR ]; then
|
|
for i in $BASH_COMPLETION_DIR/*; do
|
|
[[ ${i##*/} != @(*~|*.bak|*.swp|\#*\#|*.dpkg*) ]] &&
|
|
[ -f $i -a -r $i ] && . $i
|
|
done
|
|
fi
|
|
unset i
|
|
|
|
# source user completion file
|
|
[ $BASH_COMPLETION != ~/.bash_completion -a -r ~/.bash_completion ] \
|
|
&& . ~/.bash_completion
|
|
unset -f have
|
|
unset UNAME RELEASE have default dirnames filenames nospace
|
|
|
|
### Local Variables:
|
|
### mode: shell-script
|
|
### End:
|