7038N/A#

7038N/A# This file contains an example set of shell completions that can be used with

7038N/A# bash(1). These completions allow a user to complete filenames, commands

7038N/A# name, command line options, and command line arguments using the [tab] key.

7038N/A# The completions defined here are specific to the GNU command set, as a result

7038N/A# they will provide the choice of GNU command line options in response to the

7038N/A# [tab] key. For the completed options to match the command implementation,

7038N/A# you may have to have /usr/gnu/bin at the head of your PATH.

7038N/A#

7038N/A# These completions are not included in the default bash(1) environment. To

7038N/A# include them in the default environment, it is recommended that this file be

7038N/A# copied to /etc/bash/bash_completion and be sourced from either a system wide

7038N/A# bashrc in /etc/bash/bashrc or individual bashrcs in ~/.bashrc via

7038N/A# [ -f /etc/bash/bash_completion ] && . /etc/bash/bash_completion

7038N/A#

7038N/A

7038N/A# bash_completion - programmable completion functions for bash 3.x

7038N/A# (backwards compatible with bash 2.05b)

7038N/A#

7038N/A# $Id: bash_completion,v 1.872 2006/03/01 16:20:18 ianmacd Exp $

7038N/A#

7038N/A# Copyright (C) Ian Macdonald <ian@caliban.org>

7038N/A#

7038N/A# This program is free software; you can redistribute it and/or modify

7038N/A# it under the terms of the GNU General Public License as published by

7411N/A# the Free Software Foundation; either version 2, or (at your option)

7038N/A# any later version.

7038N/A#

7038N/A# This program is distributed in the hope that it will be useful,

7038N/A# but WITHOUT ANY WARRANTY; without even the implied warranty of

7038N/A# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

7038N/A# GNU General Public License for more details.

7038N/A#

7038N/A# You should have received a copy of the GNU General Public License

7038N/A# along with this program; if not, write to the Free Software Foundation,

7038N/A# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

7038N/A#

7038N/A# The latest version of this software can be obtained here:

7038N/A#

7038N/A# http://www.caliban.org/bash/index.shtml#completion

7038N/A#

7038N/A# RELEASE: 20060301

7038N/A

7038N/Aif [[ $- == *v* ]]; then

7038N/A BASH_COMPLETION_ORIGINAL_V_VALUE="-v"

7038N/Aelse

7038N/A BASH_COMPLETION_ORIGINAL_V_VALUE="+v"

7038N/Afi

7038N/A

7038N/Aif [[ -n $BASH_COMPLETION_DEBUG ]]; then

7038N/A set -v

7038N/Aelse

7038N/A set +v

7038N/Afi

7038N/A

7038N/A# Alter the following to reflect the location of this file.

7038N/A#

7038N/A[ -n "$BASH_COMPLETION" ] || BASH_COMPLETION=/etc/bash/bash_completion

7038N/A[ -n "$BASH_COMPLETION_DIR" ] || BASH_COMPLETION_DIR=/etc/bash/bash_completion.d

7038N/Areadonly BASH_COMPLETION BASH_COMPLETION_DIR

7038N/A

# Set a couple of useful vars

#

UNAME=$( uname -s )

# strip OS type and version under Cygwin (e.g. CYGWIN_NT-5.1 => Cygwin)

UNAME=${UNAME/CYGWIN_*/Cygwin}

RELEASE=$( uname -r )

# features supported by bash 2.05 and higher

if [ ${BASH_VERSINFO[0]} -eq 2 ] && [[ ${BASH_VERSINFO[1]} > 04 ]] ||

[ ${BASH_VERSINFO[0]} -gt 2 ]; then

declare -r bash205=$BASH_VERSION 2>/dev/null || :

default="-o default"

dirnames="-o dirnames"

filenames="-o filenames"

fi

# features supported by bash 2.05b and higher

if [ ${BASH_VERSINFO[0]} -eq 2 ] && [[ ${BASH_VERSINFO[1]} = "05b" ]] ||

[ ${BASH_VERSINFO[0]} -gt 2 ]; then

declare -r bash205b=$BASH_VERSION 2>/dev/null || :

nospace="-o nospace"

fi

# features supported by bash 3.0 and higher

if [ ${BASH_VERSINFO[0]} -gt 2 ]; then

declare -r bash3=$BASH_VERSION 2>/dev/null || :

bashdefault="-o bashdefault"

plusdirs="-o plusdirs"

fi

# 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)bz?(2)' bunzip2 bzcat bzcmp bzdiff bzegrep bzfgrep bzgrep

complete -f -X '!*.@(zip|ZIP|jar|JAR|exe|EXE|pk3|war|wsz|ear|zargo|xpi|sxw|ott)' 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|miff|tif?(f)|pn[gm]|p[bgp]m|bmp|xpm|ico|xwd|tga|pcx|GIF|JP?(E)G|MIFF|TIF?(F)|PN[GM]|P[BGP]M|BMP|XPM|ICO|XWD|TGA|PCX)' ee display

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|.bz2|.BZ2|.Z))' gv ggv kghostview

complete -f -X '!*.@(dvi|DVI)?(.@(gz|Z|bz2))' xdvi

