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