]>
Commit | Line | Data |
---|---|---|
0a920b5b | 1 | #!/usr/bin/perl -w |
dbf004d7 | 2 | # (c) 2001, Dave Jones. (the file handling bit) |
00df344f | 3 | # (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit) |
2a5a2c25 | 4 | # (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite) |
015830be | 5 | # (c) 2008-2010 Andy Whitcroft <apw@canonical.com> |
0a920b5b AW |
6 | # Licensed under the terms of the GNU GPL License version 2 |
7 | ||
8 | use strict; | |
c707a81d | 9 | use POSIX; |
36061e38 JP |
10 | use File::Basename; |
11 | use Cwd 'abs_path'; | |
57230297 | 12 | use Term::ANSIColor qw(:constants); |
0a920b5b AW |
13 | |
14 | my $P = $0; | |
36061e38 | 15 | my $D = dirname(abs_path($P)); |
0a920b5b | 16 | |
000d1cc1 | 17 | my $V = '0.32'; |
0a920b5b AW |
18 | |
19 | use Getopt::Long qw(:config no_auto_abbrev); | |
20 | ||
21 | my $quiet = 0; | |
22 | my $tree = 1; | |
23 | my $chk_signoff = 1; | |
24 | my $chk_patch = 1; | |
773647a0 | 25 | my $tst_only; |
6c72ffaa | 26 | my $emacs = 0; |
8905a67c | 27 | my $terse = 0; |
34d8815f | 28 | my $showfile = 0; |
6c72ffaa | 29 | my $file = 0; |
4a593c34 | 30 | my $git = 0; |
0dea9f1e | 31 | my %git_commits = (); |
6c72ffaa | 32 | my $check = 0; |
2ac73b4f | 33 | my $check_orig = 0; |
8905a67c AW |
34 | my $summary = 1; |
35 | my $mailback = 0; | |
13214adf | 36 | my $summary_file = 0; |
000d1cc1 | 37 | my $show_types = 0; |
3beb42ec | 38 | my $list_types = 0; |
3705ce5b | 39 | my $fix = 0; |
9624b8d6 | 40 | my $fix_inplace = 0; |
6c72ffaa | 41 | my $root; |
c2fdda0d | 42 | my %debug; |
3445686a | 43 | my %camelcase = (); |
91bfe484 JP |
44 | my %use_type = (); |
45 | my @use = (); | |
46 | my %ignore_type = (); | |
000d1cc1 | 47 | my @ignore = (); |
77f5b10a | 48 | my $help = 0; |
000d1cc1 | 49 | my $configuration_file = ".checkpatch.conf"; |
6cd7f386 | 50 | my $max_line_length = 80; |
d62a201f DH |
51 | my $ignore_perl_version = 0; |
52 | my $minimum_perl_version = 5.10.0; | |
56193274 | 53 | my $min_conf_desc_length = 4; |
66b47b4a | 54 | my $spelling_file = "$D/spelling.txt"; |
ebfd7d62 | 55 | my $codespell = 0; |
f1a63678 | 56 | my $codespellfile = "/usr/share/codespell/dictionary.txt"; |
bf1fa1da | 57 | my $conststructsfile = "$D/const_structs.checkpatch"; |
57230297 | 58 | my $color = 1; |
dadf680d | 59 | my $allow_c99_comments = 1; |
77f5b10a HE |
60 | |
61 | sub help { | |
62 | my ($exitcode) = @_; | |
63 | ||
64 | print << "EOM"; | |
65 | Usage: $P [OPTION]... [FILE]... | |
66 | Version: $V | |
67 | ||
68 | Options: | |
69 | -q, --quiet quiet | |
70 | --no-tree run without a kernel tree | |
71 | --no-signoff do not check for 'Signed-off-by' line | |
72 | --patch treat FILE as patchfile (default) | |
73 | --emacs emacs compile window format | |
74 | --terse one line per report | |
34d8815f | 75 | --showfile emit diffed file position, not input file position |
4a593c34 CD |
76 | -g, --git treat FILE as a single commit or git revision range |
77 | single git commit with: | |
78 | <rev> | |
79 | <rev>^ | |
80 | <rev>~n | |
81 | multiple git commits with: | |
82 | <rev1>..<rev2> | |
83 | <rev1>...<rev2> | |
84 | <rev>-<count> | |
85 | git merges are ignored | |
77f5b10a HE |
86 | -f, --file treat FILE as regular source file |
87 | --subjective, --strict enable more subjective tests | |
3beb42ec | 88 | --list-types list the possible message types |
91bfe484 | 89 | --types TYPE(,TYPE2...) show only these comma separated message types |
000d1cc1 | 90 | --ignore TYPE(,TYPE2...) ignore various comma separated message types |
3beb42ec | 91 | --show-types show the specific message type in the output |
6cd7f386 | 92 | --max-line-length=n set the maximum line length, if exceeded, warn |
56193274 | 93 | --min-conf-desc-length=n set the min description length, if shorter, warn |
77f5b10a HE |
94 | --root=PATH PATH to the kernel tree root |
95 | --no-summary suppress the per-file summary | |
96 | --mailback only produce a report in case of warnings/errors | |
97 | --summary-file include the filename in summary | |
98 | --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of | |
99 | 'values', 'possible', 'type', and 'attr' (default | |
100 | is all off) | |
101 | --test-only=WORD report only warnings/errors containing WORD | |
102 | literally | |
3705ce5b JP |
103 | --fix EXPERIMENTAL - may create horrible results |
104 | If correctable single-line errors exist, create | |
105 | "<inputfile>.EXPERIMENTAL-checkpatch-fixes" | |
106 | with potential errors corrected to the preferred | |
107 | checkpatch style | |
9624b8d6 JP |
108 | --fix-inplace EXPERIMENTAL - may create horrible results |
109 | Is the same as --fix, but overwrites the input | |
110 | file. It's your fault if there's no backup or git | |
d62a201f DH |
111 | --ignore-perl-version override checking of perl version. expect |
112 | runtime errors. | |
ebfd7d62 | 113 | --codespell Use the codespell dictionary for spelling/typos |
f1a63678 | 114 | (default:/usr/share/codespell/dictionary.txt) |
ebfd7d62 | 115 | --codespellfile Use this codespell dictionary |
57230297 | 116 | --color Use colors when output is STDOUT (default: on) |
77f5b10a HE |
117 | -h, --help, --version display this help and exit |
118 | ||
119 | When FILE is - read standard input. | |
120 | EOM | |
121 | ||
122 | exit($exitcode); | |
123 | } | |
124 | ||
3beb42ec JP |
125 | sub uniq { |
126 | my %seen; | |
127 | return grep { !$seen{$_}++ } @_; | |
128 | } | |
129 | ||
130 | sub list_types { | |
131 | my ($exitcode) = @_; | |
132 | ||
133 | my $count = 0; | |
134 | ||
135 | local $/ = undef; | |
136 | ||
137 | open(my $script, '<', abs_path($P)) or | |
138 | die "$P: Can't read '$P' $!\n"; | |
139 | ||
140 | my $text = <$script>; | |
141 | close($script); | |
142 | ||
143 | my @types = (); | |
144 | for ($text =~ /\b(?:(?:CHK|WARN|ERROR)\s*\(\s*"([^"]+)")/g) { | |
145 | push (@types, $_); | |
146 | } | |
147 | @types = sort(uniq(@types)); | |
148 | print("#\tMessage type\n\n"); | |
149 | foreach my $type (@types) { | |
150 | print(++$count . "\t" . $type . "\n"); | |
151 | } | |
152 | ||
153 | exit($exitcode); | |
154 | } | |
155 | ||
000d1cc1 JP |
156 | my $conf = which_conf($configuration_file); |
157 | if (-f $conf) { | |
158 | my @conf_args; | |
159 | open(my $conffile, '<', "$conf") | |
160 | or warn "$P: Can't find a readable $configuration_file file $!\n"; | |
161 | ||
162 | while (<$conffile>) { | |
163 | my $line = $_; | |
164 | ||
165 | $line =~ s/\s*\n?$//g; | |
166 | $line =~ s/^\s*//g; | |
167 | $line =~ s/\s+/ /g; | |
168 | ||
169 | next if ($line =~ m/^\s*#/); | |
170 | next if ($line =~ m/^\s*$/); | |
171 | ||
172 | my @words = split(" ", $line); | |
173 | foreach my $word (@words) { | |
174 | last if ($word =~ m/^#/); | |
175 | push (@conf_args, $word); | |
176 | } | |
177 | } | |
178 | close($conffile); | |
179 | unshift(@ARGV, @conf_args) if @conf_args; | |
180 | } | |
181 | ||
0a920b5b | 182 | GetOptions( |
6c72ffaa | 183 | 'q|quiet+' => \$quiet, |
0a920b5b AW |
184 | 'tree!' => \$tree, |
185 | 'signoff!' => \$chk_signoff, | |
186 | 'patch!' => \$chk_patch, | |
6c72ffaa | 187 | 'emacs!' => \$emacs, |
8905a67c | 188 | 'terse!' => \$terse, |
34d8815f | 189 | 'showfile!' => \$showfile, |
77f5b10a | 190 | 'f|file!' => \$file, |
4a593c34 | 191 | 'g|git!' => \$git, |
6c72ffaa AW |
192 | 'subjective!' => \$check, |
193 | 'strict!' => \$check, | |
000d1cc1 | 194 | 'ignore=s' => \@ignore, |
91bfe484 | 195 | 'types=s' => \@use, |
000d1cc1 | 196 | 'show-types!' => \$show_types, |
3beb42ec | 197 | 'list-types!' => \$list_types, |
6cd7f386 | 198 | 'max-line-length=i' => \$max_line_length, |
56193274 | 199 | 'min-conf-desc-length=i' => \$min_conf_desc_length, |
6c72ffaa | 200 | 'root=s' => \$root, |
8905a67c AW |
201 | 'summary!' => \$summary, |
202 | 'mailback!' => \$mailback, | |
13214adf | 203 | 'summary-file!' => \$summary_file, |
3705ce5b | 204 | 'fix!' => \$fix, |
9624b8d6 | 205 | 'fix-inplace!' => \$fix_inplace, |
d62a201f | 206 | 'ignore-perl-version!' => \$ignore_perl_version, |
c2fdda0d | 207 | 'debug=s' => \%debug, |
773647a0 | 208 | 'test-only=s' => \$tst_only, |
ebfd7d62 JP |
209 | 'codespell!' => \$codespell, |
210 | 'codespellfile=s' => \$codespellfile, | |
57230297 | 211 | 'color!' => \$color, |
77f5b10a HE |
212 | 'h|help' => \$help, |
213 | 'version' => \$help | |
214 | ) or help(1); | |
215 | ||
216 | help(0) if ($help); | |
0a920b5b | 217 | |
3beb42ec JP |
218 | list_types(0) if ($list_types); |
219 | ||
9624b8d6 | 220 | $fix = 1 if ($fix_inplace); |
2ac73b4f | 221 | $check_orig = $check; |
9624b8d6 | 222 | |
0a920b5b AW |
223 | my $exit = 0; |
224 | ||
d62a201f DH |
225 | if ($^V && $^V lt $minimum_perl_version) { |
226 | printf "$P: requires at least perl version %vd\n", $minimum_perl_version; | |
227 | if (!$ignore_perl_version) { | |
228 | exit(1); | |
229 | } | |
230 | } | |
231 | ||
45107ff6 | 232 | #if no filenames are given, push '-' to read patch from stdin |
0a920b5b | 233 | if ($#ARGV < 0) { |
45107ff6 | 234 | push(@ARGV, '-'); |
0a920b5b AW |
235 | } |
236 | ||
91bfe484 JP |
237 | sub hash_save_array_words { |
238 | my ($hashRef, $arrayRef) = @_; | |
239 | ||
240 | my @array = split(/,/, join(',', @$arrayRef)); | |
241 | foreach my $word (@array) { | |
242 | $word =~ s/\s*\n?$//g; | |
243 | $word =~ s/^\s*//g; | |
244 | $word =~ s/\s+/ /g; | |
245 | $word =~ tr/[a-z]/[A-Z]/; | |
246 | ||
247 | next if ($word =~ m/^\s*#/); | |
248 | next if ($word =~ m/^\s*$/); | |
249 | ||
250 | $hashRef->{$word}++; | |
251 | } | |
252 | } | |
000d1cc1 | 253 | |
91bfe484 JP |
254 | sub hash_show_words { |
255 | my ($hashRef, $prefix) = @_; | |
000d1cc1 | 256 | |
3c816e49 | 257 | if (keys %$hashRef) { |
d8469f16 | 258 | print "\nNOTE: $prefix message types:"; |
58cb3cf6 | 259 | foreach my $word (sort keys %$hashRef) { |
91bfe484 JP |
260 | print " $word"; |
261 | } | |
d8469f16 | 262 | print "\n"; |
91bfe484 | 263 | } |
000d1cc1 JP |
264 | } |
265 | ||
91bfe484 JP |
266 | hash_save_array_words(\%ignore_type, \@ignore); |
267 | hash_save_array_words(\%use_type, \@use); | |
268 | ||
c2fdda0d AW |
269 | my $dbg_values = 0; |
270 | my $dbg_possible = 0; | |
7429c690 | 271 | my $dbg_type = 0; |
a1ef277e | 272 | my $dbg_attr = 0; |
c2fdda0d | 273 | for my $key (keys %debug) { |
21caa13c AW |
274 | ## no critic |
275 | eval "\${dbg_$key} = '$debug{$key}';"; | |
276 | die "$@" if ($@); | |
c2fdda0d AW |
277 | } |
278 | ||
d2c0a235 AW |
279 | my $rpt_cleaners = 0; |
280 | ||
8905a67c AW |
281 | if ($terse) { |
282 | $emacs = 1; | |
283 | $quiet++; | |
284 | } | |
285 | ||
6c72ffaa AW |
286 | if ($tree) { |
287 | if (defined $root) { | |
288 | if (!top_of_kernel_tree($root)) { | |
289 | die "$P: $root: --root does not point at a valid tree\n"; | |
290 | } | |
291 | } else { | |
292 | if (top_of_kernel_tree('.')) { | |
293 | $root = '.'; | |
294 | } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ && | |
295 | top_of_kernel_tree($1)) { | |
296 | $root = $1; | |
297 | } | |
298 | } | |
299 | ||
300 | if (!defined $root) { | |
301 | print "Must be run from the top-level dir. of a kernel tree\n"; | |
302 | exit(2); | |
303 | } | |
0a920b5b AW |
304 | } |
305 | ||
6c72ffaa AW |
306 | my $emitted_corrupt = 0; |
307 | ||
2ceb532b AW |
308 | our $Ident = qr{ |
309 | [A-Za-z_][A-Za-z\d_]* | |
310 | (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)* | |
311 | }x; | |
6c72ffaa AW |
312 | our $Storage = qr{extern|static|asmlinkage}; |
313 | our $Sparse = qr{ | |
314 | __user| | |
315 | __kernel| | |
316 | __force| | |
317 | __iomem| | |
318 | __must_check| | |
319 | __init_refok| | |
417495ed | 320 | __kprobes| |
165e72a6 | 321 | __ref| |
ad315455 BF |
322 | __rcu| |
323 | __private | |
6c72ffaa | 324 | }x; |
e970b884 JP |
325 | our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)}; |
326 | our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)}; | |
327 | our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)}; | |
328 | our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)}; | |
329 | our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit}; | |
8716de38 | 330 | |
52131292 WS |
331 | # Notes to $Attribute: |
332 | # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check | |
6c72ffaa AW |
333 | our $Attribute = qr{ |
334 | const| | |
03f1df7d JP |
335 | __percpu| |
336 | __nocast| | |
337 | __safe| | |
338 | __bitwise__| | |
339 | __packed__| | |
340 | __packed2__| | |
341 | __naked| | |
342 | __maybe_unused| | |
343 | __always_unused| | |
344 | __noreturn| | |
345 | __used| | |
346 | __cold| | |
e23ef1f3 | 347 | __pure| |
03f1df7d JP |
348 | __noclone| |
349 | __deprecated| | |
6c72ffaa AW |
350 | __read_mostly| |
351 | __kprobes| | |
8716de38 | 352 | $InitAttribute| |
24e1d81a AW |
353 | ____cacheline_aligned| |
354 | ____cacheline_aligned_in_smp| | |
5fe3af11 AW |
355 | ____cacheline_internodealigned_in_smp| |
356 | __weak | |
6c72ffaa | 357 | }x; |
c45dcabd | 358 | our $Modifier; |
91cb5195 | 359 | our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__}; |
6c72ffaa AW |
360 | our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]}; |
361 | our $Lval = qr{$Ident(?:$Member)*}; | |
362 | ||
95e2c602 JP |
363 | our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u}; |
364 | our $Binary = qr{(?i)0b[01]+$Int_type?}; | |
365 | our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?}; | |
366 | our $Int = qr{[0-9]+$Int_type?}; | |
2435880f | 367 | our $Octal = qr{0[0-7]+$Int_type?}; |
c0a5c898 | 368 | our $String = qr{"[X\t]*"}; |
326b1ffc JP |
369 | our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?}; |
370 | our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?}; | |
371 | our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?}; | |
74349bcc | 372 | our $Float = qr{$Float_hex|$Float_dec|$Float_int}; |
2435880f | 373 | our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int}; |
326b1ffc | 374 | our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=}; |
447432f3 | 375 | our $Compare = qr{<=|>=|==|!=|<|(?<!-)>}; |
23f780c9 | 376 | our $Arithmetic = qr{\+|-|\*|\/|%}; |
6c72ffaa AW |
377 | our $Operators = qr{ |
378 | <=|>=|==|!=| | |
379 | =>|->|<<|>>|<|>|!|~| | |
23f780c9 | 380 | &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic |
6c72ffaa AW |
381 | }x; |
382 | ||
91cb5195 JP |
383 | our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x; |
384 | ||
ab7e23f3 | 385 | our $BasicType; |
8905a67c | 386 | our $NonptrType; |
1813087d | 387 | our $NonptrTypeMisordered; |
8716de38 | 388 | our $NonptrTypeWithAttr; |
8905a67c | 389 | our $Type; |
1813087d | 390 | our $TypeMisordered; |
8905a67c | 391 | our $Declare; |
1813087d | 392 | our $DeclareMisordered; |
8905a67c | 393 | |
15662b3e JP |
394 | our $NON_ASCII_UTF8 = qr{ |
395 | [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte | |
171ae1a4 AW |
396 | | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs |
397 | | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte | |
398 | | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates | |
399 | | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3 | |
400 | | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15 | |
401 | | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16 | |
402 | }x; | |
403 | ||
15662b3e JP |
404 | our $UTF8 = qr{ |
405 | [\x09\x0A\x0D\x20-\x7E] # ASCII | |
406 | | $NON_ASCII_UTF8 | |
407 | }x; | |
408 | ||
e6176fa4 | 409 | our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t}; |
021158b4 JP |
410 | our $typeOtherOSTypedefs = qr{(?x: |
411 | u_(?:char|short|int|long) | # bsd | |
412 | u(?:nchar|short|int|long) # sysv | |
413 | )}; | |
e6176fa4 | 414 | our $typeKernelTypedefs = qr{(?x: |
fb9e9096 | 415 | (?:__)?(?:u|s|be|le)(?:8|16|32|64)| |
8ed22cad AW |
416 | atomic_t |
417 | )}; | |
e6176fa4 JP |
418 | our $typeTypedefs = qr{(?x: |
419 | $typeC99Typedefs\b| | |
420 | $typeOtherOSTypedefs\b| | |
421 | $typeKernelTypedefs\b | |
422 | )}; | |
8ed22cad | 423 | |
6d32f7a3 JP |
424 | our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b}; |
425 | ||
691e669b | 426 | our $logFunctions = qr{(?x: |
6e60c02e | 427 | printk(?:_ratelimited|_once|)| |
7d0b6594 | 428 | (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)| |
6e60c02e | 429 | WARN(?:_RATELIMIT|_ONCE|)| |
b0531722 | 430 | panic| |
06668727 JP |
431 | MODULE_[A-Z_]+| |
432 | seq_vprintf|seq_printf|seq_puts | |
691e669b JP |
433 | )}; |
434 | ||
20112475 JP |
435 | our $signature_tags = qr{(?xi: |
436 | Signed-off-by:| | |
437 | Acked-by:| | |
438 | Tested-by:| | |
439 | Reviewed-by:| | |
440 | Reported-by:| | |
8543ae12 | 441 | Suggested-by:| |
20112475 JP |
442 | To:| |
443 | Cc: | |
444 | )}; | |
445 | ||
1813087d JP |
446 | our @typeListMisordered = ( |
447 | qr{char\s+(?:un)?signed}, | |
448 | qr{int\s+(?:(?:un)?signed\s+)?short\s}, | |
449 | qr{int\s+short(?:\s+(?:un)?signed)}, | |
450 | qr{short\s+int(?:\s+(?:un)?signed)}, | |
451 | qr{(?:un)?signed\s+int\s+short}, | |
452 | qr{short\s+(?:un)?signed}, | |
453 | qr{long\s+int\s+(?:un)?signed}, | |
454 | qr{int\s+long\s+(?:un)?signed}, | |
455 | qr{long\s+(?:un)?signed\s+int}, | |
456 | qr{int\s+(?:un)?signed\s+long}, | |
457 | qr{int\s+(?:un)?signed}, | |
458 | qr{int\s+long\s+long\s+(?:un)?signed}, | |
459 | qr{long\s+long\s+int\s+(?:un)?signed}, | |
460 | qr{long\s+long\s+(?:un)?signed\s+int}, | |
461 | qr{long\s+long\s+(?:un)?signed}, | |
462 | qr{long\s+(?:un)?signed}, | |
463 | ); | |
464 | ||
8905a67c AW |
465 | our @typeList = ( |
466 | qr{void}, | |
0c773d9d JP |
467 | qr{(?:(?:un)?signed\s+)?char}, |
468 | qr{(?:(?:un)?signed\s+)?short\s+int}, | |
469 | qr{(?:(?:un)?signed\s+)?short}, | |
470 | qr{(?:(?:un)?signed\s+)?int}, | |
471 | qr{(?:(?:un)?signed\s+)?long\s+int}, | |
472 | qr{(?:(?:un)?signed\s+)?long\s+long\s+int}, | |
473 | qr{(?:(?:un)?signed\s+)?long\s+long}, | |
474 | qr{(?:(?:un)?signed\s+)?long}, | |
475 | qr{(?:un)?signed}, | |
8905a67c AW |
476 | qr{float}, |
477 | qr{double}, | |
478 | qr{bool}, | |
8905a67c AW |
479 | qr{struct\s+$Ident}, |
480 | qr{union\s+$Ident}, | |
481 | qr{enum\s+$Ident}, | |
482 | qr{${Ident}_t}, | |
483 | qr{${Ident}_handler}, | |
484 | qr{${Ident}_handler_fn}, | |
1813087d | 485 | @typeListMisordered, |
8905a67c | 486 | ); |
938224b5 JP |
487 | |
488 | our $C90_int_types = qr{(?x: | |
489 | long\s+long\s+int\s+(?:un)?signed| | |
490 | long\s+long\s+(?:un)?signed\s+int| | |
491 | long\s+long\s+(?:un)?signed| | |
492 | (?:(?:un)?signed\s+)?long\s+long\s+int| | |
493 | (?:(?:un)?signed\s+)?long\s+long| | |
494 | int\s+long\s+long\s+(?:un)?signed| | |
495 | int\s+(?:(?:un)?signed\s+)?long\s+long| | |
496 | ||
497 | long\s+int\s+(?:un)?signed| | |
498 | long\s+(?:un)?signed\s+int| | |
499 | long\s+(?:un)?signed| | |
500 | (?:(?:un)?signed\s+)?long\s+int| | |
501 | (?:(?:un)?signed\s+)?long| | |
502 | int\s+long\s+(?:un)?signed| | |
503 | int\s+(?:(?:un)?signed\s+)?long| | |
504 | ||
505 | int\s+(?:un)?signed| | |
506 | (?:(?:un)?signed\s+)?int | |
507 | )}; | |
508 | ||
485ff23e | 509 | our @typeListFile = (); |
8716de38 JP |
510 | our @typeListWithAttr = ( |
511 | @typeList, | |
512 | qr{struct\s+$InitAttribute\s+$Ident}, | |
513 | qr{union\s+$InitAttribute\s+$Ident}, | |
514 | ); | |
515 | ||
c45dcabd AW |
516 | our @modifierList = ( |
517 | qr{fastcall}, | |
518 | ); | |
485ff23e | 519 | our @modifierListFile = (); |
8905a67c | 520 | |
2435880f JP |
521 | our @mode_permission_funcs = ( |
522 | ["module_param", 3], | |
523 | ["module_param_(?:array|named|string)", 4], | |
524 | ["module_param_array_named", 5], | |
525 | ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2], | |
526 | ["proc_create(?:_data|)", 2], | |
527 | ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2], | |
528 | ); | |
529 | ||
515a235e JP |
530 | #Create a search pattern for all these functions to speed up a loop below |
531 | our $mode_perms_search = ""; | |
532 | foreach my $entry (@mode_permission_funcs) { | |
533 | $mode_perms_search .= '|' if ($mode_perms_search ne ""); | |
534 | $mode_perms_search .= $entry->[0]; | |
535 | } | |
536 | ||
b392c64f JP |
537 | our $mode_perms_world_writable = qr{ |
538 | S_IWUGO | | |
539 | S_IWOTH | | |
540 | S_IRWXUGO | | |
541 | S_IALLUGO | | |
542 | 0[0-7][0-7][2367] | |
543 | }x; | |
544 | ||
f90774e1 JP |
545 | our %mode_permission_string_types = ( |
546 | "S_IRWXU" => 0700, | |
547 | "S_IRUSR" => 0400, | |
548 | "S_IWUSR" => 0200, | |
549 | "S_IXUSR" => 0100, | |
550 | "S_IRWXG" => 0070, | |
551 | "S_IRGRP" => 0040, | |
552 | "S_IWGRP" => 0020, | |
553 | "S_IXGRP" => 0010, | |
554 | "S_IRWXO" => 0007, | |
555 | "S_IROTH" => 0004, | |
556 | "S_IWOTH" => 0002, | |
557 | "S_IXOTH" => 0001, | |
558 | "S_IRWXUGO" => 0777, | |
559 | "S_IRUGO" => 0444, | |
560 | "S_IWUGO" => 0222, | |
561 | "S_IXUGO" => 0111, | |
562 | ); | |
563 | ||
564 | #Create a search pattern for all these strings to speed up a loop below | |
565 | our $mode_perms_string_search = ""; | |
566 | foreach my $entry (keys %mode_permission_string_types) { | |
567 | $mode_perms_string_search .= '|' if ($mode_perms_string_search ne ""); | |
568 | $mode_perms_string_search .= $entry; | |
569 | } | |
570 | ||
7840a94c WS |
571 | our $allowed_asm_includes = qr{(?x: |
572 | irq| | |
cdcee686 SR |
573 | memory| |
574 | time| | |
575 | reboot | |
7840a94c WS |
576 | )}; |
577 | # memory.h: ARM has a custom one | |
578 | ||
66b47b4a KC |
579 | # Load common spelling mistakes and build regular expression list. |
580 | my $misspellings; | |
66b47b4a | 581 | my %spelling_fix; |
66b47b4a | 582 | |
36061e38 | 583 | if (open(my $spelling, '<', $spelling_file)) { |
36061e38 JP |
584 | while (<$spelling>) { |
585 | my $line = $_; | |
66b47b4a | 586 | |
36061e38 JP |
587 | $line =~ s/\s*\n?$//g; |
588 | $line =~ s/^\s*//g; | |
66b47b4a | 589 | |
36061e38 JP |
590 | next if ($line =~ m/^\s*#/); |
591 | next if ($line =~ m/^\s*$/); | |
592 | ||
593 | my ($suspect, $fix) = split(/\|\|/, $line); | |
66b47b4a | 594 | |
36061e38 JP |
595 | $spelling_fix{$suspect} = $fix; |
596 | } | |
597 | close($spelling); | |
36061e38 JP |
598 | } else { |
599 | warn "No typos will be found - file '$spelling_file': $!\n"; | |
66b47b4a | 600 | } |
66b47b4a | 601 | |
ebfd7d62 JP |
602 | if ($codespell) { |
603 | if (open(my $spelling, '<', $codespellfile)) { | |
604 | while (<$spelling>) { | |
605 | my $line = $_; | |
606 | ||
607 | $line =~ s/\s*\n?$//g; | |
608 | $line =~ s/^\s*//g; | |
609 | ||
610 | next if ($line =~ m/^\s*#/); | |
611 | next if ($line =~ m/^\s*$/); | |
612 | next if ($line =~ m/, disabled/i); | |
613 | ||
614 | $line =~ s/,.*$//; | |
615 | ||
616 | my ($suspect, $fix) = split(/->/, $line); | |
617 | ||
618 | $spelling_fix{$suspect} = $fix; | |
619 | } | |
620 | close($spelling); | |
621 | } else { | |
622 | warn "No codespell typos will be found - file '$codespellfile': $!\n"; | |
623 | } | |
624 | } | |
625 | ||
626 | $misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix; | |
627 | ||
bf1fa1da JP |
628 | my $const_structs = ""; |
629 | if (open(my $conststructs, '<', $conststructsfile)) { | |
630 | while (<$conststructs>) { | |
631 | my $line = $_; | |
632 | ||
633 | $line =~ s/\s*\n?$//g; | |
634 | $line =~ s/^\s*//g; | |
635 | ||
636 | next if ($line =~ m/^\s*#/); | |
637 | next if ($line =~ m/^\s*$/); | |
638 | if ($line =~ /\s/) { | |
639 | print("$conststructsfile: '$line' invalid - ignored\n"); | |
640 | next; | |
641 | } | |
642 | ||
643 | $const_structs .= '|' if ($const_structs ne ""); | |
644 | $const_structs .= $line; | |
645 | } | |
646 | close($conststructsfile); | |
647 | } else { | |
648 | warn "No structs that should be const will be found - file '$conststructsfile': $!\n"; | |
649 | } | |
650 | ||
8905a67c | 651 | sub build_types { |
485ff23e AD |
652 | my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)"; |
653 | my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)"; | |
1813087d | 654 | my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)"; |
8716de38 | 655 | my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)"; |
c8cb2ca3 | 656 | $Modifier = qr{(?:$Attribute|$Sparse|$mods)}; |
ab7e23f3 | 657 | $BasicType = qr{ |
ab7e23f3 JP |
658 | (?:$typeTypedefs\b)| |
659 | (?:${all}\b) | |
660 | }x; | |
8905a67c | 661 | $NonptrType = qr{ |
d2172eb5 | 662 | (?:$Modifier\s+|const\s+)* |
cf655043 | 663 | (?: |
6b48db24 | 664 | (?:typeof|__typeof__)\s*\([^\)]*\)| |
8ed22cad | 665 | (?:$typeTypedefs\b)| |
c45dcabd | 666 | (?:${all}\b) |
cf655043 | 667 | ) |
c8cb2ca3 | 668 | (?:\s+$Modifier|\s+const)* |
8905a67c | 669 | }x; |
1813087d JP |
670 | $NonptrTypeMisordered = qr{ |
671 | (?:$Modifier\s+|const\s+)* | |
672 | (?: | |
673 | (?:${Misordered}\b) | |
674 | ) | |
675 | (?:\s+$Modifier|\s+const)* | |
676 | }x; | |
8716de38 JP |
677 | $NonptrTypeWithAttr = qr{ |
678 | (?:$Modifier\s+|const\s+)* | |
679 | (?: | |
680 | (?:typeof|__typeof__)\s*\([^\)]*\)| | |
681 | (?:$typeTypedefs\b)| | |
682 | (?:${allWithAttr}\b) | |
683 | ) | |
684 | (?:\s+$Modifier|\s+const)* | |
685 | }x; | |
8905a67c | 686 | $Type = qr{ |
c45dcabd | 687 | $NonptrType |
1574a29f | 688 | (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)? |
c8cb2ca3 | 689 | (?:\s+$Inline|\s+$Modifier)* |
8905a67c | 690 | }x; |
1813087d JP |
691 | $TypeMisordered = qr{ |
692 | $NonptrTypeMisordered | |
693 | (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)? | |
694 | (?:\s+$Inline|\s+$Modifier)* | |
695 | }x; | |
91cb5195 | 696 | $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type}; |
1813087d | 697 | $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered}; |
8905a67c AW |
698 | } |
699 | build_types(); | |
6c72ffaa | 700 | |
7d2367af | 701 | our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*}; |
d1fe9c09 JP |
702 | |
703 | # Using $balanced_parens, $LvalOrFunc, or $FuncArg | |
704 | # requires at least perl version v5.10.0 | |
705 | # Any use must be runtime checked with $^V | |
706 | ||
707 | our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/; | |
2435880f | 708 | our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*}; |
c0a5c898 | 709 | our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)}; |
7d2367af | 710 | |
f8422308 | 711 | our $declaration_macros = qr{(?x: |
3e838b6c | 712 | (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(| |
f8422308 JP |
713 | (?:$Storage\s+)?LIST_HEAD\s*\(| |
714 | (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\( | |
715 | )}; | |
716 | ||
7d2367af JP |
717 | sub deparenthesize { |
718 | my ($string) = @_; | |
719 | return "" if (!defined($string)); | |
5b9553ab JP |
720 | |
721 | while ($string =~ /^\s*\(.*\)\s*$/) { | |
722 | $string =~ s@^\s*\(\s*@@; | |
723 | $string =~ s@\s*\)\s*$@@; | |
724 | } | |
725 | ||
7d2367af | 726 | $string =~ s@\s+@ @g; |
5b9553ab | 727 | |
7d2367af JP |
728 | return $string; |
729 | } | |
730 | ||
3445686a JP |
731 | sub seed_camelcase_file { |
732 | my ($file) = @_; | |
733 | ||
734 | return if (!(-f $file)); | |
735 | ||
736 | local $/; | |
737 | ||
738 | open(my $include_file, '<', "$file") | |
739 | or warn "$P: Can't read '$file' $!\n"; | |
740 | my $text = <$include_file>; | |
741 | close($include_file); | |
742 | ||
743 | my @lines = split('\n', $text); | |
744 | ||
745 | foreach my $line (@lines) { | |
746 | next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/); | |
747 | if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) { | |
748 | $camelcase{$1} = 1; | |
11ea516a JP |
749 | } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) { |
750 | $camelcase{$1} = 1; | |
751 | } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) { | |
3445686a JP |
752 | $camelcase{$1} = 1; |
753 | } | |
754 | } | |
755 | } | |
756 | ||
85b0ee18 JP |
757 | sub is_maintained_obsolete { |
758 | my ($filename) = @_; | |
759 | ||
760 | return 0 if (!(-e "$root/scripts/get_maintainer.pl")); | |
761 | ||
0616efa4 | 762 | my $status = `perl $root/scripts/get_maintainer.pl --status --nom --nol --nogit --nogit-fallback -f $filename 2>&1`; |
85b0ee18 JP |
763 | |
764 | return $status =~ /obsolete/i; | |
765 | } | |
766 | ||
3445686a JP |
767 | my $camelcase_seeded = 0; |
768 | sub seed_camelcase_includes { | |
769 | return if ($camelcase_seeded); | |
770 | ||
771 | my $files; | |
c707a81d JP |
772 | my $camelcase_cache = ""; |
773 | my @include_files = (); | |
774 | ||
775 | $camelcase_seeded = 1; | |
351b2a1f | 776 | |
3645e328 | 777 | if (-e ".git") { |
351b2a1f JP |
778 | my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`; |
779 | chomp $git_last_include_commit; | |
c707a81d | 780 | $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit"; |
3445686a | 781 | } else { |
c707a81d | 782 | my $last_mod_date = 0; |
3445686a | 783 | $files = `find $root/include -name "*.h"`; |
c707a81d JP |
784 | @include_files = split('\n', $files); |
785 | foreach my $file (@include_files) { | |
786 | my $date = POSIX::strftime("%Y%m%d%H%M", | |
787 | localtime((stat $file)[9])); | |
788 | $last_mod_date = $date if ($last_mod_date < $date); | |
789 | } | |
790 | $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date"; | |
791 | } | |
792 | ||
793 | if ($camelcase_cache ne "" && -f $camelcase_cache) { | |
794 | open(my $camelcase_file, '<', "$camelcase_cache") | |
795 | or warn "$P: Can't read '$camelcase_cache' $!\n"; | |
796 | while (<$camelcase_file>) { | |
797 | chomp; | |
798 | $camelcase{$_} = 1; | |
799 | } | |
800 | close($camelcase_file); | |
801 | ||
802 | return; | |
3445686a | 803 | } |
c707a81d | 804 | |
3645e328 | 805 | if (-e ".git") { |
c707a81d JP |
806 | $files = `git ls-files "include/*.h"`; |
807 | @include_files = split('\n', $files); | |
808 | } | |
809 | ||
3445686a JP |
810 | foreach my $file (@include_files) { |
811 | seed_camelcase_file($file); | |
812 | } | |
351b2a1f | 813 | |
c707a81d | 814 | if ($camelcase_cache ne "") { |
351b2a1f | 815 | unlink glob ".checkpatch-camelcase.*"; |
c707a81d JP |
816 | open(my $camelcase_file, '>', "$camelcase_cache") |
817 | or warn "$P: Can't write '$camelcase_cache' $!\n"; | |
351b2a1f JP |
818 | foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) { |
819 | print $camelcase_file ("$_\n"); | |
820 | } | |
821 | close($camelcase_file); | |
822 | } | |
3445686a JP |
823 | } |
824 | ||
d311cd44 JP |
825 | sub git_commit_info { |
826 | my ($commit, $id, $desc) = @_; | |
827 | ||
828 | return ($id, $desc) if ((which("git") eq "") || !(-e ".git")); | |
829 | ||
830 | my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`; | |
831 | $output =~ s/^\s*//gm; | |
832 | my @lines = split("\n", $output); | |
833 | ||
0d7835fc JP |
834 | return ($id, $desc) if ($#lines < 0); |
835 | ||
d311cd44 JP |
836 | if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) { |
837 | # Maybe one day convert this block of bash into something that returns | |
838 | # all matching commit ids, but it's very slow... | |
839 | # | |
840 | # echo "checking commits $1..." | |
841 | # git rev-list --remotes | grep -i "^$1" | | |
842 | # while read line ; do | |
843 | # git log --format='%H %s' -1 $line | | |
844 | # echo "commit $(cut -c 1-12,41-)" | |
845 | # done | |
846 | } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) { | |
847 | } else { | |
848 | $id = substr($lines[0], 0, 12); | |
849 | $desc = substr($lines[0], 41); | |
850 | } | |
851 | ||
852 | return ($id, $desc); | |
853 | } | |
854 | ||
6c72ffaa AW |
855 | $chk_signoff = 0 if ($file); |
856 | ||
00df344f | 857 | my @rawlines = (); |
c2fdda0d | 858 | my @lines = (); |
3705ce5b | 859 | my @fixed = (); |
d752fcc8 JP |
860 | my @fixed_inserted = (); |
861 | my @fixed_deleted = (); | |
194f66fc JP |
862 | my $fixlinenr = -1; |
863 | ||
4a593c34 CD |
864 | # If input is git commits, extract all commits from the commit expressions. |
865 | # For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'. | |
866 | die "$P: No git repository found\n" if ($git && !-e ".git"); | |
867 | ||
868 | if ($git) { | |
869 | my @commits = (); | |
0dea9f1e | 870 | foreach my $commit_expr (@ARGV) { |
4a593c34 | 871 | my $git_range; |
28898fd1 JP |
872 | if ($commit_expr =~ m/^(.*)-(\d+)$/) { |
873 | $git_range = "-$2 $1"; | |
4a593c34 CD |
874 | } elsif ($commit_expr =~ m/\.\./) { |
875 | $git_range = "$commit_expr"; | |
4a593c34 | 876 | } else { |
0dea9f1e JP |
877 | $git_range = "-1 $commit_expr"; |
878 | } | |
879 | my $lines = `git log --no-color --no-merges --pretty=format:'%H %s' $git_range`; | |
880 | foreach my $line (split(/\n/, $lines)) { | |
28898fd1 JP |
881 | $line =~ /^([0-9a-fA-F]{40,40}) (.*)$/; |
882 | next if (!defined($1) || !defined($2)); | |
0dea9f1e JP |
883 | my $sha1 = $1; |
884 | my $subject = $2; | |
885 | unshift(@commits, $sha1); | |
886 | $git_commits{$sha1} = $subject; | |
4a593c34 CD |
887 | } |
888 | } | |
889 | die "$P: no git commits after extraction!\n" if (@commits == 0); | |
890 | @ARGV = @commits; | |
891 | } | |
892 | ||
c2fdda0d | 893 | my $vname; |
6c72ffaa | 894 | for my $filename (@ARGV) { |
21caa13c | 895 | my $FILE; |
4a593c34 CD |
896 | if ($git) { |
897 | open($FILE, '-|', "git format-patch -M --stdout -1 $filename") || | |
898 | die "$P: $filename: git format-patch failed - $!\n"; | |
899 | } elsif ($file) { | |
21caa13c | 900 | open($FILE, '-|', "diff -u /dev/null $filename") || |
6c72ffaa | 901 | die "$P: $filename: diff failed - $!\n"; |
21caa13c AW |
902 | } elsif ($filename eq '-') { |
903 | open($FILE, '<&STDIN'); | |
6c72ffaa | 904 | } else { |
21caa13c | 905 | open($FILE, '<', "$filename") || |
6c72ffaa | 906 | die "$P: $filename: open failed - $!\n"; |
0a920b5b | 907 | } |
c2fdda0d AW |
908 | if ($filename eq '-') { |
909 | $vname = 'Your patch'; | |
4a593c34 | 910 | } elsif ($git) { |
0dea9f1e | 911 | $vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")'; |
c2fdda0d AW |
912 | } else { |
913 | $vname = $filename; | |
914 | } | |
21caa13c | 915 | while (<$FILE>) { |
6c72ffaa AW |
916 | chomp; |
917 | push(@rawlines, $_); | |
918 | } | |
21caa13c | 919 | close($FILE); |
d8469f16 JP |
920 | |
921 | if ($#ARGV > 0 && $quiet == 0) { | |
922 | print '-' x length($vname) . "\n"; | |
923 | print "$vname\n"; | |
924 | print '-' x length($vname) . "\n"; | |
925 | } | |
926 | ||
c2fdda0d | 927 | if (!process($filename)) { |
6c72ffaa AW |
928 | $exit = 1; |
929 | } | |
930 | @rawlines = (); | |
13214adf | 931 | @lines = (); |
3705ce5b | 932 | @fixed = (); |
d752fcc8 JP |
933 | @fixed_inserted = (); |
934 | @fixed_deleted = (); | |
194f66fc | 935 | $fixlinenr = -1; |
485ff23e AD |
936 | @modifierListFile = (); |
937 | @typeListFile = (); | |
938 | build_types(); | |
0a920b5b AW |
939 | } |
940 | ||
d8469f16 | 941 | if (!$quiet) { |
3c816e49 JP |
942 | hash_show_words(\%use_type, "Used"); |
943 | hash_show_words(\%ignore_type, "Ignored"); | |
944 | ||
d8469f16 JP |
945 | if ($^V lt 5.10.0) { |
946 | print << "EOM" | |
947 | ||
948 | NOTE: perl $^V is not modern enough to detect all possible issues. | |
949 | An upgrade to at least perl v5.10.0 is suggested. | |
950 | EOM | |
951 | } | |
952 | if ($exit) { | |
953 | print << "EOM" | |
954 | ||
955 | NOTE: If any of the errors are false positives, please report | |
956 | them to the maintainer, see CHECKPATCH in MAINTAINERS. | |
957 | EOM | |
958 | } | |
959 | } | |
960 | ||
0a920b5b AW |
961 | exit($exit); |
962 | ||
963 | sub top_of_kernel_tree { | |
6c72ffaa AW |
964 | my ($root) = @_; |
965 | ||
966 | my @tree_check = ( | |
967 | "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile", | |
968 | "README", "Documentation", "arch", "include", "drivers", | |
969 | "fs", "init", "ipc", "kernel", "lib", "scripts", | |
970 | ); | |
971 | ||
972 | foreach my $check (@tree_check) { | |
973 | if (! -e $root . '/' . $check) { | |
974 | return 0; | |
975 | } | |
0a920b5b | 976 | } |
6c72ffaa | 977 | return 1; |
8f26b837 | 978 | } |
0a920b5b | 979 | |
20112475 JP |
980 | sub parse_email { |
981 | my ($formatted_email) = @_; | |
982 | ||
983 | my $name = ""; | |
984 | my $address = ""; | |
985 | my $comment = ""; | |
986 | ||
987 | if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) { | |
988 | $name = $1; | |
989 | $address = $2; | |
990 | $comment = $3 if defined $3; | |
991 | } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) { | |
992 | $address = $1; | |
993 | $comment = $2 if defined $2; | |
994 | } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) { | |
995 | $address = $1; | |
996 | $comment = $2 if defined $2; | |
997 | $formatted_email =~ s/$address.*$//; | |
998 | $name = $formatted_email; | |
3705ce5b | 999 | $name = trim($name); |
20112475 JP |
1000 | $name =~ s/^\"|\"$//g; |
1001 | # If there's a name left after stripping spaces and | |
1002 | # leading quotes, and the address doesn't have both | |
1003 | # leading and trailing angle brackets, the address | |
1004 | # is invalid. ie: | |
1005 | # "joe smith joe@smith.com" bad | |
1006 | # "joe smith <joe@smith.com" bad | |
1007 | if ($name ne "" && $address !~ /^<[^>]+>$/) { | |
1008 | $name = ""; | |
1009 | $address = ""; | |
1010 | $comment = ""; | |
1011 | } | |
1012 | } | |
1013 | ||
3705ce5b | 1014 | $name = trim($name); |
20112475 | 1015 | $name =~ s/^\"|\"$//g; |
3705ce5b | 1016 | $address = trim($address); |
20112475 JP |
1017 | $address =~ s/^\<|\>$//g; |
1018 | ||
1019 | if ($name =~ /[^\w \-]/i) { ##has "must quote" chars | |
1020 | $name =~ s/(?<!\\)"/\\"/g; ##escape quotes | |
1021 | $name = "\"$name\""; | |
1022 | } | |
1023 | ||
1024 | return ($name, $address, $comment); | |
1025 | } | |
1026 | ||
1027 | sub format_email { | |
1028 | my ($name, $address) = @_; | |
1029 | ||
1030 | my $formatted_email; | |
1031 | ||
3705ce5b | 1032 | $name = trim($name); |
20112475 | 1033 | $name =~ s/^\"|\"$//g; |
3705ce5b | 1034 | $address = trim($address); |
20112475 JP |
1035 | |
1036 | if ($name =~ /[^\w \-]/i) { ##has "must quote" chars | |
1037 | $name =~ s/(?<!\\)"/\\"/g; ##escape quotes | |
1038 | $name = "\"$name\""; | |
1039 | } | |
1040 | ||
1041 | if ("$name" eq "") { | |
1042 | $formatted_email = "$address"; | |
1043 | } else { | |
1044 | $formatted_email = "$name <$address>"; | |
1045 | } | |
1046 | ||
1047 | return $formatted_email; | |
1048 | } | |
1049 | ||
d311cd44 | 1050 | sub which { |
bd474ca0 | 1051 | my ($bin) = @_; |
d311cd44 | 1052 | |
bd474ca0 JP |
1053 | foreach my $path (split(/:/, $ENV{PATH})) { |
1054 | if (-e "$path/$bin") { | |
1055 | return "$path/$bin"; | |
1056 | } | |
d311cd44 | 1057 | } |
d311cd44 | 1058 | |
bd474ca0 | 1059 | return ""; |
d311cd44 JP |
1060 | } |
1061 | ||
000d1cc1 JP |
1062 | sub which_conf { |
1063 | my ($conf) = @_; | |
1064 | ||
1065 | foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) { | |
1066 | if (-e "$path/$conf") { | |
1067 | return "$path/$conf"; | |
1068 | } | |
1069 | } | |
1070 | ||
1071 | return ""; | |
1072 | } | |
1073 | ||
0a920b5b AW |
1074 | sub expand_tabs { |
1075 | my ($str) = @_; | |
1076 | ||
1077 | my $res = ''; | |
1078 | my $n = 0; | |
1079 | for my $c (split(//, $str)) { | |
1080 | if ($c eq "\t") { | |
1081 | $res .= ' '; | |
1082 | $n++; | |
1083 | for (; ($n % 8) != 0; $n++) { | |
1084 | $res .= ' '; | |
1085 | } | |
1086 | next; | |
1087 | } | |
1088 | $res .= $c; | |
1089 | $n++; | |
1090 | } | |
1091 | ||
1092 | return $res; | |
1093 | } | |
6c72ffaa | 1094 | sub copy_spacing { |
773647a0 | 1095 | (my $res = shift) =~ tr/\t/ /c; |
6c72ffaa AW |
1096 | return $res; |
1097 | } | |
0a920b5b | 1098 | |
4a0df2ef AW |
1099 | sub line_stats { |
1100 | my ($line) = @_; | |
1101 | ||
1102 | # Drop the diff line leader and expand tabs | |
1103 | $line =~ s/^.//; | |
1104 | $line = expand_tabs($line); | |
1105 | ||
1106 | # Pick the indent from the front of the line. | |
1107 | my ($white) = ($line =~ /^(\s*)/); | |
1108 | ||
1109 | return (length($line), length($white)); | |
1110 | } | |
1111 | ||
773647a0 AW |
1112 | my $sanitise_quote = ''; |
1113 | ||
1114 | sub sanitise_line_reset { | |
1115 | my ($in_comment) = @_; | |
1116 | ||
1117 | if ($in_comment) { | |
1118 | $sanitise_quote = '*/'; | |
1119 | } else { | |
1120 | $sanitise_quote = ''; | |
1121 | } | |
1122 | } | |
00df344f AW |
1123 | sub sanitise_line { |
1124 | my ($line) = @_; | |
1125 | ||
1126 | my $res = ''; | |
1127 | my $l = ''; | |
1128 | ||
c2fdda0d | 1129 | my $qlen = 0; |
773647a0 AW |
1130 | my $off = 0; |
1131 | my $c; | |
00df344f | 1132 | |
773647a0 AW |
1133 | # Always copy over the diff marker. |
1134 | $res = substr($line, 0, 1); | |
1135 | ||
1136 | for ($off = 1; $off < length($line); $off++) { | |
1137 | $c = substr($line, $off, 1); | |
1138 | ||
1139 | # Comments we are wacking completly including the begin | |
1140 | # and end, all to $;. | |
1141 | if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') { | |
1142 | $sanitise_quote = '*/'; | |
1143 | ||
1144 | substr($res, $off, 2, "$;$;"); | |
1145 | $off++; | |
1146 | next; | |
00df344f | 1147 | } |
81bc0e02 | 1148 | if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') { |
773647a0 AW |
1149 | $sanitise_quote = ''; |
1150 | substr($res, $off, 2, "$;$;"); | |
1151 | $off++; | |
1152 | next; | |
c2fdda0d | 1153 | } |
113f04a8 DW |
1154 | if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') { |
1155 | $sanitise_quote = '//'; | |
1156 | ||
1157 | substr($res, $off, 2, $sanitise_quote); | |
1158 | $off++; | |
1159 | next; | |
1160 | } | |
773647a0 AW |
1161 | |
1162 | # A \ in a string means ignore the next character. | |
1163 | if (($sanitise_quote eq "'" || $sanitise_quote eq '"') && | |
1164 | $c eq "\\") { | |
1165 | substr($res, $off, 2, 'XX'); | |
1166 | $off++; | |
1167 | next; | |
00df344f | 1168 | } |
773647a0 AW |
1169 | # Regular quotes. |
1170 | if ($c eq "'" || $c eq '"') { | |
1171 | if ($sanitise_quote eq '') { | |
1172 | $sanitise_quote = $c; | |
00df344f | 1173 | |
773647a0 AW |
1174 | substr($res, $off, 1, $c); |
1175 | next; | |
1176 | } elsif ($sanitise_quote eq $c) { | |
1177 | $sanitise_quote = ''; | |
1178 | } | |
1179 | } | |
00df344f | 1180 | |
fae17dae | 1181 | #print "c<$c> SQ<$sanitise_quote>\n"; |
773647a0 AW |
1182 | if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") { |
1183 | substr($res, $off, 1, $;); | |
113f04a8 DW |
1184 | } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") { |
1185 | substr($res, $off, 1, $;); | |
773647a0 AW |
1186 | } elsif ($off != 0 && $sanitise_quote && $c ne "\t") { |
1187 | substr($res, $off, 1, 'X'); | |
1188 | } else { | |
1189 | substr($res, $off, 1, $c); | |
1190 | } | |
c2fdda0d AW |
1191 | } |
1192 | ||
113f04a8 DW |
1193 | if ($sanitise_quote eq '//') { |
1194 | $sanitise_quote = ''; | |
1195 | } | |
1196 | ||
c2fdda0d | 1197 | # The pathname on a #include may be surrounded by '<' and '>'. |
c45dcabd | 1198 | if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) { |
c2fdda0d AW |
1199 | my $clean = 'X' x length($1); |
1200 | $res =~ s@\<.*\>@<$clean>@; | |
1201 | ||
1202 | # The whole of a #error is a string. | |
c45dcabd | 1203 | } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) { |
c2fdda0d | 1204 | my $clean = 'X' x length($1); |
c45dcabd | 1205 | $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@; |
c2fdda0d AW |
1206 | } |
1207 | ||
dadf680d JP |
1208 | if ($allow_c99_comments && $res =~ m@(//.*$)@) { |
1209 | my $match = $1; | |
1210 | $res =~ s/\Q$match\E/"$;" x length($match)/e; | |
1211 | } | |
1212 | ||
00df344f AW |
1213 | return $res; |
1214 | } | |
1215 | ||
a6962d72 JP |
1216 | sub get_quoted_string { |
1217 | my ($line, $rawline) = @_; | |
1218 | ||
33acb54a | 1219 | return "" if ($line !~ m/($String)/g); |
a6962d72 JP |
1220 | return substr($rawline, $-[0], $+[0] - $-[0]); |
1221 | } | |
1222 | ||
8905a67c AW |
1223 | sub ctx_statement_block { |
1224 | my ($linenr, $remain, $off) = @_; | |
1225 | my $line = $linenr - 1; | |
1226 | my $blk = ''; | |
1227 | my $soff = $off; | |
1228 | my $coff = $off - 1; | |
773647a0 | 1229 | my $coff_set = 0; |
8905a67c | 1230 | |
13214adf AW |
1231 | my $loff = 0; |
1232 | ||
8905a67c AW |
1233 | my $type = ''; |
1234 | my $level = 0; | |
a2750645 | 1235 | my @stack = (); |
cf655043 | 1236 | my $p; |
8905a67c AW |
1237 | my $c; |
1238 | my $len = 0; | |
13214adf AW |
1239 | |
1240 | my $remainder; | |
8905a67c | 1241 | while (1) { |
a2750645 AW |
1242 | @stack = (['', 0]) if ($#stack == -1); |
1243 | ||
773647a0 | 1244 | #warn "CSB: blk<$blk> remain<$remain>\n"; |
8905a67c AW |
1245 | # If we are about to drop off the end, pull in more |
1246 | # context. | |
1247 | if ($off >= $len) { | |
1248 | for (; $remain > 0; $line++) { | |
dea33496 | 1249 | last if (!defined $lines[$line]); |
c2fdda0d | 1250 | next if ($lines[$line] =~ /^-/); |
8905a67c | 1251 | $remain--; |
13214adf | 1252 | $loff = $len; |
c2fdda0d | 1253 | $blk .= $lines[$line] . "\n"; |
8905a67c AW |
1254 | $len = length($blk); |
1255 | $line++; | |
1256 | last; | |
1257 | } | |
1258 | # Bail if there is no further context. | |
1259 | #warn "CSB: blk<$blk> off<$off> len<$len>\n"; | |
13214adf | 1260 | if ($off >= $len) { |
8905a67c AW |
1261 | last; |
1262 | } | |
f74bd194 AW |
1263 | if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) { |
1264 | $level++; | |
1265 | $type = '#'; | |
1266 | } | |
8905a67c | 1267 | } |
cf655043 | 1268 | $p = $c; |
8905a67c | 1269 | $c = substr($blk, $off, 1); |
13214adf | 1270 | $remainder = substr($blk, $off); |
8905a67c | 1271 | |
773647a0 | 1272 | #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n"; |
4635f4fb AW |
1273 | |
1274 | # Handle nested #if/#else. | |
1275 | if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) { | |
1276 | push(@stack, [ $type, $level ]); | |
1277 | } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) { | |
1278 | ($type, $level) = @{$stack[$#stack - 1]}; | |
1279 | } elsif ($remainder =~ /^#\s*endif\b/) { | |
1280 | ($type, $level) = @{pop(@stack)}; | |
1281 | } | |
1282 | ||
8905a67c AW |
1283 | # Statement ends at the ';' or a close '}' at the |
1284 | # outermost level. | |
1285 | if ($level == 0 && $c eq ';') { | |
1286 | last; | |
1287 | } | |
1288 | ||
13214adf | 1289 | # An else is really a conditional as long as its not else if |
773647a0 AW |
1290 | if ($level == 0 && $coff_set == 0 && |
1291 | (!defined($p) || $p =~ /(?:\s|\}|\+)/) && | |
1292 | $remainder =~ /^(else)(?:\s|{)/ && | |
1293 | $remainder !~ /^else\s+if\b/) { | |
1294 | $coff = $off + length($1) - 1; | |
1295 | $coff_set = 1; | |
1296 | #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n"; | |
1297 | #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n"; | |
13214adf AW |
1298 | } |
1299 | ||
8905a67c AW |
1300 | if (($type eq '' || $type eq '(') && $c eq '(') { |
1301 | $level++; | |
1302 | $type = '('; | |
1303 | } | |
1304 | if ($type eq '(' && $c eq ')') { | |
1305 | $level--; | |
1306 | $type = ($level != 0)? '(' : ''; | |
1307 | ||
1308 | if ($level == 0 && $coff < $soff) { | |
1309 | $coff = $off; | |
773647a0 AW |
1310 | $coff_set = 1; |
1311 | #warn "CSB: mark coff<$coff>\n"; | |
8905a67c AW |
1312 | } |
1313 | } | |
1314 | if (($type eq '' || $type eq '{') && $c eq '{') { | |
1315 | $level++; | |
1316 | $type = '{'; | |
1317 | } | |
1318 | if ($type eq '{' && $c eq '}') { | |
1319 | $level--; | |
1320 | $type = ($level != 0)? '{' : ''; | |
1321 | ||
1322 | if ($level == 0) { | |
b998e001 PP |
1323 | if (substr($blk, $off + 1, 1) eq ';') { |
1324 | $off++; | |
1325 | } | |
8905a67c AW |
1326 | last; |
1327 | } | |
1328 | } | |
f74bd194 AW |
1329 | # Preprocessor commands end at the newline unless escaped. |
1330 | if ($type eq '#' && $c eq "\n" && $p ne "\\") { | |
1331 | $level--; | |
1332 | $type = ''; | |
1333 | $off++; | |
1334 | last; | |
1335 | } | |
8905a67c AW |
1336 | $off++; |
1337 | } | |
a3bb97a7 | 1338 | # We are truly at the end, so shuffle to the next line. |
13214adf | 1339 | if ($off == $len) { |
a3bb97a7 | 1340 | $loff = $len + 1; |
13214adf AW |
1341 | $line++; |
1342 | $remain--; | |
1343 | } | |
8905a67c AW |
1344 | |
1345 | my $statement = substr($blk, $soff, $off - $soff + 1); | |
1346 | my $condition = substr($blk, $soff, $coff - $soff + 1); | |
1347 | ||
1348 | #warn "STATEMENT<$statement>\n"; | |
1349 | #warn "CONDITION<$condition>\n"; | |
1350 | ||
773647a0 | 1351 | #print "coff<$coff> soff<$off> loff<$loff>\n"; |
13214adf AW |
1352 | |
1353 | return ($statement, $condition, | |
1354 | $line, $remain + 1, $off - $loff + 1, $level); | |
1355 | } | |
1356 | ||
cf655043 AW |
1357 | sub statement_lines { |
1358 | my ($stmt) = @_; | |
1359 | ||
1360 | # Strip the diff line prefixes and rip blank lines at start and end. | |
1361 | $stmt =~ s/(^|\n)./$1/g; | |
1362 | $stmt =~ s/^\s*//; | |
1363 | $stmt =~ s/\s*$//; | |
1364 | ||
1365 | my @stmt_lines = ($stmt =~ /\n/g); | |
1366 | ||
1367 | return $#stmt_lines + 2; | |
1368 | } | |
1369 | ||
1370 | sub statement_rawlines { | |
1371 | my ($stmt) = @_; | |
1372 | ||
1373 | my @stmt_lines = ($stmt =~ /\n/g); | |
1374 | ||
1375 | return $#stmt_lines + 2; | |
1376 | } | |
1377 | ||
1378 | sub statement_block_size { | |
1379 | my ($stmt) = @_; | |
1380 | ||
1381 | $stmt =~ s/(^|\n)./$1/g; | |
1382 | $stmt =~ s/^\s*{//; | |
1383 | $stmt =~ s/}\s*$//; | |
1384 | $stmt =~ s/^\s*//; | |
1385 | $stmt =~ s/\s*$//; | |
1386 | ||
1387 | my @stmt_lines = ($stmt =~ /\n/g); | |
1388 | my @stmt_statements = ($stmt =~ /;/g); | |
1389 | ||
1390 | my $stmt_lines = $#stmt_lines + 2; | |
1391 | my $stmt_statements = $#stmt_statements + 1; | |
1392 | ||
1393 | if ($stmt_lines > $stmt_statements) { | |
1394 | return $stmt_lines; | |
1395 | } else { | |
1396 | return $stmt_statements; | |
1397 | } | |
1398 | } | |
1399 | ||
13214adf AW |
1400 | sub ctx_statement_full { |
1401 | my ($linenr, $remain, $off) = @_; | |
1402 | my ($statement, $condition, $level); | |
1403 | ||
1404 | my (@chunks); | |
1405 | ||
cf655043 | 1406 | # Grab the first conditional/block pair. |
13214adf AW |
1407 | ($statement, $condition, $linenr, $remain, $off, $level) = |
1408 | ctx_statement_block($linenr, $remain, $off); | |
773647a0 | 1409 | #print "F: c<$condition> s<$statement> remain<$remain>\n"; |
cf655043 AW |
1410 | push(@chunks, [ $condition, $statement ]); |
1411 | if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) { | |
1412 | return ($level, $linenr, @chunks); | |
1413 | } | |
1414 | ||
1415 | # Pull in the following conditional/block pairs and see if they | |
1416 | # could continue the statement. | |
13214adf | 1417 | for (;;) { |
13214adf AW |
1418 | ($statement, $condition, $linenr, $remain, $off, $level) = |
1419 | ctx_statement_block($linenr, $remain, $off); | |
cf655043 | 1420 | #print "C: c<$condition> s<$statement> remain<$remain>\n"; |
773647a0 | 1421 | last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s)); |
cf655043 AW |
1422 | #print "C: push\n"; |
1423 | push(@chunks, [ $condition, $statement ]); | |
13214adf AW |
1424 | } |
1425 | ||
1426 | return ($level, $linenr, @chunks); | |
8905a67c AW |
1427 | } |
1428 | ||
4a0df2ef | 1429 | sub ctx_block_get { |
f0a594c1 | 1430 | my ($linenr, $remain, $outer, $open, $close, $off) = @_; |
4a0df2ef AW |
1431 | my $line; |
1432 | my $start = $linenr - 1; | |
4a0df2ef AW |
1433 | my $blk = ''; |
1434 | my @o; | |
1435 | my @c; | |
1436 | my @res = (); | |
1437 | ||
f0a594c1 | 1438 | my $level = 0; |
4635f4fb | 1439 | my @stack = ($level); |
00df344f AW |
1440 | for ($line = $start; $remain > 0; $line++) { |
1441 | next if ($rawlines[$line] =~ /^-/); | |
1442 | $remain--; | |
1443 | ||
1444 | $blk .= $rawlines[$line]; | |
4635f4fb AW |
1445 | |
1446 | # Handle nested #if/#else. | |
01464f30 | 1447 | if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) { |
4635f4fb | 1448 | push(@stack, $level); |
01464f30 | 1449 | } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) { |
4635f4fb | 1450 | $level = $stack[$#stack - 1]; |
01464f30 | 1451 | } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) { |
4635f4fb AW |
1452 | $level = pop(@stack); |
1453 | } | |
1454 | ||
01464f30 | 1455 | foreach my $c (split(//, $lines[$line])) { |
f0a594c1 AW |
1456 | ##print "C<$c>L<$level><$open$close>O<$off>\n"; |
1457 | if ($off > 0) { | |
1458 | $off--; | |
1459 | next; | |
1460 | } | |
4a0df2ef | 1461 | |
f0a594c1 AW |
1462 | if ($c eq $close && $level > 0) { |
1463 | $level--; | |
1464 | last if ($level == 0); | |
1465 | } elsif ($c eq $open) { | |
1466 | $level++; | |
1467 | } | |
1468 | } | |
4a0df2ef | 1469 | |
f0a594c1 | 1470 | if (!$outer || $level <= 1) { |
00df344f | 1471 | push(@res, $rawlines[$line]); |
4a0df2ef AW |
1472 | } |
1473 | ||
f0a594c1 | 1474 | last if ($level == 0); |
4a0df2ef AW |
1475 | } |
1476 | ||
f0a594c1 | 1477 | return ($level, @res); |
4a0df2ef AW |
1478 | } |
1479 | sub ctx_block_outer { | |
1480 | my ($linenr, $remain) = @_; | |
1481 | ||
f0a594c1 AW |
1482 | my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0); |
1483 | return @r; | |
4a0df2ef AW |
1484 | } |
1485 | sub ctx_block { | |
1486 | my ($linenr, $remain) = @_; | |
1487 | ||
f0a594c1 AW |
1488 | my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0); |
1489 | return @r; | |
653d4876 AW |
1490 | } |
1491 | sub ctx_statement { | |
f0a594c1 AW |
1492 | my ($linenr, $remain, $off) = @_; |
1493 | ||
1494 | my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off); | |
1495 | return @r; | |
1496 | } | |
1497 | sub ctx_block_level { | |
653d4876 AW |
1498 | my ($linenr, $remain) = @_; |
1499 | ||
f0a594c1 | 1500 | return ctx_block_get($linenr, $remain, 0, '{', '}', 0); |
4a0df2ef | 1501 | } |
9c0ca6f9 AW |
1502 | sub ctx_statement_level { |
1503 | my ($linenr, $remain, $off) = @_; | |
1504 | ||
1505 | return ctx_block_get($linenr, $remain, 0, '(', ')', $off); | |
1506 | } | |
4a0df2ef AW |
1507 | |
1508 | sub ctx_locate_comment { | |
1509 | my ($first_line, $end_line) = @_; | |
1510 | ||
1511 | # Catch a comment on the end of the line itself. | |
beae6332 | 1512 | my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@); |
4a0df2ef AW |
1513 | return $current_comment if (defined $current_comment); |
1514 | ||
1515 | # Look through the context and try and figure out if there is a | |
1516 | # comment. | |
1517 | my $in_comment = 0; | |
1518 | $current_comment = ''; | |
1519 | for (my $linenr = $first_line; $linenr < $end_line; $linenr++) { | |
00df344f AW |
1520 | my $line = $rawlines[$linenr - 1]; |
1521 | #warn " $line\n"; | |
4a0df2ef AW |
1522 | if ($linenr == $first_line and $line =~ m@^.\s*\*@) { |
1523 | $in_comment = 1; | |
1524 | } | |
1525 | if ($line =~ m@/\*@) { | |
1526 | $in_comment = 1; | |
1527 | } | |
1528 | if (!$in_comment && $current_comment ne '') { | |
1529 | $current_comment = ''; | |
1530 | } | |
1531 | $current_comment .= $line . "\n" if ($in_comment); | |
1532 | if ($line =~ m@\*/@) { | |
1533 | $in_comment = 0; | |
1534 | } | |
1535 | } | |
1536 | ||
1537 | chomp($current_comment); | |
1538 | return($current_comment); | |
1539 | } | |
1540 | sub ctx_has_comment { | |
1541 | my ($first_line, $end_line) = @_; | |
1542 | my $cmt = ctx_locate_comment($first_line, $end_line); | |
1543 | ||
00df344f | 1544 | ##print "LINE: $rawlines[$end_line - 1 ]\n"; |
4a0df2ef AW |
1545 | ##print "CMMT: $cmt\n"; |
1546 | ||
1547 | return ($cmt ne ''); | |
1548 | } | |
1549 | ||
4d001e4d AW |
1550 | sub raw_line { |
1551 | my ($linenr, $cnt) = @_; | |
1552 | ||
1553 | my $offset = $linenr - 1; | |
1554 | $cnt++; | |
1555 | ||
1556 | my $line; | |
1557 | while ($cnt) { | |
1558 | $line = $rawlines[$offset++]; | |
1559 | next if (defined($line) && $line =~ /^-/); | |
1560 | $cnt--; | |
1561 | } | |
1562 | ||
1563 | return $line; | |
1564 | } | |
1565 | ||
6c72ffaa AW |
1566 | sub cat_vet { |
1567 | my ($vet) = @_; | |
1568 | my ($res, $coded); | |
9c0ca6f9 | 1569 | |
6c72ffaa AW |
1570 | $res = ''; |
1571 | while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) { | |
1572 | $res .= $1; | |
1573 | if ($2 ne '') { | |
1574 | $coded = sprintf("^%c", unpack('C', $2) + 64); | |
1575 | $res .= $coded; | |
9c0ca6f9 AW |
1576 | } |
1577 | } | |
6c72ffaa | 1578 | $res =~ s/$/\$/; |
9c0ca6f9 | 1579 | |
6c72ffaa | 1580 | return $res; |
9c0ca6f9 AW |
1581 | } |
1582 | ||
c2fdda0d | 1583 | my $av_preprocessor = 0; |
cf655043 | 1584 | my $av_pending; |
c2fdda0d | 1585 | my @av_paren_type; |
1f65f947 | 1586 | my $av_pend_colon; |
c2fdda0d AW |
1587 | |
1588 | sub annotate_reset { | |
1589 | $av_preprocessor = 0; | |
cf655043 AW |
1590 | $av_pending = '_'; |
1591 | @av_paren_type = ('E'); | |
1f65f947 | 1592 | $av_pend_colon = 'O'; |
c2fdda0d AW |
1593 | } |
1594 | ||
6c72ffaa AW |
1595 | sub annotate_values { |
1596 | my ($stream, $type) = @_; | |
0a920b5b | 1597 | |
6c72ffaa | 1598 | my $res; |
1f65f947 | 1599 | my $var = '_' x length($stream); |
6c72ffaa AW |
1600 | my $cur = $stream; |
1601 | ||
c2fdda0d | 1602 | print "$stream\n" if ($dbg_values > 1); |
6c72ffaa | 1603 | |
6c72ffaa | 1604 | while (length($cur)) { |
773647a0 | 1605 | @av_paren_type = ('E') if ($#av_paren_type < 0); |
cf655043 | 1606 | print " <" . join('', @av_paren_type) . |
171ae1a4 | 1607 | "> <$type> <$av_pending>" if ($dbg_values > 1); |
6c72ffaa | 1608 | if ($cur =~ /^(\s+)/o) { |
c2fdda0d AW |
1609 | print "WS($1)\n" if ($dbg_values > 1); |
1610 | if ($1 =~ /\n/ && $av_preprocessor) { | |
cf655043 | 1611 | $type = pop(@av_paren_type); |
c2fdda0d | 1612 | $av_preprocessor = 0; |
6c72ffaa AW |
1613 | } |
1614 | ||
c023e473 | 1615 | } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') { |
9446ef56 AW |
1616 | print "CAST($1)\n" if ($dbg_values > 1); |
1617 | push(@av_paren_type, $type); | |
addcdcea | 1618 | $type = 'c'; |
9446ef56 | 1619 | |
e91b6e26 | 1620 | } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) { |
c2fdda0d | 1621 | print "DECLARE($1)\n" if ($dbg_values > 1); |
6c72ffaa AW |
1622 | $type = 'T'; |
1623 | ||
389a2fe5 AW |
1624 | } elsif ($cur =~ /^($Modifier)\s*/) { |
1625 | print "MODIFIER($1)\n" if ($dbg_values > 1); | |
1626 | $type = 'T'; | |
1627 | ||
c45dcabd | 1628 | } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) { |
171ae1a4 | 1629 | print "DEFINE($1,$2)\n" if ($dbg_values > 1); |
c2fdda0d | 1630 | $av_preprocessor = 1; |
171ae1a4 AW |
1631 | push(@av_paren_type, $type); |
1632 | if ($2 ne '') { | |
1633 | $av_pending = 'N'; | |
1634 | } | |
1635 | $type = 'E'; | |
1636 | ||
c45dcabd | 1637 | } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) { |
171ae1a4 AW |
1638 | print "UNDEF($1)\n" if ($dbg_values > 1); |
1639 | $av_preprocessor = 1; | |
1640 | push(@av_paren_type, $type); | |
6c72ffaa | 1641 | |
c45dcabd | 1642 | } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) { |
cf655043 | 1643 | print "PRE_START($1)\n" if ($dbg_values > 1); |
c2fdda0d | 1644 | $av_preprocessor = 1; |
cf655043 AW |
1645 | |
1646 | push(@av_paren_type, $type); | |
1647 | push(@av_paren_type, $type); | |
171ae1a4 | 1648 | $type = 'E'; |
cf655043 | 1649 | |
c45dcabd | 1650 | } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) { |
cf655043 AW |
1651 | print "PRE_RESTART($1)\n" if ($dbg_values > 1); |
1652 | $av_preprocessor = 1; | |
1653 | ||
1654 | push(@av_paren_type, $av_paren_type[$#av_paren_type]); | |
1655 | ||
171ae1a4 | 1656 | $type = 'E'; |
cf655043 | 1657 | |
c45dcabd | 1658 | } elsif ($cur =~ /^(\#\s*(?:endif))/o) { |
cf655043 AW |
1659 | print "PRE_END($1)\n" if ($dbg_values > 1); |
1660 | ||
1661 | $av_preprocessor = 1; | |
1662 | ||
1663 | # Assume all arms of the conditional end as this | |
1664 | # one does, and continue as if the #endif was not here. | |
1665 | pop(@av_paren_type); | |
1666 | push(@av_paren_type, $type); | |
171ae1a4 | 1667 | $type = 'E'; |
6c72ffaa AW |
1668 | |
1669 | } elsif ($cur =~ /^(\\\n)/o) { | |
c2fdda0d | 1670 | print "PRECONT($1)\n" if ($dbg_values > 1); |
6c72ffaa | 1671 | |
171ae1a4 AW |
1672 | } elsif ($cur =~ /^(__attribute__)\s*\(?/o) { |
1673 | print "ATTR($1)\n" if ($dbg_values > 1); | |
1674 | $av_pending = $type; | |
1675 | $type = 'N'; | |
1676 | ||
6c72ffaa | 1677 | } elsif ($cur =~ /^(sizeof)\s*(\()?/o) { |
c2fdda0d | 1678 | print "SIZEOF($1)\n" if ($dbg_values > 1); |
6c72ffaa | 1679 | if (defined $2) { |
cf655043 | 1680 | $av_pending = 'V'; |
6c72ffaa AW |
1681 | } |
1682 | $type = 'N'; | |
1683 | ||
14b111c1 | 1684 | } elsif ($cur =~ /^(if|while|for)\b/o) { |
c2fdda0d | 1685 | print "COND($1)\n" if ($dbg_values > 1); |
14b111c1 | 1686 | $av_pending = 'E'; |
6c72ffaa AW |
1687 | $type = 'N'; |
1688 | ||
1f65f947 AW |
1689 | } elsif ($cur =~/^(case)/o) { |
1690 | print "CASE($1)\n" if ($dbg_values > 1); | |
1691 | $av_pend_colon = 'C'; | |
1692 | $type = 'N'; | |
1693 | ||
14b111c1 | 1694 | } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) { |
c2fdda0d | 1695 | print "KEYWORD($1)\n" if ($dbg_values > 1); |
6c72ffaa AW |
1696 | $type = 'N'; |
1697 | ||
1698 | } elsif ($cur =~ /^(\()/o) { | |
c2fdda0d | 1699 | print "PAREN('$1')\n" if ($dbg_values > 1); |
cf655043 AW |
1700 | push(@av_paren_type, $av_pending); |
1701 | $av_pending = '_'; | |
6c72ffaa AW |
1702 | $type = 'N'; |
1703 | ||
1704 | } elsif ($cur =~ /^(\))/o) { | |
cf655043 AW |
1705 | my $new_type = pop(@av_paren_type); |
1706 | if ($new_type ne '_') { | |
1707 | $type = $new_type; | |
c2fdda0d AW |
1708 | print "PAREN('$1') -> $type\n" |
1709 | if ($dbg_values > 1); | |
6c72ffaa | 1710 | } else { |
c2fdda0d | 1711 | print "PAREN('$1')\n" if ($dbg_values > 1); |
6c72ffaa AW |
1712 | } |
1713 | ||
c8cb2ca3 | 1714 | } elsif ($cur =~ /^($Ident)\s*\(/o) { |
c2fdda0d | 1715 | print "FUNC($1)\n" if ($dbg_values > 1); |
c8cb2ca3 | 1716 | $type = 'V'; |
cf655043 | 1717 | $av_pending = 'V'; |
6c72ffaa | 1718 | |
8e761b04 AW |
1719 | } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) { |
1720 | if (defined $2 && $type eq 'C' || $type eq 'T') { | |
1f65f947 | 1721 | $av_pend_colon = 'B'; |
8e761b04 AW |
1722 | } elsif ($type eq 'E') { |
1723 | $av_pend_colon = 'L'; | |
1f65f947 AW |
1724 | } |
1725 | print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1); | |
1726 | $type = 'V'; | |
1727 | ||
6c72ffaa | 1728 | } elsif ($cur =~ /^($Ident|$Constant)/o) { |
c2fdda0d | 1729 | print "IDENT($1)\n" if ($dbg_values > 1); |
6c72ffaa AW |
1730 | $type = 'V'; |
1731 | ||
1732 | } elsif ($cur =~ /^($Assignment)/o) { | |
c2fdda0d | 1733 | print "ASSIGN($1)\n" if ($dbg_values > 1); |
6c72ffaa AW |
1734 | $type = 'N'; |
1735 | ||
cf655043 | 1736 | } elsif ($cur =~/^(;|{|})/) { |
c2fdda0d | 1737 | print "END($1)\n" if ($dbg_values > 1); |
13214adf | 1738 | $type = 'E'; |
1f65f947 AW |
1739 | $av_pend_colon = 'O'; |
1740 | ||
8e761b04 AW |
1741 | } elsif ($cur =~/^(,)/) { |
1742 | print "COMMA($1)\n" if ($dbg_values > 1); | |
1743 | $type = 'C'; | |
1744 | ||
1f65f947 AW |
1745 | } elsif ($cur =~ /^(\?)/o) { |
1746 | print "QUESTION($1)\n" if ($dbg_values > 1); | |
1747 | $type = 'N'; | |
1748 | ||
1749 | } elsif ($cur =~ /^(:)/o) { | |
1750 | print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1); | |
1751 | ||
1752 | substr($var, length($res), 1, $av_pend_colon); | |
1753 | if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') { | |
1754 | $type = 'E'; | |
1755 | } else { | |
1756 | $type = 'N'; | |
1757 | } | |
1758 | $av_pend_colon = 'O'; | |
13214adf | 1759 | |
8e761b04 | 1760 | } elsif ($cur =~ /^(\[)/o) { |
13214adf | 1761 | print "CLOSE($1)\n" if ($dbg_values > 1); |
6c72ffaa AW |
1762 | $type = 'N'; |
1763 | ||
0d413866 | 1764 | } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) { |
74048ed8 AW |
1765 | my $variant; |
1766 | ||
1767 | print "OPV($1)\n" if ($dbg_values > 1); | |
1768 | if ($type eq 'V') { | |
1769 | $variant = 'B'; | |
1770 | } else { | |
1771 | $variant = 'U'; | |
1772 | } | |
1773 | ||
1774 | substr($var, length($res), 1, $variant); | |
1775 | $type = 'N'; | |
1776 | ||
6c72ffaa | 1777 | } elsif ($cur =~ /^($Operators)/o) { |
c2fdda0d | 1778 | print "OP($1)\n" if ($dbg_values > 1); |
6c72ffaa AW |
1779 | if ($1 ne '++' && $1 ne '--') { |
1780 | $type = 'N'; | |
1781 | } | |
1782 | ||
1783 | } elsif ($cur =~ /(^.)/o) { | |
c2fdda0d | 1784 | print "C($1)\n" if ($dbg_values > 1); |
6c72ffaa AW |
1785 | } |
1786 | if (defined $1) { | |
1787 | $cur = substr($cur, length($1)); | |
1788 | $res .= $type x length($1); | |
1789 | } | |
9c0ca6f9 | 1790 | } |
0a920b5b | 1791 | |
1f65f947 | 1792 | return ($res, $var); |
0a920b5b AW |
1793 | } |
1794 | ||
8905a67c | 1795 | sub possible { |
13214adf | 1796 | my ($possible, $line) = @_; |
9a974fdb | 1797 | my $notPermitted = qr{(?: |
0776e594 AW |
1798 | ^(?: |
1799 | $Modifier| | |
1800 | $Storage| | |
1801 | $Type| | |
9a974fdb AW |
1802 | DEFINE_\S+ |
1803 | )$| | |
1804 | ^(?: | |
0776e594 AW |
1805 | goto| |
1806 | return| | |
1807 | case| | |
1808 | else| | |
1809 | asm|__asm__| | |
89a88353 AW |
1810 | do| |
1811 | \#| | |
1812 | \#\#| | |
9a974fdb | 1813 | )(?:\s|$)| |
0776e594 | 1814 | ^(?:typedef|struct|enum)\b |
9a974fdb AW |
1815 | )}x; |
1816 | warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2); | |
1817 | if ($possible !~ $notPermitted) { | |
c45dcabd AW |
1818 | # Check for modifiers. |
1819 | $possible =~ s/\s*$Storage\s*//g; | |
1820 | $possible =~ s/\s*$Sparse\s*//g; | |
1821 | if ($possible =~ /^\s*$/) { | |
1822 | ||
1823 | } elsif ($possible =~ /\s/) { | |
1824 | $possible =~ s/\s*$Type\s*//g; | |
d2506586 | 1825 | for my $modifier (split(' ', $possible)) { |
9a974fdb AW |
1826 | if ($modifier !~ $notPermitted) { |
1827 | warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible); | |
485ff23e | 1828 | push(@modifierListFile, $modifier); |
9a974fdb | 1829 | } |
d2506586 | 1830 | } |
c45dcabd AW |
1831 | |
1832 | } else { | |
1833 | warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible); | |
485ff23e | 1834 | push(@typeListFile, $possible); |
c45dcabd | 1835 | } |
8905a67c | 1836 | build_types(); |
0776e594 AW |
1837 | } else { |
1838 | warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1); | |
8905a67c AW |
1839 | } |
1840 | } | |
1841 | ||
6c72ffaa AW |
1842 | my $prefix = ''; |
1843 | ||
000d1cc1 | 1844 | sub show_type { |
cbec18af | 1845 | my ($type) = @_; |
91bfe484 | 1846 | |
cbec18af JP |
1847 | return defined $use_type{$type} if (scalar keys %use_type > 0); |
1848 | ||
1849 | return !defined $ignore_type{$type}; | |
000d1cc1 JP |
1850 | } |
1851 | ||
f0a594c1 | 1852 | sub report { |
cbec18af JP |
1853 | my ($level, $type, $msg) = @_; |
1854 | ||
1855 | if (!show_type($type) || | |
1856 | (defined $tst_only && $msg !~ /\Q$tst_only\E/)) { | |
773647a0 AW |
1857 | return 0; |
1858 | } | |
57230297 JP |
1859 | my $output = ''; |
1860 | if (-t STDOUT && $color) { | |
1861 | if ($level eq 'ERROR') { | |
1862 | $output .= RED; | |
1863 | } elsif ($level eq 'WARNING') { | |
1864 | $output .= YELLOW; | |
1865 | } else { | |
1866 | $output .= GREEN; | |
1867 | } | |
1868 | } | |
1869 | $output .= $prefix . $level . ':'; | |
000d1cc1 | 1870 | if ($show_types) { |
57230297 JP |
1871 | $output .= BLUE if (-t STDOUT && $color); |
1872 | $output .= "$type:"; | |
000d1cc1 | 1873 | } |
57230297 JP |
1874 | $output .= RESET if (-t STDOUT && $color); |
1875 | $output .= ' ' . $msg . "\n"; | |
34d8815f JP |
1876 | |
1877 | if ($showfile) { | |
1878 | my @lines = split("\n", $output, -1); | |
1879 | splice(@lines, 1, 1); | |
1880 | $output = join("\n", @lines); | |
1881 | } | |
57230297 | 1882 | $output = (split('\n', $output))[0] . "\n" if ($terse); |
8905a67c | 1883 | |
57230297 | 1884 | push(our @report, $output); |
773647a0 AW |
1885 | |
1886 | return 1; | |
f0a594c1 | 1887 | } |
cbec18af | 1888 | |
f0a594c1 | 1889 | sub report_dump { |
13214adf | 1890 | our @report; |
f0a594c1 | 1891 | } |
000d1cc1 | 1892 | |
d752fcc8 JP |
1893 | sub fixup_current_range { |
1894 | my ($lineRef, $offset, $length) = @_; | |
1895 | ||
1896 | if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) { | |
1897 | my $o = $1; | |
1898 | my $l = $2; | |
1899 | my $no = $o + $offset; | |
1900 | my $nl = $l + $length; | |
1901 | $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/; | |
1902 | } | |
1903 | } | |
1904 | ||
1905 | sub fix_inserted_deleted_lines { | |
1906 | my ($linesRef, $insertedRef, $deletedRef) = @_; | |
1907 | ||
1908 | my $range_last_linenr = 0; | |
1909 | my $delta_offset = 0; | |
1910 | ||
1911 | my $old_linenr = 0; | |
1912 | my $new_linenr = 0; | |
1913 | ||
1914 | my $next_insert = 0; | |
1915 | my $next_delete = 0; | |
1916 | ||
1917 | my @lines = (); | |
1918 | ||
1919 | my $inserted = @{$insertedRef}[$next_insert++]; | |
1920 | my $deleted = @{$deletedRef}[$next_delete++]; | |
1921 | ||
1922 | foreach my $old_line (@{$linesRef}) { | |
1923 | my $save_line = 1; | |
1924 | my $line = $old_line; #don't modify the array | |
323b267f | 1925 | if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename |
d752fcc8 JP |
1926 | $delta_offset = 0; |
1927 | } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk | |
1928 | $range_last_linenr = $new_linenr; | |
1929 | fixup_current_range(\$line, $delta_offset, 0); | |
1930 | } | |
1931 | ||
1932 | while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) { | |
1933 | $deleted = @{$deletedRef}[$next_delete++]; | |
1934 | $save_line = 0; | |
1935 | fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1); | |
1936 | } | |
1937 | ||
1938 | while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) { | |
1939 | push(@lines, ${$inserted}{'LINE'}); | |
1940 | $inserted = @{$insertedRef}[$next_insert++]; | |
1941 | $new_linenr++; | |
1942 | fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1); | |
1943 | } | |
1944 | ||
1945 | if ($save_line) { | |
1946 | push(@lines, $line); | |
1947 | $new_linenr++; | |
1948 | } | |
1949 | ||
1950 | $old_linenr++; | |
1951 | } | |
1952 | ||
1953 | return @lines; | |
1954 | } | |
1955 | ||
f2d7e4d4 JP |
1956 | sub fix_insert_line { |
1957 | my ($linenr, $line) = @_; | |
1958 | ||
1959 | my $inserted = { | |
1960 | LINENR => $linenr, | |
1961 | LINE => $line, | |
1962 | }; | |
1963 | push(@fixed_inserted, $inserted); | |
1964 | } | |
1965 | ||
1966 | sub fix_delete_line { | |
1967 | my ($linenr, $line) = @_; | |
1968 | ||
1969 | my $deleted = { | |
1970 | LINENR => $linenr, | |
1971 | LINE => $line, | |
1972 | }; | |
1973 | ||
1974 | push(@fixed_deleted, $deleted); | |
1975 | } | |
1976 | ||
de7d4f0e | 1977 | sub ERROR { |
cbec18af JP |
1978 | my ($type, $msg) = @_; |
1979 | ||
1980 | if (report("ERROR", $type, $msg)) { | |
773647a0 AW |
1981 | our $clean = 0; |
1982 | our $cnt_error++; | |
3705ce5b | 1983 | return 1; |
773647a0 | 1984 | } |
3705ce5b | 1985 | return 0; |
de7d4f0e AW |
1986 | } |
1987 | sub WARN { | |
cbec18af JP |
1988 | my ($type, $msg) = @_; |
1989 | ||
1990 | if (report("WARNING", $type, $msg)) { | |
773647a0 AW |
1991 | our $clean = 0; |
1992 | our $cnt_warn++; | |
3705ce5b | 1993 | return 1; |
773647a0 | 1994 | } |
3705ce5b | 1995 | return 0; |
de7d4f0e AW |
1996 | } |
1997 | sub CHK { | |
cbec18af JP |
1998 | my ($type, $msg) = @_; |
1999 | ||
2000 | if ($check && report("CHECK", $type, $msg)) { | |
6c72ffaa AW |
2001 | our $clean = 0; |
2002 | our $cnt_chk++; | |
3705ce5b | 2003 | return 1; |
6c72ffaa | 2004 | } |
3705ce5b | 2005 | return 0; |
de7d4f0e AW |
2006 | } |
2007 | ||
6ecd9674 AW |
2008 | sub check_absolute_file { |
2009 | my ($absolute, $herecurr) = @_; | |
2010 | my $file = $absolute; | |
2011 | ||
2012 | ##print "absolute<$absolute>\n"; | |
2013 | ||
2014 | # See if any suffix of this path is a path within the tree. | |
2015 | while ($file =~ s@^[^/]*/@@) { | |
2016 | if (-f "$root/$file") { | |
2017 | ##print "file<$file>\n"; | |
2018 | last; | |
2019 | } | |
2020 | } | |
2021 | if (! -f _) { | |
2022 | return 0; | |
2023 | } | |
2024 | ||
2025 | # It is, so see if the prefix is acceptable. | |
2026 | my $prefix = $absolute; | |
2027 | substr($prefix, -length($file)) = ''; | |
2028 | ||
2029 | ##print "prefix<$prefix>\n"; | |
2030 | if ($prefix ne ".../") { | |
000d1cc1 JP |
2031 | WARN("USE_RELATIVE_PATH", |
2032 | "use relative pathname instead of absolute in changelog text\n" . $herecurr); | |
6ecd9674 AW |
2033 | } |
2034 | } | |
2035 | ||
3705ce5b JP |
2036 | sub trim { |
2037 | my ($string) = @_; | |
2038 | ||
b34c648b JP |
2039 | $string =~ s/^\s+|\s+$//g; |
2040 | ||
2041 | return $string; | |
2042 | } | |
2043 | ||
2044 | sub ltrim { | |
2045 | my ($string) = @_; | |
2046 | ||
2047 | $string =~ s/^\s+//; | |
2048 | ||
2049 | return $string; | |
2050 | } | |
2051 | ||
2052 | sub rtrim { | |
2053 | my ($string) = @_; | |
2054 | ||
2055 | $string =~ s/\s+$//; | |
3705ce5b JP |
2056 | |
2057 | return $string; | |
2058 | } | |
2059 | ||
52ea8506 JP |
2060 | sub string_find_replace { |
2061 | my ($string, $find, $replace) = @_; | |
2062 | ||
2063 | $string =~ s/$find/$replace/g; | |
2064 | ||
2065 | return $string; | |
2066 | } | |
2067 | ||
3705ce5b JP |
2068 | sub tabify { |
2069 | my ($leading) = @_; | |
2070 | ||
2071 | my $source_indent = 8; | |
2072 | my $max_spaces_before_tab = $source_indent - 1; | |
2073 | my $spaces_to_tab = " " x $source_indent; | |
2074 | ||
2075 | #convert leading spaces to tabs | |
2076 | 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g; | |
2077 | #Remove spaces before a tab | |
2078 | 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g; | |
2079 | ||
2080 | return "$leading"; | |
2081 | } | |
2082 | ||
d1fe9c09 JP |
2083 | sub pos_last_openparen { |
2084 | my ($line) = @_; | |
2085 | ||
2086 | my $pos = 0; | |
2087 | ||
2088 | my $opens = $line =~ tr/\(/\(/; | |
2089 | my $closes = $line =~ tr/\)/\)/; | |
2090 | ||
2091 | my $last_openparen = 0; | |
2092 | ||
2093 | if (($opens == 0) || ($closes >= $opens)) { | |
2094 | return -1; | |
2095 | } | |
2096 | ||
2097 | my $len = length($line); | |
2098 | ||
2099 | for ($pos = 0; $pos < $len; $pos++) { | |
2100 | my $string = substr($line, $pos); | |
2101 | if ($string =~ /^($FuncArg|$balanced_parens)/) { | |
2102 | $pos += length($1) - 1; | |
2103 | } elsif (substr($line, $pos, 1) eq '(') { | |
2104 | $last_openparen = $pos; | |
2105 | } elsif (index($string, '(') == -1) { | |
2106 | last; | |
2107 | } | |
2108 | } | |
2109 | ||
91cb5195 | 2110 | return length(expand_tabs(substr($line, 0, $last_openparen))) + 1; |
d1fe9c09 JP |
2111 | } |
2112 | ||
0a920b5b AW |
2113 | sub process { |
2114 | my $filename = shift; | |
0a920b5b AW |
2115 | |
2116 | my $linenr=0; | |
2117 | my $prevline=""; | |
c2fdda0d | 2118 | my $prevrawline=""; |
0a920b5b | 2119 | my $stashline=""; |
c2fdda0d | 2120 | my $stashrawline=""; |
0a920b5b | 2121 | |
4a0df2ef | 2122 | my $length; |
0a920b5b AW |
2123 | my $indent; |
2124 | my $previndent=0; | |
2125 | my $stashindent=0; | |
2126 | ||
de7d4f0e | 2127 | our $clean = 1; |
0a920b5b AW |
2128 | my $signoff = 0; |
2129 | my $is_patch = 0; | |
29ee1b0c | 2130 | my $in_header_lines = $file ? 0 : 1; |
15662b3e | 2131 | my $in_commit_log = 0; #Scanning lines before patch |
ed43c4e5 | 2132 | my $has_commit_log = 0; #Encountered lines before patch |
bf4daf12 | 2133 | my $commit_log_possible_stack_dump = 0; |
2a076f40 | 2134 | my $commit_log_long_line = 0; |
e518e9a5 | 2135 | my $commit_log_has_diff = 0; |
13f1937e | 2136 | my $reported_maintainer_file = 0; |
fa64205d PS |
2137 | my $non_utf8_charset = 0; |
2138 | ||
365dd4ea | 2139 | my $last_blank_line = 0; |
5e4f6ba5 | 2140 | my $last_coalesced_string_linenr = -1; |
365dd4ea | 2141 | |
13214adf | 2142 | our @report = (); |
6c72ffaa AW |
2143 | our $cnt_lines = 0; |
2144 | our $cnt_error = 0; | |
2145 | our $cnt_warn = 0; | |
2146 | our $cnt_chk = 0; | |
2147 | ||
0a920b5b AW |
2148 | # Trace the real file/line as we go. |
2149 | my $realfile = ''; | |
2150 | my $realline = 0; | |
2151 | my $realcnt = 0; | |
2152 | my $here = ''; | |
2153 | my $in_comment = 0; | |
c2fdda0d | 2154 | my $comment_edge = 0; |
0a920b5b | 2155 | my $first_line = 0; |
1e855726 | 2156 | my $p1_prefix = ''; |
0a920b5b | 2157 | |
13214adf AW |
2158 | my $prev_values = 'E'; |
2159 | ||
2160 | # suppression flags | |
773647a0 | 2161 | my %suppress_ifbraces; |
170d3a22 | 2162 | my %suppress_whiletrailers; |
2b474a1a | 2163 | my %suppress_export; |
3e469cdc | 2164 | my $suppress_statement = 0; |
653d4876 | 2165 | |
7e51f197 | 2166 | my %signatures = (); |
323c1260 | 2167 | |
c2fdda0d | 2168 | # Pre-scan the patch sanitizing the lines. |
de7d4f0e | 2169 | # Pre-scan the patch looking for any __setup documentation. |
c2fdda0d | 2170 | # |
de7d4f0e AW |
2171 | my @setup_docs = (); |
2172 | my $setup_docs = 0; | |
773647a0 | 2173 | |
d8b07710 JP |
2174 | my $camelcase_file_seeded = 0; |
2175 | ||
773647a0 | 2176 | sanitise_line_reset(); |
c2fdda0d AW |
2177 | my $line; |
2178 | foreach my $rawline (@rawlines) { | |
773647a0 AW |
2179 | $linenr++; |
2180 | $line = $rawline; | |
c2fdda0d | 2181 | |
3705ce5b JP |
2182 | push(@fixed, $rawline) if ($fix); |
2183 | ||
773647a0 | 2184 | if ($rawline=~/^\+\+\+\s+(\S+)/) { |
de7d4f0e AW |
2185 | $setup_docs = 0; |
2186 | if ($1 =~ m@Documentation/kernel-parameters.txt$@) { | |
2187 | $setup_docs = 1; | |
2188 | } | |
773647a0 AW |
2189 | #next; |
2190 | } | |
2191 | if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) { | |
2192 | $realline=$1-1; | |
2193 | if (defined $2) { | |
2194 | $realcnt=$3+1; | |
2195 | } else { | |
2196 | $realcnt=1+1; | |
2197 | } | |
c45dcabd | 2198 | $in_comment = 0; |
773647a0 AW |
2199 | |
2200 | # Guestimate if this is a continuing comment. Run | |
2201 | # the context looking for a comment "edge". If this | |
2202 | # edge is a close comment then we must be in a comment | |
2203 | # at context start. | |
2204 | my $edge; | |
01fa9147 AW |
2205 | my $cnt = $realcnt; |
2206 | for (my $ln = $linenr + 1; $cnt > 0; $ln++) { | |
2207 | next if (defined $rawlines[$ln - 1] && | |
2208 | $rawlines[$ln - 1] =~ /^-/); | |
2209 | $cnt--; | |
2210 | #print "RAW<$rawlines[$ln - 1]>\n"; | |
721c1cb6 | 2211 | last if (!defined $rawlines[$ln - 1]); |
fae17dae AW |
2212 | if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ && |
2213 | $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) { | |
2214 | ($edge) = $1; | |
2215 | last; | |
2216 | } | |
773647a0 AW |
2217 | } |
2218 | if (defined $edge && $edge eq '*/') { | |
2219 | $in_comment = 1; | |
2220 | } | |
2221 | ||
2222 | # Guestimate if this is a continuing comment. If this | |
2223 | # is the start of a diff block and this line starts | |
2224 | # ' *' then it is very likely a comment. | |
2225 | if (!defined $edge && | |
83242e0c | 2226 | $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@) |
773647a0 AW |
2227 | { |
2228 | $in_comment = 1; | |
2229 | } | |
2230 | ||
2231 | ##print "COMMENT:$in_comment edge<$edge> $rawline\n"; | |
2232 | sanitise_line_reset($in_comment); | |
2233 | ||
171ae1a4 | 2234 | } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) { |
773647a0 | 2235 | # Standardise the strings and chars within the input to |
171ae1a4 | 2236 | # simplify matching -- only bother with positive lines. |
773647a0 | 2237 | $line = sanitise_line($rawline); |
de7d4f0e | 2238 | } |
773647a0 AW |
2239 | push(@lines, $line); |
2240 | ||
2241 | if ($realcnt > 1) { | |
2242 | $realcnt-- if ($line =~ /^(?:\+| |$)/); | |
2243 | } else { | |
2244 | $realcnt = 0; | |
2245 | } | |
2246 | ||
2247 | #print "==>$rawline\n"; | |
2248 | #print "-->$line\n"; | |
de7d4f0e AW |
2249 | |
2250 | if ($setup_docs && $line =~ /^\+/) { | |
2251 | push(@setup_docs, $line); | |
2252 | } | |
2253 | } | |
2254 | ||
6c72ffaa AW |
2255 | $prefix = ''; |
2256 | ||
773647a0 AW |
2257 | $realcnt = 0; |
2258 | $linenr = 0; | |
194f66fc | 2259 | $fixlinenr = -1; |
0a920b5b AW |
2260 | foreach my $line (@lines) { |
2261 | $linenr++; | |
194f66fc | 2262 | $fixlinenr++; |
1b5539b1 JP |
2263 | my $sline = $line; #copy of $line |
2264 | $sline =~ s/$;/ /g; #with comments as spaces | |
0a920b5b | 2265 | |
c2fdda0d | 2266 | my $rawline = $rawlines[$linenr - 1]; |
6c72ffaa | 2267 | |
0a920b5b | 2268 | #extract the line range in the file after the patch is applied |
e518e9a5 JP |
2269 | if (!$in_commit_log && |
2270 | $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) { | |
0a920b5b | 2271 | $is_patch = 1; |
4a0df2ef | 2272 | $first_line = $linenr + 1; |
0a920b5b AW |
2273 | $realline=$1-1; |
2274 | if (defined $2) { | |
2275 | $realcnt=$3+1; | |
2276 | } else { | |
2277 | $realcnt=1+1; | |
2278 | } | |
c2fdda0d | 2279 | annotate_reset(); |
13214adf AW |
2280 | $prev_values = 'E'; |
2281 | ||
773647a0 | 2282 | %suppress_ifbraces = (); |
170d3a22 | 2283 | %suppress_whiletrailers = (); |
2b474a1a | 2284 | %suppress_export = (); |
3e469cdc | 2285 | $suppress_statement = 0; |
0a920b5b | 2286 | next; |
0a920b5b | 2287 | |
4a0df2ef AW |
2288 | # track the line number as we move through the hunk, note that |
2289 | # new versions of GNU diff omit the leading space on completely | |
2290 | # blank context lines so we need to count that too. | |
773647a0 | 2291 | } elsif ($line =~ /^( |\+|$)/) { |
0a920b5b | 2292 | $realline++; |
d8aaf121 | 2293 | $realcnt-- if ($realcnt != 0); |
0a920b5b | 2294 | |
4a0df2ef | 2295 | # Measure the line length and indent. |
c2fdda0d | 2296 | ($length, $indent) = line_stats($rawline); |
0a920b5b AW |
2297 | |
2298 | # Track the previous line. | |
2299 | ($prevline, $stashline) = ($stashline, $line); | |
2300 | ($previndent, $stashindent) = ($stashindent, $indent); | |
c2fdda0d AW |
2301 | ($prevrawline, $stashrawline) = ($stashrawline, $rawline); |
2302 | ||
773647a0 | 2303 | #warn "line<$line>\n"; |
6c72ffaa | 2304 | |
d8aaf121 AW |
2305 | } elsif ($realcnt == 1) { |
2306 | $realcnt--; | |
0a920b5b AW |
2307 | } |
2308 | ||
cc77cdca AW |
2309 | my $hunk_line = ($realcnt != 0); |
2310 | ||
6c72ffaa AW |
2311 | $here = "#$linenr: " if (!$file); |
2312 | $here = "#$realline: " if ($file); | |
773647a0 | 2313 | |
2ac73b4f | 2314 | my $found_file = 0; |
773647a0 | 2315 | # extract the filename as it passes |
3bf9a009 RV |
2316 | if ($line =~ /^diff --git.*?(\S+)$/) { |
2317 | $realfile = $1; | |
2b7ab453 | 2318 | $realfile =~ s@^([^/]*)/@@ if (!$file); |
270c49a0 | 2319 | $in_commit_log = 0; |
2ac73b4f | 2320 | $found_file = 1; |
3bf9a009 | 2321 | } elsif ($line =~ /^\+\+\+\s+(\S+)/) { |
773647a0 | 2322 | $realfile = $1; |
2b7ab453 | 2323 | $realfile =~ s@^([^/]*)/@@ if (!$file); |
270c49a0 | 2324 | $in_commit_log = 0; |
1e855726 WS |
2325 | |
2326 | $p1_prefix = $1; | |
e2f7aa4b AW |
2327 | if (!$file && $tree && $p1_prefix ne '' && |
2328 | -e "$root/$p1_prefix") { | |
000d1cc1 JP |
2329 | WARN("PATCH_PREFIX", |
2330 | "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n"); | |
1e855726 | 2331 | } |
773647a0 | 2332 | |
c1ab3326 | 2333 | if ($realfile =~ m@^include/asm/@) { |
000d1cc1 JP |
2334 | ERROR("MODIFIED_INCLUDE_ASM", |
2335 | "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n"); | |
773647a0 | 2336 | } |
2ac73b4f JP |
2337 | $found_file = 1; |
2338 | } | |
2339 | ||
34d8815f JP |
2340 | #make up the handle for any error we report on this line |
2341 | if ($showfile) { | |
2342 | $prefix = "$realfile:$realline: " | |
2343 | } elsif ($emacs) { | |
7d3a9f67 JP |
2344 | if ($file) { |
2345 | $prefix = "$filename:$realline: "; | |
2346 | } else { | |
2347 | $prefix = "$filename:$linenr: "; | |
2348 | } | |
34d8815f JP |
2349 | } |
2350 | ||
2ac73b4f | 2351 | if ($found_file) { |
85b0ee18 JP |
2352 | if (is_maintained_obsolete($realfile)) { |
2353 | WARN("OBSOLETE", | |
2354 | "$realfile is marked as 'obsolete' in the MAINTAINERS hierarchy. No unnecessary modifications please.\n"); | |
2355 | } | |
7bd7e483 | 2356 | if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) { |
2ac73b4f JP |
2357 | $check = 1; |
2358 | } else { | |
2359 | $check = $check_orig; | |
2360 | } | |
773647a0 AW |
2361 | next; |
2362 | } | |
2363 | ||
389834b6 | 2364 | $here .= "FILE: $realfile:$realline:" if ($realcnt != 0); |
0a920b5b | 2365 | |
c2fdda0d AW |
2366 | my $hereline = "$here\n$rawline\n"; |
2367 | my $herecurr = "$here\n$rawline\n"; | |
2368 | my $hereprev = "$here\n$prevrawline\n$rawline\n"; | |
0a920b5b | 2369 | |
6c72ffaa AW |
2370 | $cnt_lines++ if ($realcnt != 0); |
2371 | ||
e518e9a5 JP |
2372 | # Check if the commit log has what seems like a diff which can confuse patch |
2373 | if ($in_commit_log && !$commit_log_has_diff && | |
2374 | (($line =~ m@^\s+diff\b.*a/[\w/]+@ && | |
2375 | $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) || | |
2376 | $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ || | |
2377 | $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) { | |
2378 | ERROR("DIFF_IN_COMMIT_MSG", | |
2379 | "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr); | |
2380 | $commit_log_has_diff = 1; | |
2381 | } | |
2382 | ||
3bf9a009 RV |
2383 | # Check for incorrect file permissions |
2384 | if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) { | |
2385 | my $permhere = $here . "FILE: $realfile\n"; | |
04db4d25 JP |
2386 | if ($realfile !~ m@scripts/@ && |
2387 | $realfile !~ /\.(py|pl|awk|sh)$/) { | |
000d1cc1 JP |
2388 | ERROR("EXECUTE_PERMISSIONS", |
2389 | "do not set execute permissions for source files\n" . $permhere); | |
3bf9a009 RV |
2390 | } |
2391 | } | |
2392 | ||
20112475 | 2393 | # Check the patch for a signoff: |
d8aaf121 | 2394 | if ($line =~ /^\s*signed-off-by:/i) { |
4a0df2ef | 2395 | $signoff++; |
15662b3e | 2396 | $in_commit_log = 0; |
20112475 JP |
2397 | } |
2398 | ||
e0d975b1 JP |
2399 | # Check if MAINTAINERS is being updated. If so, there's probably no need to |
2400 | # emit the "does MAINTAINERS need updating?" message on file add/move/delete | |
2401 | if ($line =~ /^\s*MAINTAINERS\s*\|/) { | |
2402 | $reported_maintainer_file = 1; | |
2403 | } | |
2404 | ||
20112475 | 2405 | # Check signature styles |
270c49a0 | 2406 | if (!$in_header_lines && |
ce0338df | 2407 | $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) { |
20112475 JP |
2408 | my $space_before = $1; |
2409 | my $sign_off = $2; | |
2410 | my $space_after = $3; | |
2411 | my $email = $4; | |
2412 | my $ucfirst_sign_off = ucfirst(lc($sign_off)); | |
2413 | ||
ce0338df JP |
2414 | if ($sign_off !~ /$signature_tags/) { |
2415 | WARN("BAD_SIGN_OFF", | |
2416 | "Non-standard signature: $sign_off\n" . $herecurr); | |
2417 | } | |
20112475 | 2418 | if (defined $space_before && $space_before ne "") { |
3705ce5b JP |
2419 | if (WARN("BAD_SIGN_OFF", |
2420 | "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) && | |
2421 | $fix) { | |
194f66fc | 2422 | $fixed[$fixlinenr] = |
3705ce5b JP |
2423 | "$ucfirst_sign_off $email"; |
2424 | } | |
20112475 JP |
2425 | } |
2426 | if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) { | |
3705ce5b JP |
2427 | if (WARN("BAD_SIGN_OFF", |
2428 | "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) && | |
2429 | $fix) { | |
194f66fc | 2430 | $fixed[$fixlinenr] = |
3705ce5b JP |
2431 | "$ucfirst_sign_off $email"; |
2432 | } | |
2433 | ||
20112475 JP |
2434 | } |
2435 | if (!defined $space_after || $space_after ne " ") { | |
3705ce5b JP |
2436 | if (WARN("BAD_SIGN_OFF", |
2437 | "Use a single space after $ucfirst_sign_off\n" . $herecurr) && | |
2438 | $fix) { | |
194f66fc | 2439 | $fixed[$fixlinenr] = |
3705ce5b JP |
2440 | "$ucfirst_sign_off $email"; |
2441 | } | |
0a920b5b | 2442 | } |
20112475 JP |
2443 | |
2444 | my ($email_name, $email_address, $comment) = parse_email($email); | |
2445 | my $suggested_email = format_email(($email_name, $email_address)); | |
2446 | if ($suggested_email eq "") { | |
000d1cc1 JP |
2447 | ERROR("BAD_SIGN_OFF", |
2448 | "Unrecognized email address: '$email'\n" . $herecurr); | |
20112475 JP |
2449 | } else { |
2450 | my $dequoted = $suggested_email; | |
2451 | $dequoted =~ s/^"//; | |
2452 | $dequoted =~ s/" </ </; | |
2453 | # Don't force email to have quotes | |
2454 | # Allow just an angle bracketed address | |
2455 | if ("$dequoted$comment" ne $email && | |
2456 | "<$email_address>$comment" ne $email && | |
2457 | "$suggested_email$comment" ne $email) { | |
000d1cc1 JP |
2458 | WARN("BAD_SIGN_OFF", |
2459 | "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr); | |
20112475 | 2460 | } |
0a920b5b | 2461 | } |
7e51f197 JP |
2462 | |
2463 | # Check for duplicate signatures | |
2464 | my $sig_nospace = $line; | |
2465 | $sig_nospace =~ s/\s//g; | |
2466 | $sig_nospace = lc($sig_nospace); | |
2467 | if (defined $signatures{$sig_nospace}) { | |
2468 | WARN("BAD_SIGN_OFF", | |
2469 | "Duplicate signature\n" . $herecurr); | |
2470 | } else { | |
2471 | $signatures{$sig_nospace} = 1; | |
2472 | } | |
0a920b5b AW |
2473 | } |
2474 | ||
a2fe16b9 JP |
2475 | # Check email subject for common tools that don't need to be mentioned |
2476 | if ($in_header_lines && | |
2477 | $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) { | |
2478 | WARN("EMAIL_SUBJECT", | |
2479 | "A patch subject line should describe the change not the tool that found it\n" . $herecurr); | |
2480 | } | |
2481 | ||
9b3189eb JP |
2482 | # Check for old stable address |
2483 | if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) { | |
2484 | ERROR("STABLE_ADDRESS", | |
2485 | "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr); | |
2486 | } | |
2487 | ||
7ebd05ef CC |
2488 | # Check for unwanted Gerrit info |
2489 | if ($in_commit_log && $line =~ /^\s*change-id:/i) { | |
2490 | ERROR("GERRIT_CHANGE_ID", | |
2491 | "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr); | |
2492 | } | |
2493 | ||
369c8dd3 JP |
2494 | # Check if the commit log is in a possible stack dump |
2495 | if ($in_commit_log && !$commit_log_possible_stack_dump && | |
2496 | ($line =~ /^\s*(?:WARNING:|BUG:)/ || | |
2497 | $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ || | |
2498 | # timestamp | |
2499 | $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) { | |
2500 | # stack dump address | |
2501 | $commit_log_possible_stack_dump = 1; | |
2502 | } | |
2503 | ||
2a076f40 JP |
2504 | # Check for line lengths > 75 in commit log, warn once |
2505 | if ($in_commit_log && !$commit_log_long_line && | |
369c8dd3 JP |
2506 | length($line) > 75 && |
2507 | !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ || | |
2508 | # file delta changes | |
2509 | $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ || | |
2510 | # filename then : | |
2511 | $line =~ /^\s*(?:Fixes:|Link:)/i || | |
2512 | # A Fixes: or Link: line | |
2513 | $commit_log_possible_stack_dump)) { | |
2a076f40 JP |
2514 | WARN("COMMIT_LOG_LONG_LINE", |
2515 | "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr); | |
2516 | $commit_log_long_line = 1; | |
2517 | } | |
2518 | ||
bf4daf12 | 2519 | # Reset possible stack dump if a blank line is found |
369c8dd3 JP |
2520 | if ($in_commit_log && $commit_log_possible_stack_dump && |
2521 | $line =~ /^\s*$/) { | |
2522 | $commit_log_possible_stack_dump = 0; | |
2523 | } | |
bf4daf12 | 2524 | |
0d7835fc | 2525 | # Check for git id commit length and improperly formed commit descriptions |
369c8dd3 | 2526 | if ($in_commit_log && !$commit_log_possible_stack_dump && |
aab38f51 | 2527 | $line !~ /^\s*(?:Link|Patchwork|http|https|BugLink):/i && |
fe043ea1 | 2528 | ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i || |
aab38f51 | 2529 | ($line =~ /(?:\s|^)[0-9a-f]{12,40}(?:[\s"'\(\[]|$)/i && |
369c8dd3 JP |
2530 | $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i && |
2531 | $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) { | |
fe043ea1 JP |
2532 | my $init_char = "c"; |
2533 | my $orig_commit = ""; | |
0d7835fc JP |
2534 | my $short = 1; |
2535 | my $long = 0; | |
2536 | my $case = 1; | |
2537 | my $space = 1; | |
2538 | my $hasdesc = 0; | |
19c146a6 | 2539 | my $hasparens = 0; |
0d7835fc JP |
2540 | my $id = '0123456789ab'; |
2541 | my $orig_desc = "commit description"; | |
2542 | my $description = ""; | |
2543 | ||
fe043ea1 JP |
2544 | if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) { |
2545 | $init_char = $1; | |
2546 | $orig_commit = lc($2); | |
2547 | } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) { | |
2548 | $orig_commit = lc($1); | |
2549 | } | |
2550 | ||
0d7835fc JP |
2551 | $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i); |
2552 | $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i); | |
2553 | $space = 0 if ($line =~ /\bcommit [0-9a-f]/i); | |
2554 | $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/); | |
2555 | if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) { | |
2556 | $orig_desc = $1; | |
19c146a6 | 2557 | $hasparens = 1; |
0d7835fc JP |
2558 | } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i && |
2559 | defined $rawlines[$linenr] && | |
2560 | $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) { | |
2561 | $orig_desc = $1; | |
19c146a6 | 2562 | $hasparens = 1; |
b671fde0 JP |
2563 | } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i && |
2564 | defined $rawlines[$linenr] && | |
2565 | $rawlines[$linenr] =~ /^\s*[^"]+"\)/) { | |
2566 | $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i; | |
2567 | $orig_desc = $1; | |
2568 | $rawlines[$linenr] =~ /^\s*([^"]+)"\)/; | |
2569 | $orig_desc .= " " . $1; | |
19c146a6 | 2570 | $hasparens = 1; |
0d7835fc JP |
2571 | } |
2572 | ||
2573 | ($id, $description) = git_commit_info($orig_commit, | |
2574 | $id, $orig_desc); | |
2575 | ||
19c146a6 | 2576 | if ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens) { |
0d7835fc JP |
2577 | ERROR("GIT_COMMIT_ID", |
2578 | "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr); | |
2579 | } | |
d311cd44 JP |
2580 | } |
2581 | ||
13f1937e JP |
2582 | # Check for added, moved or deleted files |
2583 | if (!$reported_maintainer_file && !$in_commit_log && | |
2584 | ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ || | |
2585 | $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ || | |
2586 | ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ && | |
2587 | (defined($1) || defined($2))))) { | |
2588 | $reported_maintainer_file = 1; | |
2589 | WARN("FILE_PATH_CHANGES", | |
2590 | "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr); | |
2591 | } | |
2592 | ||
00df344f | 2593 | # Check for wrappage within a valid hunk of the file |
8905a67c | 2594 | if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) { |
000d1cc1 JP |
2595 | ERROR("CORRUPTED_PATCH", |
2596 | "patch seems to be corrupt (line wrapped?)\n" . | |
6c72ffaa | 2597 | $herecurr) if (!$emitted_corrupt++); |
de7d4f0e AW |
2598 | } |
2599 | ||
6ecd9674 AW |
2600 | # Check for absolute kernel paths. |
2601 | if ($tree) { | |
2602 | while ($line =~ m{(?:^|\s)(/\S*)}g) { | |
2603 | my $file = $1; | |
2604 | ||
2605 | if ($file =~ m{^(.*?)(?::\d+)+:?$} && | |
2606 | check_absolute_file($1, $herecurr)) { | |
2607 | # | |
2608 | } else { | |
2609 | check_absolute_file($file, $herecurr); | |
2610 | } | |
2611 | } | |
2612 | } | |
2613 | ||
de7d4f0e AW |
2614 | # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php |
2615 | if (($realfile =~ /^$/ || $line =~ /^\+/) && | |
171ae1a4 AW |
2616 | $rawline !~ m/^$UTF8*$/) { |
2617 | my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/); | |
2618 | ||
2619 | my $blank = copy_spacing($rawline); | |
2620 | my $ptr = substr($blank, 0, length($utf8_prefix)) . "^"; | |
2621 | my $hereptr = "$hereline$ptr\n"; | |
2622 | ||
34d99219 JP |
2623 | CHK("INVALID_UTF8", |
2624 | "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr); | |
00df344f AW |
2625 | } |
2626 | ||
15662b3e JP |
2627 | # Check if it's the start of a commit log |
2628 | # (not a header line and we haven't seen the patch filename) | |
2629 | if ($in_header_lines && $realfile =~ /^$/ && | |
29ee1b0c JP |
2630 | !($rawline =~ /^\s+\S/ || |
2631 | $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) { | |
15662b3e JP |
2632 | $in_header_lines = 0; |
2633 | $in_commit_log = 1; | |
ed43c4e5 | 2634 | $has_commit_log = 1; |
15662b3e JP |
2635 | } |
2636 | ||
fa64205d PS |
2637 | # Check if there is UTF-8 in a commit log when a mail header has explicitly |
2638 | # declined it, i.e defined some charset where it is missing. | |
2639 | if ($in_header_lines && | |
2640 | $rawline =~ /^Content-Type:.+charset="(.+)".*$/ && | |
2641 | $1 !~ /utf-8/i) { | |
2642 | $non_utf8_charset = 1; | |
2643 | } | |
2644 | ||
2645 | if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ && | |
15662b3e | 2646 | $rawline =~ /$NON_ASCII_UTF8/) { |
fa64205d | 2647 | WARN("UTF8_BEFORE_PATCH", |
15662b3e JP |
2648 | "8-bit UTF-8 used in possible commit log\n" . $herecurr); |
2649 | } | |
2650 | ||
66b47b4a | 2651 | # Check for various typo / spelling mistakes |
66d7a382 JP |
2652 | if (defined($misspellings) && |
2653 | ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) { | |
ebfd7d62 | 2654 | while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) { |
66b47b4a KC |
2655 | my $typo = $1; |
2656 | my $typo_fix = $spelling_fix{lc($typo)}; | |
2657 | $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/); | |
2658 | $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/); | |
2659 | my $msg_type = \&WARN; | |
2660 | $msg_type = \&CHK if ($file); | |
2661 | if (&{$msg_type}("TYPO_SPELLING", | |
2662 | "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) && | |
2663 | $fix) { | |
2664 | $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/; | |
2665 | } | |
2666 | } | |
2667 | } | |
2668 | ||
30670854 AW |
2669 | # ignore non-hunk lines and lines being removed |
2670 | next if (!$hunk_line || $line =~ /^-/); | |
0a920b5b | 2671 | |
0a920b5b | 2672 | #trailing whitespace |
9c0ca6f9 | 2673 | if ($line =~ /^\+.*\015/) { |
c2fdda0d | 2674 | my $herevet = "$here\n" . cat_vet($rawline) . "\n"; |
d5e616fc JP |
2675 | if (ERROR("DOS_LINE_ENDINGS", |
2676 | "DOS line endings\n" . $herevet) && | |
2677 | $fix) { | |
194f66fc | 2678 | $fixed[$fixlinenr] =~ s/[\s\015]+$//; |
d5e616fc | 2679 | } |
c2fdda0d AW |
2680 | } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) { |
2681 | my $herevet = "$here\n" . cat_vet($rawline) . "\n"; | |
3705ce5b JP |
2682 | if (ERROR("TRAILING_WHITESPACE", |
2683 | "trailing whitespace\n" . $herevet) && | |
2684 | $fix) { | |
194f66fc | 2685 | $fixed[$fixlinenr] =~ s/\s+$//; |
3705ce5b JP |
2686 | } |
2687 | ||
d2c0a235 | 2688 | $rpt_cleaners = 1; |
0a920b5b | 2689 | } |
5368df20 | 2690 | |
4783f894 | 2691 | # Check for FSF mailing addresses. |
109d8cb2 | 2692 | if ($rawline =~ /\bwrite to the Free/i || |
3e2232f2 JP |
2693 | $rawline =~ /\b59\s+Temple\s+Pl/i || |
2694 | $rawline =~ /\b51\s+Franklin\s+St/i) { | |
4783f894 JT |
2695 | my $herevet = "$here\n" . cat_vet($rawline) . "\n"; |
2696 | my $msg_type = \&ERROR; | |
2697 | $msg_type = \&CHK if ($file); | |
2698 | &{$msg_type}("FSF_MAILING_ADDRESS", | |
3e2232f2 | 2699 | "Do not include the paragraph about writing to the Free Software Foundation's mailing address from the sample GPL notice. The FSF has changed addresses in the past, and may do so again. Linux already includes a copy of the GPL.\n" . $herevet) |
4783f894 JT |
2700 | } |
2701 | ||
3354957a | 2702 | # check for Kconfig help text having a real description |
9fe287d7 AW |
2703 | # Only applies when adding the entry originally, after that we do not have |
2704 | # sufficient context to determine whether it is indeed long enough. | |
3354957a | 2705 | if ($realfile =~ /Kconfig/ && |
8d73e0e7 | 2706 | $line =~ /^\+\s*config\s+/) { |
3354957a | 2707 | my $length = 0; |
9fe287d7 AW |
2708 | my $cnt = $realcnt; |
2709 | my $ln = $linenr + 1; | |
2710 | my $f; | |
a1385803 | 2711 | my $is_start = 0; |
9fe287d7 | 2712 | my $is_end = 0; |
a1385803 | 2713 | for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) { |
9fe287d7 AW |
2714 | $f = $lines[$ln - 1]; |
2715 | $cnt-- if ($lines[$ln - 1] !~ /^-/); | |
2716 | $is_end = $lines[$ln - 1] =~ /^\+/; | |
9fe287d7 AW |
2717 | |
2718 | next if ($f =~ /^-/); | |
8d73e0e7 | 2719 | last if (!$file && $f =~ /^\@\@/); |
a1385803 | 2720 | |
8d73e0e7 | 2721 | if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) { |
a1385803 | 2722 | $is_start = 1; |
8d73e0e7 | 2723 | } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) { |
a1385803 AW |
2724 | $length = -1; |
2725 | } | |
2726 | ||
9fe287d7 | 2727 | $f =~ s/^.//; |
3354957a AK |
2728 | $f =~ s/#.*//; |
2729 | $f =~ s/^\s+//; | |
2730 | next if ($f =~ /^$/); | |
9fe287d7 AW |
2731 | if ($f =~ /^\s*config\s/) { |
2732 | $is_end = 1; | |
2733 | last; | |
2734 | } | |
3354957a AK |
2735 | $length++; |
2736 | } | |
56193274 VB |
2737 | if ($is_start && $is_end && $length < $min_conf_desc_length) { |
2738 | WARN("CONFIG_DESCRIPTION", | |
2739 | "please write a paragraph that describes the config symbol fully\n" . $herecurr); | |
2740 | } | |
a1385803 | 2741 | #print "is_start<$is_start> is_end<$is_end> length<$length>\n"; |
3354957a AK |
2742 | } |
2743 | ||
1ba8dfd1 KC |
2744 | # discourage the addition of CONFIG_EXPERIMENTAL in Kconfig. |
2745 | if ($realfile =~ /Kconfig/ && | |
2746 | $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) { | |
2747 | WARN("CONFIG_EXPERIMENTAL", | |
2748 | "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n"); | |
2749 | } | |
2750 | ||
327953e9 CJ |
2751 | # discourage the use of boolean for type definition attributes of Kconfig options |
2752 | if ($realfile =~ /Kconfig/ && | |
2753 | $line =~ /^\+\s*\bboolean\b/) { | |
2754 | WARN("CONFIG_TYPE_BOOLEAN", | |
2755 | "Use of boolean is deprecated, please use bool instead.\n" . $herecurr); | |
2756 | } | |
2757 | ||
c68e5878 AL |
2758 | if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) && |
2759 | ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) { | |
2760 | my $flag = $1; | |
2761 | my $replacement = { | |
2762 | 'EXTRA_AFLAGS' => 'asflags-y', | |
2763 | 'EXTRA_CFLAGS' => 'ccflags-y', | |
2764 | 'EXTRA_CPPFLAGS' => 'cppflags-y', | |
2765 | 'EXTRA_LDFLAGS' => 'ldflags-y', | |
2766 | }; | |
2767 | ||
2768 | WARN("DEPRECATED_VARIABLE", | |
2769 | "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag}); | |
2770 | } | |
2771 | ||
bff5da43 | 2772 | # check for DT compatible documentation |
7dd05b38 FV |
2773 | if (defined $root && |
2774 | (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) || | |
2775 | ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) { | |
2776 | ||
bff5da43 RH |
2777 | my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g; |
2778 | ||
cc93319b FV |
2779 | my $dt_path = $root . "/Documentation/devicetree/bindings/"; |
2780 | my $vp_file = $dt_path . "vendor-prefixes.txt"; | |
2781 | ||
bff5da43 RH |
2782 | foreach my $compat (@compats) { |
2783 | my $compat2 = $compat; | |
185d566b RH |
2784 | $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/; |
2785 | my $compat3 = $compat; | |
2786 | $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/; | |
2787 | `grep -Erq "$compat|$compat2|$compat3" $dt_path`; | |
bff5da43 RH |
2788 | if ( $? >> 8 ) { |
2789 | WARN("UNDOCUMENTED_DT_STRING", | |
2790 | "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr); | |
2791 | } | |
2792 | ||
4fbf32a6 FV |
2793 | next if $compat !~ /^([a-zA-Z0-9\-]+)\,/; |
2794 | my $vendor = $1; | |
cc93319b | 2795 | `grep -Eq "^$vendor\\b" $vp_file`; |
bff5da43 RH |
2796 | if ( $? >> 8 ) { |
2797 | WARN("UNDOCUMENTED_DT_STRING", | |
cc93319b | 2798 | "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr); |
bff5da43 RH |
2799 | } |
2800 | } | |
2801 | } | |
2802 | ||
5368df20 | 2803 | # check we are in a valid source file if not then ignore this hunk |
de4c924c | 2804 | next if ($realfile !~ /\.(h|c|s|S|pl|sh|dtsi|dts)$/); |
5368df20 | 2805 | |
47e0c88b JP |
2806 | # line length limit (with some exclusions) |
2807 | # | |
2808 | # There are a few types of lines that may extend beyond $max_line_length: | |
2809 | # logging functions like pr_info that end in a string | |
2810 | # lines with a single string | |
2811 | # #defines that are a single string | |
2812 | # | |
2813 | # There are 3 different line length message types: | |
2814 | # LONG_LINE_COMMENT a comment starts before but extends beyond $max_linelength | |
2815 | # LONG_LINE_STRING a string starts before but extends beyond $max_line_length | |
2816 | # LONG_LINE all other lines longer than $max_line_length | |
2817 | # | |
2818 | # if LONG_LINE is ignored, the other 2 types are also ignored | |
2819 | # | |
2820 | ||
b4749e96 | 2821 | if ($line =~ /^\+/ && $length > $max_line_length) { |
47e0c88b JP |
2822 | my $msg_type = "LONG_LINE"; |
2823 | ||
2824 | # Check the allowed long line types first | |
2825 | ||
2826 | # logging functions that end in a string that starts | |
2827 | # before $max_line_length | |
2828 | if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ && | |
2829 | length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) { | |
2830 | $msg_type = ""; | |
2831 | ||
2832 | # lines with only strings (w/ possible termination) | |
2833 | # #defines with only strings | |
2834 | } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ || | |
2835 | $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) { | |
2836 | $msg_type = ""; | |
2837 | ||
d560a5f8 JP |
2838 | # EFI_GUID is another special case |
2839 | } elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/) { | |
2840 | $msg_type = ""; | |
2841 | ||
47e0c88b JP |
2842 | # Otherwise set the alternate message types |
2843 | ||
2844 | # a comment starts before $max_line_length | |
2845 | } elsif ($line =~ /($;[\s$;]*)$/ && | |
2846 | length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) { | |
2847 | $msg_type = "LONG_LINE_COMMENT" | |
2848 | ||
2849 | # a quoted string starts before $max_line_length | |
2850 | } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ && | |
2851 | length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) { | |
2852 | $msg_type = "LONG_LINE_STRING" | |
2853 | } | |
2854 | ||
2855 | if ($msg_type ne "" && | |
2856 | (show_type("LONG_LINE") || show_type($msg_type))) { | |
2857 | WARN($msg_type, | |
2858 | "line over $max_line_length characters\n" . $herecurr); | |
2859 | } | |
0a920b5b AW |
2860 | } |
2861 | ||
8905a67c AW |
2862 | # check for adding lines without a newline. |
2863 | if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) { | |
000d1cc1 JP |
2864 | WARN("MISSING_EOF_NEWLINE", |
2865 | "adding a line without newline at end of file\n" . $herecurr); | |
8905a67c AW |
2866 | } |
2867 | ||
42e41c54 MF |
2868 | # Blackfin: use hi/lo macros |
2869 | if ($realfile =~ m@arch/blackfin/.*\.S$@) { | |
2870 | if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) { | |
2871 | my $herevet = "$here\n" . cat_vet($line) . "\n"; | |
000d1cc1 JP |
2872 | ERROR("LO_MACRO", |
2873 | "use the LO() macro, not (... & 0xFFFF)\n" . $herevet); | |
42e41c54 MF |
2874 | } |
2875 | if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) { | |
2876 | my $herevet = "$here\n" . cat_vet($line) . "\n"; | |
000d1cc1 JP |
2877 | ERROR("HI_MACRO", |
2878 | "use the HI() macro, not (... >> 16)\n" . $herevet); | |
42e41c54 MF |
2879 | } |
2880 | } | |
2881 | ||
b9ea10d6 | 2882 | # check we are in a valid source file C or perl if not then ignore this hunk |
de4c924c | 2883 | next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/); |
0a920b5b AW |
2884 | |
2885 | # at the beginning of a line any tabs must come first and anything | |
2886 | # more than 8 must use tabs. | |
c2fdda0d AW |
2887 | if ($rawline =~ /^\+\s* \t\s*\S/ || |
2888 | $rawline =~ /^\+\s* \s*/) { | |
2889 | my $herevet = "$here\n" . cat_vet($rawline) . "\n"; | |
d2c0a235 | 2890 | $rpt_cleaners = 1; |
3705ce5b JP |
2891 | if (ERROR("CODE_INDENT", |
2892 | "code indent should use tabs where possible\n" . $herevet) && | |
2893 | $fix) { | |
194f66fc | 2894 | $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e; |
3705ce5b | 2895 | } |
0a920b5b AW |
2896 | } |
2897 | ||
08e44365 AP |
2898 | # check for space before tabs. |
2899 | if ($rawline =~ /^\+/ && $rawline =~ / \t/) { | |
2900 | my $herevet = "$here\n" . cat_vet($rawline) . "\n"; | |
3705ce5b JP |
2901 | if (WARN("SPACE_BEFORE_TAB", |
2902 | "please, no space before tabs\n" . $herevet) && | |
2903 | $fix) { | |
194f66fc | 2904 | while ($fixed[$fixlinenr] =~ |
d2207ccb | 2905 | s/(^\+.*) {8,8}\t/$1\t\t/) {} |
194f66fc | 2906 | while ($fixed[$fixlinenr] =~ |
c76f4cb3 | 2907 | s/(^\+.*) +\t/$1\t/) {} |
3705ce5b | 2908 | } |
08e44365 AP |
2909 | } |
2910 | ||
d1fe9c09 JP |
2911 | # check for && or || at the start of a line |
2912 | if ($rawline =~ /^\+\s*(&&|\|\|)/) { | |
2913 | CHK("LOGICAL_CONTINUATIONS", | |
2914 | "Logical continuations should be on the previous line\n" . $hereprev); | |
2915 | } | |
2916 | ||
a91e8994 JP |
2917 | # check indentation starts on a tab stop |
2918 | if ($^V && $^V ge 5.10.0 && | |
2919 | $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$))/) { | |
2920 | my $indent = length($1); | |
2921 | if ($indent % 8) { | |
2922 | if (WARN("TABSTOP", | |
2923 | "Statements should start on a tabstop\n" . $herecurr) && | |
2924 | $fix) { | |
2925 | $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/8)@e; | |
2926 | } | |
2927 | } | |
2928 | } | |
2929 | ||
d1fe9c09 JP |
2930 | # check multi-line statement indentation matches previous line |
2931 | if ($^V && $^V ge 5.10.0 && | |
91cb5195 | 2932 | $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|$Ident\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) { |
d1fe9c09 JP |
2933 | $prevline =~ /^\+(\t*)(.*)$/; |
2934 | my $oldindent = $1; | |
2935 | my $rest = $2; | |
2936 | ||
2937 | my $pos = pos_last_openparen($rest); | |
2938 | if ($pos >= 0) { | |
b34a26f3 JP |
2939 | $line =~ /^(\+| )([ \t]*)/; |
2940 | my $newindent = $2; | |
d1fe9c09 JP |
2941 | |
2942 | my $goodtabindent = $oldindent . | |
2943 | "\t" x ($pos / 8) . | |
2944 | " " x ($pos % 8); | |
2945 | my $goodspaceindent = $oldindent . " " x $pos; | |
2946 | ||
2947 | if ($newindent ne $goodtabindent && | |
2948 | $newindent ne $goodspaceindent) { | |
3705ce5b JP |
2949 | |
2950 | if (CHK("PARENTHESIS_ALIGNMENT", | |
2951 | "Alignment should match open parenthesis\n" . $hereprev) && | |
2952 | $fix && $line =~ /^\+/) { | |
194f66fc | 2953 | $fixed[$fixlinenr] =~ |
3705ce5b JP |
2954 | s/^\+[ \t]*/\+$goodtabindent/; |
2955 | } | |
d1fe9c09 JP |
2956 | } |
2957 | } | |
2958 | } | |
2959 | ||
6ab3a970 JP |
2960 | # check for space after cast like "(int) foo" or "(struct foo) bar" |
2961 | # avoid checking a few false positives: | |
2962 | # "sizeof(<type>)" or "__alignof__(<type>)" | |
2963 | # function pointer declarations like "(*foo)(int) = bar;" | |
2964 | # structure definitions like "(struct foo) { 0 };" | |
2965 | # multiline macros that define functions | |
2966 | # known attributes or the __attribute__ keyword | |
2967 | if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ && | |
2968 | (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) { | |
3705ce5b | 2969 | if (CHK("SPACING", |
f27c95db | 2970 | "No space is necessary after a cast\n" . $herecurr) && |
3705ce5b | 2971 | $fix) { |
194f66fc | 2972 | $fixed[$fixlinenr] =~ |
f27c95db | 2973 | s/(\(\s*$Type\s*\))[ \t]+/$1/; |
3705ce5b | 2974 | } |
aad4f614 JP |
2975 | } |
2976 | ||
86406b1c JP |
2977 | # Block comment styles |
2978 | # Networking with an initial /* | |
05880600 | 2979 | if ($realfile =~ m@^(drivers/net/|net/)@ && |
fdb4bcd6 | 2980 | $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ && |
85ad978c JP |
2981 | $rawline =~ /^\+[ \t]*\*/ && |
2982 | $realline > 2) { | |
05880600 JP |
2983 | WARN("NETWORKING_BLOCK_COMMENT_STYLE", |
2984 | "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev); | |
2985 | } | |
2986 | ||
86406b1c JP |
2987 | # Block comments use * on subsequent lines |
2988 | if ($prevline =~ /$;[ \t]*$/ && #ends in comment | |
2989 | $prevrawline =~ /^\+.*?\/\*/ && #starting /* | |
a605e32e | 2990 | $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */ |
61135e96 | 2991 | $rawline =~ /^\+/ && #line is new |
a605e32e | 2992 | $rawline !~ /^\+[ \t]*\*/) { #no leading * |
86406b1c JP |
2993 | WARN("BLOCK_COMMENT_STYLE", |
2994 | "Block comments use * on subsequent lines\n" . $hereprev); | |
a605e32e JP |
2995 | } |
2996 | ||
86406b1c JP |
2997 | # Block comments use */ on trailing lines |
2998 | if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */ | |
c24f9f19 JP |
2999 | $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/ |
3000 | $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/ | |
3001 | $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */ | |
86406b1c JP |
3002 | WARN("BLOCK_COMMENT_STYLE", |
3003 | "Block comments use a trailing */ on a separate line\n" . $herecurr); | |
05880600 JP |
3004 | } |
3005 | ||
08eb9b80 JP |
3006 | # Block comment * alignment |
3007 | if ($prevline =~ /$;[ \t]*$/ && #ends in comment | |
af207524 JP |
3008 | $line =~ /^\+[ \t]*$;/ && #leading comment |
3009 | $rawline =~ /^\+[ \t]*\*/ && #leading * | |
3010 | (($prevrawline =~ /^\+.*?\/\*/ && #leading /* | |
08eb9b80 | 3011 | $prevrawline !~ /\*\/[ \t]*$/) || #no trailing */ |
af207524 JP |
3012 | $prevrawline =~ /^\+[ \t]*\*/)) { #leading * |
3013 | my $oldindent; | |
08eb9b80 | 3014 | $prevrawline =~ m@^\+([ \t]*/?)\*@; |
af207524 JP |
3015 | if (defined($1)) { |
3016 | $oldindent = expand_tabs($1); | |
3017 | } else { | |
3018 | $prevrawline =~ m@^\+(.*/?)\*@; | |
3019 | $oldindent = expand_tabs($1); | |
3020 | } | |
08eb9b80 JP |
3021 | $rawline =~ m@^\+([ \t]*)\*@; |
3022 | my $newindent = $1; | |
08eb9b80 | 3023 | $newindent = expand_tabs($newindent); |
af207524 | 3024 | if (length($oldindent) ne length($newindent)) { |
08eb9b80 JP |
3025 | WARN("BLOCK_COMMENT_STYLE", |
3026 | "Block comments should align the * on each line\n" . $hereprev); | |
3027 | } | |
3028 | } | |
3029 | ||
7f619191 JP |
3030 | # check for missing blank lines after struct/union declarations |
3031 | # with exceptions for various attributes and macros | |
3032 | if ($prevline =~ /^[\+ ]};?\s*$/ && | |
3033 | $line =~ /^\+/ && | |
3034 | !($line =~ /^\+\s*$/ || | |
3035 | $line =~ /^\+\s*EXPORT_SYMBOL/ || | |
3036 | $line =~ /^\+\s*MODULE_/i || | |
3037 | $line =~ /^\+\s*\#\s*(?:end|elif|else)/ || | |
3038 | $line =~ /^\+[a-z_]*init/ || | |
3039 | $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ || | |
3040 | $line =~ /^\+\s*DECLARE/ || | |
3041 | $line =~ /^\+\s*__setup/)) { | |
d752fcc8 JP |
3042 | if (CHK("LINE_SPACING", |
3043 | "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) && | |
3044 | $fix) { | |
f2d7e4d4 | 3045 | fix_insert_line($fixlinenr, "\+"); |
d752fcc8 | 3046 | } |
7f619191 JP |
3047 | } |
3048 | ||
365dd4ea JP |
3049 | # check for multiple consecutive blank lines |
3050 | if ($prevline =~ /^[\+ ]\s*$/ && | |
3051 | $line =~ /^\+\s*$/ && | |
3052 | $last_blank_line != ($linenr - 1)) { | |
d752fcc8 JP |
3053 | if (CHK("LINE_SPACING", |
3054 | "Please don't use multiple blank lines\n" . $hereprev) && | |
3055 | $fix) { | |
f2d7e4d4 | 3056 | fix_delete_line($fixlinenr, $rawline); |
d752fcc8 JP |
3057 | } |
3058 | ||
365dd4ea JP |
3059 | $last_blank_line = $linenr; |
3060 | } | |
3061 | ||
3b617e3b | 3062 | # check for missing blank lines after declarations |
3f7bac03 JP |
3063 | if ($sline =~ /^\+\s+\S/ && #Not at char 1 |
3064 | # actual declarations | |
3065 | ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ || | |
5a4e1fd3 JP |
3066 | # function pointer declarations |
3067 | $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ || | |
3f7bac03 JP |
3068 | # foo bar; where foo is some local typedef or #define |
3069 | $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ || | |
3070 | # known declaration macros | |
3071 | $prevline =~ /^\+\s+$declaration_macros/) && | |
3072 | # for "else if" which can look like "$Ident $Ident" | |
3073 | !($prevline =~ /^\+\s+$c90_Keywords\b/ || | |
3074 | # other possible extensions of declaration lines | |
3075 | $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ || | |
3076 | # not starting a section or a macro "\" extended line | |
3077 | $prevline =~ /(?:\{\s*|\\)$/) && | |
3078 | # looks like a declaration | |
3079 | !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ || | |
5a4e1fd3 JP |
3080 | # function pointer declarations |
3081 | $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ || | |
3f7bac03 JP |
3082 | # foo bar; where foo is some local typedef or #define |
3083 | $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ || | |
3084 | # known declaration macros | |
3085 | $sline =~ /^\+\s+$declaration_macros/ || | |
3086 | # start of struct or union or enum | |
3b617e3b | 3087 | $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ || |
3f7bac03 JP |
3088 | # start or end of block or continuation of declaration |
3089 | $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ || | |
3090 | # bitfield continuation | |
3091 | $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ || | |
3092 | # other possible extensions of declaration lines | |
3093 | $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) && | |
3094 | # indentation of previous and current line are the same | |
3095 | (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) { | |
d752fcc8 JP |
3096 | if (WARN("LINE_SPACING", |
3097 | "Missing a blank line after declarations\n" . $hereprev) && | |
3098 | $fix) { | |
f2d7e4d4 | 3099 | fix_insert_line($fixlinenr, "\+"); |
d752fcc8 | 3100 | } |
3b617e3b JP |
3101 | } |
3102 | ||
5f7ddae6 | 3103 | # check for spaces at the beginning of a line. |
6b4c5beb AW |
3104 | # Exceptions: |
3105 | # 1) within comments | |
3106 | # 2) indented preprocessor commands | |
3107 | # 3) hanging labels | |
3705ce5b | 3108 | if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) { |
5f7ddae6 | 3109 | my $herevet = "$here\n" . cat_vet($rawline) . "\n"; |
3705ce5b JP |
3110 | if (WARN("LEADING_SPACE", |
3111 | "please, no spaces at the start of a line\n" . $herevet) && | |
3112 | $fix) { | |
194f66fc | 3113 | $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e; |
3705ce5b | 3114 | } |
5f7ddae6 RR |
3115 | } |
3116 | ||
b9ea10d6 AW |
3117 | # check we are in a valid C source file if not then ignore this hunk |
3118 | next if ($realfile !~ /\.(h|c)$/); | |
3119 | ||
032a4c0f | 3120 | # check indentation of any line with a bare else |
840080a0 | 3121 | # (but not if it is a multiple line "if (foo) return bar; else return baz;") |
032a4c0f JP |
3122 | # if the previous line is a break or return and is indented 1 tab more... |
3123 | if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) { | |
3124 | my $tabs = length($1) + 1; | |
840080a0 JP |
3125 | if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ || |
3126 | ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ && | |
3127 | defined $lines[$linenr] && | |
3128 | $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) { | |
032a4c0f JP |
3129 | WARN("UNNECESSARY_ELSE", |
3130 | "else is not generally useful after a break or return\n" . $hereprev); | |
3131 | } | |
3132 | } | |
3133 | ||
c00df19a JP |
3134 | # check indentation of a line with a break; |
3135 | # if the previous line is a goto or return and is indented the same # of tabs | |
3136 | if ($sline =~ /^\+([\t]+)break\s*;\s*$/) { | |
3137 | my $tabs = $1; | |
3138 | if ($prevline =~ /^\+$tabs(?:goto|return)\b/) { | |
3139 | WARN("UNNECESSARY_BREAK", | |
3140 | "break is not useful after a goto or return\n" . $hereprev); | |
3141 | } | |
3142 | } | |
3143 | ||
1ba8dfd1 KC |
3144 | # discourage the addition of CONFIG_EXPERIMENTAL in #if(def). |
3145 | if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) { | |
3146 | WARN("CONFIG_EXPERIMENTAL", | |
3147 | "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n"); | |
3148 | } | |
3149 | ||
c2fdda0d | 3150 | # check for RCS/CVS revision markers |
cf655043 | 3151 | if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) { |
000d1cc1 JP |
3152 | WARN("CVS_KEYWORD", |
3153 | "CVS style keyword markers, these will _not_ be updated\n". $herecurr); | |
c2fdda0d | 3154 | } |
22f2a2ef | 3155 | |
42e41c54 MF |
3156 | # Blackfin: don't use __builtin_bfin_[cs]sync |
3157 | if ($line =~ /__builtin_bfin_csync/) { | |
3158 | my $herevet = "$here\n" . cat_vet($line) . "\n"; | |
000d1cc1 JP |
3159 | ERROR("CSYNC", |
3160 | "use the CSYNC() macro in asm/blackfin.h\n" . $herevet); | |
42e41c54 MF |
3161 | } |
3162 | if ($line =~ /__builtin_bfin_ssync/) { | |
3163 | my $herevet = "$here\n" . cat_vet($line) . "\n"; | |
000d1cc1 JP |
3164 | ERROR("SSYNC", |
3165 | "use the SSYNC() macro in asm/blackfin.h\n" . $herevet); | |
42e41c54 MF |
3166 | } |
3167 | ||
56e77d70 JP |
3168 | # check for old HOTPLUG __dev<foo> section markings |
3169 | if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) { | |
3170 | WARN("HOTPLUG_SECTION", | |
3171 | "Using $1 is unnecessary\n" . $herecurr); | |
3172 | } | |
3173 | ||
9c0ca6f9 | 3174 | # Check for potential 'bare' types |
2b474a1a AW |
3175 | my ($stat, $cond, $line_nr_next, $remain_next, $off_next, |
3176 | $realline_next); | |
3e469cdc AW |
3177 | #print "LINE<$line>\n"; |
3178 | if ($linenr >= $suppress_statement && | |
1b5539b1 | 3179 | $realcnt && $sline =~ /.\s*\S/) { |
170d3a22 | 3180 | ($stat, $cond, $line_nr_next, $remain_next, $off_next) = |
f5fe35dd | 3181 | ctx_statement_block($linenr, $realcnt, 0); |
171ae1a4 AW |
3182 | $stat =~ s/\n./\n /g; |
3183 | $cond =~ s/\n./\n /g; | |
3184 | ||
3e469cdc AW |
3185 | #print "linenr<$linenr> <$stat>\n"; |
3186 | # If this statement has no statement boundaries within | |
3187 | # it there is no point in retrying a statement scan | |
3188 | # until we hit end of it. | |
3189 | my $frag = $stat; $frag =~ s/;+\s*$//; | |
3190 | if ($frag !~ /(?:{|;)/) { | |
3191 | #print "skip<$line_nr_next>\n"; | |
3192 | $suppress_statement = $line_nr_next; | |
3193 | } | |
f74bd194 | 3194 | |
2b474a1a AW |
3195 | # Find the real next line. |
3196 | $realline_next = $line_nr_next; | |
3197 | if (defined $realline_next && | |
3198 | (!defined $lines[$realline_next - 1] || | |
3199 | substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) { | |
3200 | $realline_next++; | |
3201 | } | |
3202 | ||
171ae1a4 AW |
3203 | my $s = $stat; |
3204 | $s =~ s/{.*$//s; | |
cf655043 | 3205 | |
c2fdda0d | 3206 | # Ignore goto labels. |
171ae1a4 | 3207 | if ($s =~ /$Ident:\*$/s) { |
c2fdda0d AW |
3208 | |
3209 | # Ignore functions being called | |
171ae1a4 | 3210 | } elsif ($s =~ /^.\s*$Ident\s*\(/s) { |
c2fdda0d | 3211 | |
463f2864 AW |
3212 | } elsif ($s =~ /^.\s*else\b/s) { |
3213 | ||
c45dcabd | 3214 | # declarations always start with types |
d2506586 | 3215 | } elsif ($prev_values eq 'E' && $s =~ /^.\s*(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?((?:\s*$Ident)+?)\b(?:\s+$Sparse)?\s*\**\s*(?:$Ident|\(\*[^\)]*\))(?:\s*$Modifier)?\s*(?:;|=|,|\()/s) { |
c45dcabd AW |
3216 | my $type = $1; |
3217 | $type =~ s/\s+/ /g; | |
3218 | possible($type, "A:" . $s); | |
3219 | ||
8905a67c | 3220 | # definitions in global scope can only start with types |
a6a84062 | 3221 | } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) { |
c45dcabd | 3222 | possible($1, "B:" . $s); |
c2fdda0d | 3223 | } |
8905a67c AW |
3224 | |
3225 | # any (foo ... *) is a pointer cast, and foo is a type | |
65863862 | 3226 | while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) { |
c45dcabd | 3227 | possible($1, "C:" . $s); |
8905a67c AW |
3228 | } |
3229 | ||
3230 | # Check for any sort of function declaration. | |
3231 | # int foo(something bar, other baz); | |
3232 | # void (*store_gdt)(x86_descr_ptr *); | |
171ae1a4 | 3233 | if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) { |
8905a67c | 3234 | my ($name_len) = length($1); |
8905a67c | 3235 | |
cf655043 | 3236 | my $ctx = $s; |
773647a0 | 3237 | substr($ctx, 0, $name_len + 1, ''); |
8905a67c | 3238 | $ctx =~ s/\)[^\)]*$//; |
cf655043 | 3239 | |
8905a67c | 3240 | for my $arg (split(/\s*,\s*/, $ctx)) { |
c45dcabd | 3241 | if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) { |
8905a67c | 3242 | |
c45dcabd | 3243 | possible($1, "D:" . $s); |
8905a67c AW |
3244 | } |
3245 | } | |
9c0ca6f9 | 3246 | } |
8905a67c | 3247 | |
9c0ca6f9 AW |
3248 | } |
3249 | ||
653d4876 AW |
3250 | # |
3251 | # Checks which may be anchored in the context. | |
3252 | # | |
00df344f | 3253 | |
653d4876 AW |
3254 | # Check for switch () and associated case and default |
3255 | # statements should be at the same indent. | |
00df344f AW |
3256 | if ($line=~/\bswitch\s*\(.*\)/) { |
3257 | my $err = ''; | |
3258 | my $sep = ''; | |
3259 | my @ctx = ctx_block_outer($linenr, $realcnt); | |
3260 | shift(@ctx); | |
3261 | for my $ctx (@ctx) { | |
3262 | my ($clen, $cindent) = line_stats($ctx); | |
3263 | if ($ctx =~ /^\+\s*(case\s+|default:)/ && | |
3264 | $indent != $cindent) { | |
3265 | $err .= "$sep$ctx\n"; | |
3266 | $sep = ''; | |
3267 | } else { | |
3268 | $sep = "[...]\n"; | |
3269 | } | |
3270 | } | |
3271 | if ($err ne '') { | |
000d1cc1 JP |
3272 | ERROR("SWITCH_CASE_INDENT_LEVEL", |
3273 | "switch and case should be at the same indent\n$hereline$err"); | |
de7d4f0e AW |
3274 | } |
3275 | } | |
3276 | ||
3277 | # if/while/etc brace do not go on next line, unless defining a do while loop, | |
3278 | # or if that brace on the next line is for something else | |
0fe3dc2b | 3279 | if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) { |
773647a0 AW |
3280 | my $pre_ctx = "$1$2"; |
3281 | ||
9c0ca6f9 | 3282 | my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0); |
8eef05dd JP |
3283 | |
3284 | if ($line =~ /^\+\t{6,}/) { | |
3285 | WARN("DEEP_INDENTATION", | |
3286 | "Too many leading tabs - consider code refactoring\n" . $herecurr); | |
3287 | } | |
3288 | ||
de7d4f0e AW |
3289 | my $ctx_cnt = $realcnt - $#ctx - 1; |
3290 | my $ctx = join("\n", @ctx); | |
3291 | ||
548596d5 AW |
3292 | my $ctx_ln = $linenr; |
3293 | my $ctx_skip = $realcnt; | |
773647a0 | 3294 | |
548596d5 AW |
3295 | while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt && |
3296 | defined $lines[$ctx_ln - 1] && | |
3297 | $lines[$ctx_ln - 1] =~ /^-/)) { | |
3298 | ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n"; | |
3299 | $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/); | |
de7d4f0e | 3300 | $ctx_ln++; |
de7d4f0e | 3301 | } |
548596d5 | 3302 | |
53210168 AW |
3303 | #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n"; |
3304 | #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n"; | |
de7d4f0e | 3305 | |
d752fcc8 | 3306 | if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) { |
000d1cc1 JP |
3307 | ERROR("OPEN_BRACE", |
3308 | "that open brace { should be on the previous line\n" . | |
01464f30 | 3309 | "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n"); |
00df344f | 3310 | } |
773647a0 AW |
3311 | if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ && |
3312 | $ctx =~ /\)\s*\;\s*$/ && | |
3313 | defined $lines[$ctx_ln - 1]) | |
3314 | { | |
9c0ca6f9 AW |
3315 | my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]); |
3316 | if ($nindent > $indent) { | |
000d1cc1 JP |
3317 | WARN("TRAILING_SEMICOLON", |
3318 | "trailing semicolon indicates no statements, indent implies otherwise\n" . | |
01464f30 | 3319 | "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n"); |
9c0ca6f9 AW |
3320 | } |
3321 | } | |
00df344f AW |
3322 | } |
3323 | ||
4d001e4d | 3324 | # Check relative indent for conditionals and blocks. |
0fe3dc2b | 3325 | if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) { |
3e469cdc AW |
3326 | ($stat, $cond, $line_nr_next, $remain_next, $off_next) = |
3327 | ctx_statement_block($linenr, $realcnt, 0) | |
3328 | if (!defined $stat); | |
4d001e4d AW |
3329 | my ($s, $c) = ($stat, $cond); |
3330 | ||
3331 | substr($s, 0, length($c), ''); | |
3332 | ||
9f5af480 JP |
3333 | # remove inline comments |
3334 | $s =~ s/$;/ /g; | |
3335 | $c =~ s/$;/ /g; | |
4d001e4d AW |
3336 | |
3337 | # Find out how long the conditional actually is. | |
6f779c18 AW |
3338 | my @newlines = ($c =~ /\n/gs); |
3339 | my $cond_lines = 1 + $#newlines; | |
4d001e4d | 3340 | |
9f5af480 JP |
3341 | # Make sure we remove the line prefixes as we have |
3342 | # none on the first line, and are going to readd them | |
3343 | # where necessary. | |
3344 | $s =~ s/\n./\n/gs; | |
3345 | while ($s =~ /\n\s+\\\n/) { | |
3346 | $cond_lines += $s =~ s/\n\s+\\\n/\n/g; | |
3347 | } | |
3348 | ||
4d001e4d AW |
3349 | # We want to check the first line inside the block |
3350 | # starting at the end of the conditional, so remove: | |
3351 | # 1) any blank line termination | |
3352 | # 2) any opening brace { on end of the line | |
3353 | # 3) any do (...) { | |
3354 | my $continuation = 0; | |
3355 | my $check = 0; | |
3356 | $s =~ s/^.*\bdo\b//; | |
3357 | $s =~ s/^\s*{//; | |
3358 | if ($s =~ s/^\s*\\//) { | |
3359 | $continuation = 1; | |
3360 | } | |
9bd49efe | 3361 | if ($s =~ s/^\s*?\n//) { |
4d001e4d AW |
3362 | $check = 1; |
3363 | $cond_lines++; | |
3364 | } | |
3365 | ||
3366 | # Also ignore a loop construct at the end of a | |
3367 | # preprocessor statement. | |
3368 | if (($prevline =~ /^.\s*#\s*define\s/ || | |
3369 | $prevline =~ /\\\s*$/) && $continuation == 0) { | |
3370 | $check = 0; | |
3371 | } | |
3372 | ||
9bd49efe | 3373 | my $cond_ptr = -1; |
740504c6 | 3374 | $continuation = 0; |
9bd49efe AW |
3375 | while ($cond_ptr != $cond_lines) { |
3376 | $cond_ptr = $cond_lines; | |
3377 | ||
f16fa28f AW |
3378 | # If we see an #else/#elif then the code |
3379 | # is not linear. | |
3380 | if ($s =~ /^\s*\#\s*(?:else|elif)/) { | |
3381 | $check = 0; | |
3382 | } | |
3383 | ||
9bd49efe AW |
3384 | # Ignore: |
3385 | # 1) blank lines, they should be at 0, | |
3386 | # 2) preprocessor lines, and | |
3387 | # 3) labels. | |
740504c6 AW |
3388 | if ($continuation || |
3389 | $s =~ /^\s*?\n/ || | |
9bd49efe AW |
3390 | $s =~ /^\s*#\s*?/ || |
3391 | $s =~ /^\s*$Ident\s*:/) { | |
740504c6 | 3392 | $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0; |
30dad6eb AW |
3393 | if ($s =~ s/^.*?\n//) { |
3394 | $cond_lines++; | |
3395 | } | |
9bd49efe | 3396 | } |
4d001e4d AW |
3397 | } |
3398 | ||
3399 | my (undef, $sindent) = line_stats("+" . $s); | |
3400 | my $stat_real = raw_line($linenr, $cond_lines); | |
3401 | ||
3402 | # Check if either of these lines are modified, else | |
3403 | # this is not this patch's fault. | |
3404 | if (!defined($stat_real) || | |
3405 | $stat !~ /^\+/ && $stat_real !~ /^\+/) { | |
3406 | $check = 0; | |
3407 | } | |
3408 | if (defined($stat_real) && $cond_lines > 1) { | |
3409 | $stat_real = "[...]\n$stat_real"; | |
3410 | } | |
3411 | ||
9bd49efe | 3412 | #print "line<$line> prevline<$prevline> indent<$indent> sindent<$sindent> check<$check> continuation<$continuation> s<$s> cond_lines<$cond_lines> stat_real<$stat_real> stat<$stat>\n"; |
4d001e4d | 3413 | |
9f5af480 JP |
3414 | if ($check && $s ne '' && |
3415 | (($sindent % 8) != 0 || | |
3416 | ($sindent < $indent) || | |
3417 | ($sindent > $indent + 8))) { | |
000d1cc1 JP |
3418 | WARN("SUSPECT_CODE_INDENT", |
3419 | "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n"); | |
4d001e4d AW |
3420 | } |
3421 | } | |
3422 | ||
6c72ffaa AW |
3423 | # Track the 'values' across context and added lines. |
3424 | my $opline = $line; $opline =~ s/^./ /; | |
1f65f947 AW |
3425 | my ($curr_values, $curr_vars) = |
3426 | annotate_values($opline . "\n", $prev_values); | |
6c72ffaa | 3427 | $curr_values = $prev_values . $curr_values; |
c2fdda0d AW |
3428 | if ($dbg_values) { |
3429 | my $outline = $opline; $outline =~ s/\t/ /g; | |
cf655043 AW |
3430 | print "$linenr > .$outline\n"; |
3431 | print "$linenr > $curr_values\n"; | |
1f65f947 | 3432 | print "$linenr > $curr_vars\n"; |
c2fdda0d | 3433 | } |
6c72ffaa AW |
3434 | $prev_values = substr($curr_values, -1); |
3435 | ||
00df344f | 3436 | #ignore lines not being added |
3705ce5b | 3437 | next if ($line =~ /^[^\+]/); |
00df344f | 3438 | |
a1ce18e4 | 3439 | # check for declarations of signed or unsigned without int |
c8447115 | 3440 | while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) { |
a1ce18e4 JP |
3441 | my $type = $1; |
3442 | my $var = $2; | |
207a8e84 JP |
3443 | $var = "" if (!defined $var); |
3444 | if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) { | |
a1ce18e4 JP |
3445 | my $sign = $1; |
3446 | my $pointer = $2; | |
3447 | ||
3448 | $pointer = "" if (!defined $pointer); | |
3449 | ||
3450 | if (WARN("UNSPECIFIED_INT", | |
3451 | "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) && | |
3452 | $fix) { | |
3453 | my $decl = trim($sign) . " int "; | |
207a8e84 JP |
3454 | my $comp_pointer = $pointer; |
3455 | $comp_pointer =~ s/\s//g; | |
3456 | $decl .= $comp_pointer; | |
3457 | $decl = rtrim($decl) if ($var eq ""); | |
3458 | $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@; | |
a1ce18e4 JP |
3459 | } |
3460 | } | |
3461 | } | |
3462 | ||
653d4876 | 3463 | # TEST: allow direct testing of the type matcher. |
7429c690 AW |
3464 | if ($dbg_type) { |
3465 | if ($line =~ /^.\s*$Declare\s*$/) { | |
000d1cc1 JP |
3466 | ERROR("TEST_TYPE", |
3467 | "TEST: is type\n" . $herecurr); | |
7429c690 | 3468 | } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) { |
000d1cc1 JP |
3469 | ERROR("TEST_NOT_TYPE", |
3470 | "TEST: is not type ($1 is)\n". $herecurr); | |
7429c690 | 3471 | } |
653d4876 AW |
3472 | next; |
3473 | } | |
a1ef277e AW |
3474 | # TEST: allow direct testing of the attribute matcher. |
3475 | if ($dbg_attr) { | |
9360b0e5 | 3476 | if ($line =~ /^.\s*$Modifier\s*$/) { |
000d1cc1 JP |
3477 | ERROR("TEST_ATTR", |
3478 | "TEST: is attr\n" . $herecurr); | |
9360b0e5 | 3479 | } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) { |
000d1cc1 JP |
3480 | ERROR("TEST_NOT_ATTR", |
3481 | "TEST: is not attr ($1 is)\n". $herecurr); | |
a1ef277e AW |
3482 | } |
3483 | next; | |
3484 | } | |
653d4876 | 3485 | |
f0a594c1 | 3486 | # check for initialisation to aggregates open brace on the next line |
99423c20 AW |
3487 | if ($line =~ /^.\s*{/ && |
3488 | $prevline =~ /(?:^|[^=])=\s*$/) { | |
d752fcc8 JP |
3489 | if (ERROR("OPEN_BRACE", |
3490 | "that open brace { should be on the previous line\n" . $hereprev) && | |
f2d7e4d4 JP |
3491 | $fix && $prevline =~ /^\+/ && $line =~ /^\+/) { |
3492 | fix_delete_line($fixlinenr - 1, $prevrawline); | |
3493 | fix_delete_line($fixlinenr, $rawline); | |
d752fcc8 JP |
3494 | my $fixedline = $prevrawline; |
3495 | $fixedline =~ s/\s*=\s*$/ = {/; | |
f2d7e4d4 | 3496 | fix_insert_line($fixlinenr, $fixedline); |
d752fcc8 JP |
3497 | $fixedline = $line; |
3498 | $fixedline =~ s/^(.\s*){\s*/$1/; | |
f2d7e4d4 | 3499 | fix_insert_line($fixlinenr, $fixedline); |
d752fcc8 | 3500 | } |
f0a594c1 AW |
3501 | } |
3502 | ||
653d4876 AW |
3503 | # |
3504 | # Checks which are anchored on the added line. | |
3505 | # | |
3506 | ||
3507 | # check for malformed paths in #include statements (uses RAW line) | |
c45dcabd | 3508 | if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) { |
653d4876 AW |
3509 | my $path = $1; |
3510 | if ($path =~ m{//}) { | |
000d1cc1 | 3511 | ERROR("MALFORMED_INCLUDE", |
495e9d84 JP |
3512 | "malformed #include filename\n" . $herecurr); |
3513 | } | |
3514 | if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) { | |
3515 | ERROR("UAPI_INCLUDE", | |
3516 | "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr); | |
653d4876 | 3517 | } |
653d4876 | 3518 | } |
00df344f | 3519 | |
0a920b5b | 3520 | # no C99 // comments |
00df344f | 3521 | if ($line =~ m{//}) { |
3705ce5b JP |
3522 | if (ERROR("C99_COMMENTS", |
3523 | "do not use C99 // comments\n" . $herecurr) && | |
3524 | $fix) { | |
194f66fc | 3525 | my $line = $fixed[$fixlinenr]; |
3705ce5b JP |
3526 | if ($line =~ /\/\/(.*)$/) { |
3527 | my $comment = trim($1); | |
194f66fc | 3528 | $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@; |
3705ce5b JP |
3529 | } |
3530 | } | |
0a920b5b | 3531 | } |
00df344f | 3532 | # Remove C99 comments. |
0a920b5b | 3533 | $line =~ s@//.*@@; |
6c72ffaa | 3534 | $opline =~ s@//.*@@; |
0a920b5b | 3535 | |
2b474a1a AW |
3536 | # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider |
3537 | # the whole statement. | |
3538 | #print "APW <$lines[$realline_next - 1]>\n"; | |
3539 | if (defined $realline_next && | |
3540 | exists $lines[$realline_next - 1] && | |
3541 | !defined $suppress_export{$realline_next} && | |
3542 | ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ || | |
3543 | $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) { | |
3cbf62df AW |
3544 | # Handle definitions which produce identifiers with |
3545 | # a prefix: | |
3546 | # XXX(foo); | |
3547 | # EXPORT_SYMBOL(something_foo); | |
653d4876 | 3548 | my $name = $1; |
87a53877 | 3549 | if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ && |
3cbf62df AW |
3550 | $name =~ /^${Ident}_$2/) { |
3551 | #print "FOO C name<$name>\n"; | |
3552 | $suppress_export{$realline_next} = 1; | |
3553 | ||
3554 | } elsif ($stat !~ /(?: | |
2b474a1a | 3555 | \n.}\s*$| |
48012058 AW |
3556 | ^.DEFINE_$Ident\(\Q$name\E\)| |
3557 | ^.DECLARE_$Ident\(\Q$name\E\)| | |
3558 | ^.LIST_HEAD\(\Q$name\E\)| | |
2b474a1a AW |
3559 | ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(| |
3560 | \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\() | |
48012058 | 3561 | )/x) { |
2b474a1a AW |
3562 | #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n"; |
3563 | $suppress_export{$realline_next} = 2; | |
3564 | } else { | |
3565 | $suppress_export{$realline_next} = 1; | |
0a920b5b AW |
3566 | } |
3567 | } | |
2b474a1a AW |
3568 | if (!defined $suppress_export{$linenr} && |
3569 | $prevline =~ /^.\s*$/ && | |
3570 | ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ || | |
3571 | $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) { | |
3572 | #print "FOO B <$lines[$linenr - 1]>\n"; | |
3573 | $suppress_export{$linenr} = 2; | |
3574 | } | |
3575 | if (defined $suppress_export{$linenr} && | |
3576 | $suppress_export{$linenr} == 2) { | |
000d1cc1 JP |
3577 | WARN("EXPORT_SYMBOL", |
3578 | "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr); | |
2b474a1a | 3579 | } |
0a920b5b | 3580 | |
5150bda4 | 3581 | # check for global initialisers. |
6d32f7a3 | 3582 | if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) { |
d5e616fc | 3583 | if (ERROR("GLOBAL_INITIALISERS", |
6d32f7a3 | 3584 | "do not initialise globals to $1\n" . $herecurr) && |
d5e616fc | 3585 | $fix) { |
6d32f7a3 | 3586 | $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/; |
d5e616fc | 3587 | } |
f0a594c1 | 3588 | } |
653d4876 | 3589 | # check for static initialisers. |
6d32f7a3 | 3590 | if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) { |
d5e616fc | 3591 | if (ERROR("INITIALISED_STATIC", |
6d32f7a3 | 3592 | "do not initialise statics to $1\n" . |
d5e616fc JP |
3593 | $herecurr) && |
3594 | $fix) { | |
6d32f7a3 | 3595 | $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/; |
d5e616fc | 3596 | } |
0a920b5b AW |
3597 | } |
3598 | ||
1813087d JP |
3599 | # check for misordered declarations of char/short/int/long with signed/unsigned |
3600 | while ($sline =~ m{(\b$TypeMisordered\b)}g) { | |
3601 | my $tmp = trim($1); | |
3602 | WARN("MISORDERED_TYPE", | |
3603 | "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr); | |
3604 | } | |
3605 | ||
cb710eca JP |
3606 | # check for static const char * arrays. |
3607 | if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) { | |
000d1cc1 JP |
3608 | WARN("STATIC_CONST_CHAR_ARRAY", |
3609 | "static const char * array should probably be static const char * const\n" . | |
cb710eca JP |
3610 | $herecurr); |
3611 | } | |
3612 | ||
3613 | # check for static char foo[] = "bar" declarations. | |
3614 | if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) { | |
000d1cc1 JP |
3615 | WARN("STATIC_CONST_CHAR_ARRAY", |
3616 | "static char array declaration should probably be static const char\n" . | |
cb710eca JP |
3617 | $herecurr); |
3618 | } | |
3619 | ||
ab7e23f3 JP |
3620 | # check for const <foo> const where <foo> is not a pointer or array type |
3621 | if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) { | |
3622 | my $found = $1; | |
3623 | if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) { | |
3624 | WARN("CONST_CONST", | |
3625 | "'const $found const *' should probably be 'const $found * const'\n" . $herecurr); | |
3626 | } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) { | |
3627 | WARN("CONST_CONST", | |
3628 | "'const $found const' should probably be 'const $found'\n" . $herecurr); | |
3629 | } | |
3630 | } | |
3631 | ||
9b0fa60d JP |
3632 | # check for non-global char *foo[] = {"bar", ...} declarations. |
3633 | if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) { | |
3634 | WARN("STATIC_CONST_CHAR_ARRAY", | |
3635 | "char * array declaration might be better as static const\n" . | |
3636 | $herecurr); | |
3637 | } | |
3638 | ||
b598b670 JP |
3639 | # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo) |
3640 | if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) { | |
3641 | my $array = $1; | |
3642 | if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) { | |
3643 | my $array_div = $1; | |
3644 | if (WARN("ARRAY_SIZE", | |
3645 | "Prefer ARRAY_SIZE($array)\n" . $herecurr) && | |
3646 | $fix) { | |
3647 | $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/; | |
3648 | } | |
3649 | } | |
3650 | } | |
3651 | ||
b36190c5 JP |
3652 | # check for function declarations without arguments like "int foo()" |
3653 | if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) { | |
3654 | if (ERROR("FUNCTION_WITHOUT_ARGS", | |
3655 | "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) && | |
3656 | $fix) { | |
194f66fc | 3657 | $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/; |
b36190c5 JP |
3658 | } |
3659 | } | |
3660 | ||
653d4876 AW |
3661 | # check for new typedefs, only function parameters and sparse annotations |
3662 | # make sense. | |
3663 | if ($line =~ /\btypedef\s/ && | |
8054576d | 3664 | $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ && |
c45dcabd | 3665 | $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ && |
8ed22cad | 3666 | $line !~ /\b$typeTypedefs\b/ && |
653d4876 | 3667 | $line !~ /\b__bitwise(?:__|)\b/) { |
000d1cc1 JP |
3668 | WARN("NEW_TYPEDEFS", |
3669 | "do not add new typedefs\n" . $herecurr); | |
0a920b5b AW |
3670 | } |
3671 | ||
3672 | # * goes on variable not on type | |
65863862 | 3673 | # (char*[ const]) |
bfcb2cc7 AW |
3674 | while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) { |
3675 | #print "AA<$1>\n"; | |
3705ce5b | 3676 | my ($ident, $from, $to) = ($1, $2, $2); |
65863862 AW |
3677 | |
3678 | # Should start with a space. | |
3679 | $to =~ s/^(\S)/ $1/; | |
3680 | # Should not end with a space. | |
3681 | $to =~ s/\s+$//; | |
3682 | # '*'s should not have spaces between. | |
f9a0b3d1 | 3683 | while ($to =~ s/\*\s+\*/\*\*/) { |
65863862 | 3684 | } |
d8aaf121 | 3685 | |
3705ce5b | 3686 | ## print "1: from<$from> to<$to> ident<$ident>\n"; |
65863862 | 3687 | if ($from ne $to) { |
3705ce5b JP |
3688 | if (ERROR("POINTER_LOCATION", |
3689 | "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) && | |
3690 | $fix) { | |
3691 | my $sub_from = $ident; | |
3692 | my $sub_to = $ident; | |
3693 | $sub_to =~ s/\Q$from\E/$to/; | |
194f66fc | 3694 | $fixed[$fixlinenr] =~ |
3705ce5b JP |
3695 | s@\Q$sub_from\E@$sub_to@; |
3696 | } | |
65863862 | 3697 | } |
bfcb2cc7 AW |
3698 | } |
3699 | while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) { | |
3700 | #print "BB<$1>\n"; | |
3705ce5b | 3701 | my ($match, $from, $to, $ident) = ($1, $2, $2, $3); |
65863862 AW |
3702 | |
3703 | # Should start with a space. | |
3704 | $to =~ s/^(\S)/ $1/; | |
3705 | # Should not end with a space. | |
3706 | $to =~ s/\s+$//; | |
3707 | # '*'s should not have spaces between. | |
f9a0b3d1 | 3708 | while ($to =~ s/\*\s+\*/\*\*/) { |
65863862 AW |
3709 | } |
3710 | # Modifiers should have spaces. | |
3711 | $to =~ s/(\b$Modifier$)/$1 /; | |
d8aaf121 | 3712 | |
3705ce5b | 3713 | ## print "2: from<$from> to<$to> ident<$ident>\n"; |
667026e7 | 3714 | if ($from ne $to && $ident !~ /^$Modifier$/) { |
3705ce5b JP |
3715 | if (ERROR("POINTER_LOCATION", |
3716 | "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) && | |
3717 | $fix) { | |
3718 | ||
3719 | my $sub_from = $match; | |
3720 | my $sub_to = $match; | |
3721 | $sub_to =~ s/\Q$from\E/$to/; | |
194f66fc | 3722 | $fixed[$fixlinenr] =~ |
3705ce5b JP |
3723 | s@\Q$sub_from\E@$sub_to@; |
3724 | } | |
65863862 | 3725 | } |
0a920b5b AW |
3726 | } |
3727 | ||
9d3e3c70 JP |
3728 | # avoid BUG() or BUG_ON() |
3729 | if ($line =~ /\b(?:BUG|BUG_ON)\b/) { | |
3730 | my $msg_type = \&WARN; | |
3731 | $msg_type = \&CHK if ($file); | |
3732 | &{$msg_type}("AVOID_BUG", | |
3733 | "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr); | |
3734 | } | |
0a920b5b | 3735 | |
9d3e3c70 | 3736 | # avoid LINUX_VERSION_CODE |
8905a67c | 3737 | if ($line =~ /\bLINUX_VERSION_CODE\b/) { |
000d1cc1 JP |
3738 | WARN("LINUX_VERSION_CODE", |
3739 | "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr); | |
8905a67c AW |
3740 | } |
3741 | ||
17441227 JP |
3742 | # check for uses of printk_ratelimit |
3743 | if ($line =~ /\bprintk_ratelimit\s*\(/) { | |
000d1cc1 | 3744 | WARN("PRINTK_RATELIMITED", |
101ee680 | 3745 | "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr); |
17441227 JP |
3746 | } |
3747 | ||
00df344f AW |
3748 | # printk should use KERN_* levels. Note that follow on printk's on the |
3749 | # same line do not need a level, so we use the current block context | |
3750 | # to try and find and validate the current printk. In summary the current | |
25985edc | 3751 | # printk includes all preceding printk's which have no newline on the end. |
00df344f | 3752 | # we assume the first bad printk is the one to report. |
f0a594c1 | 3753 | if ($line =~ /\bprintk\((?!KERN_)\s*"/) { |
00df344f AW |
3754 | my $ok = 0; |
3755 | for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) { | |
3756 | #print "CHECK<$lines[$ln - 1]\n"; | |
25985edc | 3757 | # we have a preceding printk if it ends |
00df344f AW |
3758 | # with "\n" ignore it, else it is to blame |
3759 | if ($lines[$ln - 1] =~ m{\bprintk\(}) { | |
3760 | if ($rawlines[$ln - 1] !~ m{\\n"}) { | |
3761 | $ok = 1; | |
3762 | } | |
3763 | last; | |
3764 | } | |
3765 | } | |
3766 | if ($ok == 0) { | |
000d1cc1 JP |
3767 | WARN("PRINTK_WITHOUT_KERN_LEVEL", |
3768 | "printk() should include KERN_ facility level\n" . $herecurr); | |
00df344f | 3769 | } |
0a920b5b AW |
3770 | } |
3771 | ||
243f3803 JP |
3772 | if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) { |
3773 | my $orig = $1; | |
3774 | my $level = lc($orig); | |
3775 | $level = "warn" if ($level eq "warning"); | |
8f26b837 JP |
3776 | my $level2 = $level; |
3777 | $level2 = "dbg" if ($level eq "debug"); | |
243f3803 | 3778 | WARN("PREFER_PR_LEVEL", |
daa8b059 | 3779 | "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr); |
243f3803 JP |
3780 | } |
3781 | ||
3782 | if ($line =~ /\bpr_warning\s*\(/) { | |
d5e616fc JP |
3783 | if (WARN("PREFER_PR_LEVEL", |
3784 | "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) && | |
3785 | $fix) { | |
194f66fc | 3786 | $fixed[$fixlinenr] =~ |
d5e616fc JP |
3787 | s/\bpr_warning\b/pr_warn/; |
3788 | } | |
243f3803 JP |
3789 | } |
3790 | ||
dc139313 JP |
3791 | if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) { |
3792 | my $orig = $1; | |
3793 | my $level = lc($orig); | |
3794 | $level = "warn" if ($level eq "warning"); | |
3795 | $level = "dbg" if ($level eq "debug"); | |
3796 | WARN("PREFER_DEV_LEVEL", | |
3797 | "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr); | |
3798 | } | |
3799 | ||
91c9afaf AL |
3800 | # ENOSYS means "bad syscall nr" and nothing else. This will have a small |
3801 | # number of false positives, but assembly files are not checked, so at | |
3802 | # least the arch entry code will not trigger this warning. | |
3803 | if ($line =~ /\bENOSYS\b/) { | |
3804 | WARN("ENOSYS", | |
3805 | "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr); | |
3806 | } | |
3807 | ||
653d4876 AW |
3808 | # function brace can't be on same line, except for #defines of do while, |
3809 | # or if closed on same line | |
8d182478 | 3810 | if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and |
4e5d56bd | 3811 | !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) { |
8d182478 JP |
3812 | if (ERROR("OPEN_BRACE", |
3813 | "open brace '{' following function declarations go on the next line\n" . $herecurr) && | |
3814 | $fix) { | |
3815 | fix_delete_line($fixlinenr, $rawline); | |
3816 | my $fixed_line = $rawline; | |
3817 | $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/; | |
3818 | my $line1 = $1; | |
3819 | my $line2 = $2; | |
3820 | fix_insert_line($fixlinenr, ltrim($line1)); | |
3821 | fix_insert_line($fixlinenr, "\+{"); | |
3822 | if ($line2 !~ /^\s*$/) { | |
3823 | fix_insert_line($fixlinenr, "\+\t" . trim($line2)); | |
3824 | } | |
3825 | } | |
0a920b5b | 3826 | } |
653d4876 | 3827 | |
8905a67c AW |
3828 | # open braces for enum, union and struct go on the same line. |
3829 | if ($line =~ /^.\s*{/ && | |
3830 | $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) { | |
8d182478 JP |
3831 | if (ERROR("OPEN_BRACE", |
3832 | "open brace '{' following $1 go on the same line\n" . $hereprev) && | |
3833 | $fix && $prevline =~ /^\+/ && $line =~ /^\+/) { | |
3834 | fix_delete_line($fixlinenr - 1, $prevrawline); | |
3835 | fix_delete_line($fixlinenr, $rawline); | |
3836 | my $fixedline = rtrim($prevrawline) . " {"; | |
3837 | fix_insert_line($fixlinenr, $fixedline); | |
3838 | $fixedline = $rawline; | |
3839 | $fixedline =~ s/^(.\s*){\s*/$1\t/; | |
3840 | if ($fixedline !~ /^\+\s*$/) { | |
3841 | fix_insert_line($fixlinenr, $fixedline); | |
3842 | } | |
3843 | } | |
8905a67c AW |
3844 | } |
3845 | ||
0c73b4eb | 3846 | # missing space after union, struct or enum definition |
3705ce5b JP |
3847 | if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) { |
3848 | if (WARN("SPACING", | |
3849 | "missing space after $1 definition\n" . $herecurr) && | |
3850 | $fix) { | |
194f66fc | 3851 | $fixed[$fixlinenr] =~ |
3705ce5b JP |
3852 | s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/; |
3853 | } | |
0c73b4eb AW |
3854 | } |
3855 | ||
31070b5d JP |
3856 | # Function pointer declarations |
3857 | # check spacing between type, funcptr, and args | |
3858 | # canonical declaration is "type (*funcptr)(args...)" | |
91f72e9c | 3859 | if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) { |
31070b5d JP |
3860 | my $declare = $1; |
3861 | my $pre_pointer_space = $2; | |
3862 | my $post_pointer_space = $3; | |
3863 | my $funcname = $4; | |
3864 | my $post_funcname_space = $5; | |
3865 | my $pre_args_space = $6; | |
3866 | ||
91f72e9c JP |
3867 | # the $Declare variable will capture all spaces after the type |
3868 | # so check it for a missing trailing missing space but pointer return types | |
3869 | # don't need a space so don't warn for those. | |
3870 | my $post_declare_space = ""; | |
3871 | if ($declare =~ /(\s+)$/) { | |
3872 | $post_declare_space = $1; | |
3873 | $declare = rtrim($declare); | |
3874 | } | |
3875 | if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) { | |
31070b5d JP |
3876 | WARN("SPACING", |
3877 | "missing space after return type\n" . $herecurr); | |
91f72e9c | 3878 | $post_declare_space = " "; |
31070b5d JP |
3879 | } |
3880 | ||
3881 | # unnecessary space "type (*funcptr)(args...)" | |
91f72e9c JP |
3882 | # This test is not currently implemented because these declarations are |
3883 | # equivalent to | |
3884 | # int foo(int bar, ...) | |
3885 | # and this is form shouldn't/doesn't generate a checkpatch warning. | |
3886 | # | |
3887 | # elsif ($declare =~ /\s{2,}$/) { | |
3888 | # WARN("SPACING", | |
3889 | # "Multiple spaces after return type\n" . $herecurr); | |
3890 | # } | |
31070b5d JP |
3891 | |
3892 | # unnecessary space "type ( *funcptr)(args...)" | |
3893 | if (defined $pre_pointer_space && | |
3894 | $pre_pointer_space =~ /^\s/) { | |
3895 | WARN("SPACING", | |
3896 | "Unnecessary space after function pointer open parenthesis\n" . $herecurr); | |
3897 | } | |
3898 | ||
3899 | # unnecessary space "type (* funcptr)(args...)" | |
3900 | if (defined $post_pointer_space && | |
3901 | $post_pointer_space =~ /^\s/) { | |
3902 | WARN("SPACING", | |
3903 | "Unnecessary space before function pointer name\n" . $herecurr); | |
3904 | } | |
3905 | ||
3906 | # unnecessary space "type (*funcptr )(args...)" | |
3907 | if (defined $post_funcname_space && | |
3908 | $post_funcname_space =~ /^\s/) { | |
3909 | WARN("SPACING", | |
3910 | "Unnecessary space after function pointer name\n" . $herecurr); | |
3911 | } | |
3912 | ||
3913 | # unnecessary space "type (*funcptr) (args...)" | |
3914 | if (defined $pre_args_space && | |
3915 | $pre_args_space =~ /^\s/) { | |
3916 | WARN("SPACING", | |
3917 | "Unnecessary space before function pointer arguments\n" . $herecurr); | |
3918 | } | |
3919 | ||
3920 | if (show_type("SPACING") && $fix) { | |
194f66fc | 3921 | $fixed[$fixlinenr] =~ |
91f72e9c | 3922 | s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex; |
31070b5d JP |
3923 | } |
3924 | } | |
3925 | ||
8d31cfce AW |
3926 | # check for spacing round square brackets; allowed: |
3927 | # 1. with a type on the left -- int [] a; | |
fe2a7dbc AW |
3928 | # 2. at the beginning of a line for slice initialisers -- [0...10] = 5, |
3929 | # 3. inside a curly brace -- = { [0...10] = 5 } | |
8d31cfce AW |
3930 | while ($line =~ /(.*?\s)\[/g) { |
3931 | my ($where, $prefix) = ($-[1], $1); | |
3932 | if ($prefix !~ /$Type\s+$/ && | |
fe2a7dbc | 3933 | ($where != 0 || $prefix !~ /^.\s+$/) && |
daebc534 | 3934 | $prefix !~ /[{,]\s+$/) { |
3705ce5b JP |
3935 | if (ERROR("BRACKET_SPACE", |
3936 | "space prohibited before open square bracket '['\n" . $herecurr) && | |
3937 | $fix) { | |
194f66fc | 3938 | $fixed[$fixlinenr] =~ |
3705ce5b JP |
3939 | s/^(\+.*?)\s+\[/$1\[/; |
3940 | } | |
8d31cfce AW |
3941 | } |
3942 | } | |
3943 | ||
f0a594c1 | 3944 | # check for spaces between functions and their parentheses. |
6c72ffaa | 3945 | while ($line =~ /($Ident)\s+\(/g) { |
c2fdda0d | 3946 | my $name = $1; |
773647a0 AW |
3947 | my $ctx_before = substr($line, 0, $-[1]); |
3948 | my $ctx = "$ctx_before$name"; | |
c2fdda0d AW |
3949 | |
3950 | # Ignore those directives where spaces _are_ permitted. | |
773647a0 AW |
3951 | if ($name =~ /^(?: |
3952 | if|for|while|switch|return|case| | |
3953 | volatile|__volatile__| | |
3954 | __attribute__|format|__extension__| | |
3955 | asm|__asm__)$/x) | |
3956 | { | |
c2fdda0d AW |
3957 | # cpp #define statements have non-optional spaces, ie |
3958 | # if there is a space between the name and the open | |
3959 | # parenthesis it is simply not a parameter group. | |
c45dcabd | 3960 | } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) { |
773647a0 AW |
3961 | |
3962 | # cpp #elif statement condition may start with a ( | |
c45dcabd | 3963 | } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) { |
c2fdda0d AW |
3964 | |
3965 | # If this whole things ends with a type its most | |
3966 | # likely a typedef for a function. | |
773647a0 | 3967 | } elsif ($ctx =~ /$Type$/) { |
c2fdda0d AW |
3968 | |
3969 | } else { | |
3705ce5b JP |
3970 | if (WARN("SPACING", |
3971 | "space prohibited between function name and open parenthesis '('\n" . $herecurr) && | |
3972 | $fix) { | |
194f66fc | 3973 | $fixed[$fixlinenr] =~ |
3705ce5b JP |
3974 | s/\b$name\s+\(/$name\(/; |
3975 | } | |
6c72ffaa | 3976 | } |
f0a594c1 | 3977 | } |
9a4cad4e | 3978 | |
653d4876 | 3979 | # Check operator spacing. |
0a920b5b | 3980 | if (!($line=~/\#\s*include/)) { |
3705ce5b JP |
3981 | my $fixed_line = ""; |
3982 | my $line_fixed = 0; | |
3983 | ||
9c0ca6f9 AW |
3984 | my $ops = qr{ |
3985 | <<=|>>=|<=|>=|==|!=| | |
3986 | \+=|-=|\*=|\/=|%=|\^=|\|=|&=| | |
3987 | =>|->|<<|>>|<|>|=|!|~| | |
1f65f947 | 3988 | &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%| |
84731623 | 3989 | \?:|\?|: |
9c0ca6f9 | 3990 | }x; |
cf655043 | 3991 | my @elements = split(/($ops|;)/, $opline); |
3705ce5b JP |
3992 | |
3993 | ## print("element count: <" . $#elements . ">\n"); | |
3994 | ## foreach my $el (@elements) { | |
3995 | ## print("el: <$el>\n"); | |
3996 | ## } | |
3997 | ||
3998 | my @fix_elements = (); | |
00df344f | 3999 | my $off = 0; |
6c72ffaa | 4000 | |
3705ce5b JP |
4001 | foreach my $el (@elements) { |
4002 | push(@fix_elements, substr($rawline, $off, length($el))); | |
4003 | $off += length($el); | |
4004 | } | |
4005 | ||
4006 | $off = 0; | |
4007 | ||
6c72ffaa | 4008 | my $blank = copy_spacing($opline); |
b34c648b | 4009 | my $last_after = -1; |
6c72ffaa | 4010 | |
0a920b5b | 4011 | for (my $n = 0; $n < $#elements; $n += 2) { |
3705ce5b JP |
4012 | |
4013 | my $good = $fix_elements[$n] . $fix_elements[$n + 1]; | |
4014 | ||
4015 | ## print("n: <$n> good: <$good>\n"); | |
4016 | ||
4a0df2ef AW |
4017 | $off += length($elements[$n]); |
4018 | ||
25985edc | 4019 | # Pick up the preceding and succeeding characters. |
773647a0 AW |
4020 | my $ca = substr($opline, 0, $off); |
4021 | my $cc = ''; | |
4022 | if (length($opline) >= ($off + length($elements[$n + 1]))) { | |
4023 | $cc = substr($opline, $off + length($elements[$n + 1])); | |
4024 | } | |
4025 | my $cb = "$ca$;$cc"; | |
4026 | ||
4a0df2ef AW |
4027 | my $a = ''; |
4028 | $a = 'V' if ($elements[$n] ne ''); | |
4029 | $a = 'W' if ($elements[$n] =~ /\s$/); | |
cf655043 | 4030 | $a = 'C' if ($elements[$n] =~ /$;$/); |
4a0df2ef AW |
4031 | $a = 'B' if ($elements[$n] =~ /(\[|\()$/); |
4032 | $a = 'O' if ($elements[$n] eq ''); | |
773647a0 | 4033 | $a = 'E' if ($ca =~ /^\s*$/); |
4a0df2ef | 4034 | |
0a920b5b | 4035 | my $op = $elements[$n + 1]; |
4a0df2ef AW |
4036 | |
4037 | my $c = ''; | |
0a920b5b | 4038 | if (defined $elements[$n + 2]) { |
4a0df2ef AW |
4039 | $c = 'V' if ($elements[$n + 2] ne ''); |
4040 | $c = 'W' if ($elements[$n + 2] =~ /^\s/); | |
cf655043 | 4041 | $c = 'C' if ($elements[$n + 2] =~ /^$;/); |
4a0df2ef AW |
4042 | $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/); |
4043 | $c = 'O' if ($elements[$n + 2] eq ''); | |
8b1b3378 | 4044 | $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/); |
4a0df2ef AW |
4045 | } else { |
4046 | $c = 'E'; | |
0a920b5b AW |
4047 | } |
4048 | ||
4a0df2ef AW |
4049 | my $ctx = "${a}x${c}"; |
4050 | ||
4051 | my $at = "(ctx:$ctx)"; | |
4052 | ||
6c72ffaa | 4053 | my $ptr = substr($blank, 0, $off) . "^"; |
de7d4f0e | 4054 | my $hereptr = "$hereline$ptr\n"; |
0a920b5b | 4055 | |
74048ed8 | 4056 | # Pull out the value of this operator. |
6c72ffaa | 4057 | my $op_type = substr($curr_values, $off + 1, 1); |
0a920b5b | 4058 | |
1f65f947 AW |
4059 | # Get the full operator variant. |
4060 | my $opv = $op . substr($curr_vars, $off, 1); | |
4061 | ||
13214adf AW |
4062 | # Ignore operators passed as parameters. |
4063 | if ($op_type ne 'V' && | |
d7fe8065 | 4064 | $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) { |
13214adf | 4065 | |
cf655043 AW |
4066 | # # Ignore comments |
4067 | # } elsif ($op =~ /^$;+$/) { | |
13214adf | 4068 | |
d8aaf121 | 4069 | # ; should have either the end of line or a space or \ after it |
13214adf | 4070 | } elsif ($op eq ';') { |
cf655043 AW |
4071 | if ($ctx !~ /.x[WEBC]/ && |
4072 | $cc !~ /^\\/ && $cc !~ /^;/) { | |
3705ce5b JP |
4073 | if (ERROR("SPACING", |
4074 | "space required after that '$op' $at\n" . $hereptr)) { | |
b34c648b | 4075 | $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " "; |
3705ce5b JP |
4076 | $line_fixed = 1; |
4077 | } | |
d8aaf121 AW |
4078 | } |
4079 | ||
4080 | # // is a comment | |
4081 | } elsif ($op eq '//') { | |
0a920b5b | 4082 | |
b00e4814 JP |
4083 | # : when part of a bitfield |
4084 | } elsif ($opv eq ':B') { | |
4085 | # skip the bitfield test for now | |
4086 | ||
1f65f947 AW |
4087 | # No spaces for: |
4088 | # -> | |
b00e4814 | 4089 | } elsif ($op eq '->') { |
4a0df2ef | 4090 | if ($ctx =~ /Wx.|.xW/) { |
3705ce5b JP |
4091 | if (ERROR("SPACING", |
4092 | "spaces prohibited around that '$op' $at\n" . $hereptr)) { | |
b34c648b | 4093 | $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]); |
3705ce5b JP |
4094 | if (defined $fix_elements[$n + 2]) { |
4095 | $fix_elements[$n + 2] =~ s/^\s+//; | |
4096 | } | |
b34c648b | 4097 | $line_fixed = 1; |
3705ce5b | 4098 | } |
0a920b5b AW |
4099 | } |
4100 | ||
2381097b | 4101 | # , must not have a space before and must have a space on the right. |
0a920b5b | 4102 | } elsif ($op eq ',') { |
2381097b JP |
4103 | my $rtrim_before = 0; |
4104 | my $space_after = 0; | |
4105 | if ($ctx =~ /Wx./) { | |
4106 | if (ERROR("SPACING", | |
4107 | "space prohibited before that '$op' $at\n" . $hereptr)) { | |
4108 | $line_fixed = 1; | |
4109 | $rtrim_before = 1; | |
4110 | } | |
4111 | } | |
cf655043 | 4112 | if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) { |
3705ce5b JP |
4113 | if (ERROR("SPACING", |
4114 | "space required after that '$op' $at\n" . $hereptr)) { | |
3705ce5b | 4115 | $line_fixed = 1; |
b34c648b | 4116 | $last_after = $n; |
2381097b JP |
4117 | $space_after = 1; |
4118 | } | |
4119 | } | |
4120 | if ($rtrim_before || $space_after) { | |
4121 | if ($rtrim_before) { | |
4122 | $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]); | |
4123 | } else { | |
4124 | $good = $fix_elements[$n] . trim($fix_elements[$n + 1]); | |
4125 | } | |
4126 | if ($space_after) { | |
4127 | $good .= " "; | |
3705ce5b | 4128 | } |
0a920b5b AW |
4129 | } |
4130 | ||
9c0ca6f9 | 4131 | # '*' as part of a type definition -- reported already. |
74048ed8 | 4132 | } elsif ($opv eq '*_') { |
9c0ca6f9 AW |
4133 | #warn "'*' is part of type\n"; |
4134 | ||
4135 | # unary operators should have a space before and | |
4136 | # none after. May be left adjacent to another | |
4137 | # unary operator, or a cast | |
4138 | } elsif ($op eq '!' || $op eq '~' || | |
74048ed8 | 4139 | $opv eq '*U' || $opv eq '-U' || |
0d413866 | 4140 | $opv eq '&U' || $opv eq '&&U') { |
cf655043 | 4141 | if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) { |
3705ce5b JP |
4142 | if (ERROR("SPACING", |
4143 | "space required before that '$op' $at\n" . $hereptr)) { | |
b34c648b JP |
4144 | if ($n != $last_after + 2) { |
4145 | $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]); | |
4146 | $line_fixed = 1; | |
4147 | } | |
3705ce5b | 4148 | } |
0a920b5b | 4149 | } |
a3340b35 | 4150 | if ($op eq '*' && $cc =~/\s*$Modifier\b/) { |
171ae1a4 AW |
4151 | # A unary '*' may be const |
4152 | ||
4153 | } elsif ($ctx =~ /.xW/) { | |
3705ce5b JP |
4154 | if (ERROR("SPACING", |
4155 | "space prohibited after that '$op' $at\n" . $hereptr)) { | |
b34c648b | 4156 | $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]); |
3705ce5b JP |
4157 | if (defined $fix_elements[$n + 2]) { |
4158 | $fix_elements[$n + 2] =~ s/^\s+//; | |
4159 | } | |
b34c648b | 4160 | $line_fixed = 1; |
3705ce5b | 4161 | } |
0a920b5b AW |
4162 | } |
4163 | ||
4164 | # unary ++ and unary -- are allowed no space on one side. | |
4165 | } elsif ($op eq '++' or $op eq '--') { | |
773647a0 | 4166 | if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) { |
3705ce5b JP |
4167 | if (ERROR("SPACING", |
4168 | "space required one side of that '$op' $at\n" . $hereptr)) { | |
b34c648b | 4169 | $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " "; |
3705ce5b JP |
4170 | $line_fixed = 1; |
4171 | } | |
773647a0 AW |
4172 | } |
4173 | if ($ctx =~ /Wx[BE]/ || | |
4174 | ($ctx =~ /Wx./ && $cc =~ /^;/)) { | |
3705ce5b JP |
4175 | if (ERROR("SPACING", |
4176 | "space prohibited before that '$op' $at\n" . $hereptr)) { | |
b34c648b | 4177 | $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]); |
3705ce5b JP |
4178 | $line_fixed = 1; |
4179 | } | |
0a920b5b | 4180 | } |
773647a0 | 4181 | if ($ctx =~ /ExW/) { |
3705ce5b JP |
4182 | if (ERROR("SPACING", |
4183 | "space prohibited after that '$op' $at\n" . $hereptr)) { | |
b34c648b | 4184 | $good = $fix_elements[$n] . trim($fix_elements[$n + 1]); |
3705ce5b JP |
4185 | if (defined $fix_elements[$n + 2]) { |
4186 | $fix_elements[$n + 2] =~ s/^\s+//; | |
4187 | } | |
b34c648b | 4188 | $line_fixed = 1; |
3705ce5b | 4189 | } |
653d4876 | 4190 | } |
0a920b5b | 4191 | |
0a920b5b | 4192 | # << and >> may either have or not have spaces both sides |
9c0ca6f9 AW |
4193 | } elsif ($op eq '<<' or $op eq '>>' or |
4194 | $op eq '&' or $op eq '^' or $op eq '|' or | |
4195 | $op eq '+' or $op eq '-' or | |
c2fdda0d AW |
4196 | $op eq '*' or $op eq '/' or |
4197 | $op eq '%') | |
0a920b5b | 4198 | { |
d2e025f3 JP |
4199 | if ($check) { |
4200 | if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) { | |
4201 | if (CHK("SPACING", | |
4202 | "spaces preferred around that '$op' $at\n" . $hereptr)) { | |
4203 | $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " "; | |
4204 | $fix_elements[$n + 2] =~ s/^\s+//; | |
4205 | $line_fixed = 1; | |
4206 | } | |
4207 | } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) { | |
4208 | if (CHK("SPACING", | |
4209 | "space preferred before that '$op' $at\n" . $hereptr)) { | |
4210 | $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]); | |
4211 | $line_fixed = 1; | |
4212 | } | |
4213 | } | |
4214 | } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) { | |
3705ce5b JP |
4215 | if (ERROR("SPACING", |
4216 | "need consistent spacing around '$op' $at\n" . $hereptr)) { | |
b34c648b JP |
4217 | $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " "; |
4218 | if (defined $fix_elements[$n + 2]) { | |
4219 | $fix_elements[$n + 2] =~ s/^\s+//; | |
4220 | } | |
3705ce5b JP |
4221 | $line_fixed = 1; |
4222 | } | |
0a920b5b AW |
4223 | } |
4224 | ||
1f65f947 AW |
4225 | # A colon needs no spaces before when it is |
4226 | # terminating a case value or a label. | |
4227 | } elsif ($opv eq ':C' || $opv eq ':L') { | |
4228 | if ($ctx =~ /Wx./) { | |
3705ce5b JP |
4229 | if (ERROR("SPACING", |
4230 | "space prohibited before that '$op' $at\n" . $hereptr)) { | |
b34c648b | 4231 | $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]); |
3705ce5b JP |
4232 | $line_fixed = 1; |
4233 | } | |
1f65f947 AW |
4234 | } |
4235 | ||
0a920b5b | 4236 | # All the others need spaces both sides. |
cf655043 | 4237 | } elsif ($ctx !~ /[EWC]x[CWE]/) { |
1f65f947 AW |
4238 | my $ok = 0; |
4239 | ||
22f2a2ef | 4240 | # Ignore email addresses <foo@bar> |
1f65f947 AW |
4241 | if (($op eq '<' && |
4242 | $cc =~ /^\S+\@\S+>/) || | |
4243 | ($op eq '>' && | |
4244 | $ca =~ /<\S+\@\S+$/)) | |
4245 | { | |
4246 | $ok = 1; | |
4247 | } | |
4248 | ||
e0df7e1f JP |
4249 | # for asm volatile statements |
4250 | # ignore a colon with another | |
4251 | # colon immediately before or after | |
4252 | if (($op eq ':') && | |
4253 | ($ca =~ /:$/ || $cc =~ /^:/)) { | |
4254 | $ok = 1; | |
4255 | } | |
4256 | ||
84731623 | 4257 | # messages are ERROR, but ?: are CHK |
1f65f947 | 4258 | if ($ok == 0) { |
84731623 JP |
4259 | my $msg_type = \&ERROR; |
4260 | $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/); | |
4261 | ||
4262 | if (&{$msg_type}("SPACING", | |
4263 | "spaces required around that '$op' $at\n" . $hereptr)) { | |
b34c648b JP |
4264 | $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " "; |
4265 | if (defined $fix_elements[$n + 2]) { | |
4266 | $fix_elements[$n + 2] =~ s/^\s+//; | |
4267 | } | |
3705ce5b JP |
4268 | $line_fixed = 1; |
4269 | } | |
22f2a2ef | 4270 | } |
0a920b5b | 4271 | } |
4a0df2ef | 4272 | $off += length($elements[$n + 1]); |
3705ce5b JP |
4273 | |
4274 | ## print("n: <$n> GOOD: <$good>\n"); | |
4275 | ||
4276 | $fixed_line = $fixed_line . $good; | |
4277 | } | |
4278 | ||
4279 | if (($#elements % 2) == 0) { | |
4280 | $fixed_line = $fixed_line . $fix_elements[$#elements]; | |
0a920b5b | 4281 | } |
3705ce5b | 4282 | |
194f66fc JP |
4283 | if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) { |
4284 | $fixed[$fixlinenr] = $fixed_line; | |
3705ce5b JP |
4285 | } |
4286 | ||
4287 | ||
0a920b5b AW |
4288 | } |
4289 | ||
786b6326 | 4290 | # check for whitespace before a non-naked semicolon |
d2e248e7 | 4291 | if ($line =~ /^\+.*\S\s+;\s*$/) { |
786b6326 JP |
4292 | if (WARN("SPACING", |
4293 | "space prohibited before semicolon\n" . $herecurr) && | |
4294 | $fix) { | |
194f66fc | 4295 | 1 while $fixed[$fixlinenr] =~ |
786b6326 JP |
4296 | s/^(\+.*\S)\s+;/$1;/; |
4297 | } | |
4298 | } | |
4299 | ||
f0a594c1 AW |
4300 | # check for multiple assignments |
4301 | if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) { | |
000d1cc1 JP |
4302 | CHK("MULTIPLE_ASSIGNMENTS", |
4303 | "multiple assignments should be avoided\n" . $herecurr); | |
f0a594c1 AW |
4304 | } |
4305 | ||
22f2a2ef AW |
4306 | ## # check for multiple declarations, allowing for a function declaration |
4307 | ## # continuation. | |
4308 | ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ && | |
4309 | ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) { | |
4310 | ## | |
4311 | ## # Remove any bracketed sections to ensure we do not | |
4312 | ## # falsly report the parameters of functions. | |
4313 | ## my $ln = $line; | |
4314 | ## while ($ln =~ s/\([^\(\)]*\)//g) { | |
4315 | ## } | |
4316 | ## if ($ln =~ /,/) { | |
000d1cc1 JP |
4317 | ## WARN("MULTIPLE_DECLARATION", |
4318 | ## "declaring multiple variables together should be avoided\n" . $herecurr); | |
22f2a2ef AW |
4319 | ## } |
4320 | ## } | |
f0a594c1 | 4321 | |
0a920b5b | 4322 | #need space before brace following if, while, etc |
6b8c69e4 | 4323 | if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) || |
4e5d56bd | 4324 | $line =~ /do\{/) { |
3705ce5b JP |
4325 | if (ERROR("SPACING", |
4326 | "space required before the open brace '{'\n" . $herecurr) && | |
4327 | $fix) { | |
194f66fc | 4328 | $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/; |
3705ce5b | 4329 | } |
de7d4f0e AW |
4330 | } |
4331 | ||
c4a62ef9 JP |
4332 | ## # check for blank lines before declarations |
4333 | ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ && | |
4334 | ## $prevrawline =~ /^.\s*$/) { | |
4335 | ## WARN("SPACING", | |
4336 | ## "No blank lines before declarations\n" . $hereprev); | |
4337 | ## } | |
4338 | ## | |
4339 | ||
de7d4f0e AW |
4340 | # closing brace should have a space following it when it has anything |
4341 | # on the line | |
4342 | if ($line =~ /}(?!(?:,|;|\)))\S/) { | |
d5e616fc JP |
4343 | if (ERROR("SPACING", |
4344 | "space required after that close brace '}'\n" . $herecurr) && | |
4345 | $fix) { | |
194f66fc | 4346 | $fixed[$fixlinenr] =~ |
d5e616fc JP |
4347 | s/}((?!(?:,|;|\)))\S)/} $1/; |
4348 | } | |
0a920b5b AW |
4349 | } |
4350 | ||
22f2a2ef AW |
4351 | # check spacing on square brackets |
4352 | if ($line =~ /\[\s/ && $line !~ /\[\s*$/) { | |
3705ce5b JP |
4353 | if (ERROR("SPACING", |
4354 | "space prohibited after that open square bracket '['\n" . $herecurr) && | |
4355 | $fix) { | |
194f66fc | 4356 | $fixed[$fixlinenr] =~ |
3705ce5b JP |
4357 | s/\[\s+/\[/; |
4358 | } | |
22f2a2ef AW |
4359 | } |
4360 | if ($line =~ /\s\]/) { | |
3705ce5b JP |
4361 | if (ERROR("SPACING", |
4362 | "space prohibited before that close square bracket ']'\n" . $herecurr) && | |
4363 | $fix) { | |
194f66fc | 4364 | $fixed[$fixlinenr] =~ |
3705ce5b JP |
4365 | s/\s+\]/\]/; |
4366 | } | |
22f2a2ef AW |
4367 | } |
4368 | ||
c45dcabd | 4369 | # check spacing on parentheses |
9c0ca6f9 AW |
4370 | if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ && |
4371 | $line !~ /for\s*\(\s+;/) { | |
3705ce5b JP |
4372 | if (ERROR("SPACING", |
4373 | "space prohibited after that open parenthesis '('\n" . $herecurr) && | |
4374 | $fix) { | |
194f66fc | 4375 | $fixed[$fixlinenr] =~ |
3705ce5b JP |
4376 | s/\(\s+/\(/; |
4377 | } | |
22f2a2ef | 4378 | } |
13214adf | 4379 | if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ && |
c45dcabd AW |
4380 | $line !~ /for\s*\(.*;\s+\)/ && |
4381 | $line !~ /:\s+\)/) { | |
3705ce5b JP |
4382 | if (ERROR("SPACING", |
4383 | "space prohibited before that close parenthesis ')'\n" . $herecurr) && | |
4384 | $fix) { | |
194f66fc | 4385 | $fixed[$fixlinenr] =~ |
3705ce5b JP |
4386 | s/\s+\)/\)/; |
4387 | } | |
22f2a2ef AW |
4388 | } |
4389 | ||
e2826fd0 JP |
4390 | # check unnecessary parentheses around addressof/dereference single $Lvals |
4391 | # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar | |
4392 | ||
4393 | while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) { | |
ea4acbb1 JP |
4394 | my $var = $1; |
4395 | if (CHK("UNNECESSARY_PARENTHESES", | |
4396 | "Unnecessary parentheses around $var\n" . $herecurr) && | |
4397 | $fix) { | |
4398 | $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/; | |
4399 | } | |
4400 | } | |
4401 | ||
4402 | # check for unnecessary parentheses around function pointer uses | |
4403 | # ie: (foo->bar)(); should be foo->bar(); | |
4404 | # but not "if (foo->bar) (" to avoid some false positives | |
4405 | if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) { | |
4406 | my $var = $2; | |
4407 | if (CHK("UNNECESSARY_PARENTHESES", | |
4408 | "Unnecessary parentheses around function pointer $var\n" . $herecurr) && | |
4409 | $fix) { | |
4410 | my $var2 = deparenthesize($var); | |
4411 | $var2 =~ s/\s//g; | |
4412 | $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/; | |
4413 | } | |
4414 | } | |
e2826fd0 | 4415 | |
0a920b5b | 4416 | #goto labels aren't indented, allow a single space however |
4a0df2ef | 4417 | if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and |
0a920b5b | 4418 | !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) { |
3705ce5b JP |
4419 | if (WARN("INDENTED_LABEL", |
4420 | "labels should not be indented\n" . $herecurr) && | |
4421 | $fix) { | |
194f66fc | 4422 | $fixed[$fixlinenr] =~ |
3705ce5b JP |
4423 | s/^(.)\s+/$1/; |
4424 | } | |
0a920b5b AW |
4425 | } |
4426 | ||
5b9553ab | 4427 | # return is not a function |
507e5141 | 4428 | if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) { |
c45dcabd | 4429 | my $spacing = $1; |
507e5141 | 4430 | if ($^V && $^V ge 5.10.0 && |
5b9553ab JP |
4431 | $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) { |
4432 | my $value = $1; | |
4433 | $value = deparenthesize($value); | |
4434 | if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) { | |
4435 | ERROR("RETURN_PARENTHESES", | |
4436 | "return is not a function, parentheses are not required\n" . $herecurr); | |
4437 | } | |
c45dcabd | 4438 | } elsif ($spacing !~ /\s+/) { |
000d1cc1 JP |
4439 | ERROR("SPACING", |
4440 | "space required before the open parenthesis '('\n" . $herecurr); | |
c45dcabd AW |
4441 | } |
4442 | } | |
507e5141 | 4443 | |
b43ae21b JP |
4444 | # unnecessary return in a void function |
4445 | # at end-of-function, with the previous line a single leading tab, then return; | |
4446 | # and the line before that not a goto label target like "out:" | |
4447 | if ($sline =~ /^[ \+]}\s*$/ && | |
4448 | $prevline =~ /^\+\treturn\s*;\s*$/ && | |
4449 | $linenr >= 3 && | |
4450 | $lines[$linenr - 3] =~ /^[ +]/ && | |
4451 | $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) { | |
9819cf25 | 4452 | WARN("RETURN_VOID", |
b43ae21b JP |
4453 | "void function return statements are not generally useful\n" . $hereprev); |
4454 | } | |
9819cf25 | 4455 | |
189248d8 JP |
4456 | # if statements using unnecessary parentheses - ie: if ((foo == bar)) |
4457 | if ($^V && $^V ge 5.10.0 && | |
4458 | $line =~ /\bif\s*((?:\(\s*){2,})/) { | |
4459 | my $openparens = $1; | |
4460 | my $count = $openparens =~ tr@\(@\(@; | |
4461 | my $msg = ""; | |
4462 | if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) { | |
4463 | my $comp = $4; #Not $1 because of $LvalOrFunc | |
4464 | $msg = " - maybe == should be = ?" if ($comp eq "=="); | |
4465 | WARN("UNNECESSARY_PARENTHESES", | |
4466 | "Unnecessary parentheses$msg\n" . $herecurr); | |
4467 | } | |
4468 | } | |
4469 | ||
c5595fa2 JP |
4470 | # comparisons with a constant or upper case identifier on the left |
4471 | # avoid cases like "foo + BAR < baz" | |
4472 | # only fix matches surrounded by parentheses to avoid incorrect | |
4473 | # conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5" | |
4474 | if ($^V && $^V ge 5.10.0 && | |
4475 | $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) { | |
4476 | my $lead = $1; | |
4477 | my $const = $2; | |
4478 | my $comp = $3; | |
4479 | my $to = $4; | |
4480 | my $newcomp = $comp; | |
f39e1769 | 4481 | if ($lead !~ /(?:$Operators|\.)\s*$/ && |
c5595fa2 JP |
4482 | $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ && |
4483 | WARN("CONSTANT_COMPARISON", | |
4484 | "Comparisons should place the constant on the right side of the test\n" . $herecurr) && | |
4485 | $fix) { | |
4486 | if ($comp eq "<") { | |
4487 | $newcomp = ">"; | |
4488 | } elsif ($comp eq "<=") { | |
4489 | $newcomp = ">="; | |
4490 | } elsif ($comp eq ">") { | |
4491 | $newcomp = "<"; | |
4492 | } elsif ($comp eq ">=") { | |
4493 | $newcomp = "<="; | |
4494 | } | |
4495 | $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/; | |
4496 | } | |
4497 | } | |
4498 | ||
f34e4a4f JP |
4499 | # Return of what appears to be an errno should normally be negative |
4500 | if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) { | |
53a3c448 AW |
4501 | my $name = $1; |
4502 | if ($name ne 'EOF' && $name ne 'ERROR') { | |
000d1cc1 | 4503 | WARN("USE_NEGATIVE_ERRNO", |
f34e4a4f | 4504 | "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr); |
53a3c448 AW |
4505 | } |
4506 | } | |
c45dcabd | 4507 | |
0a920b5b | 4508 | # Need a space before open parenthesis after if, while etc |
3705ce5b JP |
4509 | if ($line =~ /\b(if|while|for|switch)\(/) { |
4510 | if (ERROR("SPACING", | |
4511 | "space required before the open parenthesis '('\n" . $herecurr) && | |
4512 | $fix) { | |
194f66fc | 4513 | $fixed[$fixlinenr] =~ |
3705ce5b JP |
4514 | s/\b(if|while|for|switch)\(/$1 \(/; |
4515 | } | |
0a920b5b AW |
4516 | } |
4517 | ||
f5fe35dd AW |
4518 | # Check for illegal assignment in if conditional -- and check for trailing |
4519 | # statements after the conditional. | |
170d3a22 | 4520 | if ($line =~ /do\s*(?!{)/) { |
3e469cdc AW |
4521 | ($stat, $cond, $line_nr_next, $remain_next, $off_next) = |
4522 | ctx_statement_block($linenr, $realcnt, 0) | |
4523 | if (!defined $stat); | |
170d3a22 AW |
4524 | my ($stat_next) = ctx_statement_block($line_nr_next, |
4525 | $remain_next, $off_next); | |
4526 | $stat_next =~ s/\n./\n /g; | |
4527 | ##print "stat<$stat> stat_next<$stat_next>\n"; | |
4528 | ||
4529 | if ($stat_next =~ /^\s*while\b/) { | |
4530 | # If the statement carries leading newlines, | |
4531 | # then count those as offsets. | |
4532 | my ($whitespace) = | |
4533 | ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s); | |
4534 | my $offset = | |
4535 | statement_rawlines($whitespace) - 1; | |
4536 | ||
4537 | $suppress_whiletrailers{$line_nr_next + | |
4538 | $offset} = 1; | |
4539 | } | |
4540 | } | |
4541 | if (!defined $suppress_whiletrailers{$linenr} && | |
c11230f4 | 4542 | defined($stat) && defined($cond) && |
170d3a22 | 4543 | $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) { |
171ae1a4 | 4544 | my ($s, $c) = ($stat, $cond); |
8905a67c | 4545 | |
b53c8e10 | 4546 | if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) { |
000d1cc1 JP |
4547 | ERROR("ASSIGN_IN_IF", |
4548 | "do not use assignment in if condition\n" . $herecurr); | |
8905a67c AW |
4549 | } |
4550 | ||
4551 | # Find out what is on the end of the line after the | |
4552 | # conditional. | |
773647a0 | 4553 | substr($s, 0, length($c), ''); |
8905a67c | 4554 | $s =~ s/\n.*//g; |
13214adf | 4555 | $s =~ s/$;//g; # Remove any comments |
53210168 AW |
4556 | if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ && |
4557 | $c !~ /}\s*while\s*/) | |
773647a0 | 4558 | { |
bb44ad39 AW |
4559 | # Find out how long the conditional actually is. |
4560 | my @newlines = ($c =~ /\n/gs); | |
4561 | my $cond_lines = 1 + $#newlines; | |
42bdf74c | 4562 | my $stat_real = ''; |
bb44ad39 | 4563 | |
42bdf74c HS |
4564 | $stat_real = raw_line($linenr, $cond_lines) |
4565 | . "\n" if ($cond_lines); | |
bb44ad39 AW |
4566 | if (defined($stat_real) && $cond_lines > 1) { |
4567 | $stat_real = "[...]\n$stat_real"; | |
4568 | } | |
4569 | ||
000d1cc1 JP |
4570 | ERROR("TRAILING_STATEMENTS", |
4571 | "trailing statements should be on next line\n" . $herecurr . $stat_real); | |
8905a67c AW |
4572 | } |
4573 | } | |
4574 | ||
13214adf AW |
4575 | # Check for bitwise tests written as boolean |
4576 | if ($line =~ / | |
4577 | (?: | |
4578 | (?:\[|\(|\&\&|\|\|) | |
4579 | \s*0[xX][0-9]+\s* | |
4580 | (?:\&\&|\|\|) | |
4581 | | | |
4582 | (?:\&\&|\|\|) | |
4583 | \s*0[xX][0-9]+\s* | |
4584 | (?:\&\&|\|\||\)|\]) | |
4585 | )/x) | |
4586 | { | |
000d1cc1 JP |
4587 | WARN("HEXADECIMAL_BOOLEAN_TEST", |
4588 | "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr); | |
13214adf AW |
4589 | } |
4590 | ||
8905a67c | 4591 | # if and else should not have general statements after it |
13214adf AW |
4592 | if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) { |
4593 | my $s = $1; | |
4594 | $s =~ s/$;//g; # Remove any comments | |
4595 | if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) { | |
000d1cc1 JP |
4596 | ERROR("TRAILING_STATEMENTS", |
4597 | "trailing statements should be on next line\n" . $herecurr); | |
13214adf | 4598 | } |
0a920b5b | 4599 | } |
39667782 AW |
4600 | # if should not continue a brace |
4601 | if ($line =~ /}\s*if\b/) { | |
000d1cc1 | 4602 | ERROR("TRAILING_STATEMENTS", |
048b123f | 4603 | "trailing statements should be on next line (or did you mean 'else if'?)\n" . |
39667782 AW |
4604 | $herecurr); |
4605 | } | |
a1080bf8 AW |
4606 | # case and default should not have general statements after them |
4607 | if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g && | |
4608 | $line !~ /\G(?: | |
3fef12d6 | 4609 | (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$| |
a1080bf8 AW |
4610 | \s*return\s+ |
4611 | )/xg) | |
4612 | { | |
000d1cc1 JP |
4613 | ERROR("TRAILING_STATEMENTS", |
4614 | "trailing statements should be on next line\n" . $herecurr); | |
a1080bf8 | 4615 | } |
0a920b5b AW |
4616 | |
4617 | # Check for }<nl>else {, these must be at the same | |
4618 | # indent level to be relevant to each other. | |
8b8856f4 JP |
4619 | if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ && |
4620 | $previndent == $indent) { | |
4621 | if (ERROR("ELSE_AFTER_BRACE", | |
4622 | "else should follow close brace '}'\n" . $hereprev) && | |
4623 | $fix && $prevline =~ /^\+/ && $line =~ /^\+/) { | |
4624 | fix_delete_line($fixlinenr - 1, $prevrawline); | |
4625 | fix_delete_line($fixlinenr, $rawline); | |
4626 | my $fixedline = $prevrawline; | |
4627 | $fixedline =~ s/}\s*$//; | |
4628 | if ($fixedline !~ /^\+\s*$/) { | |
4629 | fix_insert_line($fixlinenr, $fixedline); | |
4630 | } | |
4631 | $fixedline = $rawline; | |
4632 | $fixedline =~ s/^(.\s*)else/$1} else/; | |
4633 | fix_insert_line($fixlinenr, $fixedline); | |
4634 | } | |
0a920b5b AW |
4635 | } |
4636 | ||
8b8856f4 JP |
4637 | if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ && |
4638 | $previndent == $indent) { | |
c2fdda0d AW |
4639 | my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0); |
4640 | ||
4641 | # Find out what is on the end of the line after the | |
4642 | # conditional. | |
773647a0 | 4643 | substr($s, 0, length($c), ''); |
c2fdda0d AW |
4644 | $s =~ s/\n.*//g; |
4645 | ||
4646 | if ($s =~ /^\s*;/) { | |
8b8856f4 JP |
4647 | if (ERROR("WHILE_AFTER_BRACE", |
4648 | "while should follow close brace '}'\n" . $hereprev) && | |
4649 | $fix && $prevline =~ /^\+/ && $line =~ /^\+/) { | |
4650 | fix_delete_line($fixlinenr - 1, $prevrawline); | |
4651 | fix_delete_line($fixlinenr, $rawline); | |
4652 | my $fixedline = $prevrawline; | |
4653 | my $trailing = $rawline; | |
4654 | $trailing =~ s/^\+//; | |
4655 | $trailing = trim($trailing); | |
4656 | $fixedline =~ s/}\s*$/} $trailing/; | |
4657 | fix_insert_line($fixlinenr, $fixedline); | |
4658 | } | |
c2fdda0d AW |
4659 | } |
4660 | } | |
4661 | ||
95e2c602 | 4662 | #Specific variable tests |
323c1260 JP |
4663 | while ($line =~ m{($Constant|$Lval)}g) { |
4664 | my $var = $1; | |
95e2c602 JP |
4665 | |
4666 | #gcc binary extension | |
4667 | if ($var =~ /^$Binary$/) { | |
d5e616fc JP |
4668 | if (WARN("GCC_BINARY_CONSTANT", |
4669 | "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) && | |
4670 | $fix) { | |
4671 | my $hexval = sprintf("0x%x", oct($var)); | |
194f66fc | 4672 | $fixed[$fixlinenr] =~ |
d5e616fc JP |
4673 | s/\b$var\b/$hexval/; |
4674 | } | |
95e2c602 JP |
4675 | } |
4676 | ||
4677 | #CamelCase | |
807bd26c | 4678 | if ($var !~ /^$Constant$/ && |
be79794b | 4679 | $var =~ /[A-Z][a-z]|[a-z][A-Z]/ && |
22735ce8 | 4680 | #Ignore Page<foo> variants |
807bd26c | 4681 | $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ && |
22735ce8 | 4682 | #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show) |
f5123576 JW |
4683 | $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ && |
4684 | #Ignore some three character SI units explicitly, like MiB and KHz | |
4685 | $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) { | |
7e781f67 JP |
4686 | while ($var =~ m{($Ident)}g) { |
4687 | my $word = $1; | |
4688 | next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/); | |
d8b07710 JP |
4689 | if ($check) { |
4690 | seed_camelcase_includes(); | |
4691 | if (!$file && !$camelcase_file_seeded) { | |
4692 | seed_camelcase_file($realfile); | |
4693 | $camelcase_file_seeded = 1; | |
4694 | } | |
4695 | } | |
7e781f67 JP |
4696 | if (!defined $camelcase{$word}) { |
4697 | $camelcase{$word} = 1; | |
4698 | CHK("CAMELCASE", | |
4699 | "Avoid CamelCase: <$word>\n" . $herecurr); | |
4700 | } | |
3445686a | 4701 | } |
323c1260 JP |
4702 | } |
4703 | } | |
0a920b5b AW |
4704 | |
4705 | #no spaces allowed after \ in define | |
d5e616fc JP |
4706 | if ($line =~ /\#\s*define.*\\\s+$/) { |
4707 | if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION", | |
4708 | "Whitespace after \\ makes next lines useless\n" . $herecurr) && | |
4709 | $fix) { | |
194f66fc | 4710 | $fixed[$fixlinenr] =~ s/\s+$//; |
d5e616fc | 4711 | } |
0a920b5b AW |
4712 | } |
4713 | ||
0e212e0a FF |
4714 | # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes |
4715 | # itself <asm/foo.h> (uses RAW line) | |
c45dcabd | 4716 | if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) { |
e09dec48 AW |
4717 | my $file = "$1.h"; |
4718 | my $checkfile = "include/linux/$file"; | |
4719 | if (-f "$root/$checkfile" && | |
4720 | $realfile ne $checkfile && | |
7840a94c | 4721 | $1 !~ /$allowed_asm_includes/) |
c45dcabd | 4722 | { |
0e212e0a FF |
4723 | my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`; |
4724 | if ($asminclude > 0) { | |
4725 | if ($realfile =~ m{^arch/}) { | |
4726 | CHK("ARCH_INCLUDE_LINUX", | |
4727 | "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr); | |
4728 | } else { | |
4729 | WARN("INCLUDE_LINUX", | |
4730 | "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr); | |
4731 | } | |
e09dec48 | 4732 | } |
0a920b5b AW |
4733 | } |
4734 | } | |
4735 | ||
653d4876 AW |
4736 | # multi-statement macros should be enclosed in a do while loop, grab the |
4737 | # first statement and ensure its the whole macro if its not enclosed | |
cf655043 | 4738 | # in a known good container |
b8f96a31 AW |
4739 | if ($realfile !~ m@/vmlinux.lds.h$@ && |
4740 | $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) { | |
d8aaf121 AW |
4741 | my $ln = $linenr; |
4742 | my $cnt = $realcnt; | |
c45dcabd AW |
4743 | my ($off, $dstat, $dcond, $rest); |
4744 | my $ctx = ''; | |
08a2843e JP |
4745 | my $has_flow_statement = 0; |
4746 | my $has_arg_concat = 0; | |
c45dcabd | 4747 | ($dstat, $dcond, $ln, $cnt, $off) = |
f74bd194 AW |
4748 | ctx_statement_block($linenr, $realcnt, 0); |
4749 | $ctx = $dstat; | |
c45dcabd | 4750 | #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n"; |
a3bb97a7 | 4751 | #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n"; |
c45dcabd | 4752 | |
08a2843e | 4753 | $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/); |
62e15a6d | 4754 | $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/); |
08a2843e | 4755 | |
f74bd194 | 4756 | $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//; |
292f1a9b | 4757 | $dstat =~ s/$;//g; |
c45dcabd AW |
4758 | $dstat =~ s/\\\n.//g; |
4759 | $dstat =~ s/^\s*//s; | |
4760 | $dstat =~ s/\s*$//s; | |
de7d4f0e | 4761 | |
c45dcabd | 4762 | # Flatten any parentheses and braces |
bf30d6ed AW |
4763 | while ($dstat =~ s/\([^\(\)]*\)/1/ || |
4764 | $dstat =~ s/\{[^\{\}]*\}/1/ || | |
6b10df42 | 4765 | $dstat =~ s/.\[[^\[\]]*\]/1/) |
bf30d6ed | 4766 | { |
de7d4f0e | 4767 | } |
d8aaf121 | 4768 | |
e45bab8e | 4769 | # Flatten any obvious string concatentation. |
33acb54a JP |
4770 | while ($dstat =~ s/($String)\s*$Ident/$1/ || |
4771 | $dstat =~ s/$Ident\s*($String)/$1/) | |
e45bab8e AW |
4772 | { |
4773 | } | |
4774 | ||
42e15293 JP |
4775 | # Make asm volatile uses seem like a generic function |
4776 | $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g; | |
4777 | ||
c45dcabd AW |
4778 | my $exceptions = qr{ |
4779 | $Declare| | |
4780 | module_param_named| | |
a0a0a7a9 | 4781 | MODULE_PARM_DESC| |
c45dcabd AW |
4782 | DECLARE_PER_CPU| |
4783 | DEFINE_PER_CPU| | |
383099fd | 4784 | __typeof__\(| |
22fd2d3e SS |
4785 | union| |
4786 | struct| | |
ea71a0a0 | 4787 | \.$Ident\s*=\s*| |
6b10df42 VZ |
4788 | ^\"|\"$| |
4789 | ^\[ | |
c45dcabd | 4790 | }x; |
5eaa20b9 | 4791 | #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n"; |
f74bd194 AW |
4792 | if ($dstat ne '' && |
4793 | $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(), | |
4794 | $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo(); | |
3cc4b1c3 | 4795 | $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz |
356fd398 | 4796 | $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants |
f74bd194 AW |
4797 | $dstat !~ /$exceptions/ && |
4798 | $dstat !~ /^\.$Ident\s*=/ && # .foo = | |
e942e2c3 | 4799 | $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo |
72f115f9 | 4800 | $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...) |
f74bd194 AW |
4801 | $dstat !~ /^for\s*$Constant$/ && # for (...) |
4802 | $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar() | |
4803 | $dstat !~ /^do\s*{/ && # do {... | |
4e5d56bd | 4804 | $dstat !~ /^\(\{/ && # ({... |
f95a7e6a | 4805 | $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/) |
f74bd194 AW |
4806 | { |
4807 | $ctx =~ s/\n*$//; | |
4808 | my $herectx = $here . "\n"; | |
4809 | my $cnt = statement_rawlines($ctx); | |
4810 | ||
4811 | for (my $n = 0; $n < $cnt; $n++) { | |
4812 | $herectx .= raw_line($linenr, $n) . "\n"; | |
c45dcabd AW |
4813 | } |
4814 | ||
f74bd194 AW |
4815 | if ($dstat =~ /;/) { |
4816 | ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE", | |
4817 | "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx"); | |
4818 | } else { | |
000d1cc1 | 4819 | ERROR("COMPLEX_MACRO", |
388982b5 | 4820 | "Macros with complex values should be enclosed in parentheses\n" . "$herectx"); |
d8aaf121 | 4821 | } |
653d4876 | 4822 | } |
5023d347 | 4823 | |
08a2843e JP |
4824 | # check for macros with flow control, but without ## concatenation |
4825 | # ## concatenation is commonly a macro that defines a function so ignore those | |
4826 | if ($has_flow_statement && !$has_arg_concat) { | |
4827 | my $herectx = $here . "\n"; | |
4828 | my $cnt = statement_rawlines($ctx); | |
4829 | ||
4830 | for (my $n = 0; $n < $cnt; $n++) { | |
4831 | $herectx .= raw_line($linenr, $n) . "\n"; | |
4832 | } | |
4833 | WARN("MACRO_WITH_FLOW_CONTROL", | |
4834 | "Macros with flow control statements should be avoided\n" . "$herectx"); | |
4835 | } | |
4836 | ||
481eb486 | 4837 | # check for line continuations outside of #defines, preprocessor #, and asm |
5023d347 JP |
4838 | |
4839 | } else { | |
4840 | if ($prevline !~ /^..*\\$/ && | |
481eb486 JP |
4841 | $line !~ /^\+\s*\#.*\\$/ && # preprocessor |
4842 | $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm | |
5023d347 JP |
4843 | $line =~ /^\+.*\\$/) { |
4844 | WARN("LINE_CONTINUATIONS", | |
4845 | "Avoid unnecessary line continuations\n" . $herecurr); | |
4846 | } | |
0a920b5b AW |
4847 | } |
4848 | ||
b13edf7f JP |
4849 | # do {} while (0) macro tests: |
4850 | # single-statement macros do not need to be enclosed in do while (0) loop, | |
4851 | # macro should not end with a semicolon | |
4852 | if ($^V && $^V ge 5.10.0 && | |
4853 | $realfile !~ m@/vmlinux.lds.h$@ && | |
4854 | $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) { | |
4855 | my $ln = $linenr; | |
4856 | my $cnt = $realcnt; | |
4857 | my ($off, $dstat, $dcond, $rest); | |
4858 | my $ctx = ''; | |
4859 | ($dstat, $dcond, $ln, $cnt, $off) = | |
4860 | ctx_statement_block($linenr, $realcnt, 0); | |
4861 | $ctx = $dstat; | |
4862 | ||
4863 | $dstat =~ s/\\\n.//g; | |
1b36b201 | 4864 | $dstat =~ s/$;/ /g; |
b13edf7f JP |
4865 | |
4866 | if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) { | |
4867 | my $stmts = $2; | |
4868 | my $semis = $3; | |
4869 | ||
4870 | $ctx =~ s/\n*$//; | |
4871 | my $cnt = statement_rawlines($ctx); | |
4872 | my $herectx = $here . "\n"; | |
4873 | ||
4874 | for (my $n = 0; $n < $cnt; $n++) { | |
4875 | $herectx .= raw_line($linenr, $n) . "\n"; | |
4876 | } | |
4877 | ||
ac8e97f8 JP |
4878 | if (($stmts =~ tr/;/;/) == 1 && |
4879 | $stmts !~ /^\s*(if|while|for|switch)\b/) { | |
b13edf7f JP |
4880 | WARN("SINGLE_STATEMENT_DO_WHILE_MACRO", |
4881 | "Single statement macros should not use a do {} while (0) loop\n" . "$herectx"); | |
4882 | } | |
4883 | if (defined $semis && $semis ne "") { | |
4884 | WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON", | |
4885 | "do {} while (0) macros should not be semicolon terminated\n" . "$herectx"); | |
4886 | } | |
f5ef95b1 JP |
4887 | } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) { |
4888 | $ctx =~ s/\n*$//; | |
4889 | my $cnt = statement_rawlines($ctx); | |
4890 | my $herectx = $here . "\n"; | |
4891 | ||
4892 | for (my $n = 0; $n < $cnt; $n++) { | |
4893 | $herectx .= raw_line($linenr, $n) . "\n"; | |
4894 | } | |
4895 | ||
4896 | WARN("TRAILING_SEMICOLON", | |
4897 | "macros should not use a trailing semicolon\n" . "$herectx"); | |
b13edf7f JP |
4898 | } |
4899 | } | |
4900 | ||
080ba929 MF |
4901 | # make sure symbols are always wrapped with VMLINUX_SYMBOL() ... |
4902 | # all assignments may have only one of the following with an assignment: | |
4903 | # . | |
4904 | # ALIGN(...) | |
4905 | # VMLINUX_SYMBOL(...) | |
4906 | if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) { | |
000d1cc1 JP |
4907 | WARN("MISSING_VMLINUX_SYMBOL", |
4908 | "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr); | |
080ba929 MF |
4909 | } |
4910 | ||
f0a594c1 | 4911 | # check for redundant bracing round if etc |
13214adf AW |
4912 | if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) { |
4913 | my ($level, $endln, @chunks) = | |
cf655043 | 4914 | ctx_statement_full($linenr, $realcnt, 1); |
13214adf | 4915 | #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n"; |
cf655043 AW |
4916 | #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n"; |
4917 | if ($#chunks > 0 && $level == 0) { | |
aad4f614 JP |
4918 | my @allowed = (); |
4919 | my $allow = 0; | |
13214adf | 4920 | my $seen = 0; |
773647a0 | 4921 | my $herectx = $here . "\n"; |
cf655043 | 4922 | my $ln = $linenr - 1; |
13214adf AW |
4923 | for my $chunk (@chunks) { |
4924 | my ($cond, $block) = @{$chunk}; | |
4925 | ||
773647a0 AW |
4926 | # If the condition carries leading newlines, then count those as offsets. |
4927 | my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s); | |
4928 | my $offset = statement_rawlines($whitespace) - 1; | |
4929 | ||
aad4f614 | 4930 | $allowed[$allow] = 0; |
773647a0 AW |
4931 | #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n"; |
4932 | ||
4933 | # We have looked at and allowed this specific line. | |
4934 | $suppress_ifbraces{$ln + $offset} = 1; | |
4935 | ||
4936 | $herectx .= "$rawlines[$ln + $offset]\n[...]\n"; | |
cf655043 AW |
4937 | $ln += statement_rawlines($block) - 1; |
4938 | ||
773647a0 | 4939 | substr($block, 0, length($cond), ''); |
13214adf AW |
4940 | |
4941 | $seen++ if ($block =~ /^\s*{/); | |
4942 | ||
aad4f614 | 4943 | #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n"; |
cf655043 AW |
4944 | if (statement_lines($cond) > 1) { |
4945 | #print "APW: ALLOWED: cond<$cond>\n"; | |
aad4f614 | 4946 | $allowed[$allow] = 1; |
13214adf AW |
4947 | } |
4948 | if ($block =~/\b(?:if|for|while)\b/) { | |
cf655043 | 4949 | #print "APW: ALLOWED: block<$block>\n"; |
aad4f614 | 4950 | $allowed[$allow] = 1; |
13214adf | 4951 | } |
cf655043 AW |
4952 | if (statement_block_size($block) > 1) { |
4953 | #print "APW: ALLOWED: lines block<$block>\n"; | |
aad4f614 | 4954 | $allowed[$allow] = 1; |
13214adf | 4955 | } |
aad4f614 | 4956 | $allow++; |
13214adf | 4957 | } |
aad4f614 JP |
4958 | if ($seen) { |
4959 | my $sum_allowed = 0; | |
4960 | foreach (@allowed) { | |
4961 | $sum_allowed += $_; | |
4962 | } | |
4963 | if ($sum_allowed == 0) { | |
4964 | WARN("BRACES", | |
4965 | "braces {} are not necessary for any arm of this statement\n" . $herectx); | |
4966 | } elsif ($sum_allowed != $allow && | |
4967 | $seen != $allow) { | |
4968 | CHK("BRACES", | |
4969 | "braces {} should be used on all arms of this statement\n" . $herectx); | |
4970 | } | |
13214adf AW |
4971 | } |
4972 | } | |
4973 | } | |
773647a0 | 4974 | if (!defined $suppress_ifbraces{$linenr - 1} && |
13214adf | 4975 | $line =~ /\b(if|while|for|else)\b/) { |
cf655043 AW |
4976 | my $allowed = 0; |
4977 | ||
4978 | # Check the pre-context. | |
4979 | if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) { | |
4980 | #print "APW: ALLOWED: pre<$1>\n"; | |
4981 | $allowed = 1; | |
4982 | } | |
773647a0 AW |
4983 | |
4984 | my ($level, $endln, @chunks) = | |
4985 | ctx_statement_full($linenr, $realcnt, $-[0]); | |
4986 | ||
cf655043 AW |
4987 | # Check the condition. |
4988 | my ($cond, $block) = @{$chunks[0]}; | |
773647a0 | 4989 | #print "CHECKING<$linenr> cond<$cond> block<$block>\n"; |
cf655043 | 4990 | if (defined $cond) { |
773647a0 | 4991 | substr($block, 0, length($cond), ''); |
cf655043 AW |
4992 | } |
4993 | if (statement_lines($cond) > 1) { | |
4994 | #print "APW: ALLOWED: cond<$cond>\n"; | |
4995 | $allowed = 1; | |
4996 | } | |
4997 | if ($block =~/\b(?:if|for|while)\b/) { | |
4998 | #print "APW: ALLOWED: block<$block>\n"; | |
4999 | $allowed = 1; | |
5000 | } | |
5001 | if (statement_block_size($block) > 1) { | |
5002 | #print "APW: ALLOWED: lines block<$block>\n"; | |
5003 | $allowed = 1; | |
5004 | } | |
5005 | # Check the post-context. | |
5006 | if (defined $chunks[1]) { | |
5007 | my ($cond, $block) = @{$chunks[1]}; | |
5008 | if (defined $cond) { | |
773647a0 | 5009 | substr($block, 0, length($cond), ''); |
cf655043 AW |
5010 | } |
5011 | if ($block =~ /^\s*\{/) { | |
5012 | #print "APW: ALLOWED: chunk-1 block<$block>\n"; | |
5013 | $allowed = 1; | |
5014 | } | |
5015 | } | |
5016 | if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) { | |
69932487 | 5017 | my $herectx = $here . "\n"; |
f055663c | 5018 | my $cnt = statement_rawlines($block); |
cf655043 | 5019 | |
f055663c | 5020 | for (my $n = 0; $n < $cnt; $n++) { |
69932487 | 5021 | $herectx .= raw_line($linenr, $n) . "\n"; |
f0a594c1 | 5022 | } |
cf655043 | 5023 | |
000d1cc1 JP |
5024 | WARN("BRACES", |
5025 | "braces {} are not necessary for single statement blocks\n" . $herectx); | |
f0a594c1 AW |
5026 | } |
5027 | } | |
5028 | ||
0979ae66 | 5029 | # check for unnecessary blank lines around braces |
77b9a53a | 5030 | if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) { |
f8e58219 JP |
5031 | if (CHK("BRACES", |
5032 | "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) && | |
5033 | $fix && $prevrawline =~ /^\+/) { | |
5034 | fix_delete_line($fixlinenr - 1, $prevrawline); | |
5035 | } | |
0979ae66 | 5036 | } |
77b9a53a | 5037 | if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) { |
f8e58219 JP |
5038 | if (CHK("BRACES", |
5039 | "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) && | |
5040 | $fix) { | |
5041 | fix_delete_line($fixlinenr, $rawline); | |
5042 | } | |
0979ae66 JP |
5043 | } |
5044 | ||
4a0df2ef | 5045 | # no volatiles please |
6c72ffaa AW |
5046 | my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b}; |
5047 | if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) { | |
000d1cc1 JP |
5048 | WARN("VOLATILE", |
5049 | "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr); | |
4a0df2ef AW |
5050 | } |
5051 | ||
5e4f6ba5 JP |
5052 | # Check for user-visible strings broken across lines, which breaks the ability |
5053 | # to grep for the string. Make exceptions when the previous string ends in a | |
5054 | # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{' | |
5055 | # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value | |
33acb54a | 5056 | if ($line =~ /^\+\s*$String/ && |
5e4f6ba5 JP |
5057 | $prevline =~ /"\s*$/ && |
5058 | $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) { | |
5059 | if (WARN("SPLIT_STRING", | |
5060 | "quoted string split across lines\n" . $hereprev) && | |
5061 | $fix && | |
5062 | $prevrawline =~ /^\+.*"\s*$/ && | |
5063 | $last_coalesced_string_linenr != $linenr - 1) { | |
5064 | my $extracted_string = get_quoted_string($line, $rawline); | |
5065 | my $comma_close = ""; | |
5066 | if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) { | |
5067 | $comma_close = $1; | |
5068 | } | |
5069 | ||
5070 | fix_delete_line($fixlinenr - 1, $prevrawline); | |
5071 | fix_delete_line($fixlinenr, $rawline); | |
5072 | my $fixedline = $prevrawline; | |
5073 | $fixedline =~ s/"\s*$//; | |
5074 | $fixedline .= substr($extracted_string, 1) . trim($comma_close); | |
5075 | fix_insert_line($fixlinenr - 1, $fixedline); | |
5076 | $fixedline = $rawline; | |
5077 | $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//; | |
5078 | if ($fixedline !~ /\+\s*$/) { | |
5079 | fix_insert_line($fixlinenr, $fixedline); | |
5080 | } | |
5081 | $last_coalesced_string_linenr = $linenr; | |
5082 | } | |
5083 | } | |
5084 | ||
5085 | # check for missing a space in a string concatenation | |
5086 | if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) { | |
5087 | WARN('MISSING_SPACE', | |
5088 | "break quoted strings at a space character\n" . $hereprev); | |
5089 | } | |
5090 | ||
5091 | # check for spaces before a quoted newline | |
5092 | if ($rawline =~ /^.*\".*\s\\n/) { | |
5093 | if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE", | |
5094 | "unnecessary whitespace before a quoted newline\n" . $herecurr) && | |
5095 | $fix) { | |
5096 | $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/; | |
5097 | } | |
5098 | ||
5099 | } | |
5100 | ||
f17dba4f | 5101 | # concatenated string without spaces between elements |
33acb54a | 5102 | if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) { |
f17dba4f JP |
5103 | CHK("CONCATENATED_STRING", |
5104 | "Concatenated strings should use spaces between elements\n" . $herecurr); | |
5105 | } | |
5106 | ||
90ad30e5 | 5107 | # uncoalesced string fragments |
33acb54a | 5108 | if ($line =~ /$String\s*"/) { |
90ad30e5 JP |
5109 | WARN("STRING_FRAGMENTS", |
5110 | "Consecutive strings are generally better as a single string\n" . $herecurr); | |
5111 | } | |
5112 | ||
6e300757 | 5113 | # check for %L{u,d,i} and 0x%[udi] in strings |
5e4f6ba5 JP |
5114 | my $string; |
5115 | while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) { | |
5116 | $string = substr($rawline, $-[1], $+[1] - $-[1]); | |
5117 | $string =~ s/%%/__/g; | |
6e300757 | 5118 | if ($string =~ /(?<!%)%[\*\d\.\$]*L[udi]/) { |
5e4f6ba5 JP |
5119 | WARN("PRINTF_L", |
5120 | "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr); | |
5121 | last; | |
5122 | } | |
6e300757 JP |
5123 | if ($string =~ /0x%[\*\d\.\$\Llzth]*[udi]/) { |
5124 | ERROR("PRINTF_0xDECIMAL", | |
5125 | "Prefixing 0x with decimal output is defective\n" . $herecurr); | |
5126 | } | |
5e4f6ba5 JP |
5127 | } |
5128 | ||
5129 | # check for line continuations in quoted strings with odd counts of " | |
5130 | if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) { | |
5131 | WARN("LINE_CONTINUATIONS", | |
5132 | "Avoid line continuations in quoted strings\n" . $herecurr); | |
5133 | } | |
5134 | ||
00df344f | 5135 | # warn about #if 0 |
c45dcabd | 5136 | if ($line =~ /^.\s*\#\s*if\s+0\b/) { |
000d1cc1 JP |
5137 | CHK("REDUNDANT_CODE", |
5138 | "if this code is redundant consider removing it\n" . | |
de7d4f0e | 5139 | $herecurr); |
4a0df2ef AW |
5140 | } |
5141 | ||
03df4b51 AW |
5142 | # check for needless "if (<foo>) fn(<foo>)" uses |
5143 | if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) { | |
100425de JP |
5144 | my $tested = quotemeta($1); |
5145 | my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;'; | |
5146 | if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) { | |
5147 | my $func = $1; | |
5148 | if (WARN('NEEDLESS_IF', | |
5149 | "$func(NULL) is safe and this check is probably not required\n" . $hereprev) && | |
5150 | $fix) { | |
5151 | my $do_fix = 1; | |
5152 | my $leading_tabs = ""; | |
5153 | my $new_leading_tabs = ""; | |
5154 | if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) { | |
5155 | $leading_tabs = $1; | |
5156 | } else { | |
5157 | $do_fix = 0; | |
5158 | } | |
5159 | if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) { | |
5160 | $new_leading_tabs = $1; | |
5161 | if (length($leading_tabs) + 1 ne length($new_leading_tabs)) { | |
5162 | $do_fix = 0; | |
5163 | } | |
5164 | } else { | |
5165 | $do_fix = 0; | |
5166 | } | |
5167 | if ($do_fix) { | |
5168 | fix_delete_line($fixlinenr - 1, $prevrawline); | |
5169 | $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/; | |
5170 | } | |
5171 | } | |
4c432a8f GKH |
5172 | } |
5173 | } | |
f0a594c1 | 5174 | |
ebfdc409 JP |
5175 | # check for unnecessary "Out of Memory" messages |
5176 | if ($line =~ /^\+.*\b$logFunctions\s*\(/ && | |
5177 | $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ && | |
5178 | (defined $1 || defined $3) && | |
5179 | $linenr > 3) { | |
5180 | my $testval = $2; | |
5181 | my $testline = $lines[$linenr - 3]; | |
5182 | ||
5183 | my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0); | |
5184 | # print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n"); | |
5185 | ||
5186 | if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) { | |
5187 | WARN("OOM_MESSAGE", | |
5188 | "Possible unnecessary 'out of memory' message\n" . $hereprev); | |
5189 | } | |
5190 | } | |
5191 | ||
f78d98f6 | 5192 | # check for logging functions with KERN_<LEVEL> |
dcaf1123 | 5193 | if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ && |
f78d98f6 JP |
5194 | $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) { |
5195 | my $level = $1; | |
5196 | if (WARN("UNNECESSARY_KERN_LEVEL", | |
5197 | "Possible unnecessary $level\n" . $herecurr) && | |
5198 | $fix) { | |
5199 | $fixed[$fixlinenr] =~ s/\s*$level\s*//; | |
5200 | } | |
5201 | } | |
5202 | ||
abb08a53 JP |
5203 | # check for mask then right shift without a parentheses |
5204 | if ($^V && $^V ge 5.10.0 && | |
5205 | $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ && | |
5206 | $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so | |
5207 | WARN("MASK_THEN_SHIFT", | |
5208 | "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr); | |
5209 | } | |
5210 | ||
b75ac618 JP |
5211 | # check for pointer comparisons to NULL |
5212 | if ($^V && $^V ge 5.10.0) { | |
5213 | while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) { | |
5214 | my $val = $1; | |
5215 | my $equal = "!"; | |
5216 | $equal = "" if ($4 eq "!="); | |
5217 | if (CHK("COMPARISON_TO_NULL", | |
5218 | "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) && | |
5219 | $fix) { | |
5220 | $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/; | |
5221 | } | |
5222 | } | |
5223 | } | |
5224 | ||
8716de38 JP |
5225 | # check for bad placement of section $InitAttribute (e.g.: __initdata) |
5226 | if ($line =~ /(\b$InitAttribute\b)/) { | |
5227 | my $attr = $1; | |
5228 | if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) { | |
5229 | my $ptr = $1; | |
5230 | my $var = $2; | |
5231 | if ((($ptr =~ /\b(union|struct)\s+$attr\b/ && | |
5232 | ERROR("MISPLACED_INIT", | |
5233 | "$attr should be placed after $var\n" . $herecurr)) || | |
5234 | ($ptr !~ /\b(union|struct)\s+$attr\b/ && | |
5235 | WARN("MISPLACED_INIT", | |
5236 | "$attr should be placed after $var\n" . $herecurr))) && | |
5237 | $fix) { | |
194f66fc | 5238 | $fixed[$fixlinenr] =~ s/(\bstatic\s+(?:const\s+)?)(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*([=;])\s*/"$1" . trim(string_find_replace($2, "\\s*$attr\\s*", " ")) . " " . trim(string_find_replace($3, "\\s*$attr\\s*", "")) . " $attr" . ("$4" eq ";" ? ";" : " = ")/e; |
8716de38 JP |
5239 | } |
5240 | } | |
5241 | } | |
5242 | ||
e970b884 JP |
5243 | # check for $InitAttributeData (ie: __initdata) with const |
5244 | if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) { | |
5245 | my $attr = $1; | |
5246 | $attr =~ /($InitAttributePrefix)(.*)/; | |
5247 | my $attr_prefix = $1; | |
5248 | my $attr_type = $2; | |
5249 | if (ERROR("INIT_ATTRIBUTE", | |
5250 | "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) && | |
5251 | $fix) { | |
194f66fc | 5252 | $fixed[$fixlinenr] =~ |
e970b884 JP |
5253 | s/$InitAttributeData/${attr_prefix}initconst/; |
5254 | } | |
5255 | } | |
5256 | ||
5257 | # check for $InitAttributeConst (ie: __initconst) without const | |
5258 | if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) { | |
5259 | my $attr = $1; | |
5260 | if (ERROR("INIT_ATTRIBUTE", | |
5261 | "Use of $attr requires a separate use of const\n" . $herecurr) && | |
5262 | $fix) { | |
194f66fc | 5263 | my $lead = $fixed[$fixlinenr] =~ |
e970b884 JP |
5264 | /(^\+\s*(?:static\s+))/; |
5265 | $lead = rtrim($1); | |
5266 | $lead = "$lead " if ($lead !~ /^\+$/); | |
5267 | $lead = "${lead}const "; | |
194f66fc | 5268 | $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/; |
e970b884 JP |
5269 | } |
5270 | } | |
5271 | ||
c17893c7 JP |
5272 | # check for __read_mostly with const non-pointer (should just be const) |
5273 | if ($line =~ /\b__read_mostly\b/ && | |
5274 | $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) { | |
5275 | if (ERROR("CONST_READ_MOSTLY", | |
5276 | "Invalid use of __read_mostly with const type\n" . $herecurr) && | |
5277 | $fix) { | |
5278 | $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//; | |
5279 | } | |
5280 | } | |
5281 | ||
fbdb8138 JP |
5282 | # don't use __constant_<foo> functions outside of include/uapi/ |
5283 | if ($realfile !~ m@^include/uapi/@ && | |
5284 | $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) { | |
5285 | my $constant_func = $1; | |
5286 | my $func = $constant_func; | |
5287 | $func =~ s/^__constant_//; | |
5288 | if (WARN("CONSTANT_CONVERSION", | |
5289 | "$constant_func should be $func\n" . $herecurr) && | |
5290 | $fix) { | |
194f66fc | 5291 | $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g; |
fbdb8138 JP |
5292 | } |
5293 | } | |
5294 | ||
1a15a250 | 5295 | # prefer usleep_range over udelay |
37581c28 | 5296 | if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) { |
43c1d77c | 5297 | my $delay = $1; |
1a15a250 | 5298 | # ignore udelay's < 10, however |
43c1d77c | 5299 | if (! ($delay < 10) ) { |
000d1cc1 | 5300 | CHK("USLEEP_RANGE", |
43c1d77c JP |
5301 | "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr); |
5302 | } | |
5303 | if ($delay > 2000) { | |
5304 | WARN("LONG_UDELAY", | |
5305 | "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr); | |
1a15a250 PP |
5306 | } |
5307 | } | |
5308 | ||
09ef8725 PP |
5309 | # warn about unexpectedly long msleep's |
5310 | if ($line =~ /\bmsleep\s*\((\d+)\);/) { | |
5311 | if ($1 < 20) { | |
000d1cc1 | 5312 | WARN("MSLEEP", |
43c1d77c | 5313 | "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr); |
09ef8725 PP |
5314 | } |
5315 | } | |
5316 | ||
36ec1939 JP |
5317 | # check for comparisons of jiffies |
5318 | if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) { | |
5319 | WARN("JIFFIES_COMPARISON", | |
5320 | "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr); | |
5321 | } | |
5322 | ||
9d7a34a5 JP |
5323 | # check for comparisons of get_jiffies_64() |
5324 | if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) { | |
5325 | WARN("JIFFIES_COMPARISON", | |
5326 | "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr); | |
5327 | } | |
5328 | ||
00df344f | 5329 | # warn about #ifdefs in C files |
c45dcabd | 5330 | # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) { |
00df344f AW |
5331 | # print "#ifdef in C files should be avoided\n"; |
5332 | # print "$herecurr"; | |
5333 | # $clean = 0; | |
5334 | # } | |
5335 | ||
22f2a2ef | 5336 | # warn about spacing in #ifdefs |
c45dcabd | 5337 | if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) { |
3705ce5b JP |
5338 | if (ERROR("SPACING", |
5339 | "exactly one space required after that #$1\n" . $herecurr) && | |
5340 | $fix) { | |
194f66fc | 5341 | $fixed[$fixlinenr] =~ |
3705ce5b JP |
5342 | s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /; |
5343 | } | |
5344 | ||
22f2a2ef AW |
5345 | } |
5346 | ||
4a0df2ef | 5347 | # check for spinlock_t definitions without a comment. |
171ae1a4 AW |
5348 | if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ || |
5349 | $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) { | |
4a0df2ef AW |
5350 | my $which = $1; |
5351 | if (!ctx_has_comment($first_line, $linenr)) { | |
000d1cc1 JP |
5352 | CHK("UNCOMMENTED_DEFINITION", |
5353 | "$1 definition without comment\n" . $herecurr); | |
4a0df2ef AW |
5354 | } |
5355 | } | |
5356 | # check for memory barriers without a comment. | |
402c2553 MT |
5357 | |
5358 | my $barriers = qr{ | |
5359 | mb| | |
5360 | rmb| | |
5361 | wmb| | |
5362 | read_barrier_depends | |
5363 | }x; | |
5364 | my $barrier_stems = qr{ | |
5365 | mb__before_atomic| | |
5366 | mb__after_atomic| | |
5367 | store_release| | |
5368 | load_acquire| | |
5369 | store_mb| | |
5370 | (?:$barriers) | |
5371 | }x; | |
5372 | my $all_barriers = qr{ | |
5373 | (?:$barriers)| | |
43e361f2 MT |
5374 | smp_(?:$barrier_stems)| |
5375 | virt_(?:$barrier_stems) | |
402c2553 MT |
5376 | }x; |
5377 | ||
5378 | if ($line =~ /\b(?:$all_barriers)\s*\(/) { | |
4a0df2ef | 5379 | if (!ctx_has_comment($first_line, $linenr)) { |
c1fd7bb9 JP |
5380 | WARN("MEMORY_BARRIER", |
5381 | "memory barrier without comment\n" . $herecurr); | |
4a0df2ef AW |
5382 | } |
5383 | } | |
3ad81779 | 5384 | |
f4073b0f MT |
5385 | my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x; |
5386 | ||
5387 | if ($realfile !~ m@^include/asm-generic/@ && | |
5388 | $realfile !~ m@/barrier\.h$@ && | |
5389 | $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ && | |
5390 | $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) { | |
5391 | WARN("MEMORY_BARRIER", | |
5392 | "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr); | |
5393 | } | |
5394 | ||
cb426e99 JP |
5395 | # check for waitqueue_active without a comment. |
5396 | if ($line =~ /\bwaitqueue_active\s*\(/) { | |
5397 | if (!ctx_has_comment($first_line, $linenr)) { | |
5398 | WARN("WAITQUEUE_ACTIVE", | |
5399 | "waitqueue_active without comment\n" . $herecurr); | |
5400 | } | |
5401 | } | |
3ad81779 PM |
5402 | |
5403 | # Check for expedited grace periods that interrupt non-idle non-nohz | |
5404 | # online CPUs. These expedited can therefore degrade real-time response | |
5405 | # if used carelessly, and should be avoided where not absolutely | |
5406 | # needed. It is always OK to use synchronize_rcu_expedited() and | |
5407 | # synchronize_sched_expedited() at boot time (before real-time applications | |
5408 | # start) and in error situations where real-time response is compromised in | |
5409 | # any case. Note that synchronize_srcu_expedited() does -not- interrupt | |
5410 | # other CPUs, so don't warn on uses of synchronize_srcu_expedited(). | |
5411 | # Of course, nothing comes for free, and srcu_read_lock() and | |
5412 | # srcu_read_unlock() do contain full memory barriers in payment for | |
5413 | # synchronize_srcu_expedited() non-interruption properties. | |
5414 | if ($line =~ /\b(synchronize_rcu_expedited|synchronize_sched_expedited)\(/) { | |
5415 | WARN("EXPEDITED_RCU_GRACE_PERIOD", | |
5416 | "expedited RCU grace periods should be avoided where they can degrade real-time response\n" . $herecurr); | |
5417 | ||
5418 | } | |
5419 | ||
4a0df2ef | 5420 | # check of hardware specific defines |
c45dcabd | 5421 | if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) { |
000d1cc1 JP |
5422 | CHK("ARCH_DEFINES", |
5423 | "architecture specific defines should be avoided\n" . $herecurr); | |
0a920b5b | 5424 | } |
653d4876 | 5425 | |
d4977c78 TK |
5426 | # Check that the storage class is at the beginning of a declaration |
5427 | if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) { | |
000d1cc1 JP |
5428 | WARN("STORAGE_CLASS", |
5429 | "storage class should be at the beginning of the declaration\n" . $herecurr) | |
d4977c78 TK |
5430 | } |
5431 | ||
de7d4f0e AW |
5432 | # check the location of the inline attribute, that it is between |
5433 | # storage class and type. | |
9c0ca6f9 AW |
5434 | if ($line =~ /\b$Type\s+$Inline\b/ || |
5435 | $line =~ /\b$Inline\s+$Storage\b/) { | |
000d1cc1 JP |
5436 | ERROR("INLINE_LOCATION", |
5437 | "inline keyword should sit between storage class and type\n" . $herecurr); | |
de7d4f0e AW |
5438 | } |
5439 | ||
8905a67c | 5440 | # Check for __inline__ and __inline, prefer inline |
2b7ab453 JP |
5441 | if ($realfile !~ m@\binclude/uapi/@ && |
5442 | $line =~ /\b(__inline__|__inline)\b/) { | |
d5e616fc JP |
5443 | if (WARN("INLINE", |
5444 | "plain inline is preferred over $1\n" . $herecurr) && | |
5445 | $fix) { | |
194f66fc | 5446 | $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/; |
d5e616fc JP |
5447 | |
5448 | } | |
8905a67c AW |
5449 | } |
5450 | ||
3d130fd0 | 5451 | # Check for __attribute__ packed, prefer __packed |
2b7ab453 JP |
5452 | if ($realfile !~ m@\binclude/uapi/@ && |
5453 | $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) { | |
000d1cc1 JP |
5454 | WARN("PREFER_PACKED", |
5455 | "__packed is preferred over __attribute__((packed))\n" . $herecurr); | |
3d130fd0 JP |
5456 | } |
5457 | ||
39b7e287 | 5458 | # Check for __attribute__ aligned, prefer __aligned |
2b7ab453 JP |
5459 | if ($realfile !~ m@\binclude/uapi/@ && |
5460 | $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) { | |
000d1cc1 JP |
5461 | WARN("PREFER_ALIGNED", |
5462 | "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr); | |
39b7e287 JP |
5463 | } |
5464 | ||
5f14d3bd | 5465 | # Check for __attribute__ format(printf, prefer __printf |
2b7ab453 JP |
5466 | if ($realfile !~ m@\binclude/uapi/@ && |
5467 | $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) { | |
d5e616fc JP |
5468 | if (WARN("PREFER_PRINTF", |
5469 | "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) && | |
5470 | $fix) { | |
194f66fc | 5471 | $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex; |
d5e616fc JP |
5472 | |
5473 | } | |
5f14d3bd JP |
5474 | } |
5475 | ||
6061d949 | 5476 | # Check for __attribute__ format(scanf, prefer __scanf |
2b7ab453 JP |
5477 | if ($realfile !~ m@\binclude/uapi/@ && |
5478 | $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) { | |
d5e616fc JP |
5479 | if (WARN("PREFER_SCANF", |
5480 | "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) && | |
5481 | $fix) { | |
194f66fc | 5482 | $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex; |
d5e616fc | 5483 | } |
6061d949 JP |
5484 | } |
5485 | ||
619a908a JP |
5486 | # Check for __attribute__ weak, or __weak declarations (may have link issues) |
5487 | if ($^V && $^V ge 5.10.0 && | |
5488 | $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ && | |
5489 | ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ || | |
5490 | $line =~ /\b__weak\b/)) { | |
5491 | ERROR("WEAK_DECLARATION", | |
5492 | "Using weak declarations can have unintended link defects\n" . $herecurr); | |
5493 | } | |
5494 | ||
e6176fa4 JP |
5495 | # check for c99 types like uint8_t used outside of uapi/ |
5496 | if ($realfile !~ m@\binclude/uapi/@ && | |
5497 | $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) { | |
5498 | my $type = $1; | |
5499 | if ($type =~ /\b($typeC99Typedefs)\b/) { | |
5500 | $type = $1; | |
5501 | my $kernel_type = 'u'; | |
5502 | $kernel_type = 's' if ($type =~ /^_*[si]/); | |
5503 | $type =~ /(\d+)/; | |
5504 | $kernel_type .= $1; | |
5505 | if (CHK("PREFER_KERNEL_TYPES", | |
5506 | "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) && | |
5507 | $fix) { | |
5508 | $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/; | |
5509 | } | |
5510 | } | |
5511 | } | |
5512 | ||
938224b5 JP |
5513 | # check for cast of C90 native int or longer types constants |
5514 | if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) { | |
5515 | my $cast = $1; | |
5516 | my $const = $2; | |
5517 | if (WARN("TYPECAST_INT_CONSTANT", | |
5518 | "Unnecessary typecast of c90 int constant\n" . $herecurr) && | |
5519 | $fix) { | |
5520 | my $suffix = ""; | |
5521 | my $newconst = $const; | |
5522 | $newconst =~ s/${Int_type}$//; | |
5523 | $suffix .= 'U' if ($cast =~ /\bunsigned\b/); | |
5524 | if ($cast =~ /\blong\s+long\b/) { | |
5525 | $suffix .= 'LL'; | |
5526 | } elsif ($cast =~ /\blong\b/) { | |
5527 | $suffix .= 'L'; | |
5528 | } | |
5529 | $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/; | |
5530 | } | |
5531 | } | |
5532 | ||
8f53a9b8 JP |
5533 | # check for sizeof(&) |
5534 | if ($line =~ /\bsizeof\s*\(\s*\&/) { | |
000d1cc1 JP |
5535 | WARN("SIZEOF_ADDRESS", |
5536 | "sizeof(& should be avoided\n" . $herecurr); | |
8f53a9b8 JP |
5537 | } |
5538 | ||
66c80b60 JP |
5539 | # check for sizeof without parenthesis |
5540 | if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) { | |
d5e616fc JP |
5541 | if (WARN("SIZEOF_PARENTHESIS", |
5542 | "sizeof $1 should be sizeof($1)\n" . $herecurr) && | |
5543 | $fix) { | |
194f66fc | 5544 | $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex; |
d5e616fc | 5545 | } |
66c80b60 JP |
5546 | } |
5547 | ||
88982fea JP |
5548 | # check for struct spinlock declarations |
5549 | if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) { | |
5550 | WARN("USE_SPINLOCK_T", | |
5551 | "struct spinlock should be spinlock_t\n" . $herecurr); | |
5552 | } | |
5553 | ||
a6962d72 | 5554 | # check for seq_printf uses that could be seq_puts |
06668727 | 5555 | if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) { |
a6962d72 | 5556 | my $fmt = get_quoted_string($line, $rawline); |
caac1d5f HA |
5557 | $fmt =~ s/%%//g; |
5558 | if ($fmt !~ /%/) { | |
d5e616fc JP |
5559 | if (WARN("PREFER_SEQ_PUTS", |
5560 | "Prefer seq_puts to seq_printf\n" . $herecurr) && | |
5561 | $fix) { | |
194f66fc | 5562 | $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/; |
d5e616fc | 5563 | } |
a6962d72 JP |
5564 | } |
5565 | } | |
5566 | ||
554e165c | 5567 | # Check for misused memsets |
d1fe9c09 JP |
5568 | if ($^V && $^V ge 5.10.0 && |
5569 | defined $stat && | |
9e20a853 | 5570 | $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) { |
d7c76ba7 JP |
5571 | |
5572 | my $ms_addr = $2; | |
d1fe9c09 JP |
5573 | my $ms_val = $7; |
5574 | my $ms_size = $12; | |
554e165c | 5575 | |
554e165c AW |
5576 | if ($ms_size =~ /^(0x|)0$/i) { |
5577 | ERROR("MEMSET", | |
d7c76ba7 | 5578 | "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n"); |
554e165c AW |
5579 | } elsif ($ms_size =~ /^(0x|)1$/i) { |
5580 | WARN("MEMSET", | |
d7c76ba7 JP |
5581 | "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n"); |
5582 | } | |
5583 | } | |
5584 | ||
98a9bba5 | 5585 | # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar) |
f333195d JP |
5586 | # if ($^V && $^V ge 5.10.0 && |
5587 | # defined $stat && | |
5588 | # $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) { | |
5589 | # if (WARN("PREFER_ETHER_ADDR_COPY", | |
5590 | # "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") && | |
5591 | # $fix) { | |
5592 | # $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/; | |
5593 | # } | |
5594 | # } | |
98a9bba5 | 5595 | |
b6117d17 | 5596 | # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar) |
f333195d JP |
5597 | # if ($^V && $^V ge 5.10.0 && |
5598 | # defined $stat && | |
5599 | # $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) { | |
5600 | # WARN("PREFER_ETHER_ADDR_EQUAL", | |
5601 | # "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n") | |
5602 | # } | |
b6117d17 | 5603 | |
8617cd09 MK |
5604 | # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr |
5605 | # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr | |
f333195d JP |
5606 | # if ($^V && $^V ge 5.10.0 && |
5607 | # defined $stat && | |
5608 | # $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) { | |
5609 | # | |
5610 | # my $ms_val = $7; | |
5611 | # | |
5612 | # if ($ms_val =~ /^(?:0x|)0+$/i) { | |
5613 | # if (WARN("PREFER_ETH_ZERO_ADDR", | |
5614 | # "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") && | |
5615 | # $fix) { | |
5616 | # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/; | |
5617 | # } | |
5618 | # } elsif ($ms_val =~ /^(?:0xff|255)$/i) { | |
5619 | # if (WARN("PREFER_ETH_BROADCAST_ADDR", | |
5620 | # "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") && | |
5621 | # $fix) { | |
5622 | # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/; | |
5623 | # } | |
5624 | # } | |
5625 | # } | |
8617cd09 | 5626 | |
d7c76ba7 | 5627 | # typecasts on min/max could be min_t/max_t |
d1fe9c09 JP |
5628 | if ($^V && $^V ge 5.10.0 && |
5629 | defined $stat && | |
d7c76ba7 | 5630 | $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) { |
d1fe9c09 | 5631 | if (defined $2 || defined $7) { |
d7c76ba7 JP |
5632 | my $call = $1; |
5633 | my $cast1 = deparenthesize($2); | |
5634 | my $arg1 = $3; | |
d1fe9c09 JP |
5635 | my $cast2 = deparenthesize($7); |
5636 | my $arg2 = $8; | |
d7c76ba7 JP |
5637 | my $cast; |
5638 | ||
d1fe9c09 | 5639 | if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) { |
d7c76ba7 JP |
5640 | $cast = "$cast1 or $cast2"; |
5641 | } elsif ($cast1 ne "") { | |
5642 | $cast = $cast1; | |
5643 | } else { | |
5644 | $cast = $cast2; | |
5645 | } | |
5646 | WARN("MINMAX", | |
5647 | "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n"); | |
554e165c AW |
5648 | } |
5649 | } | |
5650 | ||
4a273195 JP |
5651 | # check usleep_range arguments |
5652 | if ($^V && $^V ge 5.10.0 && | |
5653 | defined $stat && | |
5654 | $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) { | |
5655 | my $min = $1; | |
5656 | my $max = $7; | |
5657 | if ($min eq $max) { | |
5658 | WARN("USLEEP_RANGE", | |
5659 | "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n"); | |
5660 | } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ && | |
5661 | $min > $max) { | |
5662 | WARN("USLEEP_RANGE", | |
5663 | "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n"); | |
5664 | } | |
5665 | } | |
5666 | ||
823b794c JP |
5667 | # check for naked sscanf |
5668 | if ($^V && $^V ge 5.10.0 && | |
5669 | defined $stat && | |
6c8bd707 | 5670 | $line =~ /\bsscanf\b/ && |
823b794c JP |
5671 | ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ && |
5672 | $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ && | |
5673 | $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) { | |
5674 | my $lc = $stat =~ tr@\n@@; | |
5675 | $lc = $lc + $linenr; | |
5676 | my $stat_real = raw_line($linenr, 0); | |
5677 | for (my $count = $linenr + 1; $count <= $lc; $count++) { | |
5678 | $stat_real = $stat_real . "\n" . raw_line($count, 0); | |
5679 | } | |
5680 | WARN("NAKED_SSCANF", | |
5681 | "unchecked sscanf return value\n" . "$here\n$stat_real\n"); | |
5682 | } | |
5683 | ||
afc819ab JP |
5684 | # check for simple sscanf that should be kstrto<foo> |
5685 | if ($^V && $^V ge 5.10.0 && | |
5686 | defined $stat && | |
5687 | $line =~ /\bsscanf\b/) { | |
5688 | my $lc = $stat =~ tr@\n@@; | |
5689 | $lc = $lc + $linenr; | |
5690 | my $stat_real = raw_line($linenr, 0); | |
5691 | for (my $count = $linenr + 1; $count <= $lc; $count++) { | |
5692 | $stat_real = $stat_real . "\n" . raw_line($count, 0); | |
5693 | } | |
5694 | if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) { | |
5695 | my $format = $6; | |
5696 | my $count = $format =~ tr@%@%@; | |
5697 | if ($count == 1 && | |
5698 | $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) { | |
5699 | WARN("SSCANF_TO_KSTRTO", | |
5700 | "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n"); | |
5701 | } | |
5702 | } | |
5703 | } | |
5704 | ||
70dc8a48 JP |
5705 | # check for new externs in .h files. |
5706 | if ($realfile =~ /\.h$/ && | |
5707 | $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) { | |
d1d85780 JP |
5708 | if (CHK("AVOID_EXTERNS", |
5709 | "extern prototypes should be avoided in .h files\n" . $herecurr) && | |
70dc8a48 | 5710 | $fix) { |
194f66fc | 5711 | $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/; |
70dc8a48 JP |
5712 | } |
5713 | } | |
5714 | ||
de7d4f0e | 5715 | # check for new externs in .c files. |
171ae1a4 | 5716 | if ($realfile =~ /\.c$/ && defined $stat && |
c45dcabd | 5717 | $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s) |
171ae1a4 | 5718 | { |
c45dcabd AW |
5719 | my $function_name = $1; |
5720 | my $paren_space = $2; | |
171ae1a4 AW |
5721 | |
5722 | my $s = $stat; | |
5723 | if (defined $cond) { | |
5724 | substr($s, 0, length($cond), ''); | |
5725 | } | |
c45dcabd AW |
5726 | if ($s =~ /^\s*;/ && |
5727 | $function_name ne 'uninitialized_var') | |
5728 | { | |
000d1cc1 JP |
5729 | WARN("AVOID_EXTERNS", |
5730 | "externs should be avoided in .c files\n" . $herecurr); | |
171ae1a4 AW |
5731 | } |
5732 | ||
5733 | if ($paren_space =~ /\n/) { | |
000d1cc1 JP |
5734 | WARN("FUNCTION_ARGUMENTS", |
5735 | "arguments for function declarations should follow identifier\n" . $herecurr); | |
171ae1a4 | 5736 | } |
9c9ba34e AW |
5737 | |
5738 | } elsif ($realfile =~ /\.c$/ && defined $stat && | |
5739 | $stat =~ /^.\s*extern\s+/) | |
5740 | { | |
000d1cc1 JP |
5741 | WARN("AVOID_EXTERNS", |
5742 | "externs should be avoided in .c files\n" . $herecurr); | |
de7d4f0e AW |
5743 | } |
5744 | ||
5745 | # checks for new __setup's | |
5746 | if ($rawline =~ /\b__setup\("([^"]*)"/) { | |
5747 | my $name = $1; | |
5748 | ||
5749 | if (!grep(/$name/, @setup_docs)) { | |
000d1cc1 JP |
5750 | CHK("UNDOCUMENTED_SETUP", |
5751 | "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr); | |
de7d4f0e | 5752 | } |
653d4876 | 5753 | } |
9c0ca6f9 AW |
5754 | |
5755 | # check for pointless casting of kmalloc return | |
caf2a54f | 5756 | if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) { |
000d1cc1 JP |
5757 | WARN("UNNECESSARY_CASTS", |
5758 | "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr); | |
9c0ca6f9 | 5759 | } |
13214adf | 5760 | |
a640d25c JP |
5761 | # alloc style |
5762 | # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...) | |
5763 | if ($^V && $^V ge 5.10.0 && | |
5764 | $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) { | |
5765 | CHK("ALLOC_SIZEOF_STRUCT", | |
5766 | "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr); | |
5767 | } | |
5768 | ||
60a55369 JP |
5769 | # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc |
5770 | if ($^V && $^V ge 5.10.0 && | |
e367455a | 5771 | $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) { |
60a55369 JP |
5772 | my $oldfunc = $3; |
5773 | my $a1 = $4; | |
5774 | my $a2 = $10; | |
5775 | my $newfunc = "kmalloc_array"; | |
5776 | $newfunc = "kcalloc" if ($oldfunc eq "kzalloc"); | |
e367455a JP |
5777 | my $r1 = $a1; |
5778 | my $r2 = $a2; | |
5779 | if ($a1 =~ /^sizeof\s*\S/) { | |
5780 | $r1 = $a2; | |
5781 | $r2 = $a1; | |
5782 | } | |
5783 | if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ && | |
5784 | !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) { | |
60a55369 JP |
5785 | if (WARN("ALLOC_WITH_MULTIPLY", |
5786 | "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) && | |
5787 | $fix) { | |
194f66fc | 5788 | $fixed[$fixlinenr] =~ s/\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/$1 . ' = ' . "$newfunc(" . trim($r1) . ', ' . trim($r2)/e; |
60a55369 JP |
5789 | |
5790 | } | |
5791 | } | |
5792 | } | |
5793 | ||
972fdea2 JP |
5794 | # check for krealloc arg reuse |
5795 | if ($^V && $^V ge 5.10.0 && | |
5796 | $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) { | |
5797 | WARN("KREALLOC_ARG_REUSE", | |
5798 | "Reusing the krealloc arg is almost always a bug\n" . $herecurr); | |
5799 | } | |
5800 | ||
5ce59ae0 JP |
5801 | # check for alloc argument mismatch |
5802 | if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) { | |
5803 | WARN("ALLOC_ARRAY_ARGS", | |
5804 | "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr); | |
5805 | } | |
5806 | ||
caf2a54f JP |
5807 | # check for multiple semicolons |
5808 | if ($line =~ /;\s*;\s*$/) { | |
d5e616fc JP |
5809 | if (WARN("ONE_SEMICOLON", |
5810 | "Statements terminations use 1 semicolon\n" . $herecurr) && | |
5811 | $fix) { | |
194f66fc | 5812 | $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g; |
d5e616fc | 5813 | } |
d1e2ad07 JP |
5814 | } |
5815 | ||
cec3aaa5 TW |
5816 | # check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi |
5817 | if ($realfile !~ m@^include/uapi/@ && | |
5818 | $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) { | |
0ab90191 JP |
5819 | my $ull = ""; |
5820 | $ull = "_ULL" if (defined($1) && $1 =~ /ll/i); | |
5821 | if (CHK("BIT_MACRO", | |
5822 | "Prefer using the BIT$ull macro\n" . $herecurr) && | |
5823 | $fix) { | |
5824 | $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/; | |
5825 | } | |
5826 | } | |
5827 | ||
2d632745 JP |
5828 | # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE |
5829 | if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(CONFIG_[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) { | |
5830 | my $config = $1; | |
5831 | if (WARN("PREFER_IS_ENABLED", | |
5832 | "Prefer IS_ENABLED(<FOO>) to CONFIG_<FOO> || CONFIG_<FOO>_MODULE\n" . $herecurr) && | |
5833 | $fix) { | |
5834 | $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)"; | |
5835 | } | |
5836 | } | |
5837 | ||
e81f239b | 5838 | # check for case / default statements not preceded by break/fallthrough/switch |
c34c09a8 JP |
5839 | if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) { |
5840 | my $has_break = 0; | |
5841 | my $has_statement = 0; | |
5842 | my $count = 0; | |
5843 | my $prevline = $linenr; | |
e81f239b | 5844 | while ($prevline > 1 && ($file || $count < 3) && !$has_break) { |
c34c09a8 JP |
5845 | $prevline--; |
5846 | my $rline = $rawlines[$prevline - 1]; | |
5847 | my $fline = $lines[$prevline - 1]; | |
5848 | last if ($fline =~ /^\@\@/); | |
5849 | next if ($fline =~ /^\-/); | |
5850 | next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/); | |
5851 | $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i); | |
5852 | next if ($fline =~ /^.[\s$;]*$/); | |
5853 | $has_statement = 1; | |
5854 | $count++; | |
5855 | $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/); | |
5856 | } | |
5857 | if (!$has_break && $has_statement) { | |
5858 | WARN("MISSING_BREAK", | |
5859 | "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr); | |
5860 | } | |
5861 | } | |
5862 | ||
d1e2ad07 JP |
5863 | # check for switch/default statements without a break; |
5864 | if ($^V && $^V ge 5.10.0 && | |
5865 | defined $stat && | |
5866 | $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) { | |
5867 | my $ctx = ''; | |
5868 | my $herectx = $here . "\n"; | |
5869 | my $cnt = statement_rawlines($stat); | |
5870 | for (my $n = 0; $n < $cnt; $n++) { | |
5871 | $herectx .= raw_line($linenr, $n) . "\n"; | |
5872 | } | |
5873 | WARN("DEFAULT_NO_BREAK", | |
5874 | "switch default: should use break\n" . $herectx); | |
caf2a54f JP |
5875 | } |
5876 | ||
13214adf | 5877 | # check for gcc specific __FUNCTION__ |
d5e616fc JP |
5878 | if ($line =~ /\b__FUNCTION__\b/) { |
5879 | if (WARN("USE_FUNC", | |
5880 | "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) && | |
5881 | $fix) { | |
194f66fc | 5882 | $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g; |
d5e616fc | 5883 | } |
13214adf | 5884 | } |
773647a0 | 5885 | |
62ec818f JP |
5886 | # check for uses of __DATE__, __TIME__, __TIMESTAMP__ |
5887 | while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) { | |
5888 | ERROR("DATE_TIME", | |
5889 | "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr); | |
5890 | } | |
5891 | ||
2c92488a JP |
5892 | # check for use of yield() |
5893 | if ($line =~ /\byield\s*\(\s*\)/) { | |
5894 | WARN("YIELD", | |
5895 | "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr); | |
5896 | } | |
5897 | ||
179f8f40 JP |
5898 | # check for comparisons against true and false |
5899 | if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) { | |
5900 | my $lead = $1; | |
5901 | my $arg = $2; | |
5902 | my $test = $3; | |
5903 | my $otype = $4; | |
5904 | my $trail = $5; | |
5905 | my $op = "!"; | |
5906 | ||
5907 | ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i); | |
5908 | ||
5909 | my $type = lc($otype); | |
5910 | if ($type =~ /^(?:true|false)$/) { | |
5911 | if (("$test" eq "==" && "$type" eq "true") || | |
5912 | ("$test" eq "!=" && "$type" eq "false")) { | |
5913 | $op = ""; | |
5914 | } | |
5915 | ||
5916 | CHK("BOOL_COMPARISON", | |
5917 | "Using comparison to $otype is error prone\n" . $herecurr); | |
5918 | ||
5919 | ## maybe suggesting a correct construct would better | |
5920 | ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr); | |
5921 | ||
5922 | } | |
5923 | } | |
5924 | ||
4882720b TG |
5925 | # check for semaphores initialized locked |
5926 | if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) { | |
000d1cc1 JP |
5927 | WARN("CONSIDER_COMPLETION", |
5928 | "consider using a completion\n" . $herecurr); | |
773647a0 | 5929 | } |
6712d858 | 5930 | |
67d0a075 JP |
5931 | # recommend kstrto* over simple_strto* and strict_strto* |
5932 | if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) { | |
000d1cc1 | 5933 | WARN("CONSIDER_KSTRTO", |
67d0a075 | 5934 | "$1 is obsolete, use k$3 instead\n" . $herecurr); |
773647a0 | 5935 | } |
6712d858 | 5936 | |
ae3ccc46 | 5937 | # check for __initcall(), use device_initcall() explicitly or more appropriate function please |
f3db6639 | 5938 | if ($line =~ /^.\s*__initcall\s*\(/) { |
000d1cc1 | 5939 | WARN("USE_DEVICE_INITCALL", |
ae3ccc46 | 5940 | "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr); |
f3db6639 | 5941 | } |
6712d858 | 5942 | |
0f3c5aab | 5943 | # check for various structs that are normally const (ops, kgdb, device_tree) |
6903ffb2 | 5944 | if ($line !~ /\bconst\b/ && |
0f3c5aab | 5945 | $line =~ /\bstruct\s+($const_structs)\b/) { |
000d1cc1 JP |
5946 | WARN("CONST_STRUCT", |
5947 | "struct $1 should normally be const\n" . | |
6903ffb2 | 5948 | $herecurr); |
2b6db5cb | 5949 | } |
773647a0 AW |
5950 | |
5951 | # use of NR_CPUS is usually wrong | |
5952 | # ignore definitions of NR_CPUS and usage to define arrays as likely right | |
5953 | if ($line =~ /\bNR_CPUS\b/ && | |
c45dcabd AW |
5954 | $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ && |
5955 | $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ && | |
171ae1a4 AW |
5956 | $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ && |
5957 | $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ && | |
5958 | $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/) | |
773647a0 | 5959 | { |
000d1cc1 JP |
5960 | WARN("NR_CPUS", |
5961 | "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr); | |
773647a0 | 5962 | } |
9c9ba34e | 5963 | |
52ea8506 JP |
5964 | # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong. |
5965 | if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) { | |
5966 | ERROR("DEFINE_ARCH_HAS", | |
5967 | "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr); | |
5968 | } | |
5969 | ||
acd9362c JP |
5970 | # likely/unlikely comparisons similar to "(likely(foo) > 0)" |
5971 | if ($^V && $^V ge 5.10.0 && | |
5972 | $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) { | |
5973 | WARN("LIKELY_MISUSE", | |
5974 | "Using $1 should generally have parentheses around the comparison\n" . $herecurr); | |
5975 | } | |
5976 | ||
691d77b6 AW |
5977 | # whine mightly about in_atomic |
5978 | if ($line =~ /\bin_atomic\s*\(/) { | |
5979 | if ($realfile =~ m@^drivers/@) { | |
000d1cc1 JP |
5980 | ERROR("IN_ATOMIC", |
5981 | "do not use in_atomic in drivers\n" . $herecurr); | |
f4a87736 | 5982 | } elsif ($realfile !~ m@^kernel/@) { |
000d1cc1 JP |
5983 | WARN("IN_ATOMIC", |
5984 | "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr); | |
691d77b6 AW |
5985 | } |
5986 | } | |
1704f47b | 5987 | |
481aea5c JP |
5988 | # whine about ACCESS_ONCE |
5989 | if ($^V && $^V ge 5.10.0 && | |
5990 | $line =~ /\bACCESS_ONCE\s*$balanced_parens\s*(=(?!=))?\s*($FuncArg)?/) { | |
5991 | my $par = $1; | |
5992 | my $eq = $2; | |
5993 | my $fun = $3; | |
5994 | $par =~ s/^\(\s*(.*)\s*\)$/$1/; | |
5995 | if (defined($eq)) { | |
5996 | if (WARN("PREFER_WRITE_ONCE", | |
5997 | "Prefer WRITE_ONCE(<FOO>, <BAR>) over ACCESS_ONCE(<FOO>) = <BAR>\n" . $herecurr) && | |
5998 | $fix) { | |
5999 | $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)\s*$eq\s*\Q$fun\E/WRITE_ONCE($par, $fun)/; | |
6000 | } | |
6001 | } else { | |
6002 | if (WARN("PREFER_READ_ONCE", | |
6003 | "Prefer READ_ONCE(<FOO>) over ACCESS_ONCE(<FOO>)\n" . $herecurr) && | |
6004 | $fix) { | |
6005 | $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)/READ_ONCE($par)/; | |
6006 | } | |
6007 | } | |
6008 | } | |
6009 | ||
1704f47b PZ |
6010 | # check for lockdep_set_novalidate_class |
6011 | if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ || | |
6012 | $line =~ /__lockdep_no_validate__\s*\)/ ) { | |
6013 | if ($realfile !~ m@^kernel/lockdep@ && | |
6014 | $realfile !~ m@^include/linux/lockdep@ && | |
6015 | $realfile !~ m@^drivers/base/core@) { | |
000d1cc1 JP |
6016 | ERROR("LOCKDEP", |
6017 | "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr); | |
1704f47b PZ |
6018 | } |
6019 | } | |
88f8831c | 6020 | |
b392c64f JP |
6021 | if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ || |
6022 | $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) { | |
000d1cc1 JP |
6023 | WARN("EXPORTED_WORLD_WRITABLE", |
6024 | "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr); | |
88f8831c | 6025 | } |
2435880f | 6026 | |
515a235e JP |
6027 | # Mode permission misuses where it seems decimal should be octal |
6028 | # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop | |
6029 | if ($^V && $^V ge 5.10.0 && | |
6030 | $line =~ /$mode_perms_search/) { | |
6031 | foreach my $entry (@mode_permission_funcs) { | |
6032 | my $func = $entry->[0]; | |
6033 | my $arg_pos = $entry->[1]; | |
6034 | ||
6035 | my $skip_args = ""; | |
6036 | if ($arg_pos > 1) { | |
6037 | $arg_pos--; | |
6038 | $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}"; | |
6039 | } | |
f90774e1 | 6040 | my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]"; |
515a235e JP |
6041 | if ($line =~ /$test/) { |
6042 | my $val = $1; | |
6043 | $val = $6 if ($skip_args ne ""); | |
f90774e1 JP |
6044 | if (($val =~ /^$Int$/ && $val !~ /^$Octal$/) || |
6045 | ($val =~ /^$Octal$/ && length($val) ne 4)) { | |
515a235e JP |
6046 | ERROR("NON_OCTAL_PERMISSIONS", |
6047 | "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr); | |
f90774e1 JP |
6048 | } |
6049 | if ($val =~ /^$Octal$/ && (oct($val) & 02)) { | |
c0a5c898 JP |
6050 | ERROR("EXPORTED_WORLD_WRITABLE", |
6051 | "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr); | |
515a235e | 6052 | } |
f90774e1 JP |
6053 | if ($val =~ /\b$mode_perms_string_search\b/) { |
6054 | my $to = 0; | |
6055 | while ($val =~ /\b($mode_perms_string_search)\b(?:\s*\|\s*)?\s*/g) { | |
6056 | $to |= $mode_permission_string_types{$1}; | |
6057 | } | |
6058 | my $new = sprintf("%04o", $to); | |
6059 | if (WARN("SYMBOLIC_PERMS", | |
6060 | "Symbolic permissions are not preferred. Consider using octal permissions $new.\n" . $herecurr) && | |
6061 | $fix) { | |
6062 | $fixed[$fixlinenr] =~ s/\Q$val\E/$new/; | |
6063 | } | |
6064 | } | |
2435880f JP |
6065 | } |
6066 | } | |
6067 | } | |
5a6d20ce BA |
6068 | |
6069 | # validate content of MODULE_LICENSE against list from include/linux/module.h | |
6070 | if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) { | |
6071 | my $extracted_string = get_quoted_string($line, $rawline); | |
6072 | my $valid_licenses = qr{ | |
6073 | GPL| | |
6074 | GPL\ v2| | |
6075 | GPL\ and\ additional\ rights| | |
6076 | Dual\ BSD/GPL| | |
6077 | Dual\ MIT/GPL| | |
6078 | Dual\ MPL/GPL| | |
6079 | Proprietary | |
6080 | }x; | |
6081 | if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) { | |
6082 | WARN("MODULE_LICENSE", | |
6083 | "unknown module license " . $extracted_string . "\n" . $herecurr); | |
6084 | } | |
6085 | } | |
13214adf AW |
6086 | } |
6087 | ||
6088 | # If we have no input at all, then there is nothing to report on | |
6089 | # so just keep quiet. | |
6090 | if ($#rawlines == -1) { | |
6091 | exit(0); | |
0a920b5b AW |
6092 | } |
6093 | ||
8905a67c AW |
6094 | # In mailback mode only produce a report in the negative, for |
6095 | # things that appear to be patches. | |
6096 | if ($mailback && ($clean == 1 || !$is_patch)) { | |
6097 | exit(0); | |
6098 | } | |
6099 | ||
6100 | # This is not a patch, and we are are in 'no-patch' mode so | |
6101 | # just keep quiet. | |
6102 | if (!$chk_patch && !$is_patch) { | |
6103 | exit(0); | |
6104 | } | |
6105 | ||
06330fc4 | 6106 | if (!$is_patch && $file !~ /cover-letter\.patch$/) { |
000d1cc1 JP |
6107 | ERROR("NOT_UNIFIED_DIFF", |
6108 | "Does not appear to be a unified-diff format patch\n"); | |
0a920b5b | 6109 | } |
ed43c4e5 | 6110 | if ($is_patch && $has_commit_log && $chk_signoff && $signoff == 0) { |
000d1cc1 JP |
6111 | ERROR("MISSING_SIGN_OFF", |
6112 | "Missing Signed-off-by: line(s)\n"); | |
0a920b5b AW |
6113 | } |
6114 | ||
8905a67c | 6115 | print report_dump(); |
13214adf AW |
6116 | if ($summary && !($clean == 1 && $quiet == 1)) { |
6117 | print "$filename " if ($summary_file); | |
8905a67c AW |
6118 | print "total: $cnt_error errors, $cnt_warn warnings, " . |
6119 | (($check)? "$cnt_chk checks, " : "") . | |
6120 | "$cnt_lines lines checked\n"; | |
f0a594c1 | 6121 | } |
8905a67c | 6122 | |
d2c0a235 | 6123 | if ($quiet == 0) { |
ef212196 JP |
6124 | # If there were any defects found and not already fixing them |
6125 | if (!$clean and !$fix) { | |
6126 | print << "EOM" | |
6127 | ||
6128 | NOTE: For some of the reported defects, checkpatch may be able to | |
6129 | mechanically convert to the typical style using --fix or --fix-inplace. | |
6130 | EOM | |
6131 | } | |
d2c0a235 AW |
6132 | # If there were whitespace errors which cleanpatch can fix |
6133 | # then suggest that. | |
6134 | if ($rpt_cleaners) { | |
b0781216 | 6135 | $rpt_cleaners = 0; |
d8469f16 JP |
6136 | print << "EOM" |
6137 | ||
6138 | NOTE: Whitespace errors detected. | |
6139 | You may wish to use scripts/cleanpatch or scripts/cleanfile | |
6140 | EOM | |
d2c0a235 AW |
6141 | } |
6142 | } | |
6143 | ||
d752fcc8 JP |
6144 | if ($clean == 0 && $fix && |
6145 | ("@rawlines" ne "@fixed" || | |
6146 | $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) { | |
9624b8d6 JP |
6147 | my $newfile = $filename; |
6148 | $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace); | |
3705ce5b JP |
6149 | my $linecount = 0; |
6150 | my $f; | |
6151 | ||
d752fcc8 JP |
6152 | @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted); |
6153 | ||
3705ce5b JP |
6154 | open($f, '>', $newfile) |
6155 | or die "$P: Can't open $newfile for write\n"; | |
6156 | foreach my $fixed_line (@fixed) { | |
6157 | $linecount++; | |
6158 | if ($file) { | |
6159 | if ($linecount > 3) { | |
6160 | $fixed_line =~ s/^\+//; | |
d752fcc8 | 6161 | print $f $fixed_line . "\n"; |
3705ce5b JP |
6162 | } |
6163 | } else { | |
6164 | print $f $fixed_line . "\n"; | |
6165 | } | |
6166 | } | |
6167 | close($f); | |
6168 | ||
6169 | if (!$quiet) { | |
6170 | print << "EOM"; | |
d8469f16 | 6171 | |
3705ce5b JP |
6172 | Wrote EXPERIMENTAL --fix correction(s) to '$newfile' |
6173 | ||
6174 | Do _NOT_ trust the results written to this file. | |
6175 | Do _NOT_ submit these changes without inspecting them for correctness. | |
6176 | ||
6177 | This EXPERIMENTAL file is simply a convenience to help rewrite patches. | |
6178 | No warranties, expressed or implied... | |
3705ce5b JP |
6179 | EOM |
6180 | } | |
6181 | } | |
6182 | ||
d8469f16 JP |
6183 | if ($quiet == 0) { |
6184 | print "\n"; | |
6185 | if ($clean == 1) { | |
6186 | print "$vname has no obvious style problems and is ready for submission.\n"; | |
6187 | } else { | |
6188 | print "$vname has style problems, please review.\n"; | |
6189 | } | |
0a920b5b AW |
6190 | } |
6191 | return $clean; | |
6192 | } |