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