Loading...
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
50type _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
79type __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_main ()
104{
105 local cmd
106
107 cmd=${words[0]}
108 COMPREPLY=()
109
110 # List perf subcommands or long options
111 if [ $cword -eq 1 ]; then
112 if [[ $cur == --* ]]; then
113 __perfcomp '--help --version \
114 --exec-path --html-path --paginate --no-pager \
115 --perf-dir --work-tree --debugfs-dir' -- "$cur"
116 else
117 cmds=$($cmd --list-cmds)
118 __perfcomp "$cmds" "$cur"
119 fi
120 # List possible events for -e option
121 elif [[ $prev == "-e" && "${words[1]}" == @(record|stat|top) ]]; then
122 evts=$($cmd list --raw-dump)
123 __perfcomp_colon "$evts" "$cur"
124 # List subcommands for 'perf kvm'
125 elif [[ $prev == "kvm" ]]; then
126 subcmds=$($cmd $prev --list-cmds)
127 __perfcomp_colon "$subcmds" "$cur"
128 # List long option names
129 elif [[ $cur == --* ]]; then
130 subcmd=${words[1]}
131 opts=$($cmd $subcmd --list-opts)
132 __perfcomp "$opts" "$cur"
133 fi
134}
135
136if [[ -n ${ZSH_VERSION-} ]]; then
137 autoload -U +X compinit && compinit
138
139 __perfcomp ()
140 {
141 emulate -L zsh
142
143 local c IFS=$' \t\n'
144 local -a array
145
146 for c in ${=1}; do
147 case $c in
148 --*=*|*.) ;;
149 *) c="$c " ;;
150 esac
151 array[${#array[@]}+1]="$c"
152 done
153
154 compset -P '*[=:]'
155 compadd -Q -S '' -a -- array && _ret=0
156 }
157
158 __perfcomp_colon ()
159 {
160 emulate -L zsh
161
162 local cur_="${2-$cur}"
163 local c IFS=$' \t\n'
164 local -a array
165
166 if [[ "$cur_" == *:* ]]; then
167 local colon_word=${cur_%"${cur_##*:}"}
168 fi
169
170 for c in ${=1}; do
171 case $c in
172 --*=*|*.) ;;
173 *) c="$c " ;;
174 esac
175 array[$#array+1]=${c#"$colon_word"}
176 done
177
178 compset -P '*[=:]'
179 compadd -Q -S '' -a -- array && _ret=0
180 }
181
182 _perf ()
183 {
184 local _ret=1 cur cword prev
185 cur=${words[CURRENT]}
186 prev=${words[CURRENT-1]}
187 let cword=CURRENT-1
188 emulate ksh -c __perf_main
189 let _ret && _default && _ret=0
190 return _ret
191 }
192
193 compdef _perf perf
194 return
195fi
196
197type perf &>/dev/null &&
198_perf()
199{
200 local cur words cword prev
201 _get_comp_words_by_ref -n =: cur words cword prev
202 __perf_main
203} &&
204
205complete -o bashdefault -o default -o nospace -F _perf perf 2>/dev/null \
206 || complete -o default -o nospace -F _perf perf
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.
53preload_get_comp_words_by_ref="true"
54
55if [ $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"
58fi
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.
90preload__ltrim_colon_completions="true"
91
92if [ $preload__ltrim_colon_completions = "true" ]; then
93 type __ltrim_colon_completions &>/dev/null ||
94 preload__ltrim_colon_completions="false"
95fi
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
169
170 if [[ "$cur1" == */* && ${cur1#*/} =~ ^[A-Z] ]]; then
171 OLD_IFS="$IFS"
172 IFS=" "
173 arr=($raw_evts)
174 IFS="$OLD_IFS"
175
176 for s in ${arr[@]}
177 do
178 if [[ "$s" == *cpu/* ]]; then
179 tmp=${s#*cpu/}
180 result=$result" ""cpu/"${tmp^^}
181 else
182 result=$result" "$s
183 fi
184 done
185
186 evts=${result}" "$(ls /sys/bus/event_source/devices/cpu/events)
187 else
188 evts=${raw_evts}" "$(ls /sys/bus/event_source/devices/cpu/events)
189 fi
190
191 if [[ "$cur1" == , ]]; then
192 __perfcomp_colon "$evts" ""
193 else
194 __perfcomp_colon "$evts" "$cur1"
195 fi
196 else
197 # List subcommands for perf commands
198 if [[ $prev_skip_opts == @(kvm|kmem|mem|lock|sched|
199 |data|help|script|test|timechart|trace) ]]; then
200 subcmds=$($cmd $prev_skip_opts --list-cmds)
201 __perfcomp_colon "$subcmds" "$cur"
202 fi
203 # List long option names
204 if [[ $cur == --* ]]; then
205 subcmd=$prev_skip_opts
206 __perf_prev_skip_opts $subcmd
207 subcmd=$subcmd" "$prev_skip_opts
208 opts=$($cmd $subcmd --list-opts)
209 __perfcomp "$opts" "$cur"
210 fi
211 fi
212}
213
214if [[ -n ${ZSH_VERSION-} ]]; then
215 autoload -U +X compinit && compinit
216
217 __perfcomp ()
218 {
219 emulate -L zsh
220
221 local c IFS=$' \t\n'
222 local -a array
223
224 for c in ${=1}; do
225 case $c in
226 --*=*|*.) ;;
227 *) c="$c " ;;
228 esac
229 array[${#array[@]}+1]="$c"
230 done
231
232 compset -P '*[=:]'
233 compadd -Q -S '' -a -- array && _ret=0
234 }
235
236 __perfcomp_colon ()
237 {
238 emulate -L zsh
239
240 local cur_="${2-$cur}"
241 local c IFS=$' \t\n'
242 local -a array
243
244 if [[ "$cur_" == *:* ]]; then
245 local colon_word=${cur_%"${cur_##*:}"}
246 fi
247
248 for c in ${=1}; do
249 case $c in
250 --*=*|*.) ;;
251 *) c="$c " ;;
252 esac
253 array[$#array+1]=${c#"$colon_word"}
254 done
255
256 compset -P '*[=:]'
257 compadd -Q -S '' -a -- array && _ret=0
258 }
259
260 _perf ()
261 {
262 local _ret=1 cur cword prev
263 cur=${words[CURRENT]}
264 prev=${words[CURRENT-1]}
265 let cword=CURRENT-1
266 emulate ksh -c __perf_main
267 let _ret && _default && _ret=0
268 return _ret
269 }
270
271 compdef _perf perf
272 return
273fi
274
275type perf &>/dev/null &&
276_perf()
277{
278 if [[ "$COMP_WORDBREAKS" != *,* ]]; then
279 COMP_WORDBREAKS="${COMP_WORDBREAKS},"
280 export COMP_WORDBREAKS
281 fi
282
283 if [[ "$COMP_WORDBREAKS" == *:* ]]; then
284 COMP_WORDBREAKS="${COMP_WORDBREAKS/:/}"
285 export COMP_WORDBREAKS
286 fi
287
288 local cur words cword prev
289 if [ $preload_get_comp_words_by_ref = "true" ]; then
290 _get_comp_words_by_ref -n =:, cur words cword prev
291 else
292 __perf_get_comp_words_by_ref -n =:, cur words cword prev
293 fi
294 __perf_main
295} &&
296
297complete -o bashdefault -o default -o nospace -F _perf perf 2>/dev/null \
298 || complete -o default -o nospace -F _perf perf