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 type _get_comp_words_by_ref &>/dev/null ||
  51 _get_comp_words_by_ref()
  52 {
  53         local exclude cur_ words_ cword_
  54         if [ "$1" = "-n" ]; then
  55                 exclude=$2
  56                 shift 2
  57         fi
  58         __my_reassemble_comp_words_by_ref "$exclude"
  59         cur_=${words_[cword_]}
  60         while [ $# -gt 0 ]; do
  61                 case "$1" in
  62                 cur)
  63                         cur=$cur_
  64                         ;;
  65                 prev)
  66                         prev=${words_[$cword_-1]}
  67                         ;;
  68                 words)
  69                         words=("${words_[@]}")
  70                         ;;
  71                 cword)
  72                         cword=$cword_
  73                         ;;
  74                 esac
  75                 shift
  76         done
  77 }
  78
  79 type __ltrim_colon_completions &>/dev/null ||
  80 __ltrim_colon_completions()
  81 {
  82         if [[ "$1" == *:* && "$COMP_WORDBREAKS" == *:* ]]; then
  83                 # Remove colon-word prefix from COMPREPLY items
  84                 local colon_word=${1%"${1##*:}"}
  85                 local i=${#COMPREPLY[*]}
  86                 while [[ $((--i)) -ge 0 ]]; do
  87                         COMPREPLY[$i]=${COMPREPLY[$i]#"$colon_word"}
  88                 done
  89         fi
  90 }
  91
  92 __perfcomp ()
  93 {
  94         COMPREPLY=( $( compgen -W "$1" -- "$2" ) )
  95 }
  96
  97 __perfcomp_colon ()
  98 {
  99         __perfcomp "$1" "$2"
 100         __ltrim_colon_completions $cur
 101 }
 102
 103 __perf_prev_skip_opts ()
 104 {
 105         local i cmd_ cmds_
 106
 107         let i=cword-1
 108         cmds_=$($cmd $1 --list-cmds)
 109         prev_skip_opts=()
 110         while [ $i -ge 0 ]; do
 111                 if [[ ${words[i]} == $1 ]]; then
 112                         return
 113                 fi
 114                 for cmd_ in $cmds_; do
 115                         if [[ ${words[i]} == $cmd_ ]]; then
 116                                 prev_skip_opts=${words[i]}
 117                                 return
 118                         fi
 119                 done
 120                 ((i--))
 121         done
 122 }
 123 __perf_main ()
 124 {
 125         local cmd
 126
 127         cmd=${words[0]}
 128         COMPREPLY=()
 129
 130         # Skip options backward and find the last perf command
 131         __perf_prev_skip_opts
 132         # List perf subcommands or long options
 133         if [ -z $prev_skip_opts ]; then
 134                 if [[ $cur == --* ]]; then
 135                         cmds=$($cmd --list-opts)
 136                 else
 137                         cmds=$($cmd --list-cmds)
 138                 fi
 139                 __perfcomp "$cmds" "$cur"
 140         # List possible events for -e and --event option
 141         elif [[ $prev == @("-e"|"--event") && $prev_skip_opts == @(record|stat|top) ]]; then
 142                 evts=$($cmd list --raw-dump)
 143                 __perfcomp_colon "$evts" "$cur"
 144         else
 145                 # List subcommands for perf commands
 146                 if [[ $prev_skip_opts == @(kvm|kmem|mem|lock|sched|data|help|script|test) ]]; then
 147                         subcmds=$($cmd $prev_skip_opts --list-cmds)
 148                         __perfcomp_colon "$subcmds" "$cur"
 149                 fi
 150                 # List long option names
 151                 if [[ $cur == --* ]];  then
 152                         subcmd=$prev_skip_opts
 153                         __perf_prev_skip_opts $subcmd
 154                         subcmd=$subcmd" "$prev_skip_opts
 155                         opts=$($cmd $subcmd --list-opts)
 156                         __perfcomp "$opts" "$cur"
 157                 fi
 158         fi
 159 }
 160
 161 if [[ -n ${ZSH_VERSION-} ]]; then
 162         autoload -U +X compinit && compinit
 163
 164         __perfcomp ()
 165         {
 166                 emulate -L zsh
 167
 168                 local c IFS=$' \t\n'
 169                 local -a array
 170
 171                 for c in ${=1}; do
 172                         case $c in
 173                         --*=*|*.) ;;
 174                         *) c="$c " ;;
 175                         esac
 176                         array[${#array[@]}+1]="$c"
 177                 done
 178
 179                 compset -P '*[=:]'
 180                 compadd -Q -S '' -a -- array && _ret=0
 181         }
 182
 183         __perfcomp_colon ()
 184         {
 185                 emulate -L zsh
 186
 187                 local cur_="${2-$cur}"
 188                 local c IFS=$' \t\n'
 189                 local -a array
 190
 191                 if [[ "$cur_" == *:* ]]; then
 192                         local colon_word=${cur_%"${cur_##*:}"}
 193                 fi
 194
 195                 for c in ${=1}; do
 196                         case $c in
 197                         --*=*|*.) ;;
 198                         *) c="$c " ;;
 199                         esac
 200                         array[$#array+1]=${c#"$colon_word"}
 201                 done
 202
 203                 compset -P '*[=:]'
 204                 compadd -Q -S '' -a -- array && _ret=0
 205         }
 206
 207         _perf ()
 208         {
 209                 local _ret=1 cur cword prev
 210                 cur=${words[CURRENT]}
 211                 prev=${words[CURRENT-1]}
 212                 let cword=CURRENT-1
 213                 emulate ksh -c __perf_main
 214                 let _ret && _default && _ret=0
 215                 return _ret
 216         }
 217
 218         compdef _perf perf
 219         return
 220 fi
 221
 222 type perf &>/dev/null &&
 223 _perf()
 224 {
 225         local cur words cword prev
 226         _get_comp_words_by_ref -n =: cur words cword prev
 227         __perf_main
 228 } &&
 229
 230 complete -o bashdefault -o default -o nospace -F _perf perf 2>/dev/null \
 231         || complete -o default -o nospace -F _perf perf