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