complete -f -X '!*.@(dvi|DVI)?(.@(gz|bz2))' kdvi

complete -f -X '!*.@(dvi|DVI)' dvips dviselect dvitype dvipdf advi dvipdfm dvipdfmx

complete -f -X '!*.@(pdf|PDF)' acroread gpdf xpdf

complete -f -X '!*.@(?(e)ps|?(E)PS|pdf|PDF)' kpdf

complete -f -X '!*.@(@(?(e)ps|?(E)PS|pdf|PDF)?(.gz|.GZ)|cb(r|z)|CB(R|Z)|djv?(u)|DJV?(U)||dvi|DVI|gif|jp?(e)g|miff|tif?(f)|pn[gm]|p[bgp]m|bmp|xpm|ico|xwd|tga|pcx|GIF|JP?(E)G|MIFF|TIF?(F)|PN[GM]|P[BGP]M|BMP|XPM|ICO|XWD|TGA|PCX)' evince

complete -f -X '!*.@(?(e)ps|?(E)PS)' ps2pdf

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 madplay

complete -f -X '!*.@(mp?(e)g|MP?(E)G|wma|avi|AVI|asf|vob|VOB|bin|dat|divx|DIVX|vcd|ps|pes|fli|flv|FLV|viv|rm|ram|yuv|mov|MOV|qt|QT|wmv|mp3|MP3|m4v|M4V|ogg|OGG|ogm|OGM|mp4|MP4|wav|WAV|asx|ASX|mng|MNG|srt)' xine aaxine fbxine kaffeine

complete -f -X '!*.@(avi|asf|wmv)' aviplay

complete -f -X '!*.@(rm?(j)|ra?(m)|smi?(l))' realplay

complete -f -X '!*.@(mpg|mpeg|avi|mov|qt)' xanim

complete -f -X '!*.@(ogg|OGG|m3u|flac|spx)' ogg123

complete -f -X '!*.@(mp3|MP3|ogg|OGG|pls|m3u)' gqmpeg freeamp

complete -f -X '!*.fig' xfig

complete -f -X '!*.@(mid?(i)|MID?(I))' playmidi

complete -f -X '!*.@(mid?(i)|MID?(I)|rmi|RMI|rcp|RCP|[gr]36|[GR]36|g18|G18|mod|MOD|xm|XM|it|IT|x3m|X3M)' timidity

complete -f -X '*.@(o|so|so.!(conf)|a|rpm|gif|GIF|jp?(e)g|JP?(E)G|mp3|MP3|mp?(e)g|MPG|avi|AVI|asf|ASF|ogg|OGG|class|CLASS)' vi vim gvim rvim view rview rgvim rgview gview

complete -f -X '*.@(o|so|so.!(conf)|a|rpm|gif|GIF|jp?(e)g|JP?(E)G|mp3|MP3|mp?(e)g|MPG|avi|AVI|asf|ASF|ogg|OGG|class|CLASS)' emacs

complete -f -X '!*.@(exe|EXE|com|COM|scr|SCR|exe.so)' wine

complete -f -X '!*.@(zip|ZIP|z|Z|gz|GZ|tgz|TGZ)' bzme

complete -f -X '!*.@(?([xX]|[sS])[hH][tT][mM]?([lL]))' netscape mozilla lynx opera galeon curl dillo elinks amaya

complete -f -X '!*.@(sxw|stw|sxg|sgl|doc|dot|rtf|txt|htm|html|odt|ott|odm)' oowriter

complete -f -X '!*.@(sxi|sti|pps|ppt|pot|odp|otp)' ooimpress

complete -f -X '!*.@(sxc|stc|xls|xlw|xlt|csv|ods|ots)' oocalc

complete -f -X '!*.@(sxd|std|sda|sdd|odg|otg)' oodraw

complete -f -X '!*.@(sxm|smf|mml|odf)' oomath

complete -f -X '!*.odb' oobase

complete -f -X '!*.rpm' rpm2cpio

# 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 groups slay w sux

# group commands see only groups

[ -n "$bash205" ] && 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

# builtin completes on builtins

complete -b builtin

# start of section containing completion functions called by other functions

# This function checks whether we have a given program on the system.

# No need for bulky functions in memory if we don't.

#

have()

