Subversion Repositories configs

# perf bash and zsh completion

# Taken from git.git's completion script.

__my_reassemble_comp_words_by_ref()

{

	local exclude i j first

	# Which word separators to exclude?

	exclude="${1//[^$COMP_WORDBREAKS]}"

	cword_=$COMP_CWORD

	if [ -z "$exclude" ]; then

		words_=("${COMP_WORDS[@]}")

		return

	fi

	# List of word completion separators has shrunk;

	# re-assemble words to complete.

	for ((i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do

		# Append each nonempty word consisting of just

		# word separator characters to the current word.

		first=t

		while

			[ $i -gt 0 ] &&

			[ -n "${COMP_WORDS[$i]}" ] &&

			# word consists of excluded word separators

			[ "${COMP_WORDS[$i]//[^$exclude]}" = "${COMP_WORDS[$i]}" ]

		do

			# Attach to the previous token,

			# unless the previous token is the command name.

			if [ $j -ge 2 ] && [ -n "$first" ]; then

				((j--))

			fi

			first=

			words_[$j]=${words_[j]}${COMP_WORDS[i]}

			if [ $i = $COMP_CWORD ]; then

				cword_=$j

			fi

			if (($i < ${#COMP_WORDS[@]} - 1)); then

				((i++))

			else

				# Done.

				return

			fi

		done

		words_[$j]=${words_[j]}${COMP_WORDS[i]}

		if [ $i = $COMP_CWORD ]; then

			cword_=$j

		fi

	done

}

# Define preload_get_comp_words_by_ref="false", if the function

# __perf_get_comp_words_by_ref() is required instead.

preload_get_comp_words_by_ref="true"

if [ $preload_get_comp_words_by_ref = "true" ]; then

	type _get_comp_words_by_ref &>/dev/null ||

	preload_get_comp_words_by_ref="false"

fi

[ $preload_get_comp_words_by_ref = "true" ] ||

__perf_get_comp_words_by_ref()

{

	local exclude cur_ words_ cword_

	if [ "$1" = "-n" ]; then

		exclude=$2

		shift 2

	fi

	__my_reassemble_comp_words_by_ref "$exclude"

	cur_=${words_[cword_]}

	while [ $# -gt 0 ]; do

		case "$1" in

		cur)

			cur=$cur_

			;;

		prev)

			prev=${words_[$cword_-1]}

			;;

		words)

			words=("${words_[@]}")

			;;

		cword)

			cword=$cword_

			;;

		esac

		shift

	done

}

# Define preload__ltrim_colon_completions="false", if the function

# __perf__ltrim_colon_completions() is required instead.

preload__ltrim_colon_completions="true"

if [ $preload__ltrim_colon_completions = "true" ]; then

	type __ltrim_colon_completions &>/dev/null ||

	preload__ltrim_colon_completions="false"

fi

[ $preload__ltrim_colon_completions = "true" ] ||

__perf__ltrim_colon_completions()

{

	if [[ "$1" == *:* && "$COMP_WORDBREAKS" == *:* ]]; then

		# Remove colon-word prefix from COMPREPLY items

		local colon_word=${1%"${1##*:}"}

		local i=${#COMPREPLY[*]}

		while [[ $((--i)) -ge 0 ]]; do

			COMPREPLY[$i]=${COMPREPLY[$i]#"$colon_word"}

		done

	fi

}

__perfcomp ()

{

	COMPREPLY=( $( compgen -W "$1" -- "$2" ) )

}

__perfcomp_colon ()

{

	__perfcomp "$1" "$2"

	if [ $preload__ltrim_colon_completions = "true" ]; then

		__ltrim_colon_completions $cur

	else

		__perf__ltrim_colon_completions $cur

	fi

}

__perf_prev_skip_opts ()

{

	local i cmd_ cmds_

	let i=cword-1

	cmds_=$($cmd $1 --list-cmds)

	prev_skip_opts=()

	while [ $i -ge 0 ]; do

		if [[ ${words[i]} == $1 ]]; then

			return

		fi

		for cmd_ in $cmds_; do

			if [[ ${words[i]} == $cmd_ ]]; then

				prev_skip_opts=${words[i]}

				return

			fi

		done

		((i--))

	done

}

__perf_main ()

{

	local cmd

	cmd=${words[0]}

	COMPREPLY=()

	# Skip options backward and find the last perf command

	__perf_prev_skip_opts

	# List perf subcommands or long options

	if [ -z $prev_skip_opts ]; then

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

			cmds=$($cmd --list-opts)

		else

			cmds=$($cmd --list-cmds)

		fi

		__perfcomp "$cmds" "$cur"

	# List possible events for -e option

	elif [[ $prev == @("-e"|"--event") &&

		$prev_skip_opts == @(record|stat|top) ]]; then

		evts=$($cmd list --raw-dump)

		__perfcomp_colon "$evts" "$cur"

	else

		# List subcommands for perf commands

		if [[ $prev_skip_opts == @(kvm|kmem|mem|lock|sched|

			|data|help|script|test|timechart|trace) ]]; then

			subcmds=$($cmd $prev_skip_opts --list-cmds)

			__perfcomp_colon "$subcmds" "$cur"

		fi

		# List long option names

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

			subcmd=$prev_skip_opts

			__perf_prev_skip_opts $subcmd

			subcmd=$subcmd" "$prev_skip_opts

			opts=$($cmd $subcmd --list-opts)

			__perfcomp "$opts" "$cur"

		fi

	fi

}

if [[ -n ${ZSH_VERSION-} ]]; then

	autoload -U +X compinit && compinit

	__perfcomp ()

	{

		emulate -L zsh

		local c IFS=$' \t\n'

		local -a array

		for c in ${=1}; do

			case $c in

			--*=*|*.) ;;

			*) c="$c " ;;

			esac

			array[${#array[@]}+1]="$c"

		done

		compset -P '*[=:]'

		compadd -Q -S '' -a -- array && _ret=0

	}

	__perfcomp_colon ()

	{

		emulate -L zsh

		local cur_="${2-$cur}"

		local c IFS=$' \t\n'

		local -a array

		if [[ "$cur_" == *:* ]]; then

			local colon_word=${cur_%"${cur_##*:}"}

		fi

		for c in ${=1}; do

			case $c in

			--*=*|*.) ;;

			*) c="$c " ;;

			esac

			array[$#array+1]=${c#"$colon_word"}

		done

		compset -P '*[=:]'

		compadd -Q -S '' -a -- array && _ret=0

	}

	_perf ()

	{

		local _ret=1 cur cword prev

		cur=${words[CURRENT]}

		prev=${words[CURRENT-1]}

		let cword=CURRENT-1

		emulate ksh -c __perf_main

		let _ret && _default && _ret=0

		return _ret

	}

	compdef _perf perf

	return

fi

type perf &>/dev/null &&

_perf()

{

	local cur words cword prev

	if [ $preload_get_comp_words_by_ref = "true" ]; then

		_get_comp_words_by_ref -n =: cur words cword prev

	else

		__perf_get_comp_words_by_ref -n =: cur words cword prev

	fi

	__perf_main

} &&

complete -o bashdefault -o default -o nospace -F _perf perf 2>/dev/null \

	|| complete -o default -o nospace -F _perf perf