tools/perf/perf-completion.sh

   1 # perf bash and zsh completion
   2
   3 # Taken from git.git's completion script.
   4 __my_reassemble_comp_words_by_ref()
   5 {
   6         local exclude i j first
   7         # Which word separators to exclude?
   8         exclude="${1//[^$COMP_WORDBREAKS]}"
   9         cword_=$COMP_CWORD
  10         if [ -z "$exclude" ]; then
  11                 words_=("${COMP_WORDS[@]}")
  12                 return
  13         fi
  14         # List of word completion separators has shrunk;
  15         # re-assemble words to complete.
  16         for ((i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do
  17                 # Append each nonempty word consisting of just
  18                 # word separator characters to the current word.
  19                 first=t
  20                 while
  21                         [ $i -gt 0 ] &&
  22                         [ -n "${COMP_WORDS[$i]}" ] &&
  23                         # word consists of excluded word separators
  24                         [ "${COMP_WORDS[$i]//[^$exclude]}" = "${COMP_WORDS[$i]}" ]
  25                 do
  26                         # Attach to the previous token,
  27                         # unless the previous token is the command name.
  28                         if [ $j -ge 2 ] && [ -n "$first" ]; then
  29                                 ((j--))
  30                         fi
  31                         first=
  32                         words_[$j]=${words_[j]}${COMP_WORDS[i]}
  33                         if [ $i = $COMP_CWORD ]; then
  34                                 cword_=$j
  35                         fi
  36                         if (($i < ${#COMP_WORDS[@]} - 1)); then
  37                                 ((i++))
  38                         else
  39                                 # Done.
  40                                 return
  41                         fi
  42                 done
  43                 words_[$j]=${words_[j]}${COMP_WORDS[i]}
  44                 if [ $i = $COMP_CWORD ]; then
  45                         cword_=$j
  46                 fi
  47         done
  48 }
  49
  50 # Define preload_get_comp_words_by_ref="false", if the function
  51 # __perf_get_comp_words_by_ref() is required instead.
  52 preload_get_comp_words_by_ref="true"
  53
  54 if [ $preload_get_comp_words_by_ref = "true" ]; then
  55         type _get_comp_words_by_ref &>/dev/null ||
  56         preload_get_comp_words_by_ref="false"
  57 fi
  58 [ $preload_get_comp_words_by_ref = "true" ] ||
  59 __perf_get_comp_words_by_ref()
  60 {
  61         local exclude cur_ words_ cword_
  62         if [ "$1" = "-n" ]; then
  63                 exclude=$2
  64                 shift 2
  65         fi
  66         __my_reassemble_comp_words_by_ref "$exclude"
  67         cur_=${words_[cword_]}
  68         while [ $# -gt 0 ]; do
  69                 case "$1" in
  70                 cur)
  71                         cur=$cur_
  72                         ;;
  73                 prev)
  74                         prev=${words_[$cword_-1]}
  75                         ;;
  76                 words)
  77                         words=("${words_[@]}")
  78                         ;;
  79                 cword)
  80                         cword=$cword_
  81                         ;;
  82                 esac
  83                 shift
  84         done
  85 }
  86
  87 # Define preload__ltrim_colon_completions="false", if the function
  88 # __perf__ltrim_colon_completions() is required instead.
  89 preload__ltrim_colon_completions="true"
  90
  91 if [ $preload__ltrim_colon_completions = "true" ]; then
  92         type __ltrim_colon_completions &>/dev/null ||
  93         preload__ltrim_colon_completions="false"
  94 fi
  95 [ $preload__ltrim_colon_completions = "true" ] ||
  96 __perf__ltrim_colon_completions()
  97 {
  98         if [[ "$1" == *:* && "$COMP_WORDBREAKS" == *:* ]]; then
  99                 # Remove colon-word prefix from COMPREPLY items
 100                 local colon_word=${1%"${1##*:}"}
 101                 local i=${#COMPREPLY[*]}
 102                 while [[ $((--i)) -ge 0 ]]; do
 103                         COMPREPLY[$i]=${COMPREPLY[$i]#"$colon_word"}
 104                 done
 105         fi
 106 }
 107
 108 __perfcomp ()
 109 {
 110         COMPREPLY=( $( compgen -W "$1" -- "$2" ) )
 111 }
 112
 113 __perfcomp_colon ()
 114 {
 115         __perfcomp "$1" "$2"
 116         if [ $preload__ltrim_colon_completions = "true" ]; then
 117                 __ltrim_colon_completions $cur
 118         else
 119                 __perf__ltrim_colon_completions $cur
 120         fi
 121 }
 122
 123 __perf_prev_skip_opts ()
 124 {
 125         local i cmd_ cmds_
 126
 127         let i=cword-1
 128         cmds_=$($cmd $1 --list-cmds)
 129         prev_skip_opts=()
 130         while [ $i -ge 0 ]; do
 131                 if [[ ${words[i]} == $1 ]]; then
 132                         return
 133                 fi
 134                 for cmd_ in $cmds_; do
 135                         if [[ ${words[i]} == $cmd_ ]]; then
 136                                 prev_skip_opts=${words[i]}
 137                                 return
 138                         fi
 139                 done
 140                 ((i--))
 141         done
 142 }
 143
 144 __perf_main ()
 145 {
 146         local cmd
 147
 148         cmd=${words[0]}
 149         COMPREPLY=()
 150
 151         # Skip options backward and find the last perf command
 152         __perf_prev_skip_opts
 153         # List perf subcommands or long options
 154         if [ -z $prev_skip_opts ]; then
 155                 if [[ $cur == --* ]]; then
 156                         cmds=$($cmd --list-opts)
 157                 else
 158                         cmds=$($cmd --list-cmds)
 159                 fi
 160                 __perfcomp "$cmds" "$cur"
 161         # List possible events for -e option
 162         elif [[ $prev == @("-e"|"--event") &&
 163                 $prev_skip_opts == @(record|stat|top) ]]; then
 164                 evts=$($cmd list --raw-dump)
 165                 __perfcomp_colon "$evts" "$cur"
 166         else
 167                 # List subcommands for perf commands
 168                 if [[ $prev_skip_opts == @(kvm|kmem|mem|lock|sched|
 169                         |data|help|script|test|timechart|trace) ]]; then
 170                         subcmds=$($cmd $prev_skip_opts --list-cmds)
 171                         __perfcomp_colon "$subcmds" "$cur"
 172                 fi
 173                 # List long option names
 174                 if [[ $cur == --* ]];  then
 175                         subcmd=$prev_skip_opts
 176                         __perf_prev_skip_opts $subcmd
 177                         subcmd=$subcmd" "$prev_skip_opts
 178                         opts=$($cmd $subcmd --list-opts)
 179                         __perfcomp "$opts" "$cur"
 180                 fi
 181         fi
 182 }
 183
 184 if [[ -n ${ZSH_VERSION-} ]]; then
 185         autoload -U +X compinit && compinit
 186
 187         __perfcomp ()
 188         {
 189                 emulate -L zsh
 190
 191                 local c IFS=$' \t\n'
 192                 local -a array
 193
 194                 for c in ${=1}; do
 195                         case $c in
 196                         --*=*|*.) ;;
 197                         *) c="$c " ;;
 198                         esac
 199                         array[${#array[@]}+1]="$c"
 200                 done
 201
 202                 compset -P '*[=:]'
 203                 compadd -Q -S '' -a -- array && _ret=0
 204         }
 205
 206         __perfcomp_colon ()
 207         {
 208                 emulate -L zsh
 209
 210                 local cur_="${2-$cur}"
 211                 local c IFS=$' \t\n'
 212                 local -a array
 213
 214                 if [[ "$cur_" == *:* ]]; then
 215                         local colon_word=${cur_%"${cur_##*:}"}
 216                 fi
 217
 218                 for c in ${=1}; do
 219                         case $c in
 220                         --*=*|*.) ;;
 221                         *) c="$c " ;;
 222                         esac
 223                         array[$#array+1]=${c#"$colon_word"}
 224                 done
 225
 226                 compset -P '*[=:]'
 227                 compadd -Q -S '' -a -- array && _ret=0
 228         }
 229
 230         _perf ()
 231         {
 232                 local _ret=1 cur cword prev
 233                 cur=${words[CURRENT]}
 234                 prev=${words[CURRENT-1]}
 235                 let cword=CURRENT-1
 236                 emulate ksh -c __perf_main
 237                 let _ret && _default && _ret=0
 238                 return _ret
 239         }
 240
 241         compdef _perf perf
 242         return
 243 fi
 244
 245 type perf &>/dev/null &&
 246 _perf()
 247 {
 248         local cur words cword prev
 249         if [ $preload_get_comp_words_by_ref = "true" ]; then
 250                 _get_comp_words_by_ref -n =: cur words cword prev
 251         else
 252                 __perf_get_comp_words_by_ref -n =: cur words cword prev
 253         fi
 254         __perf_main
 255 } &&
 256
 257 complete -o bashdefault -o default -o nospace -F _perf perf 2>/dev/null \
 258         || complete -o default -o nospace -F _perf perf