projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'mac80211-for-davem-2016-09-13' of git://git.kernel.org/pub/scm/linux/kerne...
[deliverable/linux.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
653d4876
AW		 3573# check for new typedefs, only function parameters and sparse annotations
3574# make sense.
3575 if ($line =~ /\btypedef\s/ &&
8054576d 3576 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
c45dcabd 3577 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
8ed22cad 3578 $line !~ /\b$typeTypedefs\b/ &&
653d4876 3579 $line !~ /\b__bitwise(?:__|)\b/) {
000d1cc1
JP		 3580 WARN("NEW_TYPEDEFS",
3581 "do not add new typedefs\n" . $herecurr);
0a920b5b
AW		 3582 }
3583
3584# * goes on variable not on type
65863862 3585 # (char*[ const])
bfcb2cc7
AW		 3586 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3587 #print "AA<$1>\n";
3705ce5b 3588 my ($ident, $from, $to) = ($1, $2, $2);
65863862
AW		 3589
3590 # Should start with a space.
3591 $to =~ s/^(\S)/ $1/;
3592 # Should not end with a space.
3593 $to =~ s/\s+$//;
3594 # '*'s should not have spaces between.
f9a0b3d1 3595 while ($to =~ s/\*\s+\*/\*\*/) {
65863862 3596 }
d8aaf121 3597
3705ce5b 3598## print "1: from<$from> to<$to> ident<$ident>\n";
65863862 3599 if ($from ne $to) {
3705ce5b
JP		 3600 if (ERROR("POINTER_LOCATION",
3601 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3602 $fix) {
3603 my $sub_from = $ident;
3604 my $sub_to = $ident;
3605 $sub_to =~ s/\Q$from\E/$to/;
194f66fc 3606 $fixed[$fixlinenr] =~
3705ce5b
JP		 3607 s@\Q$sub_from\E@$sub_to@;
3608 }
65863862 3609 }
bfcb2cc7
AW		 3610 }
3611 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3612 #print "BB<$1>\n";
3705ce5b 3613 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
65863862
AW		 3614
3615 # Should start with a space.
3616 $to =~ s/^(\S)/ $1/;
3617 # Should not end with a space.
3618 $to =~ s/\s+$//;
3619 # '*'s should not have spaces between.
f9a0b3d1 3620 while ($to =~ s/\*\s+\*/\*\*/) {
65863862
AW		 3621 }
3622 # Modifiers should have spaces.
3623 $to =~ s/(\b$Modifier$)/$1 /;
d8aaf121 3624
3705ce5b 3625## print "2: from<$from> to<$to> ident<$ident>\n";
667026e7 3626 if ($from ne $to && $ident !~ /^$Modifier$/) {
3705ce5b
JP		 3627 if (ERROR("POINTER_LOCATION",
3628 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3629 $fix) {
3630
3631 my $sub_from = $match;
3632 my $sub_to = $match;
3633 $sub_to =~ s/\Q$from\E/$to/;
194f66fc 3634 $fixed[$fixlinenr] =~
3705ce5b
JP		 3635 s@\Q$sub_from\E@$sub_to@;
3636 }
65863862 3637 }
0a920b5b
AW		 3638 }
3639
9d3e3c70
JP		 3640# avoid BUG() or BUG_ON()
3641 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3642 my $msg_type = \&WARN;
3643 $msg_type = \&CHK if ($file);
3644 &{$msg_type}("AVOID_BUG",
3645 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3646 }
0a920b5b 3647
9d3e3c70 3648# avoid LINUX_VERSION_CODE
8905a67c 3649 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
000d1cc1
JP		 3650 WARN("LINUX_VERSION_CODE",
3651 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
8905a67c
AW		 3652 }
3653
17441227
JP		 3654# check for uses of printk_ratelimit
3655 if ($line =~ /\bprintk_ratelimit\s*\(/) {
000d1cc1 3656 WARN("PRINTK_RATELIMITED",
101ee680 3657 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
17441227
JP		 3658 }
3659
00df344f
AW		 3660# printk should use KERN_* levels. Note that follow on printk's on the
3661# same line do not need a level, so we use the current block context
3662# to try and find and validate the current printk. In summary the current
25985edc 3663# printk includes all preceding printk's which have no newline on the end.
00df344f 3664# we assume the first bad printk is the one to report.
f0a594c1 3665 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
00df344f
AW		 3666 my $ok = 0;
3667 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3668 #print "CHECK<$lines[$ln - 1]\n";
25985edc 3669 # we have a preceding printk if it ends
00df344f
AW		 3670 # with "\n" ignore it, else it is to blame
3671 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3672 if ($rawlines[$ln - 1] !~ m{\\n"}) {
3673 $ok = 1;
3674 }
3675 last;
3676 }
3677 }
3678 if ($ok == 0) {
000d1cc1
JP		 3679 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3680 "printk() should include KERN_ facility level\n" . $herecurr);
00df344f 3681 }
0a920b5b
AW		 3682 }
3683
243f3803
JP		 3684 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3685 my $orig = $1;
3686 my $level = lc($orig);
3687 $level = "warn" if ($level eq "warning");
8f26b837
JP		 3688 my $level2 = $level;
3689 $level2 = "dbg" if ($level eq "debug");
243f3803 3690 WARN("PREFER_PR_LEVEL",
daa8b059 3691 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
243f3803
JP		 3692 }
3693
3694 if ($line =~ /\bpr_warning\s*\(/) {
d5e616fc
JP		 3695 if (WARN("PREFER_PR_LEVEL",
3696 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3697 $fix) {
194f66fc 3698 $fixed[$fixlinenr] =~
d5e616fc
JP		 3699 s/\bpr_warning\b/pr_warn/;
3700 }
243f3803
JP		 3701 }
3702
dc139313
JP		 3703 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3704 my $orig = $1;
3705 my $level = lc($orig);
3706 $level = "warn" if ($level eq "warning");
3707 $level = "dbg" if ($level eq "debug");
3708 WARN("PREFER_DEV_LEVEL",
3709 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3710 }
3711
91c9afaf
AL		 3712# ENOSYS means "bad syscall nr" and nothing else. This will have a small
3713# number of false positives, but assembly files are not checked, so at
3714# least the arch entry code will not trigger this warning.
3715 if ($line =~ /\bENOSYS\b/) {
3716 WARN("ENOSYS",
3717 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3718 }
3719
653d4876
AW		 3720# function brace can't be on same line, except for #defines of do while,
3721# or if closed on same line
8d182478 3722 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
4e5d56bd 3723 !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) {
8d182478
JP		 3724 if (ERROR("OPEN_BRACE",
3725 "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3726 $fix) {
3727 fix_delete_line($fixlinenr, $rawline);
3728 my $fixed_line = $rawline;
3729 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3730 my $line1 = $1;
3731 my $line2 = $2;
3732 fix_insert_line($fixlinenr, ltrim($line1));
3733 fix_insert_line($fixlinenr, "\+{");
3734 if ($line2 !~ /^\s*$/) {
3735 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3736 }
3737 }
0a920b5b 3738 }
653d4876 3739
8905a67c
AW		 3740# open braces for enum, union and struct go on the same line.
3741 if ($line =~ /^.\s*{/ &&
3742 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
8d182478
JP		 3743 if (ERROR("OPEN_BRACE",
3744 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3745 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3746 fix_delete_line($fixlinenr - 1, $prevrawline);
3747 fix_delete_line($fixlinenr, $rawline);
3748 my $fixedline = rtrim($prevrawline) . " {";
3749 fix_insert_line($fixlinenr, $fixedline);
3750 $fixedline = $rawline;
3751 $fixedline =~ s/^(.\s*){\s*/$1\t/;
3752 if ($fixedline !~ /^\+\s*$/) {
3753 fix_insert_line($fixlinenr, $fixedline);
3754 }
3755 }
8905a67c
AW		 3756 }
3757
0c73b4eb 3758# missing space after union, struct or enum definition
3705ce5b
JP		 3759 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3760 if (WARN("SPACING",
3761 "missing space after $1 definition\n" . $herecurr) &&
3762 $fix) {
194f66fc 3763 $fixed[$fixlinenr] =~
3705ce5b
JP		 3764 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3765 }
0c73b4eb
AW		 3766 }
3767
31070b5d
JP		 3768# Function pointer declarations
3769# check spacing between type, funcptr, and args
3770# canonical declaration is "type (*funcptr)(args...)"
91f72e9c 3771 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
31070b5d
JP		 3772 my $declare = $1;
3773 my $pre_pointer_space = $2;
3774 my $post_pointer_space = $3;
3775 my $funcname = $4;
3776 my $post_funcname_space = $5;
3777 my $pre_args_space = $6;
3778
91f72e9c
JP		 3779# the $Declare variable will capture all spaces after the type
3780# so check it for a missing trailing missing space but pointer return types
3781# don't need a space so don't warn for those.
3782 my $post_declare_space = "";
3783 if ($declare =~ /(\s+)$/) {
3784 $post_declare_space = $1;
3785 $declare = rtrim($declare);
3786 }
3787 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
31070b5d
JP		 3788 WARN("SPACING",
3789 "missing space after return type\n" . $herecurr);
91f72e9c 3790 $post_declare_space = " ";
31070b5d
JP		 3791 }
3792
3793# unnecessary space "type (*funcptr)(args...)"
91f72e9c
JP		 3794# This test is not currently implemented because these declarations are
3795# equivalent to
3796# int foo(int bar, ...)
3797# and this is form shouldn't/doesn't generate a checkpatch warning.
3798#
3799# elsif ($declare =~ /\s{2,}$/) {
3800# WARN("SPACING",
3801# "Multiple spaces after return type\n" . $herecurr);
3802# }
31070b5d
JP		 3803
3804# unnecessary space "type ( *funcptr)(args...)"
3805 if (defined $pre_pointer_space &&
3806 $pre_pointer_space =~ /^\s/) {
3807 WARN("SPACING",
3808 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3809 }
3810
3811# unnecessary space "type (* funcptr)(args...)"
3812 if (defined $post_pointer_space &&
3813 $post_pointer_space =~ /^\s/) {
3814 WARN("SPACING",
3815 "Unnecessary space before function pointer name\n" . $herecurr);
3816 }
3817
3818# unnecessary space "type (*funcptr )(args...)"
3819 if (defined $post_funcname_space &&
3820 $post_funcname_space =~ /^\s/) {
3821 WARN("SPACING",
3822 "Unnecessary space after function pointer name\n" . $herecurr);
3823 }
3824
3825# unnecessary space "type (*funcptr) (args...)"
3826 if (defined $pre_args_space &&
3827 $pre_args_space =~ /^\s/) {
3828 WARN("SPACING",
3829 "Unnecessary space before function pointer arguments\n" . $herecurr);
3830 }
3831
3832 if (show_type("SPACING") && $fix) {
194f66fc 3833 $fixed[$fixlinenr] =~
91f72e9c 3834 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
31070b5d
JP		 3835 }
3836 }
3837
8d31cfce
AW		 3838# check for spacing round square brackets; allowed:
3839# 1. with a type on the left -- int [] a;
fe2a7dbc
AW		 3840# 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3841# 3. inside a curly brace -- = { [0...10] = 5 }
8d31cfce
AW		 3842 while ($line =~ /(.*?\s)\[/g) {
3843 my ($where, $prefix) = ($-[1], $1);
3844 if ($prefix !~ /$Type\s+$/ &&
fe2a7dbc 3845 ($where != 0 || $prefix !~ /^.\s+$/) &&
daebc534 3846 $prefix !~ /[{,]\s+$/) {
3705ce5b
JP		 3847 if (ERROR("BRACKET_SPACE",
3848 "space prohibited before open square bracket '['\n" . $herecurr) &&
3849 $fix) {
194f66fc 3850 $fixed[$fixlinenr] =~
3705ce5b
JP		 3851 s/^(\+.*?)\s+\[/$1\[/;
3852 }
8d31cfce
AW		 3853 }
3854 }
3855
f0a594c1 3856# check for spaces between functions and their parentheses.
6c72ffaa 3857 while ($line =~ /($Ident)\s+\(/g) {
c2fdda0d 3858 my $name = $1;
773647a0
AW		 3859 my $ctx_before = substr($line, 0, $-[1]);
3860 my $ctx = "$ctx_before$name";
c2fdda0d
AW		 3861
3862 # Ignore those directives where spaces _are_ permitted.
773647a0
AW		 3863 if ($name =~ /^(?:
3864 if|for|while|switch|return|case|
3865 volatile|__volatile__|
3866 __attribute__|format|__extension__|
3867 asm|__asm__)$/x)
3868 {
c2fdda0d
AW		 3869 # cpp #define statements have non-optional spaces, ie
3870 # if there is a space between the name and the open
3871 # parenthesis it is simply not a parameter group.
c45dcabd 3872 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
773647a0
AW		 3873
3874 # cpp #elif statement condition may start with a (
c45dcabd 3875 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
c2fdda0d
AW		 3876
3877 # If this whole things ends with a type its most
3878 # likely a typedef for a function.
773647a0 3879 } elsif ($ctx =~ /$Type$/) {
c2fdda0d
AW		 3880
3881 } else {
3705ce5b
JP		 3882 if (WARN("SPACING",
3883 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3884 $fix) {
194f66fc 3885 $fixed[$fixlinenr] =~
3705ce5b
JP		 3886 s/\b$name\s+\(/$name\(/;
3887 }
6c72ffaa 3888 }
f0a594c1 3889 }
9a4cad4e 3890
653d4876 3891# Check operator spacing.
0a920b5b 3892 if (!($line=~/\#\s*include/)) {
3705ce5b
JP		 3893 my $fixed_line = "";
3894 my $line_fixed = 0;
3895
9c0ca6f9
AW		 3896 my $ops = qr{
3897 <<=|>>=|<=|>=|==|!=|
3898 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3899 =>|->|<<|>>|<|>|=|!|~|
1f65f947 3900 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
84731623 3901 \?:|\?|:
9c0ca6f9 3902 }x;
cf655043 3903 my @elements = split(/($ops|;)/, $opline);
3705ce5b
JP		 3904
3905## print("element count: <" . $#elements . ">\n");
3906## foreach my $el (@elements) {
3907## print("el: <$el>\n");
3908## }
3909
3910 my @fix_elements = ();
00df344f 3911 my $off = 0;
6c72ffaa 3912
3705ce5b
JP		 3913 foreach my $el (@elements) {
3914 push(@fix_elements, substr($rawline, $off, length($el)));
3915 $off += length($el);
3916 }
3917
3918 $off = 0;
3919
6c72ffaa 3920 my $blank = copy_spacing($opline);
b34c648b 3921 my $last_after = -1;
6c72ffaa 3922
0a920b5b 3923 for (my $n = 0; $n < $#elements; $n += 2) {
3705ce5b
JP		 3924
3925 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3926
3927## print("n: <$n> good: <$good>\n");
3928
4a0df2ef
AW		 3929 $off += length($elements[$n]);
3930
25985edc 3931 # Pick up the preceding and succeeding characters.
773647a0
AW		 3932 my $ca = substr($opline, 0, $off);
3933 my $cc = '';
3934 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3935 $cc = substr($opline, $off + length($elements[$n + 1]));
3936 }
3937 my $cb = "$ca$;$cc";
3938
4a0df2ef
AW		 3939 my $a = '';
3940 $a = 'V' if ($elements[$n] ne '');
3941 $a = 'W' if ($elements[$n] =~ /\s$/);
cf655043 3942 $a = 'C' if ($elements[$n] =~ /$;$/);
4a0df2ef
AW		 3943 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3944 $a = 'O' if ($elements[$n] eq '');
773647a0 3945 $a = 'E' if ($ca =~ /^\s*$/);
4a0df2ef 3946
0a920b5b 3947 my $op = $elements[$n + 1];
4a0df2ef
AW		 3948
3949 my $c = '';
0a920b5b 3950 if (defined $elements[$n + 2]) {
4a0df2ef
AW		 3951 $c = 'V' if ($elements[$n + 2] ne '');
3952 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
cf655043 3953 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
4a0df2ef
AW		 3954 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3955 $c = 'O' if ($elements[$n + 2] eq '');
8b1b3378 3956 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
4a0df2ef
AW		 3957 } else {
3958 $c = 'E';
0a920b5b
AW		 3959 }
3960
4a0df2ef
AW		 3961 my $ctx = "${a}x${c}";
3962
3963 my $at = "(ctx:$ctx)";
3964
6c72ffaa 3965 my $ptr = substr($blank, 0, $off) . "^";
de7d4f0e 3966 my $hereptr = "$hereline$ptr\n";
0a920b5b 3967
74048ed8 3968 # Pull out the value of this operator.
6c72ffaa 3969 my $op_type = substr($curr_values, $off + 1, 1);
0a920b5b 3970
1f65f947
AW		 3971 # Get the full operator variant.
3972 my $opv = $op . substr($curr_vars, $off, 1);
3973
13214adf
AW		 3974 # Ignore operators passed as parameters.
3975 if ($op_type ne 'V' &&
d7fe8065 3976 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
13214adf 3977
cf655043
AW		 3978# # Ignore comments
3979# } elsif ($op =~ /^$;+$/) {
13214adf 3980
d8aaf121 3981 # ; should have either the end of line or a space or \ after it
13214adf 3982 } elsif ($op eq ';') {
cf655043
AW		 3983 if ($ctx !~ /.x[WEBC]/ &&
3984 $cc !~ /^\\/ && $cc !~ /^;/) {
3705ce5b
JP		 3985 if (ERROR("SPACING",
3986 "space required after that '$op' $at\n" . $hereptr)) {
b34c648b 3987 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3705ce5b
JP		 3988 $line_fixed = 1;
3989 }
d8aaf121
AW		 3990 }
3991
3992 # // is a comment
3993 } elsif ($op eq '//') {
0a920b5b 3994
b00e4814
JP		 3995 # : when part of a bitfield
3996 } elsif ($opv eq ':B') {
3997 # skip the bitfield test for now
3998
1f65f947
AW		 3999 # No spaces for:
4000 # ->
b00e4814 4001 } elsif ($op eq '->') {
4a0df2ef 4002 if ($ctx =~ /Wx.|.xW/) {
3705ce5b
JP		 4003 if (ERROR("SPACING",
4004 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
b34c648b 4005 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3705ce5b
JP		 4006 if (defined $fix_elements[$n + 2]) {
4007 $fix_elements[$n + 2] =~ s/^\s+//;
4008 }
b34c648b 4009 $line_fixed = 1;
3705ce5b 4010 }
0a920b5b
AW		 4011 }
4012
2381097b 4013 # , must not have a space before and must have a space on the right.
0a920b5b 4014 } elsif ($op eq ',') {
2381097b
JP		 4015 my $rtrim_before = 0;
4016 my $space_after = 0;
4017 if ($ctx =~ /Wx./) {
4018 if (ERROR("SPACING",
4019 "space prohibited before that '$op' $at\n" . $hereptr)) {
4020 $line_fixed = 1;
4021 $rtrim_before = 1;
4022 }
4023 }
cf655043 4024 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
3705ce5b
JP		 4025 if (ERROR("SPACING",
4026 "space required after that '$op' $at\n" . $hereptr)) {
3705ce5b 4027 $line_fixed = 1;
b34c648b 4028 $last_after = $n;
2381097b
JP		 4029 $space_after = 1;
4030 }
4031 }
4032 if ($rtrim_before || $space_after) {
4033 if ($rtrim_before) {
4034 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4035 } else {
4036 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4037 }
4038 if ($space_after) {
4039 $good .= " ";
3705ce5b 4040 }
0a920b5b
AW		 4041 }
4042
9c0ca6f9 4043 # '*' as part of a type definition -- reported already.
74048ed8 4044 } elsif ($opv eq '*_') {
9c0ca6f9
AW		 4045 #warn "'*' is part of type\n";
4046
4047 # unary operators should have a space before and
4048 # none after. May be left adjacent to another
4049 # unary operator, or a cast
4050 } elsif ($op eq '!' || $op eq '~' ||
74048ed8 4051 $opv eq '*U' || $opv eq '-U' ||
0d413866 4052 $opv eq '&U' || $opv eq '&&U') {
cf655043 4053 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
3705ce5b
JP		 4054 if (ERROR("SPACING",
4055 "space required before that '$op' $at\n" . $hereptr)) {
b34c648b
JP		 4056 if ($n != $last_after + 2) {
4057 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
4058 $line_fixed = 1;
4059 }
3705ce5b 4060 }
0a920b5b 4061 }
a3340b35 4062 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
171ae1a4
AW		 4063 # A unary '*' may be const
4064
4065 } elsif ($ctx =~ /.xW/) {
3705ce5b
JP		 4066 if (ERROR("SPACING",
4067 "space prohibited after that '$op' $at\n" . $hereptr)) {
b34c648b 4068 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
3705ce5b
JP		 4069 if (defined $fix_elements[$n + 2]) {
4070 $fix_elements[$n + 2] =~ s/^\s+//;
4071 }
b34c648b 4072 $line_fixed = 1;
3705ce5b 4073 }
0a920b5b
AW		 4074 }
4075
4076 # unary ++ and unary -- are allowed no space on one side.
4077 } elsif ($op eq '++' or $op eq '--') {
773647a0 4078 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
3705ce5b
JP		 4079 if (ERROR("SPACING",
4080 "space required one side of that '$op' $at\n" . $hereptr)) {
b34c648b 4081 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3705ce5b
JP		 4082 $line_fixed = 1;
4083 }
773647a0
AW		 4084 }
4085 if ($ctx =~ /Wx[BE]/ ||
4086 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
3705ce5b
JP		 4087 if (ERROR("SPACING",
4088 "space prohibited before that '$op' $at\n" . $hereptr)) {
b34c648b 4089 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3705ce5b
JP		 4090 $line_fixed = 1;
4091 }
0a920b5b 4092 }
773647a0 4093 if ($ctx =~ /ExW/) {
3705ce5b
JP		 4094 if (ERROR("SPACING",
4095 "space prohibited after that '$op' $at\n" . $hereptr)) {
b34c648b 4096 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3705ce5b
JP		 4097 if (defined $fix_elements[$n + 2]) {
4098 $fix_elements[$n + 2] =~ s/^\s+//;
4099 }
b34c648b 4100 $line_fixed = 1;
3705ce5b 4101 }
653d4876 4102 }
0a920b5b 4103
0a920b5b 4104 # << and >> may either have or not have spaces both sides
9c0ca6f9
AW		 4105 } elsif ($op eq '<<' or $op eq '>>' or
4106 $op eq '&' or $op eq '^' or $op eq '|' or
4107 $op eq '+' or $op eq '-' or
c2fdda0d
AW		 4108 $op eq '*' or $op eq '/' or
4109 $op eq '%')
0a920b5b 4110 {
d2e025f3
JP		 4111 if ($check) {
4112 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
4113 if (CHK("SPACING",
4114 "spaces preferred around that '$op' $at\n" . $hereptr)) {
4115 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4116 $fix_elements[$n + 2] =~ s/^\s+//;
4117 $line_fixed = 1;
4118 }
4119 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
4120 if (CHK("SPACING",
4121 "space preferred before that '$op' $at\n" . $hereptr)) {
4122 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
4123 $line_fixed = 1;
4124 }
4125 }
4126 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
3705ce5b
JP		 4127 if (ERROR("SPACING",
4128 "need consistent spacing around '$op' $at\n" . $hereptr)) {
b34c648b
JP		 4129 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4130 if (defined $fix_elements[$n + 2]) {
4131 $fix_elements[$n + 2] =~ s/^\s+//;
4132 }
3705ce5b
JP		 4133 $line_fixed = 1;
4134 }
0a920b5b
AW		 4135 }
4136
1f65f947
AW		 4137 # A colon needs no spaces before when it is
4138 # terminating a case value or a label.
4139 } elsif ($opv eq ':C' || $opv eq ':L') {
4140 if ($ctx =~ /Wx./) {
3705ce5b
JP		 4141 if (ERROR("SPACING",
4142 "space prohibited before that '$op' $at\n" . $hereptr)) {
b34c648b 4143 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3705ce5b
JP		 4144 $line_fixed = 1;
4145 }
1f65f947
AW		 4146 }
4147
0a920b5b 4148 # All the others need spaces both sides.
cf655043 4149 } elsif ($ctx !~ /[EWC]x[CWE]/) {
1f65f947
AW		 4150 my $ok = 0;
4151
22f2a2ef 4152 # Ignore email addresses <foo@bar>
1f65f947
AW		 4153 if (($op eq '<' &&
4154 $cc =~ /^\S+\@\S+>/) ||
4155 ($op eq '>' &&
4156 $ca =~ /<\S+\@\S+$/))
4157 {
4158 $ok = 1;
4159 }
4160
e0df7e1f
JP		 4161 # for asm volatile statements
4162 # ignore a colon with another
4163 # colon immediately before or after
4164 if (($op eq ':') &&
4165 ($ca =~ /:$/ || $cc =~ /^:/)) {
4166 $ok = 1;
4167 }
4168
84731623 4169 # messages are ERROR, but ?: are CHK
1f65f947 4170 if ($ok == 0) {
84731623
JP		 4171 my $msg_type = \&ERROR;
4172 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4173
4174 if (&{$msg_type}("SPACING",
4175 "spaces required around that '$op' $at\n" . $hereptr)) {
b34c648b
JP		 4176 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4177 if (defined $fix_elements[$n + 2]) {
4178 $fix_elements[$n + 2] =~ s/^\s+//;
4179 }
3705ce5b
JP		 4180 $line_fixed = 1;
4181 }
22f2a2ef 4182 }
0a920b5b 4183 }
4a0df2ef 4184 $off += length($elements[$n + 1]);
3705ce5b
JP		 4185
4186## print("n: <$n> GOOD: <$good>\n");
4187
4188 $fixed_line = $fixed_line . $good;
4189 }
4190
4191 if (($#elements % 2) == 0) {
4192 $fixed_line = $fixed_line . $fix_elements[$#elements];
0a920b5b 4193 }
3705ce5b 4194
194f66fc
JP		 4195 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4196 $fixed[$fixlinenr] = $fixed_line;
3705ce5b
JP		 4197 }
4198
4199
0a920b5b
AW		 4200 }
4201
786b6326 4202# check for whitespace before a non-naked semicolon
d2e248e7 4203 if ($line =~ /^\+.*\S\s+;\s*$/) {
786b6326
JP		 4204 if (WARN("SPACING",
4205 "space prohibited before semicolon\n" . $herecurr) &&
4206 $fix) {
194f66fc 4207 1 while $fixed[$fixlinenr] =~
786b6326
JP		 4208 s/^(\+.*\S)\s+;/$1;/;
4209 }
4210 }
4211
f0a594c1
AW		 4212# check for multiple assignments
4213 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
000d1cc1
JP		 4214 CHK("MULTIPLE_ASSIGNMENTS",
4215 "multiple assignments should be avoided\n" . $herecurr);
f0a594c1
AW		 4216 }
4217
22f2a2ef
AW		 4218## # check for multiple declarations, allowing for a function declaration
4219## # continuation.
4220## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4221## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4222##
4223## # Remove any bracketed sections to ensure we do not
4224## # falsly report the parameters of functions.
4225## my $ln = $line;
4226## while ($ln =~ s/\([^\(\)]*\)//g) {
4227## }
4228## if ($ln =~ /,/) {
000d1cc1
JP		 4229## WARN("MULTIPLE_DECLARATION",
4230## "declaring multiple variables together should be avoided\n" . $herecurr);
22f2a2ef
AW		 4231## }
4232## }
f0a594c1 4233
0a920b5b 4234#need space before brace following if, while, etc
6b8c69e4 4235 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
4e5d56bd 4236 $line =~ /do\{/) {
3705ce5b
JP		 4237 if (ERROR("SPACING",
4238 "space required before the open brace '{'\n" . $herecurr) &&
4239 $fix) {
194f66fc 4240 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/;
3705ce5b 4241 }
de7d4f0e
AW		 4242 }
4243
c4a62ef9
JP		 4244## # check for blank lines before declarations
4245## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4246## $prevrawline =~ /^.\s*$/) {
4247## WARN("SPACING",
4248## "No blank lines before declarations\n" . $hereprev);
4249## }
4250##
4251
de7d4f0e
AW		 4252# closing brace should have a space following it when it has anything
4253# on the line
4254 if ($line =~ /}(?!(?:,|;|\)))\S/) {
d5e616fc
JP		 4255 if (ERROR("SPACING",
4256 "space required after that close brace '}'\n" . $herecurr) &&
4257 $fix) {
194f66fc 4258 $fixed[$fixlinenr] =~
d5e616fc
JP		 4259 s/}((?!(?:,|;|\)))\S)/} $1/;
4260 }
0a920b5b
AW		 4261 }
4262
22f2a2ef
AW		 4263# check spacing on square brackets
4264 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
3705ce5b
JP		 4265 if (ERROR("SPACING",
4266 "space prohibited after that open square bracket '['\n" . $herecurr) &&
4267 $fix) {
194f66fc 4268 $fixed[$fixlinenr] =~
3705ce5b
JP		 4269 s/\[\s+/\[/;
4270 }
22f2a2ef
AW		 4271 }
4272 if ($line =~ /\s\]/) {
3705ce5b
JP		 4273 if (ERROR("SPACING",
4274 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4275 $fix) {
194f66fc 4276 $fixed[$fixlinenr] =~
3705ce5b
JP		 4277 s/\s+\]/\]/;
4278 }
22f2a2ef
AW		 4279 }
4280
c45dcabd 4281# check spacing on parentheses
9c0ca6f9
AW		 4282 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4283 $line !~ /for\s*\(\s+;/) {
3705ce5b
JP		 4284 if (ERROR("SPACING",
4285 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4286 $fix) {
194f66fc 4287 $fixed[$fixlinenr] =~
3705ce5b
JP		 4288 s/\(\s+/\(/;
4289 }
22f2a2ef 4290 }
13214adf 4291 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
c45dcabd
AW		 4292 $line !~ /for\s*\(.*;\s+\)/ &&
4293 $line !~ /:\s+\)/) {
3705ce5b
JP		 4294 if (ERROR("SPACING",
4295 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4296 $fix) {
194f66fc 4297 $fixed[$fixlinenr] =~
3705ce5b
JP		 4298 s/\s+\)/\)/;
4299 }
22f2a2ef
AW		 4300 }
4301
e2826fd0
JP		 4302# check unnecessary parentheses around addressof/dereference single $Lvals
4303# ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4304
4305 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
ea4acbb1
JP		 4306 my $var = $1;
4307 if (CHK("UNNECESSARY_PARENTHESES",
4308 "Unnecessary parentheses around $var\n" . $herecurr) &&
4309 $fix) {
4310 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4311 }
4312 }
4313
4314# check for unnecessary parentheses around function pointer uses
4315# ie: (foo->bar)(); should be foo->bar();
4316# but not "if (foo->bar) (" to avoid some false positives
4317 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4318 my $var = $2;
4319 if (CHK("UNNECESSARY_PARENTHESES",
4320 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4321 $fix) {
4322 my $var2 = deparenthesize($var);
4323 $var2 =~ s/\s//g;
4324 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4325 }
4326 }
e2826fd0 4327
0a920b5b 4328#goto labels aren't indented, allow a single space however
4a0df2ef 4329 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
0a920b5b 4330 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
3705ce5b
JP		 4331 if (WARN("INDENTED_LABEL",
4332 "labels should not be indented\n" . $herecurr) &&
4333 $fix) {
194f66fc 4334 $fixed[$fixlinenr] =~
3705ce5b
JP		 4335 s/^(.)\s+/$1/;
4336 }
0a920b5b
AW		 4337 }
4338
5b9553ab 4339# return is not a function
507e5141 4340 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
c45dcabd 4341 my $spacing = $1;
507e5141 4342 if ($^V && $^V ge 5.10.0 &&
5b9553ab
JP		 4343 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4344 my $value = $1;
4345 $value = deparenthesize($value);
4346 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4347 ERROR("RETURN_PARENTHESES",
4348 "return is not a function, parentheses are not required\n" . $herecurr);
4349 }
c45dcabd 4350 } elsif ($spacing !~ /\s+/) {
000d1cc1
JP		 4351 ERROR("SPACING",
4352 "space required before the open parenthesis '('\n" . $herecurr);
c45dcabd
AW		 4353 }
4354 }
507e5141 4355
b43ae21b
JP		 4356# unnecessary return in a void function
4357# at end-of-function, with the previous line a single leading tab, then return;
4358# and the line before that not a goto label target like "out:"
4359 if ($sline =~ /^[ \+]}\s*$/ &&
4360 $prevline =~ /^\+\treturn\s*;\s*$/ &&
4361 $linenr >= 3 &&
4362 $lines[$linenr - 3] =~ /^[ +]/ &&
4363 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
9819cf25 4364 WARN("RETURN_VOID",
b43ae21b
JP		 4365 "void function return statements are not generally useful\n" . $hereprev);
4366 }
9819cf25 4367
189248d8
JP		 4368# if statements using unnecessary parentheses - ie: if ((foo == bar))
4369 if ($^V && $^V ge 5.10.0 &&
4370 $line =~ /\bif\s*((?:\(\s*){2,})/) {
4371 my $openparens = $1;
4372 my $count = $openparens =~ tr@\(@\(@;
4373 my $msg = "";
4374 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4375 my $comp = $4; #Not $1 because of $LvalOrFunc
4376 $msg = " - maybe == should be = ?" if ($comp eq "==");
4377 WARN("UNNECESSARY_PARENTHESES",
4378 "Unnecessary parentheses$msg\n" . $herecurr);
4379 }
4380 }
4381
c5595fa2
JP		 4382# comparisons with a constant or upper case identifier on the left
4383# avoid cases like "foo + BAR < baz"
4384# only fix matches surrounded by parentheses to avoid incorrect
4385# conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4386 if ($^V && $^V ge 5.10.0 &&
4387 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4388 my $lead = $1;
4389 my $const = $2;
4390 my $comp = $3;
4391 my $to = $4;
4392 my $newcomp = $comp;
f39e1769 4393 if ($lead !~ /(?:$Operators|\.)\s*$/ &&
c5595fa2
JP		 4394 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4395 WARN("CONSTANT_COMPARISON",
4396 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4397 $fix) {
4398 if ($comp eq "<") {
4399 $newcomp = ">";
4400 } elsif ($comp eq "<=") {
4401 $newcomp = ">=";
4402 } elsif ($comp eq ">") {
4403 $newcomp = "<";
4404 } elsif ($comp eq ">=") {
4405 $newcomp = "<=";
4406 }
4407 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4408 }
4409 }
4410
f34e4a4f
JP		 4411# Return of what appears to be an errno should normally be negative
4412 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
53a3c448
AW		 4413 my $name = $1;
4414 if ($name ne 'EOF' && $name ne 'ERROR') {
000d1cc1 4415 WARN("USE_NEGATIVE_ERRNO",
f34e4a4f 4416 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
53a3c448
AW		 4417 }
4418 }
c45dcabd 4419
0a920b5b 4420# Need a space before open parenthesis after if, while etc
3705ce5b
JP		 4421 if ($line =~ /\b(if|while|for|switch)\(/) {
4422 if (ERROR("SPACING",
4423 "space required before the open parenthesis '('\n" . $herecurr) &&
4424 $fix) {
194f66fc 4425 $fixed[$fixlinenr] =~
3705ce5b
JP		 4426 s/\b(if|while|for|switch)\(/$1 \(/;
4427 }
0a920b5b
AW		 4428 }
4429
f5fe35dd
AW		 4430# Check for illegal assignment in if conditional -- and check for trailing
4431# statements after the conditional.
170d3a22 4432 if ($line =~ /do\s*(?!{)/) {
3e469cdc
AW		 4433 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4434 ctx_statement_block($linenr, $realcnt, 0)
4435 if (!defined $stat);
170d3a22
AW		 4436 my ($stat_next) = ctx_statement_block($line_nr_next,
4437 $remain_next, $off_next);
4438 $stat_next =~ s/\n./\n /g;
4439 ##print "stat<$stat> stat_next<$stat_next>\n";
4440
4441 if ($stat_next =~ /^\s*while\b/) {
4442 # If the statement carries leading newlines,
4443 # then count those as offsets.
4444 my ($whitespace) =
4445 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4446 my $offset =
4447 statement_rawlines($whitespace) - 1;
4448
4449 $suppress_whiletrailers{$line_nr_next +
4450 $offset} = 1;
4451 }
4452 }
4453 if (!defined $suppress_whiletrailers{$linenr} &&
c11230f4 4454 defined($stat) && defined($cond) &&
170d3a22 4455 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
171ae1a4 4456 my ($s, $c) = ($stat, $cond);
8905a67c 4457
b53c8e10 4458 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
000d1cc1
JP		 4459 ERROR("ASSIGN_IN_IF",
4460 "do not use assignment in if condition\n" . $herecurr);
8905a67c
AW		 4461 }
4462
4463 # Find out what is on the end of the line after the
4464 # conditional.
773647a0 4465 substr($s, 0, length($c), '');
8905a67c 4466 $s =~ s/\n.*//g;
13214adf 4467 $s =~ s/$;//g; # Remove any comments
53210168
AW		 4468 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4469 $c !~ /}\s*while\s*/)
773647a0 4470 {
bb44ad39
AW		 4471 # Find out how long the conditional actually is.
4472 my @newlines = ($c =~ /\n/gs);
4473 my $cond_lines = 1 + $#newlines;
42bdf74c 4474 my $stat_real = '';
bb44ad39 4475
42bdf74c
HS		 4476 $stat_real = raw_line($linenr, $cond_lines)
4477 . "\n" if ($cond_lines);
bb44ad39
AW		 4478 if (defined($stat_real) && $cond_lines > 1) {
4479 $stat_real = "[...]\n$stat_real";
4480 }
4481
000d1cc1
JP		 4482 ERROR("TRAILING_STATEMENTS",
4483 "trailing statements should be on next line\n" . $herecurr . $stat_real);
8905a67c
AW		 4484 }
4485 }
4486
13214adf
AW		 4487# Check for bitwise tests written as boolean
4488 if ($line =~ /
4489 (?:
4490 (?:\[|\(|\&\&|\|\|)
4491 \s*0[xX][0-9]+\s*
4492 (?:\&\&|\|\|)
4493 |
4494 (?:\&\&|\|\|)
4495 \s*0[xX][0-9]+\s*
4496 (?:\&\&|\|\||\)|\])
4497 )/x)
4498 {
000d1cc1
JP		 4499 WARN("HEXADECIMAL_BOOLEAN_TEST",
4500 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
13214adf
AW		 4501 }
4502
8905a67c 4503# if and else should not have general statements after it
13214adf
AW		 4504 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4505 my $s = $1;
4506 $s =~ s/$;//g; # Remove any comments
4507 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
000d1cc1
JP		 4508 ERROR("TRAILING_STATEMENTS",
4509 "trailing statements should be on next line\n" . $herecurr);
13214adf 4510 }
0a920b5b 4511 }
39667782
AW		 4512# if should not continue a brace
4513 if ($line =~ /}\s*if\b/) {
000d1cc1 4514 ERROR("TRAILING_STATEMENTS",
048b123f 4515 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
39667782
AW		 4516 $herecurr);
4517 }
a1080bf8
AW		 4518# case and default should not have general statements after them
4519 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4520 $line !~ /\G(?:
3fef12d6 4521 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
a1080bf8
AW		 4522 \s*return\s+
4523 )/xg)
4524 {
000d1cc1
JP		 4525 ERROR("TRAILING_STATEMENTS",
4526 "trailing statements should be on next line\n" . $herecurr);
a1080bf8 4527 }
0a920b5b
AW		 4528
4529 # Check for }<nl>else {, these must be at the same
4530 # indent level to be relevant to each other.
8b8856f4
JP		 4531 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4532 $previndent == $indent) {
4533 if (ERROR("ELSE_AFTER_BRACE",
4534 "else should follow close brace '}'\n" . $hereprev) &&
4535 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4536 fix_delete_line($fixlinenr - 1, $prevrawline);
4537 fix_delete_line($fixlinenr, $rawline);
4538 my $fixedline = $prevrawline;
4539 $fixedline =~ s/}\s*$//;
4540 if ($fixedline !~ /^\+\s*$/) {
4541 fix_insert_line($fixlinenr, $fixedline);
4542 }
4543 $fixedline = $rawline;
4544 $fixedline =~ s/^(.\s*)else/$1} else/;
4545 fix_insert_line($fixlinenr, $fixedline);
4546 }
0a920b5b
AW		 4547 }
4548
8b8856f4
JP		 4549 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4550 $previndent == $indent) {
c2fdda0d
AW		 4551 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4552
4553 # Find out what is on the end of the line after the
4554 # conditional.
773647a0 4555 substr($s, 0, length($c), '');
c2fdda0d
AW		 4556 $s =~ s/\n.*//g;
4557
4558 if ($s =~ /^\s*;/) {
8b8856f4
JP		 4559 if (ERROR("WHILE_AFTER_BRACE",
4560 "while should follow close brace '}'\n" . $hereprev) &&
4561 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4562 fix_delete_line($fixlinenr - 1, $prevrawline);
4563 fix_delete_line($fixlinenr, $rawline);
4564 my $fixedline = $prevrawline;
4565 my $trailing = $rawline;
4566 $trailing =~ s/^\+//;
4567 $trailing = trim($trailing);
4568 $fixedline =~ s/}\s*$/} $trailing/;
4569 fix_insert_line($fixlinenr, $fixedline);
4570 }
c2fdda0d
AW		 4571 }
4572 }
4573
95e2c602 4574#Specific variable tests
323c1260
JP		 4575 while ($line =~ m{($Constant|$Lval)}g) {
4576 my $var = $1;
95e2c602
JP		 4577
4578#gcc binary extension
4579 if ($var =~ /^$Binary$/) {
d5e616fc
JP		 4580 if (WARN("GCC_BINARY_CONSTANT",
4581 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4582 $fix) {
4583 my $hexval = sprintf("0x%x", oct($var));
194f66fc 4584 $fixed[$fixlinenr] =~
d5e616fc
JP		 4585 s/\b$var\b/$hexval/;
4586 }
95e2c602
JP		 4587 }
4588
4589#CamelCase
807bd26c 4590 if ($var !~ /^$Constant$/ &&
be79794b 4591 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
22735ce8 4592#Ignore Page<foo> variants
807bd26c 4593 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
22735ce8 4594#Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
f5123576
JW		 4595 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4596#Ignore some three character SI units explicitly, like MiB and KHz
4597 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
7e781f67
JP		 4598 while ($var =~ m{($Ident)}g) {
4599 my $word = $1;
4600 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
d8b07710
JP		 4601 if ($check) {
4602 seed_camelcase_includes();
4603 if (!$file && !$camelcase_file_seeded) {
4604 seed_camelcase_file($realfile);
4605 $camelcase_file_seeded = 1;
4606 }
4607 }
7e781f67
JP		 4608 if (!defined $camelcase{$word}) {
4609 $camelcase{$word} = 1;
4610 CHK("CAMELCASE",
4611 "Avoid CamelCase: <$word>\n" . $herecurr);
4612 }
3445686a 4613 }
323c1260
JP		 4614 }
4615 }
0a920b5b
AW		 4616
4617#no spaces allowed after \ in define
d5e616fc
JP		 4618 if ($line =~ /\#\s*define.*\\\s+$/) {
4619 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4620 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4621 $fix) {
194f66fc 4622 $fixed[$fixlinenr] =~ s/\s+$//;
d5e616fc 4623 }
0a920b5b
AW		 4624 }
4625
0e212e0a
FF		 4626# warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4627# itself <asm/foo.h> (uses RAW line)
c45dcabd 4628 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
e09dec48
AW		 4629 my $file = "$1.h";
4630 my $checkfile = "include/linux/$file";
4631 if (-f "$root/$checkfile" &&
4632 $realfile ne $checkfile &&
7840a94c 4633 $1 !~ /$allowed_asm_includes/)
c45dcabd 4634 {
0e212e0a
FF		 4635 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4636 if ($asminclude > 0) {
4637 if ($realfile =~ m{^arch/}) {
4638 CHK("ARCH_INCLUDE_LINUX",
4639 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4640 } else {
4641 WARN("INCLUDE_LINUX",
4642 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4643 }
e09dec48 4644 }
0a920b5b
AW		 4645 }
4646 }
4647
653d4876
AW		 4648# multi-statement macros should be enclosed in a do while loop, grab the
4649# first statement and ensure its the whole macro if its not enclosed
cf655043 4650# in a known good container
b8f96a31
AW		 4651 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4652 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
d8aaf121
AW		 4653 my $ln = $linenr;
4654 my $cnt = $realcnt;
c45dcabd
AW		 4655 my ($off, $dstat, $dcond, $rest);
4656 my $ctx = '';
08a2843e
JP		 4657 my $has_flow_statement = 0;
4658 my $has_arg_concat = 0;
c45dcabd 4659 ($dstat, $dcond, $ln, $cnt, $off) =
f74bd194
AW		 4660 ctx_statement_block($linenr, $realcnt, 0);
4661 $ctx = $dstat;
c45dcabd 4662 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
a3bb97a7 4663 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
c45dcabd 4664
08a2843e 4665 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
62e15a6d 4666 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
08a2843e 4667
f74bd194 4668 $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
292f1a9b 4669 $dstat =~ s/$;//g;
c45dcabd
AW		 4670 $dstat =~ s/\\\n.//g;
4671 $dstat =~ s/^\s*//s;
4672 $dstat =~ s/\s*$//s;
de7d4f0e 4673
c45dcabd 4674 # Flatten any parentheses and braces
bf30d6ed
AW		 4675 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4676 $dstat =~ s/\{[^\{\}]*\}/1/ ||
6b10df42 4677 $dstat =~ s/.\[[^\[\]]*\]/1/)
bf30d6ed 4678 {
de7d4f0e 4679 }
d8aaf121 4680
e45bab8e 4681 # Flatten any obvious string concatentation.
33acb54a
JP		 4682 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4683 $dstat =~ s/$Ident\s*($String)/$1/)
e45bab8e
AW		 4684 {
4685 }
4686
42e15293
JP		 4687 # Make asm volatile uses seem like a generic function
4688 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
4689
c45dcabd
AW		 4690 my $exceptions = qr{
4691 $Declare|
4692 module_param_named|
a0a0a7a9 4693 MODULE_PARM_DESC|
c45dcabd
AW		 4694 DECLARE_PER_CPU|
4695 DEFINE_PER_CPU|
383099fd 4696 __typeof__\(|
22fd2d3e
SS		 4697 union|
4698 struct|
ea71a0a0 4699 \.$Ident\s*=\s*|
6b10df42
VZ		 4700 ^\"|\"$|
4701 ^\[
c45dcabd 4702 }x;
5eaa20b9 4703 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
f74bd194
AW		 4704 if ($dstat ne '' &&
4705 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
4706 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
3cc4b1c3 4707 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
356fd398 4708 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
f74bd194
AW		 4709 $dstat !~ /$exceptions/ &&
4710 $dstat !~ /^\.$Ident\s*=/ && # .foo =
e942e2c3 4711 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
72f115f9 4712 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
f74bd194
AW		 4713 $dstat !~ /^for\s*$Constant$/ && # for (...)
4714 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
4715 $dstat !~ /^do\s*{/ && # do {...
4e5d56bd 4716 $dstat !~ /^\(\{/ && # ({...
f95a7e6a 4717 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
f74bd194
AW		 4718 {
4719 $ctx =~ s/\n*$//;
4720 my $herectx = $here . "\n";
4721 my $cnt = statement_rawlines($ctx);
4722
4723 for (my $n = 0; $n < $cnt; $n++) {
4724 $herectx .= raw_line($linenr, $n) . "\n";
c45dcabd
AW		 4725 }
4726
f74bd194
AW		 4727 if ($dstat =~ /;/) {
4728 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4729 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4730 } else {
000d1cc1 4731 ERROR("COMPLEX_MACRO",
388982b5 4732 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
d8aaf121 4733 }
653d4876 4734 }
5023d347 4735
08a2843e
JP		 4736# check for macros with flow control, but without ## concatenation
4737# ## concatenation is commonly a macro that defines a function so ignore those
4738 if ($has_flow_statement && !$has_arg_concat) {
4739 my $herectx = $here . "\n";
4740 my $cnt = statement_rawlines($ctx);
4741
4742 for (my $n = 0; $n < $cnt; $n++) {
4743 $herectx .= raw_line($linenr, $n) . "\n";
4744 }
4745 WARN("MACRO_WITH_FLOW_CONTROL",
4746 "Macros with flow control statements should be avoided\n" . "$herectx");
4747 }
4748
481eb486 4749# check for line continuations outside of #defines, preprocessor #, and asm
5023d347
JP		 4750
4751 } else {
4752 if ($prevline !~ /^..*\\$/ &&
481eb486
JP		 4753 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
4754 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
5023d347
JP		 4755 $line =~ /^\+.*\\$/) {
4756 WARN("LINE_CONTINUATIONS",
4757 "Avoid unnecessary line continuations\n" . $herecurr);
4758 }
0a920b5b
AW		 4759 }
4760
b13edf7f
JP		 4761# do {} while (0) macro tests:
4762# single-statement macros do not need to be enclosed in do while (0) loop,
4763# macro should not end with a semicolon
4764 if ($^V && $^V ge 5.10.0 &&
4765 $realfile !~ m@/vmlinux.lds.h$@ &&
4766 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4767 my $ln = $linenr;
4768 my $cnt = $realcnt;
4769 my ($off, $dstat, $dcond, $rest);
4770 my $ctx = '';
4771 ($dstat, $dcond, $ln, $cnt, $off) =
4772 ctx_statement_block($linenr, $realcnt, 0);
4773 $ctx = $dstat;
4774
4775 $dstat =~ s/\\\n.//g;
1b36b201 4776 $dstat =~ s/$;/ /g;
b13edf7f
JP		 4777
4778 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
4779 my $stmts = $2;
4780 my $semis = $3;
4781
4782 $ctx =~ s/\n*$//;
4783 my $cnt = statement_rawlines($ctx);
4784 my $herectx = $here . "\n";
4785
4786 for (my $n = 0; $n < $cnt; $n++) {
4787 $herectx .= raw_line($linenr, $n) . "\n";
4788 }
4789
ac8e97f8
JP		 4790 if (($stmts =~ tr/;/;/) == 1 &&
4791 $stmts !~ /^\s*(if|while|for|switch)\b/) {
b13edf7f
JP		 4792 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
4793 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
4794 }
4795 if (defined $semis && $semis ne "") {
4796 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
4797 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
4798 }
f5ef95b1
JP		 4799 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
4800 $ctx =~ s/\n*$//;
4801 my $cnt = statement_rawlines($ctx);
4802 my $herectx = $here . "\n";
4803
4804 for (my $n = 0; $n < $cnt; $n++) {
4805 $herectx .= raw_line($linenr, $n) . "\n";
4806 }
4807
4808 WARN("TRAILING_SEMICOLON",
4809 "macros should not use a trailing semicolon\n" . "$herectx");
b13edf7f
JP		 4810 }
4811 }
4812
080ba929
MF		 4813# make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
4814# all assignments may have only one of the following with an assignment:
4815# .
4816# ALIGN(...)
4817# VMLINUX_SYMBOL(...)
4818 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
000d1cc1
JP		 4819 WARN("MISSING_VMLINUX_SYMBOL",
4820 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
080ba929
MF		 4821 }
4822
f0a594c1 4823# check for redundant bracing round if etc
13214adf
AW		 4824 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
4825 my ($level, $endln, @chunks) =
cf655043 4826 ctx_statement_full($linenr, $realcnt, 1);
13214adf 4827 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
cf655043
AW		 4828 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
4829 if ($#chunks > 0 && $level == 0) {
aad4f614
JP		 4830 my @allowed = ();
4831 my $allow = 0;
13214adf 4832 my $seen = 0;
773647a0 4833 my $herectx = $here . "\n";
cf655043 4834 my $ln = $linenr - 1;
13214adf
AW		 4835 for my $chunk (@chunks) {
4836 my ($cond, $block) = @{$chunk};
4837
773647a0
AW		 4838 # If the condition carries leading newlines, then count those as offsets.
4839 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
4840 my $offset = statement_rawlines($whitespace) - 1;
4841
aad4f614 4842 $allowed[$allow] = 0;
773647a0
AW		 4843 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
4844
4845 # We have looked at and allowed this specific line.
4846 $suppress_ifbraces{$ln + $offset} = 1;
4847
4848 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
cf655043
AW		 4849 $ln += statement_rawlines($block) - 1;
4850
773647a0 4851 substr($block, 0, length($cond), '');
13214adf
AW		 4852
4853 $seen++ if ($block =~ /^\s*{/);
4854
aad4f614 4855 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
cf655043
AW		 4856 if (statement_lines($cond) > 1) {
4857 #print "APW: ALLOWED: cond<$cond>\n";
aad4f614 4858 $allowed[$allow] = 1;
13214adf
AW		 4859 }
4860 if ($block =~/\b(?:if|for|while)\b/) {
cf655043 4861 #print "APW: ALLOWED: block<$block>\n";
aad4f614 4862 $allowed[$allow] = 1;
13214adf 4863 }
cf655043
AW		 4864 if (statement_block_size($block) > 1) {
4865 #print "APW: ALLOWED: lines block<$block>\n";
aad4f614 4866 $allowed[$allow] = 1;
13214adf 4867 }
aad4f614 4868 $allow++;
13214adf 4869 }
aad4f614
JP		 4870 if ($seen) {
4871 my $sum_allowed = 0;
4872 foreach (@allowed) {
4873 $sum_allowed += $_;
4874 }
4875 if ($sum_allowed == 0) {
4876 WARN("BRACES",
4877 "braces {} are not necessary for any arm of this statement\n" . $herectx);
4878 } elsif ($sum_allowed != $allow &&
4879 $seen != $allow) {
4880 CHK("BRACES",
4881 "braces {} should be used on all arms of this statement\n" . $herectx);
4882 }
13214adf
AW		 4883 }
4884 }
4885 }
773647a0 4886 if (!defined $suppress_ifbraces{$linenr - 1} &&
13214adf 4887 $line =~ /\b(if|while|for|else)\b/) {
cf655043
AW		 4888 my $allowed = 0;
4889
4890 # Check the pre-context.
4891 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
4892 #print "APW: ALLOWED: pre<$1>\n";
4893 $allowed = 1;
4894 }
773647a0
AW		 4895
4896 my ($level, $endln, @chunks) =
4897 ctx_statement_full($linenr, $realcnt, $-[0]);
4898
cf655043
AW		 4899 # Check the condition.
4900 my ($cond, $block) = @{$chunks[0]};
773647a0 4901 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
cf655043 4902 if (defined $cond) {
773647a0 4903 substr($block, 0, length($cond), '');
cf655043
AW		 4904 }
4905 if (statement_lines($cond) > 1) {
4906 #print "APW: ALLOWED: cond<$cond>\n";
4907 $allowed = 1;
4908 }
4909 if ($block =~/\b(?:if|for|while)\b/) {
4910 #print "APW: ALLOWED: block<$block>\n";
4911 $allowed = 1;
4912 }
4913 if (statement_block_size($block) > 1) {
4914 #print "APW: ALLOWED: lines block<$block>\n";
4915 $allowed = 1;
4916 }
4917 # Check the post-context.
4918 if (defined $chunks[1]) {
4919 my ($cond, $block) = @{$chunks[1]};
4920 if (defined $cond) {
773647a0 4921 substr($block, 0, length($cond), '');
cf655043
AW		 4922 }
4923 if ($block =~ /^\s*\{/) {
4924 #print "APW: ALLOWED: chunk-1 block<$block>\n";
4925 $allowed = 1;
4926 }
4927 }
4928 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
69932487 4929 my $herectx = $here . "\n";
f055663c 4930 my $cnt = statement_rawlines($block);
cf655043 4931
f055663c 4932 for (my $n = 0; $n < $cnt; $n++) {
69932487 4933 $herectx .= raw_line($linenr, $n) . "\n";
f0a594c1 4934 }
cf655043 4935
000d1cc1
JP		 4936 WARN("BRACES",
4937 "braces {} are not necessary for single statement blocks\n" . $herectx);
f0a594c1
AW		 4938 }
4939 }
4940
0979ae66 4941# check for unnecessary blank lines around braces
77b9a53a 4942 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
f8e58219
JP		 4943 if (CHK("BRACES",
4944 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
4945 $fix && $prevrawline =~ /^\+/) {
4946 fix_delete_line($fixlinenr - 1, $prevrawline);
4947 }
0979ae66 4948 }
77b9a53a 4949 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
f8e58219
JP		 4950 if (CHK("BRACES",
4951 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
4952 $fix) {
4953 fix_delete_line($fixlinenr, $rawline);
4954 }
0979ae66
JP		 4955 }
4956
4a0df2ef 4957# no volatiles please
6c72ffaa
AW		 4958 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
4959 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
000d1cc1
JP		 4960 WARN("VOLATILE",
4961 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
4a0df2ef
AW		 4962 }
4963
5e4f6ba5
JP		 4964# Check for user-visible strings broken across lines, which breaks the ability
4965# to grep for the string. Make exceptions when the previous string ends in a
4966# newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
4967# (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
33acb54a 4968 if ($line =~ /^\+\s*$String/ &&
5e4f6ba5
JP		 4969 $prevline =~ /"\s*$/ &&
4970 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
4971 if (WARN("SPLIT_STRING",
4972 "quoted string split across lines\n" . $hereprev) &&
4973 $fix &&
4974 $prevrawline =~ /^\+.*"\s*$/ &&
4975 $last_coalesced_string_linenr != $linenr - 1) {
4976 my $extracted_string = get_quoted_string($line, $rawline);
4977 my $comma_close = "";
4978 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
4979 $comma_close = $1;
4980 }
4981
4982 fix_delete_line($fixlinenr - 1, $prevrawline);
4983 fix_delete_line($fixlinenr, $rawline);
4984 my $fixedline = $prevrawline;
4985 $fixedline =~ s/"\s*$//;
4986 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
4987 fix_insert_line($fixlinenr - 1, $fixedline);
4988 $fixedline = $rawline;
4989 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
4990 if ($fixedline !~ /\+\s*$/) {
4991 fix_insert_line($fixlinenr, $fixedline);
4992 }
4993 $last_coalesced_string_linenr = $linenr;
4994 }
4995 }
4996
4997# check for missing a space in a string concatenation
4998 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
4999 WARN('MISSING_SPACE',
5000 "break quoted strings at a space character\n" . $hereprev);
5001 }
5002
5003# check for spaces before a quoted newline
5004 if ($rawline =~ /^.*\".*\s\\n/) {
5005 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
5006 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
5007 $fix) {
5008 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
5009 }
5010
5011 }
5012
f17dba4f 5013# concatenated string without spaces between elements
33acb54a 5014 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
f17dba4f
JP		 5015 CHK("CONCATENATED_STRING",
5016 "Concatenated strings should use spaces between elements\n" . $herecurr);
5017 }
5018
90ad30e5 5019# uncoalesced string fragments
33acb54a 5020 if ($line =~ /$String\s*"/) {
90ad30e5
JP		 5021 WARN("STRING_FRAGMENTS",
5022 "Consecutive strings are generally better as a single string\n" . $herecurr);
5023 }
5024
6e300757 5025# check for %L{u,d,i} and 0x%[udi] in strings
5e4f6ba5
JP		 5026 my $string;
5027 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
5028 $string = substr($rawline, $-[1], $+[1] - $-[1]);
5029 $string =~ s/%%/__/g;
6e300757 5030 if ($string =~ /(?<!%)%[\*\d\.\$]*L[udi]/) {
5e4f6ba5
JP		 5031 WARN("PRINTF_L",
5032 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
5033 last;
5034 }
6e300757
JP		 5035 if ($string =~ /0x%[\*\d\.\$\Llzth]*[udi]/) {
5036 ERROR("PRINTF_0xDECIMAL",
5037 "Prefixing 0x with decimal output is defective\n" . $herecurr);
5038 }
5e4f6ba5
JP		 5039 }
5040
5041# check for line continuations in quoted strings with odd counts of "
5042 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
5043 WARN("LINE_CONTINUATIONS",
5044 "Avoid line continuations in quoted strings\n" . $herecurr);
5045 }
5046
00df344f 5047# warn about #if 0
c45dcabd 5048 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
000d1cc1
JP		 5049 CHK("REDUNDANT_CODE",
5050 "if this code is redundant consider removing it\n" .
de7d4f0e 5051 $herecurr);
4a0df2ef
AW		 5052 }
5053
03df4b51
AW		 5054# check for needless "if (<foo>) fn(<foo>)" uses
5055 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
100425de
JP		 5056 my $tested = quotemeta($1);
5057 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
5058 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
5059 my $func = $1;
5060 if (WARN('NEEDLESS_IF',
5061 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
5062 $fix) {
5063 my $do_fix = 1;
5064 my $leading_tabs = "";
5065 my $new_leading_tabs = "";
5066 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
5067 $leading_tabs = $1;
5068 } else {
5069 $do_fix = 0;
5070 }
5071 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
5072 $new_leading_tabs = $1;
5073 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
5074 $do_fix = 0;
5075 }
5076 } else {
5077 $do_fix = 0;
5078 }
5079 if ($do_fix) {
5080 fix_delete_line($fixlinenr - 1, $prevrawline);
5081 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
5082 }
5083 }
4c432a8f
GKH		 5084 }
5085 }
f0a594c1 5086
ebfdc409
JP		 5087# check for unnecessary "Out of Memory" messages
5088 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
5089 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
5090 (defined $1 || defined $3) &&
5091 $linenr > 3) {
5092 my $testval = $2;
5093 my $testline = $lines[$linenr - 3];
5094
5095 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
5096# print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
5097
5098 if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
5099 WARN("OOM_MESSAGE",
5100 "Possible unnecessary 'out of memory' message\n" . $hereprev);
5101 }
5102 }
5103
f78d98f6 5104# check for logging functions with KERN_<LEVEL>
dcaf1123 5105 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
f78d98f6
JP		 5106 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
5107 my $level = $1;
5108 if (WARN("UNNECESSARY_KERN_LEVEL",
5109 "Possible unnecessary $level\n" . $herecurr) &&
5110 $fix) {
5111 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
5112 }
5113 }
5114
abb08a53
JP		 5115# check for mask then right shift without a parentheses
5116 if ($^V && $^V ge 5.10.0 &&
5117 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
5118 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
5119 WARN("MASK_THEN_SHIFT",
5120 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
5121 }
5122
b75ac618
JP		 5123# check for pointer comparisons to NULL
5124 if ($^V && $^V ge 5.10.0) {
5125 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
5126 my $val = $1;
5127 my $equal = "!";
5128 $equal = "" if ($4 eq "!=");
5129 if (CHK("COMPARISON_TO_NULL",
5130 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
5131 $fix) {
5132 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
5133 }
5134 }
5135 }
5136
8716de38
JP		 5137# check for bad placement of section $InitAttribute (e.g.: __initdata)
5138 if ($line =~ /(\b$InitAttribute\b)/) {
5139 my $attr = $1;
5140 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
5141 my $ptr = $1;
5142 my $var = $2;
5143 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
5144 ERROR("MISPLACED_INIT",
5145 "$attr should be placed after $var\n" . $herecurr)) ||
5146 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
5147 WARN("MISPLACED_INIT",
5148 "$attr should be placed after $var\n" . $herecurr))) &&
5149 $fix) {
194f66fc 5150 $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		 5151 }
5152 }
5153 }
5154
e970b884
JP		 5155# check for $InitAttributeData (ie: __initdata) with const
5156 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5157 my $attr = $1;
5158 $attr =~ /($InitAttributePrefix)(.*)/;
5159 my $attr_prefix = $1;
5160 my $attr_type = $2;
5161 if (ERROR("INIT_ATTRIBUTE",
5162 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5163 $fix) {
194f66fc 5164 $fixed[$fixlinenr] =~
e970b884
JP		 5165 s/$InitAttributeData/${attr_prefix}initconst/;
5166 }
5167 }
5168
5169# check for $InitAttributeConst (ie: __initconst) without const
5170 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5171 my $attr = $1;
5172 if (ERROR("INIT_ATTRIBUTE",
5173 "Use of $attr requires a separate use of const\n" . $herecurr) &&
5174 $fix) {
194f66fc 5175 my $lead = $fixed[$fixlinenr] =~
e970b884
JP		 5176 /(^\+\s*(?:static\s+))/;
5177 $lead = rtrim($1);
5178 $lead = "$lead " if ($lead !~ /^\+$/);
5179 $lead = "${lead}const ";
194f66fc 5180 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
e970b884
JP		 5181 }
5182 }
5183
c17893c7
JP		 5184# check for __read_mostly with const non-pointer (should just be const)
5185 if ($line =~ /\b__read_mostly\b/ &&
5186 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5187 if (ERROR("CONST_READ_MOSTLY",
5188 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5189 $fix) {
5190 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5191 }
5192 }
5193
fbdb8138
JP		 5194# don't use __constant_<foo> functions outside of include/uapi/
5195 if ($realfile !~ m@^include/uapi/@ &&
5196 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5197 my $constant_func = $1;
5198 my $func = $constant_func;
5199 $func =~ s/^__constant_//;
5200 if (WARN("CONSTANT_CONVERSION",
5201 "$constant_func should be $func\n" . $herecurr) &&
5202 $fix) {
194f66fc 5203 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
fbdb8138
JP		 5204 }
5205 }
5206
1a15a250 5207# prefer usleep_range over udelay
37581c28 5208 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
43c1d77c 5209 my $delay = $1;
1a15a250 5210 # ignore udelay's < 10, however
43c1d77c 5211 if (! ($delay < 10) ) {
000d1cc1 5212 CHK("USLEEP_RANGE",
43c1d77c
JP		 5213 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5214 }
5215 if ($delay > 2000) {
5216 WARN("LONG_UDELAY",
5217 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
1a15a250
PP		 5218 }
5219 }
5220
09ef8725
PP		 5221# warn about unexpectedly long msleep's
5222 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5223 if ($1 < 20) {
000d1cc1 5224 WARN("MSLEEP",
43c1d77c 5225 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
09ef8725
PP		 5226 }
5227 }
5228
36ec1939
JP		 5229# check for comparisons of jiffies
5230 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5231 WARN("JIFFIES_COMPARISON",
5232 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5233 }
5234
9d7a34a5
JP		 5235# check for comparisons of get_jiffies_64()
5236 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5237 WARN("JIFFIES_COMPARISON",
5238 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5239 }
5240
00df344f 5241# warn about #ifdefs in C files
c45dcabd 5242# if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
00df344f
AW		 5243# print "#ifdef in C files should be avoided\n";
5244# print "$herecurr";
5245# $clean = 0;
5246# }
5247
22f2a2ef 5248# warn about spacing in #ifdefs
c45dcabd 5249 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
3705ce5b
JP		 5250 if (ERROR("SPACING",
5251 "exactly one space required after that #$1\n" . $herecurr) &&
5252 $fix) {
194f66fc 5253 $fixed[$fixlinenr] =~
3705ce5b
JP		 5254 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5255 }
5256
22f2a2ef
AW		 5257 }
5258
4a0df2ef 5259# check for spinlock_t definitions without a comment.
171ae1a4
AW		 5260 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5261 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
4a0df2ef
AW		 5262 my $which = $1;
5263 if (!ctx_has_comment($first_line, $linenr)) {
000d1cc1
JP		 5264 CHK("UNCOMMENTED_DEFINITION",
5265 "$1 definition without comment\n" . $herecurr);
4a0df2ef
AW		 5266 }
5267 }
5268# check for memory barriers without a comment.
402c2553
MT		 5269
5270 my $barriers = qr{
5271 mb|
5272 rmb|
5273 wmb|
5274 read_barrier_depends
5275 }x;
5276 my $barrier_stems = qr{
5277 mb__before_atomic|
5278 mb__after_atomic|
5279 store_release|
5280 load_acquire|
5281 store_mb|
5282 (?:$barriers)
5283 }x;
5284 my $all_barriers = qr{
5285 (?:$barriers)|
43e361f2
MT		 5286 smp_(?:$barrier_stems)|
5287 virt_(?:$barrier_stems)
402c2553
MT		 5288 }x;
5289
5290 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
4a0df2ef 5291 if (!ctx_has_comment($first_line, $linenr)) {
c1fd7bb9
JP		 5292 WARN("MEMORY_BARRIER",
5293 "memory barrier without comment\n" . $herecurr);
4a0df2ef
AW		 5294 }
5295 }
3ad81779 5296
f4073b0f
MT		 5297 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
5298
5299 if ($realfile !~ m@^include/asm-generic/@ &&
5300 $realfile !~ m@/barrier\.h$@ &&
5301 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
5302 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
5303 WARN("MEMORY_BARRIER",
5304 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
5305 }
5306
cb426e99
JP		 5307# check for waitqueue_active without a comment.
5308 if ($line =~ /\bwaitqueue_active\s*\(/) {
5309 if (!ctx_has_comment($first_line, $linenr)) {
5310 WARN("WAITQUEUE_ACTIVE",
5311 "waitqueue_active without comment\n" . $herecurr);
5312 }
5313 }
3ad81779
PM		 5314
5315# Check for expedited grace periods that interrupt non-idle non-nohz
5316# online CPUs. These expedited can therefore degrade real-time response
5317# if used carelessly, and should be avoided where not absolutely
5318# needed. It is always OK to use synchronize_rcu_expedited() and
5319# synchronize_sched_expedited() at boot time (before real-time applications
5320# start) and in error situations where real-time response is compromised in
5321# any case. Note that synchronize_srcu_expedited() does -not- interrupt
5322# other CPUs, so don't warn on uses of synchronize_srcu_expedited().
5323# Of course, nothing comes for free, and srcu_read_lock() and
5324# srcu_read_unlock() do contain full memory barriers in payment for
5325# synchronize_srcu_expedited() non-interruption properties.
5326 if ($line =~ /\b(synchronize_rcu_expedited|synchronize_sched_expedited)\(/) {
5327 WARN("EXPEDITED_RCU_GRACE_PERIOD",
5328 "expedited RCU grace periods should be avoided where they can degrade real-time response\n" . $herecurr);
5329
5330 }
5331
4a0df2ef 5332# check of hardware specific defines
c45dcabd 5333 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
000d1cc1
JP		 5334 CHK("ARCH_DEFINES",
5335 "architecture specific defines should be avoided\n" . $herecurr);
0a920b5b 5336 }
653d4876 5337
d4977c78
TK		 5338# Check that the storage class is at the beginning of a declaration
5339 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
000d1cc1
JP		 5340 WARN("STORAGE_CLASS",
5341 "storage class should be at the beginning of the declaration\n" . $herecurr)
d4977c78
TK		 5342 }
5343
de7d4f0e
AW		 5344# check the location of the inline attribute, that it is between
5345# storage class and type.
9c0ca6f9
AW		 5346 if ($line =~ /\b$Type\s+$Inline\b/ ||
5347 $line =~ /\b$Inline\s+$Storage\b/) {
000d1cc1
JP		 5348 ERROR("INLINE_LOCATION",
5349 "inline keyword should sit between storage class and type\n" . $herecurr);
de7d4f0e
AW		 5350 }
5351
8905a67c 5352# Check for __inline__ and __inline, prefer inline
2b7ab453
JP		 5353 if ($realfile !~ m@\binclude/uapi/@ &&
5354 $line =~ /\b(__inline__|__inline)\b/) {
d5e616fc
JP		 5355 if (WARN("INLINE",
5356 "plain inline is preferred over $1\n" . $herecurr) &&
5357 $fix) {
194f66fc 5358 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
d5e616fc
JP		 5359
5360 }
8905a67c
AW		 5361 }
5362
3d130fd0 5363# Check for __attribute__ packed, prefer __packed
2b7ab453
JP		 5364 if ($realfile !~ m@\binclude/uapi/@ &&
5365 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
000d1cc1
JP		 5366 WARN("PREFER_PACKED",
5367 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
3d130fd0
JP		 5368 }
5369
39b7e287 5370# Check for __attribute__ aligned, prefer __aligned
2b7ab453
JP		 5371 if ($realfile !~ m@\binclude/uapi/@ &&
5372 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
000d1cc1
JP		 5373 WARN("PREFER_ALIGNED",
5374 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
39b7e287
JP		 5375 }
5376
5f14d3bd 5377# Check for __attribute__ format(printf, prefer __printf
2b7ab453
JP		 5378 if ($realfile !~ m@\binclude/uapi/@ &&
5379 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
d5e616fc
JP		 5380 if (WARN("PREFER_PRINTF",
5381 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5382 $fix) {
194f66fc 5383 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
d5e616fc
JP		 5384
5385 }
5f14d3bd
JP		 5386 }
5387
6061d949 5388# Check for __attribute__ format(scanf, prefer __scanf
2b7ab453
JP		 5389 if ($realfile !~ m@\binclude/uapi/@ &&
5390 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
d5e616fc
JP		 5391 if (WARN("PREFER_SCANF",
5392 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5393 $fix) {
194f66fc 5394 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
d5e616fc 5395 }
6061d949
JP		 5396 }
5397
619a908a
JP		 5398# Check for __attribute__ weak, or __weak declarations (may have link issues)
5399 if ($^V && $^V ge 5.10.0 &&
5400 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5401 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5402 $line =~ /\b__weak\b/)) {
5403 ERROR("WEAK_DECLARATION",
5404 "Using weak declarations can have unintended link defects\n" . $herecurr);
5405 }
5406
e6176fa4
JP		 5407# check for c99 types like uint8_t used outside of uapi/
5408 if ($realfile !~ m@\binclude/uapi/@ &&
5409 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5410 my $type = $1;
5411 if ($type =~ /\b($typeC99Typedefs)\b/) {
5412 $type = $1;
5413 my $kernel_type = 'u';
5414 $kernel_type = 's' if ($type =~ /^_*[si]/);
5415 $type =~ /(\d+)/;
5416 $kernel_type .= $1;
5417 if (CHK("PREFER_KERNEL_TYPES",
5418 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5419 $fix) {
5420 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5421 }
5422 }
5423 }
5424
938224b5
JP		 5425# check for cast of C90 native int or longer types constants
5426 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
5427 my $cast = $1;
5428 my $const = $2;
5429 if (WARN("TYPECAST_INT_CONSTANT",
5430 "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
5431 $fix) {
5432 my $suffix = "";
5433 my $newconst = $const;
5434 $newconst =~ s/${Int_type}$//;
5435 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
5436 if ($cast =~ /\blong\s+long\b/) {
5437 $suffix .= 'LL';
5438 } elsif ($cast =~ /\blong\b/) {
5439 $suffix .= 'L';
5440 }
5441 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
5442 }
5443 }
5444
8f53a9b8
JP		 5445# check for sizeof(&)
5446 if ($line =~ /\bsizeof\s*\(\s*\&/) {
000d1cc1
JP		 5447 WARN("SIZEOF_ADDRESS",
5448 "sizeof(& should be avoided\n" . $herecurr);
8f53a9b8
JP		 5449 }
5450
66c80b60
JP		 5451# check for sizeof without parenthesis
5452 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
d5e616fc
JP		 5453 if (WARN("SIZEOF_PARENTHESIS",
5454 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5455 $fix) {
194f66fc 5456 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
d5e616fc 5457 }
66c80b60
JP		 5458 }
5459
88982fea
JP		 5460# check for struct spinlock declarations
5461 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5462 WARN("USE_SPINLOCK_T",
5463 "struct spinlock should be spinlock_t\n" . $herecurr);
5464 }
5465
a6962d72 5466# check for seq_printf uses that could be seq_puts
06668727 5467 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
a6962d72 5468 my $fmt = get_quoted_string($line, $rawline);
caac1d5f
HA		 5469 $fmt =~ s/%%//g;
5470 if ($fmt !~ /%/) {
d5e616fc
JP		 5471 if (WARN("PREFER_SEQ_PUTS",
5472 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5473 $fix) {
194f66fc 5474 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
d5e616fc 5475 }
a6962d72
JP		 5476 }
5477 }
5478
554e165c 5479# Check for misused memsets
d1fe9c09
JP		 5480 if ($^V && $^V ge 5.10.0 &&
5481 defined $stat &&
9e20a853 5482 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
d7c76ba7
JP		 5483
5484 my $ms_addr = $2;
d1fe9c09
JP		 5485 my $ms_val = $7;
5486 my $ms_size = $12;
554e165c 5487
554e165c
AW		 5488 if ($ms_size =~ /^(0x|)0$/i) {
5489 ERROR("MEMSET",
d7c76ba7 5490 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
554e165c
AW		 5491 } elsif ($ms_size =~ /^(0x|)1$/i) {
5492 WARN("MEMSET",
d7c76ba7
JP		 5493 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5494 }
5495 }
5496
98a9bba5
JP		 5497# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5498 if ($^V && $^V ge 5.10.0 &&
10895d2c
MK		 5499 defined $stat &&
5500 $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
98a9bba5 5501 if (WARN("PREFER_ETHER_ADDR_COPY",
10895d2c 5502 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
98a9bba5 5503 $fix) {
194f66fc 5504 $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
98a9bba5
JP		 5505 }
5506 }
5507
b6117d17
MK		 5508# Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5509 if ($^V && $^V ge 5.10.0 &&
5510 defined $stat &&
5511 $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5512 WARN("PREFER_ETHER_ADDR_EQUAL",
5513 "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5514 }
5515
8617cd09
MK		 5516# check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5517# check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5518 if ($^V && $^V ge 5.10.0 &&
5519 defined $stat &&
5520 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5521
5522 my $ms_val = $7;
5523
5524 if ($ms_val =~ /^(?:0x|)0+$/i) {
5525 if (WARN("PREFER_ETH_ZERO_ADDR",
5526 "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5527 $fix) {
5528 $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5529 }
5530 } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5531 if (WARN("PREFER_ETH_BROADCAST_ADDR",
5532 "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5533 $fix) {
5534 $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5535 }
5536 }
5537 }
5538
d7c76ba7 5539# typecasts on min/max could be min_t/max_t
d1fe9c09
JP		 5540 if ($^V && $^V ge 5.10.0 &&
5541 defined $stat &&
d7c76ba7 5542 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
d1fe9c09 5543 if (defined $2 || defined $7) {
d7c76ba7
JP		 5544 my $call = $1;
5545 my $cast1 = deparenthesize($2);
5546 my $arg1 = $3;
d1fe9c09
JP		 5547 my $cast2 = deparenthesize($7);
5548 my $arg2 = $8;
d7c76ba7
JP		 5549 my $cast;
5550
d1fe9c09 5551 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
d7c76ba7
JP		 5552 $cast = "$cast1 or $cast2";
5553 } elsif ($cast1 ne "") {
5554 $cast = $cast1;
5555 } else {
5556 $cast = $cast2;
5557 }
5558 WARN("MINMAX",
5559 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
554e165c
AW		 5560 }
5561 }
5562
4a273195
JP		 5563# check usleep_range arguments
5564 if ($^V && $^V ge 5.10.0 &&
5565 defined $stat &&
5566 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5567 my $min = $1;
5568 my $max = $7;
5569 if ($min eq $max) {
5570 WARN("USLEEP_RANGE",
5571 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5572 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5573 $min > $max) {
5574 WARN("USLEEP_RANGE",
5575 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5576 }
5577 }
5578
823b794c
JP		 5579# check for naked sscanf
5580 if ($^V && $^V ge 5.10.0 &&
5581 defined $stat &&
6c8bd707 5582 $line =~ /\bsscanf\b/ &&
823b794c
JP		 5583 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5584 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5585 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5586 my $lc = $stat =~ tr@\n@@;
5587 $lc = $lc + $linenr;
5588 my $stat_real = raw_line($linenr, 0);
5589 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5590 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5591 }
5592 WARN("NAKED_SSCANF",
5593 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5594 }
5595
afc819ab
JP		 5596# check for simple sscanf that should be kstrto<foo>
5597 if ($^V && $^V ge 5.10.0 &&
5598 defined $stat &&
5599 $line =~ /\bsscanf\b/) {
5600 my $lc = $stat =~ tr@\n@@;
5601 $lc = $lc + $linenr;
5602 my $stat_real = raw_line($linenr, 0);
5603 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5604 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5605 }
5606 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5607 my $format = $6;
5608 my $count = $format =~ tr@%@%@;
5609 if ($count == 1 &&
5610 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5611 WARN("SSCANF_TO_KSTRTO",
5612 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5613 }
5614 }
5615 }
5616
70dc8a48
JP		 5617# check for new externs in .h files.
5618 if ($realfile =~ /\.h$/ &&
5619 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
d1d85780
JP		 5620 if (CHK("AVOID_EXTERNS",
5621 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
70dc8a48 5622 $fix) {
194f66fc 5623 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
70dc8a48
JP		 5624 }
5625 }
5626
de7d4f0e 5627# check for new externs in .c files.
171ae1a4 5628 if ($realfile =~ /\.c$/ && defined $stat &&
c45dcabd 5629 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
171ae1a4 5630 {
c45dcabd
AW		 5631 my $function_name = $1;
5632 my $paren_space = $2;
171ae1a4
AW		 5633
5634 my $s = $stat;
5635 if (defined $cond) {
5636 substr($s, 0, length($cond), '');
5637 }
c45dcabd
AW		 5638 if ($s =~ /^\s*;/ &&
5639 $function_name ne 'uninitialized_var')
5640 {
000d1cc1
JP		 5641 WARN("AVOID_EXTERNS",
5642 "externs should be avoided in .c files\n" . $herecurr);
171ae1a4
AW		 5643 }
5644
5645 if ($paren_space =~ /\n/) {
000d1cc1
JP		 5646 WARN("FUNCTION_ARGUMENTS",
5647 "arguments for function declarations should follow identifier\n" . $herecurr);
171ae1a4 5648 }
9c9ba34e
AW		 5649
5650 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5651 $stat =~ /^.\s*extern\s+/)
5652 {
000d1cc1
JP		 5653 WARN("AVOID_EXTERNS",
5654 "externs should be avoided in .c files\n" . $herecurr);
de7d4f0e
AW		 5655 }
5656
5657# checks for new __setup's
5658 if ($rawline =~ /\b__setup\("([^"]*)"/) {
5659 my $name = $1;
5660
5661 if (!grep(/$name/, @setup_docs)) {
000d1cc1
JP		 5662 CHK("UNDOCUMENTED_SETUP",
5663 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
de7d4f0e 5664 }
653d4876 5665 }
9c0ca6f9
AW		 5666
5667# check for pointless casting of kmalloc return
caf2a54f 5668 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
000d1cc1
JP		 5669 WARN("UNNECESSARY_CASTS",
5670 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
9c0ca6f9 5671 }
13214adf 5672
a640d25c
JP		 5673# alloc style
5674# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
5675 if ($^V && $^V ge 5.10.0 &&
5676 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
5677 CHK("ALLOC_SIZEOF_STRUCT",
5678 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
5679 }
5680
60a55369
JP		 5681# check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
5682 if ($^V && $^V ge 5.10.0 &&
e367455a 5683 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
60a55369
JP		 5684 my $oldfunc = $3;
5685 my $a1 = $4;
5686 my $a2 = $10;
5687 my $newfunc = "kmalloc_array";
5688 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
e367455a
JP		 5689 my $r1 = $a1;
5690 my $r2 = $a2;
5691 if ($a1 =~ /^sizeof\s*\S/) {
5692 $r1 = $a2;
5693 $r2 = $a1;
5694 }
5695 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
5696 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
60a55369
JP		 5697 if (WARN("ALLOC_WITH_MULTIPLY",
5698 "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
5699 $fix) {
194f66fc 5700 $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		 5701
5702 }
5703 }
5704 }
5705
972fdea2
JP		 5706# check for krealloc arg reuse
5707 if ($^V && $^V ge 5.10.0 &&
5708 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
5709 WARN("KREALLOC_ARG_REUSE",
5710 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
5711 }
5712
5ce59ae0
JP		 5713# check for alloc argument mismatch
5714 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
5715 WARN("ALLOC_ARRAY_ARGS",
5716 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
5717 }
5718
caf2a54f
JP		 5719# check for multiple semicolons
5720 if ($line =~ /;\s*;\s*$/) {
d5e616fc
JP		 5721 if (WARN("ONE_SEMICOLON",
5722 "Statements terminations use 1 semicolon\n" . $herecurr) &&
5723 $fix) {
194f66fc 5724 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
d5e616fc 5725 }
d1e2ad07
JP		 5726 }
5727
cec3aaa5
TW		 5728# check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
5729 if ($realfile !~ m@^include/uapi/@ &&
5730 $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
0ab90191
JP		 5731 my $ull = "";
5732 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
5733 if (CHK("BIT_MACRO",
5734 "Prefer using the BIT$ull macro\n" . $herecurr) &&
5735 $fix) {
5736 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
5737 }
5738 }
5739
2d632745
JP		 5740# check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
5741 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(CONFIG_[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
5742 my $config = $1;
5743 if (WARN("PREFER_IS_ENABLED",
5744 "Prefer IS_ENABLED(<FOO>) to CONFIG_<FOO> || CONFIG_<FOO>_MODULE\n" . $herecurr) &&
5745 $fix) {
5746 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
5747 }
5748 }
5749
e81f239b 5750# check for case / default statements not preceded by break/fallthrough/switch
c34c09a8
JP		 5751 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
5752 my $has_break = 0;
5753 my $has_statement = 0;
5754 my $count = 0;
5755 my $prevline = $linenr;
e81f239b 5756 while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
c34c09a8
JP		 5757 $prevline--;
5758 my $rline = $rawlines[$prevline - 1];
5759 my $fline = $lines[$prevline - 1];
5760 last if ($fline =~ /^\@\@/);
5761 next if ($fline =~ /^\-/);
5762 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
5763 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
5764 next if ($fline =~ /^.[\s$;]*$/);
5765 $has_statement = 1;
5766 $count++;
5767 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
5768 }
5769 if (!$has_break && $has_statement) {
5770 WARN("MISSING_BREAK",
5771 "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
5772 }
5773 }
5774
d1e2ad07
JP		 5775# check for switch/default statements without a break;
5776 if ($^V && $^V ge 5.10.0 &&
5777 defined $stat &&
5778 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
5779 my $ctx = '';
5780 my $herectx = $here . "\n";
5781 my $cnt = statement_rawlines($stat);
5782 for (my $n = 0; $n < $cnt; $n++) {
5783 $herectx .= raw_line($linenr, $n) . "\n";
5784 }
5785 WARN("DEFAULT_NO_BREAK",
5786 "switch default: should use break\n" . $herectx);
caf2a54f
JP		 5787 }
5788
13214adf 5789# check for gcc specific __FUNCTION__
d5e616fc
JP		 5790 if ($line =~ /\b__FUNCTION__\b/) {
5791 if (WARN("USE_FUNC",
5792 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
5793 $fix) {
194f66fc 5794 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
d5e616fc 5795 }
13214adf 5796 }
773647a0 5797
62ec818f
JP		 5798# check for uses of __DATE__, __TIME__, __TIMESTAMP__
5799 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
5800 ERROR("DATE_TIME",
5801 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
5802 }
5803
2c92488a
JP		 5804# check for use of yield()
5805 if ($line =~ /\byield\s*\(\s*\)/) {
5806 WARN("YIELD",
5807 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
5808 }
5809
179f8f40
JP		 5810# check for comparisons against true and false
5811 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
5812 my $lead = $1;
5813 my $arg = $2;
5814 my $test = $3;
5815 my $otype = $4;
5816 my $trail = $5;
5817 my $op = "!";
5818
5819 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
5820
5821 my $type = lc($otype);
5822 if ($type =~ /^(?:true|false)$/) {
5823 if (("$test" eq "==" && "$type" eq "true") ||
5824 ("$test" eq "!=" && "$type" eq "false")) {
5825 $op = "";
5826 }
5827
5828 CHK("BOOL_COMPARISON",
5829 "Using comparison to $otype is error prone\n" . $herecurr);
5830
5831## maybe suggesting a correct construct would better
5832## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
5833
5834 }
5835 }
5836
4882720b
TG		 5837# check for semaphores initialized locked
5838 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
000d1cc1
JP		 5839 WARN("CONSIDER_COMPLETION",
5840 "consider using a completion\n" . $herecurr);
773647a0 5841 }
6712d858 5842
67d0a075
JP		 5843# recommend kstrto* over simple_strto* and strict_strto*
5844 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
000d1cc1 5845 WARN("CONSIDER_KSTRTO",
67d0a075 5846 "$1 is obsolete, use k$3 instead\n" . $herecurr);
773647a0 5847 }
6712d858 5848
ae3ccc46 5849# check for __initcall(), use device_initcall() explicitly or more appropriate function please
f3db6639 5850 if ($line =~ /^.\s*__initcall\s*\(/) {
000d1cc1 5851 WARN("USE_DEVICE_INITCALL",
ae3ccc46 5852 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
f3db6639 5853 }
6712d858 5854
0f3c5aab
JP		 5855# check for various structs that are normally const (ops, kgdb, device_tree)
5856 my $const_structs = qr{
5857 acpi_dock_ops|
79404849
ER		 5858 address_space_operations|
5859 backlight_ops|
5860 block_device_operations|
5861 dentry_operations|
5862 dev_pm_ops|
5863 dma_map_ops|
5864 extent_io_ops|
5865 file_lock_operations|
5866 file_operations|
5867 hv_ops|
5868 ide_dma_ops|
5869 intel_dvo_dev_ops|
5870 item_operations|
5871 iwl_ops|
5872 kgdb_arch|
5873 kgdb_io|
5874 kset_uevent_ops|
5875 lock_manager_operations|
5876 microcode_ops|
5877 mtrr_ops|
5878 neigh_ops|
5879 nlmsvc_binding|
0f3c5aab 5880 of_device_id|
79404849
ER		 5881 pci_raw_ops|
5882 pipe_buf_operations|
5883 platform_hibernation_ops|
5884 platform_suspend_ops|
5885 proto_ops|
5886 rpc_pipe_ops|
5887 seq_operations|
5888 snd_ac97_build_ops|
5889 soc_pcmcia_socket_ops|
5890 stacktrace_ops|
5891 sysfs_ops|
5892 tty_operations|
6d07d01b 5893 uart_ops|
79404849
ER		 5894 usb_mon_operations|
5895 wd_ops}x;
6903ffb2 5896 if ($line !~ /\bconst\b/ &&
0f3c5aab 5897 $line =~ /\bstruct\s+($const_structs)\b/) {
000d1cc1
JP		 5898 WARN("CONST_STRUCT",
5899 "struct $1 should normally be const\n" .
6903ffb2 5900 $herecurr);
2b6db5cb 5901 }
773647a0
AW		 5902
5903# use of NR_CPUS is usually wrong
5904# ignore definitions of NR_CPUS and usage to define arrays as likely right
5905 if ($line =~ /\bNR_CPUS\b/ &&
c45dcabd
AW		 5906 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
5907 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
171ae1a4
AW		 5908 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
5909 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
5910 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
773647a0 5911 {
000d1cc1
JP		 5912 WARN("NR_CPUS",
5913 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
773647a0 5914 }
9c9ba34e 5915
52ea8506
JP		 5916# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
5917 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
5918 ERROR("DEFINE_ARCH_HAS",
5919 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
5920 }
5921
acd9362c
JP		 5922# likely/unlikely comparisons similar to "(likely(foo) > 0)"
5923 if ($^V && $^V ge 5.10.0 &&
5924 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
5925 WARN("LIKELY_MISUSE",
5926 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
5927 }
5928
691d77b6
AW		 5929# whine mightly about in_atomic
5930 if ($line =~ /\bin_atomic\s*\(/) {
5931 if ($realfile =~ m@^drivers/@) {
000d1cc1
JP		 5932 ERROR("IN_ATOMIC",
5933 "do not use in_atomic in drivers\n" . $herecurr);
f4a87736 5934 } elsif ($realfile !~ m@^kernel/@) {
000d1cc1
JP		 5935 WARN("IN_ATOMIC",
5936 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
691d77b6
AW		 5937 }
5938 }
1704f47b 5939
481aea5c
JP		 5940# whine about ACCESS_ONCE
5941 if ($^V && $^V ge 5.10.0 &&
5942 $line =~ /\bACCESS_ONCE\s*$balanced_parens\s*(=(?!=))?\s*($FuncArg)?/) {
5943 my $par = $1;
5944 my $eq = $2;
5945 my $fun = $3;
5946 $par =~ s/^\(\s*(.*)\s*\)$/$1/;
5947 if (defined($eq)) {
5948 if (WARN("PREFER_WRITE_ONCE",
5949 "Prefer WRITE_ONCE(<FOO>, <BAR>) over ACCESS_ONCE(<FOO>) = <BAR>\n" . $herecurr) &&
5950 $fix) {
5951 $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)\s*$eq\s*\Q$fun\E/WRITE_ONCE($par, $fun)/;
5952 }
5953 } else {
5954 if (WARN("PREFER_READ_ONCE",
5955 "Prefer READ_ONCE(<FOO>) over ACCESS_ONCE(<FOO>)\n" . $herecurr) &&
5956 $fix) {
5957 $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)/READ_ONCE($par)/;
5958 }
5959 }
5960 }
5961
1704f47b
PZ		 5962# check for lockdep_set_novalidate_class
5963 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
5964 $line =~ /__lockdep_no_validate__\s*\)/ ) {
5965 if ($realfile !~ m@^kernel/lockdep@ &&
5966 $realfile !~ m@^include/linux/lockdep@ &&
5967 $realfile !~ m@^drivers/base/core@) {
000d1cc1
JP		 5968 ERROR("LOCKDEP",
5969 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
1704f47b
PZ		 5970 }
5971 }
88f8831c 5972
b392c64f
JP		 5973 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
5974 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
000d1cc1
JP		 5975 WARN("EXPORTED_WORLD_WRITABLE",
5976 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
88f8831c 5977 }
2435880f 5978
515a235e
JP		 5979# Mode permission misuses where it seems decimal should be octal
5980# This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
5981 if ($^V && $^V ge 5.10.0 &&
5982 $line =~ /$mode_perms_search/) {
5983 foreach my $entry (@mode_permission_funcs) {
5984 my $func = $entry->[0];
5985 my $arg_pos = $entry->[1];
5986
5987 my $skip_args = "";
5988 if ($arg_pos > 1) {
5989 $arg_pos--;
5990 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
5991 }
5992 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
5993 if ($line =~ /$test/) {
5994 my $val = $1;
5995 $val = $6 if ($skip_args ne "");
5996
5997 if ($val !~ /^0$/ &&
5998 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
5999 length($val) ne 4)) {
6000 ERROR("NON_OCTAL_PERMISSIONS",
6001 "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
c0a5c898
JP		 6002 } elsif ($val =~ /^$Octal$/ && (oct($val) & 02)) {
6003 ERROR("EXPORTED_WORLD_WRITABLE",
6004 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
515a235e 6005 }
2435880f
JP		 6006 }
6007 }
6008 }
5a6d20ce
BA		 6009
6010# validate content of MODULE_LICENSE against list from include/linux/module.h
6011 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
6012 my $extracted_string = get_quoted_string($line, $rawline);
6013 my $valid_licenses = qr{
6014 GPL|
6015 GPL\ v2|
6016 GPL\ and\ additional\ rights|
6017 Dual\ BSD/GPL|
6018 Dual\ MIT/GPL|
6019 Dual\ MPL/GPL|
6020 Proprietary
6021 }x;
6022 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
6023 WARN("MODULE_LICENSE",
6024 "unknown module license " . $extracted_string . "\n" . $herecurr);
6025 }
6026 }
13214adf
AW		 6027 }
6028
6029 # If we have no input at all, then there is nothing to report on
6030 # so just keep quiet.
6031 if ($#rawlines == -1) {
6032 exit(0);
0a920b5b
AW		 6033 }
6034
8905a67c
AW		 6035 # In mailback mode only produce a report in the negative, for
6036 # things that appear to be patches.
6037 if ($mailback && ($clean == 1 || !$is_patch)) {
6038 exit(0);
6039 }
6040
6041 # This is not a patch, and we are are in 'no-patch' mode so
6042 # just keep quiet.
6043 if (!$chk_patch && !$is_patch) {
6044 exit(0);
6045 }
6046
06330fc4 6047 if (!$is_patch && $file !~ /cover-letter\.patch$/) {
000d1cc1
JP		 6048 ERROR("NOT_UNIFIED_DIFF",
6049 "Does not appear to be a unified-diff format patch\n");
0a920b5b 6050 }
ed43c4e5 6051 if ($is_patch && $has_commit_log && $chk_signoff && $signoff == 0) {
000d1cc1
JP		 6052 ERROR("MISSING_SIGN_OFF",
6053 "Missing Signed-off-by: line(s)\n");
0a920b5b
AW		 6054 }
6055
8905a67c 6056 print report_dump();
13214adf
AW		 6057 if ($summary && !($clean == 1 && $quiet == 1)) {
6058 print "$filename " if ($summary_file);
8905a67c
AW		 6059 print "total: $cnt_error errors, $cnt_warn warnings, " .
6060 (($check)? "$cnt_chk checks, " : "") .
6061 "$cnt_lines lines checked\n";
f0a594c1 6062 }
8905a67c 6063
d2c0a235 6064 if ($quiet == 0) {
ef212196
JP		 6065 # If there were any defects found and not already fixing them
6066 if (!$clean and !$fix) {
6067 print << "EOM"
6068
6069NOTE: For some of the reported defects, checkpatch may be able to
6070 mechanically convert to the typical style using --fix or --fix-inplace.
6071EOM
6072 }
d2c0a235
AW		 6073 # If there were whitespace errors which cleanpatch can fix
6074 # then suggest that.
6075 if ($rpt_cleaners) {
b0781216 6076 $rpt_cleaners = 0;
d8469f16
JP		 6077 print << "EOM"
6078
6079NOTE: Whitespace errors detected.
6080 You may wish to use scripts/cleanpatch or scripts/cleanfile
6081EOM
d2c0a235
AW		 6082 }
6083 }
6084
d752fcc8
JP		 6085 if ($clean == 0 && $fix &&
6086 ("@rawlines" ne "@fixed" ||
6087 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
9624b8d6
JP		 6088 my $newfile = $filename;
6089 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
3705ce5b
JP		 6090 my $linecount = 0;
6091 my $f;
6092
d752fcc8
JP		 6093 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
6094
3705ce5b
JP		 6095 open($f, '>', $newfile)
6096 or die "$P: Can't open $newfile for write\n";
6097 foreach my $fixed_line (@fixed) {
6098 $linecount++;
6099 if ($file) {
6100 if ($linecount > 3) {
6101 $fixed_line =~ s/^\+//;
d752fcc8 6102 print $f $fixed_line . "\n";
3705ce5b
JP		 6103 }
6104 } else {
6105 print $f $fixed_line . "\n";
6106 }
6107 }
6108 close($f);
6109
6110 if (!$quiet) {
6111 print << "EOM";
d8469f16 6112
3705ce5b
JP		 6113Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
6114
6115Do _NOT_ trust the results written to this file.
6116Do _NOT_ submit these changes without inspecting them for correctness.
6117
6118This EXPERIMENTAL file is simply a convenience to help rewrite patches.
6119No warranties, expressed or implied...
3705ce5b
JP		 6120EOM
6121 }
6122 }
6123
d8469f16
JP		 6124 if ($quiet == 0) {
6125 print "\n";
6126 if ($clean == 1) {
6127 print "$vname has no obvious style problems and is ready for submission.\n";
6128 } else {
6129 print "$vname has style problems, please review.\n";
6130 }
0a920b5b
AW		 6131 }
6132 return $clean;
6133}
Linux kernel - Deliverables
This page took 1.100672 seconds and 5 git commands to generate.