[thirdparty/bash.git] / examples / complete / complete-examples

#
# Completion examples
#

#
# This encapsulates the default bash completion code
# call with the word to be completed as $1
#
# Since programmable completion does not use the bash default completions
# or the readline default of filename completion when the compspec does
# not generate any matches, this may be used as a `last resort' in a
# completion function to mimic the default bash completion behavior.
#
_bash_def_completion ()
{
	local h t
	COMPREPLY=()

	# command substitution
	if [[ "$1" == \$\(* ]]; then
		t=${1#??}
		COMPREPLY=( $(compgen -c -P '$(' $t) )
	fi
	# variables with a leading `${'
	if [ ${#COMPREPLY[@]} -eq 0 ] && [[ "$1" == \$\{* ]]; then
		t=${1#??}
		COMPREPLY=( $(compgen -v -P '${' -S '}' $t) )
	fi
	# variables with a leading `$'
	if [ ${#COMPREPLY[@]} -eq 0 ] && [[ "$1" == \$* ]]; then
		t=${1#?}
		COMPREPLY=( $(compgen -v -P '$' $t ) )
	fi
	# username expansion
	if [ ${#COMPREPLY[@]} -eq 0 ] && [[ "$1" == ~* ]] && [[ "$1" != */* ]]; then
		t=${1#?}
		COMPREPLY=( $( compgen -u -P '~' $t ) )
	fi
	# hostname
	if [ ${#COMPREPLY[@]} -eq 0 ] && [[ "$1" == *@* ]]; then
		h=${1%%@*}
		t=${1#*@}
		COMPREPLY=( $( compgen -A hostname -P "${h}@" $t ) )
	fi
	# glob pattern
	if [ ${#COMPREPLY[@]} -eq 0 ]; then
		# sh-style glob pattern
		if [[ $1 == *[*?[]* ]]; then
			COMPREPLY=( $( compgen -G "$1" ) )
		# ksh-style extended glob pattern - must be complete
		elif shopt -q extglob && [[ $1 == *[?*+\!@]\(*\)* ]]; then
			COMPREPLY=( $( compgen -G "$1" ) )
		fi
	fi

	# final default is filename completion
	if [ ${#COMPREPLY[@]} -eq 0 ]; then
		COMPREPLY=( $(compgen -f "$1" ) )
	fi
}

# 
# Return 1 if $1 appears to contain a redirection operator.  Handles backslash
# quoting (barely).
#
_redir_op()
{
	case "$1" in
	*\\'[\<\>]'*)	return 1;;
	*[\<\>]*)	return 0;;
	*)		return 1;;
	esac
}


# _redir_test tests the current word ($1) and the previous word ($2) for
# redirection operators and does filename completion on the current word
# if either one contains a redirection operator
_redir_test()
{
	if _redir_op "$1" ; then
		COMPREPLY=( $( compgen -f "$1" ) )
		return 0
	elif _redir_op "$2" ; then
		COMPREPLY=( $( compgen -f "$1" ) )
		return 0
	fi
	return 1
}

# optional, but without this you can't use extended glob patterns
shopt -s extglob

#
# Easy ones for the shell builtins
#
# nothing for: alias, break, continue, dirs, echo, eval, exit, getopts,
# let, logout, popd, printf, pwd, return, shift, suspend, test, times,
# umask
#

complete -f -- . source
complete -A enabled builtin
complete -d cd

# this isn't exactly right yet -- needs to skip shell functions and
# do $PATH lookup (or do compgen -c and filter out matches that also
# appear in compgen -A function)
complete -c command

# could add -S '=', but that currently screws up because readline appends
# a space unconditionally

complete -v export local readonly
complete -A helptopic help	# currently same as builtins

complete -d pushd

complete -A shopt shopt

complete -c type

complete -a unalias
complete -v unset 

#
# Job control builtins: fg, bg, disown, kill, wait
# kill not done yet
#

complete -A stopped -P '%' bg
complete -j -P '%' fg jobs disown

# this is not quite right at this point

_wait_func ()
{
	local cur
	cur=${COMP_WORDS[COMP_CWORD]}

	case "$cur" in
	%*)	COMPREPLY=( $(compgen -A running -P '%' ${cur#?} ) ) ;;
	[0-9]*)	COMPREPLY=( $(jobs -p | grep ^${cur}) ) ;;
	*)	COMPREPLY=( $(compgen -A running -P '%') $(jobs -p) )
		;;
	esac
}
complete -F _wait_func wait

#
# more complicated things, several as yet unimplemented
#

#complete -F _bind_func bind

_declare_func()
{
	local cur prev nflag opts

	cur=${COMP_WORDS[COMP_CWORD]}
	prev=${COMP_WORDS[COMP_CWORD-1]}

	COMPREPLY=()
	if (( $COMP_CWORD <= 1 )) || [[ $cur == '-' ]]; then
		COMPREPLY=(-a -f -F -i -r -x -p)
		return 0;
	fi
	if [[ $cur == '+' ]]; then
		COMPREPLY=(+i +x)
		return 0;
	fi
	if [[ $prev == '-p' ]]; then
		COMPREPLY=( $(compgen -v $cur) )
		return 0;
	fi
	return 1
}
complete -F _declare_func declare typeset

_enable_func()
{
	local cur prev nflag opts

	cur=${COMP_WORDS[COMP_CWORD]}
	prev=${COMP_WORDS[COMP_CWORD-1]}

	COMPREPLY=()
	if (( $COMP_CWORD <= 1 )) || [[ $cur == '-' ]]; then
		COMPREPLY=(-a -d -f -n -p -s)
		return 0;
	fi
	if [[ $prev == '-f' ]]; then
		COMPREPLY=( $( compgen -f $cur ) )
		return 0;
	fi
	for opts in "${COMP_WORDS[@]}" ; do
		if [[ $opts == -*n* ]]; then nflag=1; fi
	done

	if [ -z "$nflag" ] ; then
		COMPREPLY=( $( compgen -A enabled $cur ) )
	else
		COMPREPLY=( $( compgen -A disabled $cur ) )
	fi
	return 0;
}
complete -F _enable_func enable

_exec_func()
{
	local cur prev

	cur=${COMP_WORDS[COMP_CWORD]}
	prev=${COMP_WORDS[COMP_CWORD-1]}

	if (( $COMP_CWORD <= 1 )) || [[ $cur == '-' ]]; then
		COMPREPLY=(-a -c -l)
		return 0;
	fi
	if [[ $prev != -*a* ]]; then
		COMPREPLY=( $( compgen -c $cur ) )
		return 0
	fi
	return 1;
}
complete -F _exec_func exec

_fc_func()
{
	local cur prev

	cur=${COMP_WORDS[COMP_CWORD]}
	prev=${COMP_WORDS[COMP_CWORD-1]}

	if (( $COMP_CWORD <= 1 )) || [[ $cur == '-' ]]; then
		COMPREPLY=(-e -n -l -r -s)
		return 0;
	fi
	if [[ $prev == -*e ]]; then
		COMPREPLY=( $(compgen -c $cur) )
		return 0
	fi
	return 1
}
complete -F _fc_func fc

_hash_func()
{
	local cur prev

	cur=${COMP_WORDS[COMP_CWORD]}
	prev=${COMP_WORDS[COMP_CWORD-1]}

	if (( $COMP_CWORD <= 1 )) || [[ $cur == '-' ]]; then
		COMPREPLY=(-p -r)
		return 0;
	fi

	if [[ $prev == '-p' ]]; then
		COMPREPLY=( $( compgen -f $cur ) )
		return 0;
	fi
	COMPREPLY=( $( compgen -c $cur ) )
	return 0
}
complete -F _hash_func hash

_history_func()
{
	local cur prev

	cur=${COMP_WORDS[COMP_CWORD]}
	prev=${COMP_WORDS[COMP_CWORD-1]}

	COMPREPLY=()
	if (( $COMP_CWORD <= 1 )) || [[ $cur == '-' ]]; then
		COMPREPLY=(-a -c -d -n -r -w -p -s)
		return 0;
	fi
	if [[ $prev == -[anrw] ]]; then
		COMPREPLY=( $( compgen -f $cur ) )
	fi
	return 0
}
complete -F _history_func history

#complete -F _read_func read

_set_func ()
{
	local cur prev

	cur=${COMP_WORDS[COMP_CWORD]}
	prev=${COMP_WORDS[COMP_CWORD-1]}

	COMPREPLY=()

	_redir_test "$cur" "$prev" && return 0;

	if (( $COMP_CWORD <= 1 )) || [[ $cur == '-' ]]; then
		COMPREPLY=(-a -b -e -f -k -m -n -o -p -t -u -v -x -B -C -H -P --)
		return 0;
	fi
	if [[ $cur == '+' ]]; then
		COMPREPLY=(+a +b +e +f +k +m +n +o +p +t +u +v +x +B +C +H +P)
		return 0;
	fi
	if [[ $prev == [+-]o ]]; then
		COMPREPLY=( $(compgen -A setopt $cur) )
		return 0;
	fi
	return 1;
}
complete -F _set_func set

_trap_func ()
{
	local cur
	cur=${COMP_WORDS[COMP_CWORD]}

	if (( $COMP_CWORD <= 1 )) || [[ $cur == '-' ]]; then
		COMPREPLY=(-l -p)
		return 0;
	fi
	COMPREPLY=( $( compgen -A signal ${cur}) )
	return 0
}
complete -F _trap_func trap

#
# meta-completion (completion for complete/compgen)
#
_complete_meta_func()
{
	local cur prev cmd
	COMPREPLY=()

	cmd=$1

	cur=${COMP_WORDS[COMP_CWORD]}
	prev=${COMP_WORDS[COMP_CWORD-1]}

	_redir_test "$cur" "$prev" && return 0;

	if (( $COMP_CWORD <= 1 )) || [[ "$cur" == '-' ]]; then
		case "$cmd" in
		complete) COMPREPLY=(-a -b -c -d -e -f -j -k -v -u -r -p -A -G -W -P -S -X -F -C);;
		compgen)  COMPREPLY=(-a -b -c -d -e -f -j -k -v -u -A -G -W -P -S -X -F -C);;
		esac
		return 0
	fi

	if [[ $prev == -A ]]; then
		COMPREPLY=(alias arrayvar binding builtin command directory \
disabled enabled export file 'function' helptopic hostname job keyword \
running setopt shopt signal stopped variable)
		return 0
	elif [[ $prev == -F ]]; then
		COMPREPLY=( $( compgen -A function $cur ) )
	elif [[ $prev == -C ]]; then
		COMPREPLY=( $( compgen -c $cur ) )
	else
		COMPREPLY=( $( compgen -c $cur ) )
	fi
	return 0
}
complete -F _complete_meta_func complete compgen

#
# some completions for shell reserved words
#
#complete -c -k time do if then else elif '{'

#
# external commands
#

complete -e printenv

complete -c nohup exec nice eval trace truss strace sotruss gdb

_make_targets ()
{
	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
	case "$prev" in
	-*f)	COMPREPLY=( $(compgen -f $cur ) ); return 0;;
	esac

	# if we want an option, return the possible posix options
	case "$cur" in
	-)	COMPREPLY=(-e -f -i -k -n -p -q -r -S -s -t); return 0;;
	esac

	# make reads `makefile' before `Makefile'
	# GNU make reads `GNUmakefile' before all other makefiles, but we
	# check that we're completing `gmake' before checking for it
	if [ -f GNUmakefile ] && [ ${COMP_WORDS[0]} == gmake ]; then
		mdef=GNUmakefile
	elif [ -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
	if [ -n "$2" ]; then gcmd='grep "^$2"' ; else gcmd=cat ; fi

	# if we don't want to use *.mk, we can take out the cat and use
	# test -f $makef and input redirection	
	COMPREPLY=( $(cat $makef 2>/dev/null | awk 'BEGIN {FS=":"} /^[^.# 	][^=]*:/ {print $1}' | tr -s ' ' '\012' | sort -u | eval $gcmd ) )
}
complete -F _make_targets -X '+($*|*.[cho])' make gmake pmake

_umount_func ()
{
	COMPREPLY=( $(mount | awk '{print $1}') )
}
complete -F _umount_func umount

_configure_func ()
{
	case "$2" in
	-*)	;;
	*)	return ;;
	esac

	case "$1" in
	\~*)	eval cmd=$1 ;;
	*)	cmd="$1" ;;
	esac

	COMPREPLY=( $("$cmd" --help | awk '{if ($1 ~ /--.*/) print $1}' | grep ^"$2" | sort -u) )
}
complete -F _configure_func configure

complete -W '"${GROUPS[@]}"' newgrp

complete -f chown ln more cat
complete -d mkdir rmdir
complete -f strip

complete -f -X '*.gz' gzip
complete -f -X '*.bz2' bzip2
complete -f -X '*.Z' compress
complete -f -X '!*.+(gz|tgz|Gz)' gunzip gzcat zcat zmore
complete -f -X '!*.Z' uncompress zmore zcat
complete -f -X '!*.bz2' bunzip2
complete -f -X '!*.zip' unzip
complete -f -X '!*.+(gif|jpg|jpeg|GIF|JPG|JPEG|bmp)' xv

complete -f -X '!*.pl' perl perl5

complete -A hostname rsh telnet rlogin ftp ping xping host traceroute nslookup
complete -A hostname rxterm rxterm3 rxvt2

complete -u su

complete -f -X '!*.+(ps|PS)' gs gv ghostview psselect pswrap
complete -f -X '!*.+(dvi|DVI)' dvips xdvi dviselect dvitype catdvi
complete -f -X '!*.+(pdf|PDF)' acroread4
complete -f -X '!*.texi*' makeinfo texi2dvi texi2html
complete -f -X '!*.+(tex|TEX)' tex latex slitex

complete -f -X '!*.+(mp3|MP3)' mpg123
complete -f -X '!*.+(htm|html)' links w3m lynx

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