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