~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/perf-completion.sh

Version: ~ [ linux-6.12-rc7 ] ~ [ linux-6.11.7 ] ~ [ linux-6.10.14 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.60 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.116 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.171 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.229 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.285 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.323 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.12 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

Diff markup

Differences between /tools/perf/perf-completion.sh (Version linux-6.12-rc7) and /tools/perf/perf-completion.sh (Version policy-sample)


  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 h    
 16         # re-assemble words to complete.          
 17         for ((i=0, j=0; i < ${#COMP_WORDS[@]};    
 18                 # Append each nonempty word co    
 19                 # word separator characters to    
 20                 first=t                           
 21                 while                             
 22                         [ $i -gt 0 ] &&           
 23                         [ -n "${COMP_WORDS[$i]    
 24                         # word consists of exc    
 25                         [ "${COMP_WORDS[$i]//[    
 26                 do                                
 27                         # Attach to the previo    
 28                         # unless the previous     
 29                         if [ $j -ge 2 ] && [ -    
 30                                 ((j--))           
 31                         fi                        
 32                         first=                    
 33                         words_[$j]=${words_[j]    
 34                         if [ $i = $COMP_CWORD     
 35                                 cword_=$j         
 36                         fi                        
 37                         if (($i < ${#COMP_WORD    
 38                                 ((i++))           
 39                         else                      
 40                                 # Done.           
 41                                 return            
 42                         fi                        
 43                 done                              
 44                 words_[$j]=${words_[j]}${COMP_    
 45                 if [ $i = $COMP_CWORD ]; then     
 46                         cword_=$j                 
 47                 fi                                
 48         done                                      
 49 }                                                 
 50                                                   
 51 # Define preload_get_comp_words_by_ref="false"    
 52 # __perf_get_comp_words_by_ref() is required i    
 53 preload_get_comp_words_by_ref="true"              
 54                                                   
 55 if [ $preload_get_comp_words_by_ref = "true" ]    
 56         type _get_comp_words_by_ref &>/dev/nul    
 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 "$ex    
 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_-    
 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="fal    
 89 # __perf__ltrim_colon_completions() is require    
 90 preload__ltrim_colon_completions="true"           
 91                                                   
 92 if [ $preload__ltrim_colon_completions = "true    
 93         type __ltrim_colon_completions &>/dev/    
 94         preload__ltrim_colon_completions="fals    
 95 fi                                                
 96 [ $preload__ltrim_colon_completions = "true" ]    
 97 __perf__ltrim_colon_completions()                 
 98 {                                                 
 99         if [[ "$1" == *:* && "$COMP_WORDBREAKS    
100                 # Remove colon-word prefix fro    
101                 local colon_word=${1%"${1##*:}    
102                 local i=${#COMPREPLY[*]}          
103                 while [[ $((--i)) -ge 0 ]]; do    
104                         COMPREPLY[$i]=${COMPRE    
105                 done                              
106         fi                                        
107 }                                                 
108                                                   
109 __perfcomp ()                                     
110 {                                                 
111         # Expansion of spaces to array is deli    
112         # shellcheck disable=SC2207               
113         COMPREPLY=( $( compgen -W "$1" -- "$2"    
114 }                                                 
115                                                   
116 __perfcomp_colon ()                               
117 {                                                 
118         __perfcomp "$1" "$2"                      
119         if [ $preload__ltrim_colon_completions    
120                 __ltrim_colon_completions $cur    
121         else                                      
122                 __perf__ltrim_colon_completion    
123         fi                                        
124 }                                                 
125                                                   
126 __perf_prev_skip_opts ()                          
127 {                                                 
128         local i cmd_ cmds_                        
129                                                   
130         let i=cword-1                             
131         cmds_=$($cmd $1 --list-cmds)              
132         prev_skip_opts=""                         
133         while [ $i -ge 0 ]; do                    
134                 if [[ ${words[i]} == "$1" ]];     
135                         return                    
136                 fi                                
137                 for cmd_ in $cmds_; do            
138                         if [[ ${words[i]} == "    
139                                 prev_skip_opts    
140                                 return            
141                         fi                        
142                 done                              
143                 ((i--))                           
144         done                                      
145 }                                                 
146                                                   
147 __perf_main ()                                    
148 {                                                 
149         local cmd                                 
150                                                   
151         cmd=${words[0]}                           
152         COMPREPLY=()                              
153                                                   
154         # Skip options backward and find the l    
155         __perf_prev_skip_opts                     
156         # List perf subcommands or long option    
157         if [ -z $prev_skip_opts ]; then           
158                 if [[ $cur == --* ]]; then        
159                         cmds=$($cmd --list-opt    
160                 else                              
161                         cmds=$($cmd --list-cmd    
162                 fi                                
163                 __perfcomp "$cmds" "$cur"         
164         # List possible events for -e option      
165         elif [[ $prev == @("-e"|"--event") &&     
166                 $prev_skip_opts == @(record|st    
167                                                   
168                 local cur1=${COMP_WORDS[COMP_C    
169                 local raw_evts                    
170                 local arr s tmp result cpu_evt    
171                                                   
172                 raw_evts=$($cmd list --raw-dum    
173                 # aarch64 doesn't have /sys/bu    
174                 if [[ `uname -m` != aarch64 ]]    
175                         cpu_evts=$(ls /sys/bus    
176                 fi                                
177                                                   
178                 if [[ "$cur1" == */* && ${cur1    
179                         OLD_IFS="$IFS"            
180                         IFS=" "                   
181                         # Expansion of spaces     
182                         # shellcheck disable=S    
183                         arr=($raw_evts)           
184                         IFS="$OLD_IFS"            
185                                                   
186                         for s in "${arr[@]}"      
187                         do                        
188                                 if [[ "$s" ==     
189                                         tmp=${    
190                                         result    
191                                 else              
192                                         result    
193                                 fi                
194                         done                      
195                                                   
196                         evts=${result}" "${cpu    
197                 else                              
198                         evts=${raw_evts}" "${c    
199                 fi                                
200                                                   
201                 if [[ "$cur1" == , ]]; then       
202                         __perfcomp_colon "$evt    
203                 else                              
204                         __perfcomp_colon "$evt    
205                 fi                                
206         elif [[ $prev == @("--pfm-events") &&     
207                 $prev_skip_opts == @(record|st    
208                 local evts                        
209                 evts=$($cmd list --raw-dump pf    
210                 __perfcomp "$evts" "$cur"         
211         elif [[ $prev == @("-M"|"--metrics") &    
212                 $prev_skip_opts == @(stat) ]];    
213                 local metrics                     
214                 metrics=$($cmd list --raw-dump    
215                 __perfcomp "$metrics" "$cur"      
216         else                                      
217                 # List subcommands for perf co    
218                 if [[ $prev_skip_opts == @(kvm    
219                         |data|help|script|test    
220                         subcmds=$($cmd $prev_s    
221                         __perfcomp_colon "$sub    
222                 fi                                
223                 # List long option names          
224                 if [[ $cur == --* ]];  then       
225                         subcmd=$prev_skip_opts    
226                         __perf_prev_skip_opts     
227                         subcmd=$subcmd" "$prev    
228                         opts=$($cmd $subcmd --    
229                         __perfcomp "$opts" "$c    
230                 fi                                
231         fi                                        
232 }                                                 
233                                                   
234 if [[ -n ${ZSH_VERSION-} ]]; then                 
235         autoload -U +X compinit && compinit       
236                                                   
237         __perfcomp ()                             
238         {                                         
239                 emulate -L zsh                    
240                                                   
241                 local c IFS=$' \t\n'              
242                 local -a array                    
243                                                   
244                 for c in ${=1}; do                
245                         case $c in                
246                         --*=*|*.) ;;              
247                         *) c="$c " ;;             
248                         esac                      
249                         array[${#array[@]}+1]=    
250                 done                              
251                                                   
252                 compset -P '*[=:]'                
253                 compadd -Q -S '' -a -- array &    
254         }                                         
255                                                   
256         __perfcomp_colon ()                       
257         {                                         
258                 emulate -L zsh                    
259                                                   
260                 local cur_="${2-$cur}"            
261                 local c IFS=$' \t\n'              
262                 local -a array                    
263                                                   
264                 if [[ "$cur_" == *:* ]]; then     
265                         local colon_word=${cur    
266                 fi                                
267                                                   
268                 for c in ${=1}; do                
269                         case $c in                
270                         --*=*|*.) ;;              
271                         *) c="$c " ;;             
272                         esac                      
273                         array[$#array+1]=${c#"    
274                 done                              
275                                                   
276                 compset -P '*[=:]'                
277                 compadd -Q -S '' -a -- array &    
278         }                                         
279                                                   
280         _perf ()                                  
281         {                                         
282                 local _ret=1 cur cword prev       
283                 cur=${words[CURRENT]}             
284                 prev=${words[CURRENT-1]}          
285                 let cword=CURRENT-1               
286                 emulate ksh -c __perf_main        
287                 let _ret && _default && _ret=0    
288                 # _ret is only assigned 0 or 1    
289                 # shellcheck disable=SC2152       
290                 return _ret                       
291         }                                         
292                                                   
293         compdef _perf perf                        
294         return                                    
295 fi                                                
296                                                   
297 type perf &>/dev/null &&                          
298 _perf()                                           
299 {                                                 
300         if [[ "$COMP_WORDBREAKS" != *,* ]]; th    
301                 COMP_WORDBREAKS="${COMP_WORDBR    
302                 export COMP_WORDBREAKS            
303         fi                                        
304                                                   
305         if [[ "$COMP_WORDBREAKS" == *:* ]]; th    
306                 COMP_WORDBREAKS="${COMP_WORDBR    
307                 export COMP_WORDBREAKS            
308         fi                                        
309                                                   
310         local cur words cword prev                
311         if [ $preload_get_comp_words_by_ref =     
312                 _get_comp_words_by_ref -n =:,     
313         else                                      
314                 __perf_get_comp_words_by_ref -    
315         fi                                        
316         __perf_main                               
317 } &&                                              
318                                                   
319 complete -o bashdefault -o default -o nospace     
320         || complete -o default -o nospace -F _    
                                                      

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

sflogo.php