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