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