{

unset -v have

PATH=/usr/gnu/bin:$PATH:/sbin:/usr/sbin type $1 &>/dev/null &&

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 checks whether a given readline variable

# is `on'.

#

_rl_enabled()

{

[[ "$( bind -v )" = *$1+([[:space:]])on* ]]

}

# This function shell-quotes the argument

quote()

{

echo \'${1//\'/\'\\\'\'}\' #'# Help vim syntax highlighting

}

# This function quotes the argument in a way so that readline dequoting

# results in the original argument

quote_readline()

{

local t="${1//\\/\\\\}"

echo \'${t//\'/\'\\\'\'}\' #'# Help vim syntax highlighting

}

# This function shell-dequotes the argument

dequote()

{

eval echo "$1"

}

# Get the word to complete

# This is nicer than ${COMP_WORDS[$COMP_CWORD]}, since it handles cases

# where the user is completing in the middle of a word.

# (For example, if the line is "ls foobar",

# and the cursor is here --------> ^

# it will complete just "foo", not "foobar", which is what the user wants.)

_get_cword()

{

if [[ "${#COMP_WORDS[COMP_CWORD]}" -eq 0 ]] || [[ "$COMP_POINT" == "${#COMP_LINE}" ]]; then

echo "${COMP_WORDS[COMP_CWORD]}"

else

local i

local cur="$COMP_LINE"

local index="$COMP_POINT"

for (( i = 0; i <= COMP_CWORD; ++i )); do

while [[ "${#cur}" -ge ${#COMP_WORDS[i]} ]] && [[ "${cur:0:${#COMP_WORDS[i]}}" != "${COMP_WORDS[i]}" ]]; do

cur="${cur:1}"

index="$(( index - 1 ))"

done

if [[ "$i" -lt "$COMP_CWORD" ]]; then

local old_size="${#cur}"

cur="${cur#${COMP_WORDS[i]}}"

local new_size="${#cur}"

index="$(( index - old_size + new_size ))"

fi

done

if [[ "${COMP_WORDS[COMP_CWORD]:0:${#cur}}" != "$cur" ]]; then

# We messed up! At least return the whole word so things keep working

echo "${COMP_WORDS[COMP_CWORD]}"

else

echo "${cur:0:$index}"

fi

fi

}

# 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

local toks=( ) tmp

while read -r tmp; do

[[ -n $tmp ]] && toks[${#toks[@]}]=$tmp

done < <( compgen -d -- "$(quote_readline "$cur")" )

if [[ "$1" != -d ]]; then

xspec=${1:+"!*.$1"}

while read -r tmp; do

[[ -n $tmp ]] && toks[${#toks[@]}]=$tmp

done < <( compgen -f -X "$xspec" -- "$(quote_readline "$cur")" )

fi

COMPREPLY=( "${COMPREPLY[@]}" "${toks[@]}" )

}

# 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 completes on configured network interfaces

#

_configured_interfaces()

{

if [ -f /etc/debian_version ]; then

# Debian system

COMPREPLY=( $( sed -ne 's|^iface \([^ ]\+\).*$|\1|p' \

/etc/network/interfaces ) )

elif [ -f /etc/SuSE-release ]; then

# SuSE system

COMPREPLY=( $( command ls \

/etc/sysconfig/network/ifcfg-* | \

sed -ne 's|.*ifcfg-\('$cur'.*\)|\1|p' ) )

elif [ -f /etc/pld-release ]; then

# PLD Linux

COMPREPLY=( $( command ls -B \

/etc/sysconfig/interfaces | \

sed -ne 's|.*ifcfg-\('$cur'.*\)|\1|p' ) )

else

# Assume Red Hat

COMPREPLY=( $( command ls \

/etc/sysconfig/network-scripts/ifcfg-* | \

sed -ne 's|.*ifcfg-\('$cur'.*\)|\1|p' ) )

fi

}

# This function completes on all available network interfaces

# -a: restrict to active interfaces only

# -w: restrict to wireless interfaces only

#

_available_interfaces()

{

local cmd

if [ "${1:-}" = -w ]; then

cmd="iwconfig"

elif [ "${1:-}" = -a ]; then

cmd="ifconfig"

else

cmd="ifconfig -a"

fi

COMPREPLY=( $( eval $cmd 2>/dev/null | \

sed -ne 's|^\('$cur'[^[:space:][:punct:]]\{1,\}\).*$|\1|p') )

}

# This function expands tildes in pathnames

#

_expand()

{

# FIXME: Why was this here?

# [ "$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.

# AIX and Solaris ps prefers X/Open syntax.

[ $UNAME = SunOS -o $UNAME = AIX ] &&

_pids()

{

COMPREPLY=( $( compgen -W '$( command ps -efo pid | sed 1d )' -- $cur ))

} ||

_pids()

{

COMPREPLY=( $( compgen -W '$( command ps axo pid | sed 1d )' -- $cur ) )

}

# This function completes on process group IDs.

# AIX and SunOS prefer X/Open, all else should be BSD.

[ $UNAME = SunOS -o $UNAME = AIX ] &&

_pgids()

{

COMPREPLY=( $( compgen -W '$( command ps -efo pgid | sed 1d )' -- $cur ))

} ||

_pgids()

{

COMPREPLY=( $( compgen -W '$( command ps axo pgid | sed 1d )' -- $cur ))

}

# This function completes on user IDs

#

_uids()

{

if type getent &>/dev/null; then

COMPREPLY=( $( getent passwd | \

awk -F: '{if ($3 ~ /^'$cur'/) print $3}' ) )

elif type perl &>/dev/null; then

COMPREPLY=( $( compgen -W '$( perl -e '"'"'while (($uid) = (getpwent)[2]) { print $uid . "\n" }'"'"' )' -- $cur ) )

else

# make do with /etc/passwd

COMPREPLY=( $( awk 'BEGIN {FS=":"} {if ($3 ~ /^'$cur'/) print $3}'\

/etc/passwd ) )

fi

}

# This function completes on group IDs

#

_gids()

{

if type getent &>/dev/null; then

COMPREPLY=( $( getent group | \

awk -F: '{if ($3 ~ /^'$cur'/) print $3}' ) )

elif type perl &>/dev/null; then

COMPREPLY=( $( compgen -W '$( perl -e '"'"'while (($gid) = (getgrent)[2]) { print $gid . "\n" }'"'"' )' -- $cur ) )

else

# make do with /etc/group

COMPREPLY=( $( awk 'BEGIN {FS=":"} {if ($3 ~ /^'$cur'/) print $3}'\

/etc/group ) )

fi

}

# This function completes on services

#

_services()

{

local sysvdir famdir

[ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d || sysvdir=/etc/init.d

famdir=/etc/xinetd.d

COMPREPLY=( $( builtin echo $sysvdir/!(*.rpmsave|*.rpmorig|*~|functions)) )

if [ -d $famdir ]; then

COMPREPLY=( "${COMPREPLY[@]}" $( builtin echo $famdir/!(*.rpmsave|*.rpmorig|*~)) )

fi

COMPREPLY=( $( compgen -W '${COMPREPLY[@]#@($sysvdir|$famdir)/}' -- $cur ) )

}

# This function complete on modules

#

_modules()

{

local modpath

modpath=/lib/modules/$1

COMPREPLY=( $( command ls -R $modpath | \

sed -ne 's/^\('$cur'.*\)\.k\?o\(\|.gz\)$/\1/p') )

}

# this function complete on user:group format

#

_usergroup()

{

local IFS=$'\n'

cur=${cur//\\\\ / }

if [[ $cur = *@(\\:|.)* ]] && [ -n "$bash205" ]; then

user=${cur%%*([^:.])}

COMPREPLY=( $(compgen -P ${user/\\\\} -g -- ${cur##*[.:]}) )

elif [[ $cur = *:* ]] && [ -n "$bash205" ]; then

COMPREPLY=( $( compgen -g -- ${cur##*[.:]} ) )

else

COMPREPLY=( $( compgen -S : -u -- $cur ) )

fi

}

# this function count the number of mandatory args

#

_count_args()

{

args=1

for (( i=1; i < COMP_CWORD; i++ )); do

if [[ "${COMP_WORDS[i]}" != -* ]]; then

args=$(($args+1))

fi

done

}

# 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 $nospace 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 -n \"$`echo ${cur%=}`\" |

( echo -n \'

sed -e 's/'\''/'\''\\\'\'''\''/g'

echo -n \' ) )" )

;;

esac

}

complete -F _export $default $nospace export

# bash shell function completion

#

_function()

{

local cur prev

COMPREPLY=()

cur=`_get_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=`_get_cword`

prev=${COMP_WORDS[COMP_CWORD-1]}

case $prev in

-o)

options="default dirnames filenames"

[ -n "$bash205b" ] && options="$options nospace"

[ -n "$bash3" ] && options="$options bashdefault plusdirs"

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"

[ -n "$bash205" ] && 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

# a little help for FreeBSD ports users

[ $UNAME = FreeBSD ] && complete -W 'index search fetch fetch-list \

extract patch configure build install reinstall \

deinstall clean clean-depends kernel buildworld' make

# This completes on a list of all available service scripts for the

# 'service' command and/or the SysV init.d directory, followed by

# that script's available commands

#

{ have service || [ -d /etc/init.d/ ]; } &&

_service()

{

local cur sysvdir

COMPREPLY=()

prev=${COMP_WORDS[COMP_CWORD-1]}

cur=`_get_cword`

# don't complete for things like killall, ssh and mysql if it's

# the standalone command, rather than the init script

[[ ${COMP_WORDS[0]} != @(*init.d/!(functions|~)|service) ]] && return 0

# don't complete past 2nd token

[ $COMP_CWORD -gt 2 ] && return 0

[ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d \

|| sysvdir=/etc/init.d

if [[ $COMP_CWORD -eq 1 ]] && [[ $prev == "service" ]]; then

_services

else

COMPREPLY=( $( compgen -W '`sed -ne "y/|/ /; \

s/^.*Usage.*{\(.*\)}.*$/\1/p" \

$sysvdir/${prev##*/} 2>/dev/null`' -- $cur ) )

fi

return 0

} &&

complete -F _service service

[ -d /etc/init.d/ ] && complete -F _service $default \

$(for i in /etc/init.d/*; do echo ${i##*/}; done)

# chown(1) completion

#

_chown()

{

local cur

cur=`_get_cword`

# 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 ) )

else

_count_args

case $args in

1)

_usergroup

;;

*)

_filedir

;;

esac

fi

}

complete -F _chown $filenames chown

# chgrp(1) completion

#

_chgrp()

{

local cur prev

COMPREPLY=()

cur=`_get_cword`

cur=${cur//\\\\/}

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" == -* ]] && [ -n "$bash205" ]; then

local IFS=$'\n'

COMPREPLY=( $( compgen -g $cur 2>/dev/null ) )

else

_filedir || return 0

fi

return 0

}

complete -F _chgrp $filenames 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=`_get_cword`

OLDIFS="$IFS"

IFS="\n"

COMPREPLY=( $( compgen -W '$( mount | cut -d" " -f 3 )' -- $cur ) )

IFS="$OLDIFS"

return 0

}

complete -F _umount $dirnames umount

# mount(8) completion. This will pull a list of possible mounts out of

# /etc/{,v}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=`_get_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 2>/dev/null|

sed -ne '/^['"$'\t '"']*Sharename/,/^$/p' |

sed -ne '3,$s|^[^A-Za-z]*\([^'"$'\t '"']*\).*$|//'$host'/\1|p' ) )" -- "$cur" ) )

fi

elif [ -r /etc/vfstab ]; then

# Solaris

COMPREPLY=( $( awk '! /^[ \t]*#/ {if ($3 ~ /\//) print $3}' \

/etc/vfstab | grep "^$cur" ) )

elif [ ! -e /etc/fstab ]; then

# probably Cygwin

COMPREPLY=( $( mount | awk '! /^[ \t]*#/ {if ($3 ~ /\//) print $3}' \

| grep "^$cur" ) )

else

# probably Linux

COMPREPLY=( $( awk '! /^[ \t]*#/ {if ($2 ~ /\//) print $2}' \

/etc/fstab | grep "^$cur" ) )

fi

return 0

}

complete -F _mount $default $filenames mount

# Linux rmmod(8) completion. This completes on a list of all currently

# installed kernel modules.

#

have rmmod && {

_rmmod()

{

local cur

COMPREPLY=()

cur=`_get_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) and modinfo(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=`_get_cword`

prev=${COMP_WORDS[COMP_CWORD-1]}

# 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 '@(?(k)o?(.gz))'

return 0

fi

if [ $COMP_CWORD -gt 1 ] &&

[[ "${COMP_WORDS[COMP_CWORD-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 }}' ) )

else

_modules $(uname -r)

fi

return 0

}

complete -F _insmod $filenames insmod modprobe modinfo

}

# man(1) completion

#

[ $UNAME = GNU -o $UNAME = Linux -o $UNAME = Darwin \

-o $UNAME = FreeBSD -o $UNAME = SunOS -o $UNAME = Cygwin \

-o $UNAME = OpenBSD ] &&

_man()

{

local cur prev sect manpath UNAME

COMPREPLY=()

cur=`_get_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 )

# strip OS type and version under Cygwin

UNAME=${UNAME/CYGWIN_*/Cygwin}

if [ $UNAME = GNU -o $UNAME = Linux -o $UNAME = FreeBSD \

-o $UNAME = Cygwin ]; 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* } ${manpath//://*cat$sect/$cur* }"

else

manpath="${manpath//://*man$sect/ } ${manpath//://*cat$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 -o $UNAME = SunOS -o $UNAME = Cygwin \

-o $UNAME = OpenBSD ] && \

complete -F _man $filenames man apropos whatis

# renice(8) completion

#

_renice()

{

local command cur curopt i

COMPREPLY=()

cur=`_get_cword`

command=$1

i=0

# walk back through 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=`_get_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=`_get_cword`

if [ $COMP_CWORD -eq 1 ] && [[ "$cur" == -* ]]; then

_signals

else

COMPREPLY=( $( compgen -W '$( command ps axo command | \

sed -ne "1d; s/^\[\?\([^-][^] ]*\).*$/\1/p" | \

sed -e "s/.*\///" )' -- $cur ) )

fi

return 0

}

[ $UNAME = Linux -o $UNAME = FreeBSD ] && complete -F _killall killall pkill

# Linux and FreeBSD pgrep(1) completion.

#

[ $UNAME = Linux -o $UNAME = FreeBSD ] &&

_pgrep()

{

local cur

COMPREPLY=()

cur=`_get_cword`

COMPREPLY=( $( compgen -W '$( command ps axo command | \

sed -ne "1d; s/^\[\?\([^-][^] ]*\).*$/\1/p" | \

sed -e "s/.*\///" )' -- $cur ) )

return 0

}

[ $UNAME = Linux -o $UNAME = FreeBSD ] && complete -F _pgrep pgrep

# Linux pidof(8) completion.

[ $UNAME = Linux ] && complete -F _pgrep pidof

# 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 i exprfound onlyonce

COMPREPLY=()

cur=`_get_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|c)newer|-fls|-fprint?(0|f)|-?(i)?(l)name|-?(i)wholename)

_filedir

return 0

;;

-fstype)

# this is highly non-portable

[ -e /proc/filesystems ] &&

COMPREPLY=( $( cut -d$'\t' -f 2 /proc/filesystems | \

grep "^$cur" ) )

return 0

;;

-gid)

_gids

return 0

;;

-group)

if [ -n "$bash205" ]; then

COMPREPLY=( $( compgen -g -- $cur 2>/dev/null) )

fi

return 0

;;

-?(x)type)

COMPREPLY=( $( compgen -W 'b c d p f l s' -- $cur ) )

return 0

;;

-uid)

_uids

return 0

;;

-user)

COMPREPLY=( $( compgen -u -- $cur ) )

return 0

;;

-exec|-ok)

COMP_WORDS=(COMP_WORDS[0] $cur)

COMP_CWORD=1

_command

return 0

;;

-[acm]min|-[acm]time|-?(i)?(l)name|-inum|-?(i)path|-?(i)regex| \

-links|-perm|-size|-used|-printf)

# do nothing, just wait for a parameter to be given

return 0

;;

esac

_expand || return 0

# set exprfound to 1 if there is already an expression present

for i in ${COMP_WORDS[@]}; do

[[ "$i" = [-\(\),\!]* ]] && exprfound=1 && break

done

# handle case where first parameter is not a dash option

if [ "$exprfound" != 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 \

-wholename \

-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, as long as

# these options can only be used once (in a word, "options", in

# opposition to "tests" and "actions", as in the find(1) manpage).

onlyonce=' -daystart -depth -follow -help -maxdepth -mindepth -mount \

-noleaf -version -xdev '

COMPREPLY=( $( echo "${COMP_WORDS[@]}" | \

(while read -d ' ' i; do

[ "$i" == "" ] ||

[ "${onlyonce/ ${i%% *} / }" == "$onlyonce" ] &&

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[@]}")

) )

_filedir

return 0

}

complete -F _find $filenames find

# Linux iwconfig(8) completion

#

[ $UNAME = Linux ] && have iwconfig &&

_iwconfig()

{

local cur prev

COMPREPLY=()

cur=`_get_cword`

prev=${COMP_WORDS[COMP_CWORD-1]}

case $prev in

mode)

COMPREPLY=( $( compgen -W 'managed ad-hoc master \

repeater secondary monitor' -- $cur ) )

return 0

;;

essid)

COMPREPLY=( $( compgen -W 'on off any' -- $cur ) )

if [ -n "${COMP_IWLIST_SCAN:-}" ]; then

COMPREPLY=( "${COMPREPLY[@]}" \

$( iwlist ${COMP_WORDS[1]} scan | \

awk -F '"' '/ESSID/ {print $2}' | \

grep "^$cur" ))

fi

return 0

;;

nwid)

COMPREPLY=( $( compgen -W 'on off' -- $cur ) )

return 0

;;

channel)

COMPREPLY=( $( iwlist ${COMP_WORDS[1]} channel | \

awk '/^[[:space:]]*Channel/ {print $2}' | \

grep "^$cur" ) )

return 0

;;

freq)

COMPREPLY=( $( iwlist ${COMP_WORDS[1]} channel | \

awk '/^[[:space:]]*Channel/ {print $4"G"}' | \

grep "^$cur" ) )

return 0

;;

ap)

COMPREPLY=( $( compgen -W 'on off any' -- $cur ) )

if [ -n "${COMP_IWLIST_SCAN:-}" ]; then

COMPREPLY=( "${COMPREPLY[@]}" \

$( iwlist ${COMP_WORDS[1]} scan | \

awk -F ': ' '/Address/ {print $2}' | \

grep "^$cur" ) )

fi

return 0

;;

rate)

COMPREPLY=( $( compgen -W 'auto fixed' -- $cur ) )

COMPREPLY=( "${COMPREPLY[@]}" \

$( iwlist ${COMP_WORDS[1]} rate | \

awk '/^[[:space:]]*[0-9]/ {print $1"M"}' | \

grep "^$cur" ) )

return 0

;;

rts)

COMPREPLY=( $( compgen -W 'auto fixed off' -- $cur ) )

return 0

;;

frag)

COMPREPLY=( $( compgen -W 'auto fixed off' -- $cur ) )

return 0

;;

key)

COMPREPLY=( $( compgen -W 'off on open restricted' -- $cur ) )

return 0

;;

enc)

COMPREPLY=( $( compgen -W 'off on open restricted' -- $cur ) )

return 0

;;

power)

COMPREPLY=( $( compgen -W 'period timeout off on' -- $cur ) )

return 0

;;

txpower)

COMPREPLY=( $( compgen -W 'off on auto' -- $cur ) )

return 0

;;

retry)

COMPREPLY=( $( compgen -W 'limit lifetime' -- $cur ) )

return 0

;;

esac

if [ $COMP_CWORD -eq 1 ]; then

if [[ "$cur" == -* ]]; then

COMPREPLY=( $( compgen -W '--help --version' -- $cur ) )

else

_available_interfaces -w

fi

else

COMPREPLY=( $( compgen -W 'essid nwid mode freq channel sens mode \

ap nick rate rts frag enc key power txpower commit' -- $cur ) )

fi

} &&

complete -F _iwconfig iwconfig

# Linux iwlist(8) completion

#

[ $UNAME = Linux ] && have iwlist &&

_iwlist()

{

local cur prev

COMPREPLY=()

cur=`_get_cword`

prev=${COMP_WORDS[COMP_CWORD-1]}

if [ $COMP_CWORD -eq 1 ]; then

if [[ "$cur" == -* ]]; then

COMPREPLY=( $( compgen -W '--help --version' -- $cur ) )

else

_available_interfaces -w

fi

else

COMPREPLY=( $( compgen -W 'scan scanning freq frequency \

channel rate bit bitrate key enc encryption power \

txpower retry ap accesspoint peers event' -- $cur ) )

fi

} &&

complete -F _iwlist iwlist

# Linux iwspy(8) completion

#

[ $UNAME = Linux ] && have iwspy &&

_iwspy()

{

local cur

COMPREPLY=()

cur=`_get_cword`

if [ $COMP_CWORD -eq 1 ]; then

if [[ "$cur" == -* ]]; then

COMPREPLY=( $( compgen -W '--help --version' -- $cur ) )

else

_available_interfaces -w

fi

else

COMPREPLY=( $( compgen -W 'setthr getthr off' -- $cur ) )

fi

} &&

complete -F _iwspy iwspy

# Linux iwpriv(8) completion

#

[ $UNAME = Linux ] && have iwpriv &&

_iwpriv()

{

local cur prev

COMPREPLY=()

cur=`_get_cword`

prev=${COMP_WORDS[COMP_CWORD-1]}

case "$prev" in

roam)

COMPREPLY=( $( compgen -W 'on off' -- $cur ) )

return 0

;;

port)

COMPREPLY=( $( compgen -W 'ad-hoc managed' -- $cur ) )

return 0

;;

esac

if [ $COMP_CWORD -eq 1 ]; then

if [[ "$cur" == -* ]]; then

COMPREPLY=( $( compgen -W '--help --version' -- $cur ) )

else

_available_interfaces -w

fi

else

COMPREPLY=( $( compgen -W '--all roam port' -- $cur ) )

fi

} &&

complete -F _iwpriv iwpriv

# RedHat & Debian GNU/Linux if{up,down} completion

#

[ $UNAME = Linux ] && { have ifup || have ifdown; } &&

_ifupdown()

{

local cur

COMPREPLY=()

cur=`_get_cword`

if [ $COMP_CWORD -eq 1 ]; then

_configured_interfaces

COMPREPLY=( $(compgen -W '${COMPREPLY[@]}' -- "$cur") )

fi

return 0

} &&

complete -F _ifupdown ifup ifdown

[ $UNAME = Linux ] && have ifstatus && complete -F _ifupdown ifstatus

# Linux ipsec(8) completion (for FreeS/WAN)

#

[ $UNAME = Linux ] && have ipsec &&

_ipsec()

{

local cur

COMPREPLY=()

cur=`_get_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

} &&

complete -F _ipsec ipsec

# Postfix completion.

#

have postfix && {

# postfix(1)

#

_postfix()

{

local cur prev

cur=`_get_cword`

prev=${COMP_WORDS[COMP_CWORD-1]}

if [[ $cur == '-' ]]; then

COMPREPLY=(-c -D -v)

return 0

fi

if [[ $prev == '-c' ]]; then

_filedir -d

return 0

fi

if [[ $prev == '-D' ]]; then

COMPREPLY=( $( compgen -W 'start' -- "`get_cword`" ) )

return 0

fi

COMPREPLY=( $( compgen -W 'start stop reload abort flush check' -- \

"`get_cword`" ) )

}

complete -F _postfix postfix

# postalias(1) and postmap(1)

#

_postmap()

{

local cur prev len idx

cur=`_get_cword`

prev=${COMP_WORDS[COMP_CWORD-1]}

if [[ $cur == '-' ]]; then

COMPREPLY=(-N -f -i -n -o -p -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 $( /usr/sbin/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

# postcat(1)

#

_postcat()

{

local cur prev pval len idx qfile

cur=`_get_cword`

prev=${COMP_WORDS[COMP_CWORD-1]}

if [[ $cur == '-' ]]; then

COMPREPLY=(-c -q -v)

return 0

fi

if [[ $prev == '-c' ]]; then

_filedir -d

return 0

fi

qfile=0

for idx in "${COMP_WORDS[@]}"; do

[[ "$idx" = -q ]] && qfile=1 && break

done

if [[ $qfile == 1 ]]; 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

else

_filedir

return 0

fi

}

complete -F _postcat postcat

# postconf(1)

#

_postconf()

{

local cur prev pval len idx eqext

cur=`_get_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 $( /usr/sbin/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 pval len idx

cur=`_get_cword`

prev=${COMP_WORDS[COMP_CWORD-1]}

if [[ $cur == '-' ]]; then

COMPREPLY=(-c -d -h -H -p -r -s -v)

return 0

fi

case $prev in

-[dr])

len=${#cur}

idx=0

for pval in $( echo ALL; 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

;;

-h)

len=${#cur}

idx=0

for pval in $( echo ALL; mailq | \

sed -e '1d; $d; /^[^0-9A-Z]\|^$/d; s/[* ].*$//; /!$/d' ); do

if [[ "$cur" == "${pval:0:$len}" ]]; then

COMPREPLY[$idx]=$pval

idx=$(($idx+1))

fi

done

return 0

;;

-H)

len=${#cur}

idx=0

for pval in $( echo ALL; mailq | \

sed -e '1d; $d; /^[^0-9A-Z]\|^$/d; /^[0-9A-Z]*[* ]/d; s/!.*$//' ); do

if [[ "$cur" == "${pval:0:$len}" ]]; then

COMPREPLY[$idx]=$pval

idx=$(($idx+1))

fi

done

return 0

;;

esac

COMPREPLY=( $( compgen -W 'hold incoming active deferred' -- $cur ) )

return 0

}

complete -F _postsuper postsuper

}

# cvs(1) completion

#

have cvs && {

set_prefix()

{

[ -z ${prefix:-} ] || prefix=${cur%/*}/

[ -r ${prefix:-}CVS/Entries ] || prefix=""

}

get_entries()

{

local IFS=$'\n'

[ -r ${prefix:-}CVS/Entries ] && \

entries=$(cut -d/ -f2 -s ${prefix:-}CVS/Entries)

}

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 cvsroots pwd

local -a flags miss files entries changed newremoved

COMPREPLY=()

cur=`_get_cword`

count=0

for i in "${COMP_WORDS[@]}"; do

[ $count -eq $COMP_CWORD ] && break

# Last parameter was the CVSROOT, now go back to mode selection

if [ "${COMP_WORDS[((count))]}" == "$cvsroot" -a "$mode" == "cvsroot" ]; then

mode=""

fi

if [ -z "$mode" ]; then

case $i in

-d)

mode=cvsroot

cvsroot=${COMP_WORDS[((count+1))]}

;;

@(ad?(d)|new))

mode=add

;;

@(adm?(in)|rcs))

mode=admin

;;

ann?(notate))

mode=annotate

;;

@(checkout|co|get))

mode=checkout

;;

@(com?(mit)|ci))

mode=commit

;;

di?(f?(f)))

mode=diff

;;

ex?(p?(ort)))

mode=export

;;

?(un)edit)

mode=$i

;;

hi?(s?(tory)))

mode=history

;;

im?(p?(ort)))

mode=import

;;

re?(l?(ease)))

mode=release

;;

?(r)log)

mode=log

;;

@(rdiff|patch))

mode=rdiff

;;

@(remove|rm|delete))

mode=remove

;;

@(rtag|rfreeze))

mode=rtag

;;

st?(at?(us)))

mode=status

;;

@(tag|freeze))

mode=tag

;;

up?(d?(ate)))

mode=update

;;

*)

;;

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

;;

annotate)

if [[ "$cur" = -* ]]; then

COMPREPLY=( $( compgen -W '-D -F -f -l -R -r' -- $cur ) )

else

get_entries

COMPREPLY=( $( compgen -W '${entries[@]}' -- $cur ) )

fi

;;

checkout)

if [[ "$cur" != -* ]]; then

[ -z "$cvsroot" ] && cvsroot=$CVSROOT

COMPREPLY=( $( cvs -d "$cvsroot" co -c 2> /dev/null | \

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 -q diff --brief 2>&1 | \

sed -ne 's/^Files [^ ]* and \([^ ]*\) differ$/\1/p' ) )

newremoved=( $( cvs -q diff --brief 2>&1 | \

sed -ne 's/^cvs diff: \([^ ]*\) .*, no comparison available$/\1/p' ) )

COMPREPLY=( $( compgen -W '${changed[@]:-} \

${newremoved[@]:-}' -- $cur ) )

else

_filedir

fi

else

COMPREPLY=( $( compgen -W '-n -R -l -f -F -m -r' -- \

$cur ) )

fi

;;

cvsroot)

if [ -r ~/.cvspass ]; then

# Ugly escaping because of bash treating ':' specially

cvsroots=$( sed 's/^[^ ]* //; s/:/\\:/g' ~/.cvspass )

COMPREPLY=( $( compgen -W '$cvsroots' -- $cur ) )

fi

;;

export)

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 '-N -f -l -R -n \

-r -D -d -k' -- $cur ) )

fi

;;

diff)

if [[ "$cur" == -* ]]; then

_longopt diff

else

get_entries

COMPREPLY=( $( compgen -W '${entries[@]:-}' -- $cur ) )

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

;;

update)

if [[ "$cur" = -* ]]; then

COMPREPLY=( $( compgen -W '-A -P -C -d -f -l -R -p \

-k -r -D -j -I -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 stat status \

tag unedit up 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 ver nodig nosig

if [ -r /var/log/rpmpkgs -a \

/var/log/rpmpkgs -nt /var/lib/rpm/Packages ]; then

# using RHL 7.2 or later - 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

nodig=""

nosig=""

ver=$(rpm --version)

ver=${ver##* }

if [[ "$ver" > "4.0.4" ]]; then

nodig="--nodigest"

fi

if [[ "$ver" > "4.0.99" ]]; then

nosig="--nosignature"

fi

COMPREPLY=( $( rpm -qa $nodig $nosig | 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 $nodig $nosig --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 ver nodig nosig

COMPREPLY=()

cur=`_get_cword`

prev=${COMP_WORDS[COMP_CWORD-1]}

nodig=""

nosig=""

ver=$(rpm --version); ver=${ver##* }

if [[ "$ver" > "4.0.4" ]]; then

nodig="--nodigest"

fi

if [[ "$ver" > "4.0.99" ]]; then

nosig="--nosignature"

fi

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 $nodig $nosig --queryformat \

'%{providename}\n' | grep "^$cur" ) )

fi

return 0

;;

--whatrequires)

# complete on capabilities

COMPREPLY=( $( rpm -qa $nodig $nosig --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 \