Code Review / openocd.git / blob
? search:


b3a085483bc1156c46590b059ae5113dedc93fef
[openocd.git] / tools / 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
10 my $P = $0;
11 $P =~ s@.*/@@g;
12
13 my $V = '0.32';
14
15 use Getopt::Long qw(:config no_auto_abbrev);
16
17 my $quiet = 0;
18 my $tree = 1;
19 my $chk_signoff = 1;
20 my $chk_patch = 1;
21 my $tst_only;
22 my $emacs = 0;
23 my $terse = 0;
24 my $file = 0;
25 my $check = 0;
26 my $summary = 1;
27 my $mailback = 0;
28 my $summary_file = 0;
29 my $show_types = 0;
30 my $root;
31 my %debug;
32 my %ignore_type = ();
33 my @ignore = ();
34 my $help = 0;
35 my $configuration_file = ".checkpatch.conf";
36
37 sub help {
38 my ($exitcode) = @_;
39
40 print << "EOM";
41 Usage: $P [OPTION]... [FILE]...
42 Version: $V
43
44 Options:
45 -q, --quiet quiet
46 --no-tree run without a openocd tree
47 --no-signoff do not check for 'Signed-off-by' line
48 --patch treat FILE as patchfile (default)
49 --emacs emacs compile window format
50 --terse one line per report
51 -f, --file treat FILE as regular source file
52 --subjective, --strict enable more subjective tests
53 --ignore TYPE(,TYPE2...) ignore various comma separated message types
54 --show-types show the message "types" in the output
55 --root=PATH PATH to the openocd tree root
56 --no-summary suppress the per-file summary
57 --mailback only produce a report in case of warnings/errors
58 --summary-file include the filename in summary
59 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
60 'values', 'possible', 'type', and 'attr' (default
61 is all off)
62 --test-only=WORD report only warnings/errors containing WORD
63 literally
64 -h, --help, --version display this help and exit
65
66 When FILE is - read standard input.
67 EOM
68
69 exit($exitcode);
70 }
71
72 my $conf = which_conf($configuration_file);
73 if (-f $conf) {
74 my @conf_args;
75 open(my $conffile, '<', "$conf")
76 or warn "$P: Can't find a readable $configuration_file file $!\n";
77
78 while (<$conffile>) {
79 my $line = $_;
80
81 $line =~ s/\s*\n?$//g;
82 $line =~ s/^\s*//g;
83 $line =~ s/\s+/ /g;
84
85 next if ($line =~ m/^\s*#/);
86 next if ($line =~ m/^\s*$/);
87
88 my @words = split(" ", $line);
89 foreach my $word (@words) {
90 last if ($word =~ m/^#/);
91 push (@conf_args, $word);
92 }
93 }
94 close($conffile);
95 unshift(@ARGV, @conf_args) if @conf_args;
96 }
97
98 GetOptions(
99 'q|quiet+' => \$quiet,
100 'tree!' => \$tree,
101 'signoff!' => \$chk_signoff,
102 'patch!' => \$chk_patch,
103 'emacs!' => \$emacs,
104 'terse!' => \$terse,
105 'f|file!' => \$file,
106 'subjective!' => \$check,
107 'strict!' => \$check,
108 'ignore=s' => \@ignore,
109 'show-types!' => \$show_types,
110 'root=s' => \$root,
111 'summary!' => \$summary,
112 'mailback!' => \$mailback,
113 'summary-file!' => \$summary_file,
114
115 'debug=s' => \%debug,
116 'test-only=s' => \$tst_only,
117 'h|help' => \$help,
118 'version' => \$help
119 ) or help(1);
120
121 help(0) if ($help);
122
123 my $exit = 0;
124
125 if ($#ARGV < 0) {
126 print "$P: no input files\n";
127 exit(1);
128 }
129
130 @ignore = split(/,/, join(',',@ignore));
131 foreach my $word (@ignore) {
132 $word =~ s/\s*\n?$//g;
133 $word =~ s/^\s*//g;
134 $word =~ s/\s+/ /g;
135 $word =~ tr/[a-z]/[A-Z]/;
136
137 next if ($word =~ m/^\s*#/);
138 next if ($word =~ m/^\s*$/);
139
140 $ignore_type{$word}++;
141 }
142
143 my $dbg_values = 0;
144 my $dbg_possible = 0;
145 my $dbg_type = 0;
146 my $dbg_attr = 0;
147 for my $key (keys %debug) {
148 ## no critic
149 eval "\${dbg_$key} = '$debug{$key}';";
150 die "$@" if ($@);
151 }
152
153 my $rpt_cleaners = 0;
154
155 if ($terse) {
156 $emacs = 1;
157 $quiet++;
158 }
159
160 if ($tree) {
161 if (defined $root) {
162 if (!top_of_kernel_tree($root)) {
163 die "$P: $root: --root does not point at a valid tree\n";
164 }
165 } else {
166 if (top_of_kernel_tree('.')) {
167 $root = '.';
168 } elsif ($0 =~ m@(.*)/tools/scripts/[^/]*$@ &&
169 top_of_kernel_tree($1)) {
170 $root = $1;
171 }
172 }
173
174 if (!defined $root) {
175 print "Must be run from the top-level dir. of a openocd tree\n";
176 exit(2);
177 }
178 }
179
180 my $emitted_corrupt = 0;
181
182 our $Ident = qr{
183 [A-Za-z_][A-Za-z\d_]*
184 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
185 }x;
186 our $Storage = qr{extern|static|asmlinkage};
187 our $Sparse = qr{
188 __user|
189 __kernel|
190 __force|
191 __iomem|
192 __must_check|
193 __init_refok|
194 __kprobes|
195 __ref|
196 __rcu
197 }x;
198
199 # Notes to $Attribute:
200 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
201 our $Attribute = qr{
202 const|
203 __percpu|
204 __nocast|
205 __safe|
206 __bitwise__|
207 __packed__|
208 __packed2__|
209 __naked|
210 __maybe_unused|
211 __always_unused|
212 __noreturn|
213 __used|
214 __cold|
215 __noclone|
216 __deprecated|
217 __read_mostly|
218 __kprobes|
219 __(?:mem|cpu|dev|)(?:initdata|initconst|init\b)|
220 ____cacheline_aligned|
221 ____cacheline_aligned_in_smp|
222 ____cacheline_internodealigned_in_smp|
223 __weak
224 }x;
225 our $Modifier;
226 our $Inline = qr{inline|__always_inline|noinline};
227 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
228 our $Lval = qr{$Ident(?:$Member)*};
229
230 our $Constant = qr{(?:[0-9]+|0x[0-9a-fA-F]+)[UL]*};
231 our $Assignment = qr{(?:\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=)};
232 our $Compare = qr{<=|>=|==|!=|<|>};
233 our $Operators = qr{
234 <=|>=|==|!=|
235 =>|->|<<|>>|<|>|!|~|
236 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%
237 }x;
238
239 our $NonptrType;
240 our $Type;
241 our $Declare;
242
243 our $UTF8 = qr {
244 [\x09\x0A\x0D\x20-\x7E] # ASCII
245 | [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
246 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
247 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
248 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
249 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
250 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
251 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
252 }x;
253
254 our $typeTypedefs = qr{(?x:
255 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
256 atomic_t
257 )};
258
259 our $logFunctions = qr{(?x:
260 printk(?:_ratelimited|_once|)|
261 [a-z0-9]+_(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
262 WARN(?:_RATELIMIT|_ONCE|)|
263 panic|
264 MODULE_[A-Z_]+|
265 LOG_(?:DEBUG|INFO|WARNING|ERROR|USER|USER_N|OUTPUT)+
266 )};
267
268 our $signature_tags = qr{(?xi:
269 Signed-off-by:|
270 Acked-by:|
271 Tested-by:|
272 Reviewed-by:|
273 Reported-by:|
274 To:|
275 Cc:
276 )};
277
278 our @typeList = (
279 qr{void},
280 qr{(?:unsigned\s+)?char},
281 qr{(?:unsigned\s+)?short},
282 qr{(?:unsigned\s+)?int},
283 qr{(?:unsigned\s+)?long},
284 qr{(?:unsigned\s+)?long\s+int},
285 qr{(?:unsigned\s+)?long\s+long},
286 qr{(?:unsigned\s+)?long\s+long\s+int},
287 qr{unsigned},
288 qr{float},
289 qr{double},
290 qr{bool},
291 qr{struct\s+$Ident},
292 qr{union\s+$Ident},
293 qr{enum\s+$Ident},
294 qr{${Ident}_t},
295 qr{${Ident}_handler},
296 qr{${Ident}_handler_fn},
297 );
298 our @modifierList = (
299 qr{fastcall},
300 );
301
302 our $allowed_asm_includes = qr{(?x:
303 irq|
304 memory
305 )};
306 # memory.h: ARM has a custom one
307
308 sub build_types {
309 my $mods = "(?x: \n" . join("|\n ", @modifierList) . "\n)";
310 my $all = "(?x: \n" . join("|\n ", @typeList) . "\n)";
311 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
312 $NonptrType = qr{
313 (?:$Modifier\s+|const\s+)*
314 (?:
315 (?:typeof|__typeof__)\s*\(\s*\**\s*$Ident\s*\)|
316 (?:$typeTypedefs\b)|
317 (?:${all}\b)
318 )
319 (?:\s+$Modifier|\s+const)*
320 }x;
321 $Type = qr{
322 $NonptrType
323 (?:[\s\*]+\s*const|[\s\*]+|(?:\s*\[\s*\])+)?
324 (?:\s+$Inline|\s+$Modifier)*
325 }x;
326 $Declare = qr{(?:$Storage\s+)?$Type};
327 }
328 build_types();
329
330 our $match_balanced_parentheses = qr/(\((?:[^\(\)]+|(-1))*\))/;
331
332 our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
333 our $LvalOrFunc = qr{($Lval)\s*($match_balanced_parentheses{0,1})\s*};
334
335 sub deparenthesize {
336 my ($string) = @_;
337 return "" if (!defined($string));
338 $string =~ s@^\s*\(\s*@@g;
339 $string =~ s@\s*\)\s*$@@g;
340 $string =~ s@\s+@ @g;
341 return $string;
342 }
343
344 $chk_signoff = 0 if ($file);
345
346 my @dep_includes = ();
347 my @dep_functions = ();
348 my $removal = "Documentation/feature-removal-schedule.txt";
349 if ($tree && -f "$root/$removal") {
350 open(my $REMOVE, '<', "$root/$removal") ||
351 die "$P: $removal: open failed - $!\n";
352 while (<$REMOVE>) {
353 if (/^Check:\s+(.*\S)/) {
354 for my $entry (split(/[, ]+/, $1)) {
355 if ($entry =~ m@include/(.*)@) {
356 push(@dep_includes, $1);
357
358 } elsif ($entry !~ m@/@) {
359 push(@dep_functions, $entry);
360 }
361 }
362 }
363 }
364 close($REMOVE);
365 }
366
367 my @rawlines = ();
368 my @lines = ();
369 my $vname;
370 for my $filename (@ARGV) {
371 my $FILE;
372 if ($file) {
373 open($FILE, '-|', "diff -u /dev/null $filename") ||
374 die "$P: $filename: diff failed - $!\n";
375 } elsif ($filename eq '-') {
376 open($FILE, '<&STDIN');
377 } else {
378 open($FILE, '<', "$filename") ||
379 die "$P: $filename: open failed - $!\n";
380 }
381 if ($filename eq '-') {
382 $vname = 'Your patch';
383 } else {
384 $vname = $filename;
385 }
386 while (<$FILE>) {
387 chomp;
388 push(@rawlines, $_);
389 }
390 close($FILE);
391 if (!process($filename)) {
392 $exit = 1;
393 }
394 @rawlines = ();
395 @lines = ();
396 }
397
398 exit($exit);
399
400 sub top_of_kernel_tree {
401 my ($root) = @_;
402
403 my @tree_check = (
404 "AUTHORS", "BUGS", "COPYING", "HACKING", "Makefile.am",
405 "README", "contrib", "doc", "src", "tcl", "testing", "tools",
406 );
407
408 foreach my $check (@tree_check) {
409 if (! -e $root . '/' . $check) {
410 return 0;
411 }
412 }
413 return 1;
414 }
415
416 sub parse_email {
417 my ($formatted_email) = @_;
418
419 my $name = "";
420 my $address = "";
421 my $comment = "";
422
423 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
424 $name = $1;
425 $address = $2;
426 $comment = $3 if defined $3;
427 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
428 $address = $1;
429 $comment = $2 if defined $2;
430 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
431 $address = $1;
432 $comment = $2 if defined $2;
433 $formatted_email =~ s/$address.*$//;
434 $name = $formatted_email;
435 $name =~ s/^\s+|\s+$//g;
436 $name =~ s/^\"|\"$//g;
437 # If there's a name left after stripping spaces and
438 # leading quotes, and the address doesn't have both
439 # leading and trailing angle brackets, the address
440 # is invalid. ie:
441 # "joe smith joe@smith.com" bad
442 # "joe smith <joe@smith.com" bad
443 if ($name ne "" && $address !~ /^<[^>]+>$/) {
444 $name = "";
445 $address = "";
446 $comment = "";
447 }
448 } elsif ($formatted_email eq "jenkins") {
449 $address = "jenkins"
450 }
451
452 $name =~ s/^\s+|\s+$//g;
453 $name =~ s/^\"|\"$//g;
454 $address =~ s/^\s+|\s+$//g;
455 $address =~ s/^\<|\>$//g;
456
457 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
458 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
459 $name = "\"$name\"";
460 }
461
462 return ($name, $address, $comment);
463 }
464
465 sub format_email {
466 my ($name, $address) = @_;
467
468 my $formatted_email;
469
470 $name =~ s/^\s+|\s+$//g;
471 $name =~ s/^\"|\"$//g;
472 $address =~ s/^\s+|\s+$//g;
473
474 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
475 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
476 $name = "\"$name\"";
477 }
478
479 if ("$name" eq "") {
480 $formatted_email = "$address";
481 } else {
482 $formatted_email = "$name <$address>";
483 }
484
485 return $formatted_email;
486 }
487
488 sub which_conf {
489 my ($conf) = @_;
490
491 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
492 if (-e "$path/$conf") {
493 return "$path/$conf";
494 }
495 }
496
497 return "";
498 }
499
500 sub expand_tabs {
501 my ($str) = @_;
502
503 my $res = '';
504 my $n = 0;
505 for my $c (split(//, $str)) {
506 if ($c eq "\t") {
507 $res .= ' ';
508 $n++;
509 for (; ($n % 4) != 0; $n++) {
510 $res .= ' ';
511 }
512 next;
513 }
514 $res .= $c;
515 $n++;
516 }
517
518 return $res;
519 }
520 sub copy_spacing {
521 (my $res = shift) =~ tr/\t/ /c;
522 return $res;
523 }
524
525 sub line_stats {
526 my ($line) = @_;
527
528 # Drop the diff line leader and expand tabs
529 $line =~ s/^.//;
530 $line = expand_tabs($line);
531
532 # Pick the indent from the front of the line.
533 my ($white) = ($line =~ /^(\s*)/);
534
535 return (length($line), length($white));
536 }
537
538 my $sanitise_quote = '';
539
540 sub sanitise_line_reset {
541 my ($in_comment) = @_;
542
543 if ($in_comment) {
544 $sanitise_quote = '*/';
545 } else {
546 $sanitise_quote = '';
547 }
548 }
549 sub sanitise_line {
550 my ($line) = @_;
551
552 my $res = '';
553 my $l = '';
554
555 my $qlen = 0;
556 my $off = 0;
557 my $c;
558
559 # Always copy over the diff marker.
560 $res = substr($line, 0, 1);
561
562 for ($off = 1; $off < length($line); $off++) {
563 $c = substr($line, $off, 1);
564
565 # Comments we are wacking completly including the begin
566 # and end, all to $;.
567 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
568 $sanitise_quote = '*/';
569
570 substr($res, $off, 2, "$;$;");
571 $off++;
572 next;
573 }
574 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
575 $sanitise_quote = '';
576 substr($res, $off, 2, "$;$;");
577 $off++;
578 next;
579 }
580 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
581 $sanitise_quote = '//';
582
583 substr($res, $off, 2, $sanitise_quote);
584 $off++;
585 next;
586 }
587
588 # A \ in a string means ignore the next character.
589 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
590 $c eq "\\") {
591 substr($res, $off, 2, 'XX');
592 $off++;
593 next;
594 }
595 # Regular quotes.
596 if ($c eq "'" || $c eq '"') {
597 if ($sanitise_quote eq '') {
598 $sanitise_quote = $c;
599
600 substr($res, $off, 1, $c);
601 next;
602 } elsif ($sanitise_quote eq $c) {
603 $sanitise_quote = '';
604 }
605 }
606
607 #print "c<$c> SQ<$sanitise_quote>\n";
608 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
609 substr($res, $off, 1, $;);
610 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
611 substr($res, $off, 1, $;);
612 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
613 substr($res, $off, 1, 'X');
614 } else {
615 substr($res, $off, 1, $c);
616 }
617 }
618
619 if ($sanitise_quote eq '//') {
620 $sanitise_quote = '';
621 }
622
623 # The pathname on a #include may be surrounded by '<' and '>'.
624 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
625 my $clean = 'X' x length($1);
626 $res =~ s@\<.*\>@<$clean>@;
627
628 # The whole of a #error is a string.
629 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
630 my $clean = 'X' x length($1);
631 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
632 }
633
634 return $res;
635 }
636
637 sub ctx_statement_block {
638 my ($linenr, $remain, $off) = @_;
639 my $line = $linenr - 1;
640 my $blk = '';
641 my $soff = $off;
642 my $coff = $off - 1;
643 my $coff_set = 0;
644
645 my $loff = 0;
646
647 my $type = '';
648 my $level = 0;
649 my @stack = ();
650 my $p;
651 my $c;
652 my $len = 0;
653
654 my $remainder;
655 while (1) {
656 @stack = (['', 0]) if ($#stack == -1);
657
658 #warn "CSB: blk<$blk> remain<$remain>\n";
659 # If we are about to drop off the end, pull in more
660 # context.
661 if ($off >= $len) {
662 for (; $remain > 0; $line++) {
663 last if (!defined $lines[$line]);
664 next if ($lines[$line] =~ /^-/);
665 $remain--;
666 $loff = $len;
667 $blk .= $lines[$line] . "\n";
668 $len = length($blk);
669 $line++;
670 last;
671 }
672 # Bail if there is no further context.
673 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
674 if ($off >= $len) {
675 last;
676 }
677 }
678 $p = $c;
679 $c = substr($blk, $off, 1);
680 $remainder = substr($blk, $off);
681
682 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
683
684 # Handle nested #if/#else.
685 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
686 push(@stack, [ $type, $level ]);
687 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
688 ($type, $level) = @{$stack[$#stack - 1]};
689 } elsif ($remainder =~ /^#\s*endif\b/) {
690 ($type, $level) = @{pop(@stack)};
691 }
692
693 # Statement ends at the ';' or a close '}' at the
694 # outermost level.
695 if ($level == 0 && $c eq ';') {
696 last;
697 }
698
699 # An else is really a conditional as long as its not else if
700 if ($level == 0 && $coff_set == 0 &&
701 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
702 $remainder =~ /^(else)(?:\s|{)/ &&
703 $remainder !~ /^else\s+if\b/) {
704 $coff = $off + length($1) - 1;
705 $coff_set = 1;
706 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
707 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
708 }
709
710 if (($type eq '' || $type eq '(') && $c eq '(') {
711 $level++;
712 $type = '(';
713 }
714 if ($type eq '(' && $c eq ')') {
715 $level--;
716 $type = ($level != 0)? '(' : '';
717
718 if ($level == 0 && $coff < $soff) {
719 $coff = $off;
720 $coff_set = 1;
721 #warn "CSB: mark coff<$coff>\n";
722 }
723 }
724 if (($type eq '' || $type eq '{') && $c eq '{') {
725 $level++;
726 $type = '{';
727 }
728 if ($type eq '{' && $c eq '}') {
729 $level--;
730 $type = ($level != 0)? '{' : '';
731
732 if ($level == 0) {
733 if (substr($blk, $off + 1, 1) eq ';') {
734 $off++;
735 }
736 last;
737 }
738 }
739 $off++;
740 }
741 # We are truly at the end, so shuffle to the next line.
742 if ($off == $len) {
743 $loff = $len + 1;
744 $line++;
745 $remain--;
746 }
747
748 my $statement = substr($blk, $soff, $off - $soff + 1);
749 my $condition = substr($blk, $soff, $coff - $soff + 1);
750
751 #warn "STATEMENT<$statement>\n";
752 #warn "CONDITION<$condition>\n";
753
754 #print "coff<$coff> soff<$off> loff<$loff>\n";
755
756 return ($statement, $condition,
757 $line, $remain + 1, $off - $loff + 1, $level);
758 }
759
760 sub statement_lines {
761 my ($stmt) = @_;
762
763 # Strip the diff line prefixes and rip blank lines at start and end.
764 $stmt =~ s/(^|\n)./$1/g;
765 $stmt =~ s/^\s*//;
766 $stmt =~ s/\s*$//;
767
768 my @stmt_lines = ($stmt =~ /\n/g);
769
770 return $#stmt_lines + 2;
771 }
772
773 sub statement_rawlines {
774 my ($stmt) = @_;
775
776 my @stmt_lines = ($stmt =~ /\n/g);
777
778 return $#stmt_lines + 2;
779 }
780
781 sub statement_block_size {
782 my ($stmt) = @_;
783
784 $stmt =~ s/(^|\n)./$1/g;
785 $stmt =~ s/^\s*{//;
786 $stmt =~ s/}\s*$//;
787 $stmt =~ s/^\s*//;
788 $stmt =~ s/\s*$//;
789
790 my @stmt_lines = ($stmt =~ /\n/g);
791 my @stmt_statements = ($stmt =~ /;/g);
792
793 my $stmt_lines = $#stmt_lines + 2;
794 my $stmt_statements = $#stmt_statements + 1;
795
796 if ($stmt_lines > $stmt_statements) {
797 return $stmt_lines;
798 } else {
799 return $stmt_statements;
800 }
801 }
802
803 sub ctx_statement_full {
804 my ($linenr, $remain, $off) = @_;
805 my ($statement, $condition, $level);
806
807 my (@chunks);
808
809 # Grab the first conditional/block pair.
810 ($statement, $condition, $linenr, $remain, $off, $level) =
811 ctx_statement_block($linenr, $remain, $off);
812 #print "F: c<$condition> s<$statement> remain<$remain>\n";
813 push(@chunks, [ $condition, $statement ]);
814 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
815 return ($level, $linenr, @chunks);
816 }
817
818 # Pull in the following conditional/block pairs and see if they
819 # could continue the statement.
820 for (;;) {
821 ($statement, $condition, $linenr, $remain, $off, $level) =
822 ctx_statement_block($linenr, $remain, $off);
823 #print "C: c<$condition> s<$statement> remain<$remain>\n";
824 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
825 #print "C: push\n";
826 push(@chunks, [ $condition, $statement ]);
827 }
828
829 return ($level, $linenr, @chunks);
830 }
831
832 sub ctx_block_get {
833 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
834 my $line;
835 my $start = $linenr - 1;
836 my $blk = '';
837 my @o;
838 my @c;
839 my @res = ();
840
841 my $level = 0;
842 my @stack = ($level);
843 for ($line = $start; $remain > 0; $line++) {
844 next if ($rawlines[$line] =~ /^-/);
845 $remain--;
846
847 $blk .= $rawlines[$line];
848
849 # Handle nested #if/#else.
850 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
851 push(@stack, $level);
852 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
853 $level = $stack[$#stack - 1];
854 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
855 $level = pop(@stack);
856 }
857
858 foreach my $c (split(//, $lines[$line])) {
859 ##print "C<$c>L<$level><$open$close>O<$off>\n";
860 if ($off > 0) {
861 $off--;
862 next;
863 }
864
865 if ($c eq $close && $level > 0) {
866 $level--;
867 last if ($level == 0);
868 } elsif ($c eq $open) {
869 $level++;
870 }
871 }
872
873 if (!$outer || $level <= 1) {
874 push(@res, $rawlines[$line]);
875 }
876
877 last if ($level == 0);
878 }
879
880 return ($level, @res);
881 }
882 sub ctx_block_outer {
883 my ($linenr, $remain) = @_;
884
885 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
886 return @r;
887 }
888 sub ctx_block {
889 my ($linenr, $remain) = @_;
890
891 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
892 return @r;
893 }
894 sub ctx_statement {
895 my ($linenr, $remain, $off) = @_;
896
897 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
898 return @r;
899 }
900 sub ctx_block_level {
901 my ($linenr, $remain) = @_;
902
903 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
904 }
905 sub ctx_statement_level {
906 my ($linenr, $remain, $off) = @_;
907
908 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
909 }
910
911 sub ctx_locate_comment {
912 my ($first_line, $end_line) = @_;
913
914 # Catch a comment on the end of the line itself.
915 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
916 return $current_comment if (defined $current_comment);
917
918 # Look through the context and try and figure out if there is a
919 # comment.
920 my $in_comment = 0;
921 $current_comment = '';
922 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
923 my $line = $rawlines[$linenr - 1];
924 #warn " $line\n";
925 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
926 $in_comment = 1;
927 }
928 if ($line =~ m@/\*@) {
929 $in_comment = 1;
930 }
931 if (!$in_comment && $current_comment ne '') {
932 $current_comment = '';
933 }
934 $current_comment .= $line . "\n" if ($in_comment);
935 if ($line =~ m@\*/@) {
936 $in_comment = 0;
937 }
938 }
939
940 chomp($current_comment);
941 return($current_comment);
942 }
943 sub ctx_has_comment {
944 my ($first_line, $end_line) = @_;
945 my $cmt = ctx_locate_comment($first_line, $end_line);
946
947 ##print "LINE: $rawlines[$end_line - 1 ]\n";
948 ##print "CMMT: $cmt\n";
949
950 return ($cmt ne '');
951 }
952
953 sub raw_line {
954 my ($linenr, $cnt) = @_;
955
956 my $offset = $linenr - 1;
957 $cnt++;
958
959 my $line;
960 while ($cnt) {
961 $line = $rawlines[$offset++];
962 next if (defined($line) && $line =~ /^-/);
963 $cnt--;
964 }
965
966 return $line;
967 }
968
969 sub cat_vet {
970 my ($vet) = @_;
971 my ($res, $coded);
972
973 $res = '';
974 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
975 $res .= $1;
976 if ($2 ne '') {
977 $coded = sprintf("^%c", unpack('C', $2) + 64);
978 $res .= $coded;
979 }
980 }
981 $res =~ s/$/\$/;
982
983 return $res;
984 }
985
986 my $av_preprocessor = 0;
987 my $av_pending;
988 my @av_paren_type;
989 my $av_pend_colon;
990
991 sub annotate_reset {
992 $av_preprocessor = 0;
993 $av_pending = '_';
994 @av_paren_type = ('E');
995 $av_pend_colon = 'O';
996 }
997
998 sub annotate_values {
999 my ($stream, $type) = @_;
1000
1001 my $res;
1002 my $var = '_' x length($stream);
1003 my $cur = $stream;
1004
1005 print "$stream\n" if ($dbg_values > 1);
1006
1007 while (length($cur)) {
1008 @av_paren_type = ('E') if ($#av_paren_type < 0);
1009 print " <" . join('', @av_paren_type) .
1010 "> <$type> <$av_pending>" if ($dbg_values > 1);
1011 if ($cur =~ /^(\s+)/o) {
1012 print "WS($1)\n" if ($dbg_values > 1);
1013 if ($1 =~ /\n/ && $av_preprocessor) {
1014 $type = pop(@av_paren_type);
1015 $av_preprocessor = 0;
1016 }
1017
1018 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1019 print "CAST($1)\n" if ($dbg_values > 1);
1020 push(@av_paren_type, $type);
1021 $type = 'C';
1022
1023 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1024 print "DECLARE($1)\n" if ($dbg_values > 1);
1025 $type = 'T';
1026
1027 } elsif ($cur =~ /^($Modifier)\s*/) {
1028 print "MODIFIER($1)\n" if ($dbg_values > 1);
1029 $type = 'T';
1030
1031 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1032 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1033 $av_preprocessor = 1;
1034 push(@av_paren_type, $type);
1035 if ($2 ne '') {
1036 $av_pending = 'N';
1037 }
1038 $type = 'E';
1039
1040 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1041 print "UNDEF($1)\n" if ($dbg_values > 1);
1042 $av_preprocessor = 1;
1043 push(@av_paren_type, $type);
1044
1045 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1046 print "PRE_START($1)\n" if ($dbg_values > 1);
1047 $av_preprocessor = 1;
1048
1049 push(@av_paren_type, $type);
1050 push(@av_paren_type, $type);
1051 $type = 'E';
1052
1053 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1054 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1055 $av_preprocessor = 1;
1056
1057 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1058
1059 $type = 'E';
1060
1061 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1062 print "PRE_END($1)\n" if ($dbg_values > 1);
1063
1064 $av_preprocessor = 1;
1065
1066 # Assume all arms of the conditional end as this
1067 # one does, and continue as if the #endif was not here.
1068 pop(@av_paren_type);
1069 push(@av_paren_type, $type);
1070 $type = 'E';
1071
1072 } elsif ($cur =~ /^(\\\n)/o) {
1073 print "PRECONT($1)\n" if ($dbg_values > 1);
1074
1075 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1076 print "ATTR($1)\n" if ($dbg_values > 1);
1077 $av_pending = $type;
1078 $type = 'N';
1079
1080 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1081 print "SIZEOF($1)\n" if ($dbg_values > 1);
1082 if (defined $2) {
1083 $av_pending = 'V';
1084 }
1085 $type = 'N';
1086
1087 } elsif ($cur =~ /^(if|while|for)\b/o) {
1088 print "COND($1)\n" if ($dbg_values > 1);
1089 $av_pending = 'E';
1090 $type = 'N';
1091
1092 } elsif ($cur =~/^(case)/o) {
1093 print "CASE($1)\n" if ($dbg_values > 1);
1094 $av_pend_colon = 'C';
1095 $type = 'N';
1096
1097 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1098 print "KEYWORD($1)\n" if ($dbg_values > 1);
1099 $type = 'N';
1100
1101 } elsif ($cur =~ /^(\()/o) {
1102 print "PAREN('$1')\n" if ($dbg_values > 1);
1103 push(@av_paren_type, $av_pending);
1104 $av_pending = '_';
1105 $type = 'N';
1106
1107 } elsif ($cur =~ /^(\))/o) {
1108 my $new_type = pop(@av_paren_type);
1109 if ($new_type ne '_') {
1110 $type = $new_type;
1111 print "PAREN('$1') -> $type\n"
1112 if ($dbg_values > 1);
1113 } else {
1114 print "PAREN('$1')\n" if ($dbg_values > 1);
1115 }
1116
1117 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1118 print "FUNC($1)\n" if ($dbg_values > 1);
1119 $type = 'V';
1120 $av_pending = 'V';
1121
1122 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1123 if (defined $2 && $type eq 'C' || $type eq 'T') {
1124 $av_pend_colon = 'B';
1125 } elsif ($type eq 'E') {
1126 $av_pend_colon = 'L';
1127 }
1128 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1129 $type = 'V';
1130
1131 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1132 print "IDENT($1)\n" if ($dbg_values > 1);
1133 $type = 'V';
1134
1135 } elsif ($cur =~ /^($Assignment)/o) {
1136 print "ASSIGN($1)\n" if ($dbg_values > 1);
1137 $type = 'N';
1138
1139 } elsif ($cur =~/^(;|{|})/) {
1140 print "END($1)\n" if ($dbg_values > 1);
1141 $type = 'E';
1142 $av_pend_colon = 'O';
1143
1144 } elsif ($cur =~/^(,)/) {
1145 print "COMMA($1)\n" if ($dbg_values > 1);
1146 $type = 'C';
1147
1148 } elsif ($cur =~ /^(\?)/o) {
1149 print "QUESTION($1)\n" if ($dbg_values > 1);
1150 $type = 'N';
1151
1152 } elsif ($cur =~ /^(:)/o) {
1153 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1154
1155 substr($var, length($res), 1, $av_pend_colon);
1156 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1157 $type = 'E';
1158 } else {
1159 $type = 'N';
1160 }
1161 $av_pend_colon = 'O';
1162
1163 } elsif ($cur =~ /^(\[)/o) {
1164 print "CLOSE($1)\n" if ($dbg_values > 1);
1165 $type = 'N';
1166
1167 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1168 my $variant;
1169
1170 print "OPV($1)\n" if ($dbg_values > 1);
1171 if ($type eq 'V') {
1172 $variant = 'B';
1173 } else {
1174 $variant = 'U';
1175 }
1176
1177 substr($var, length($res), 1, $variant);
1178 $type = 'N';
1179
1180 } elsif ($cur =~ /^($Operators)/o) {
1181 print "OP($1)\n" if ($dbg_values > 1);
1182 if ($1 ne '++' && $1 ne '--') {
1183 $type = 'N';
1184 }
1185
1186 } elsif ($cur =~ /(^.)/o) {
1187 print "C($1)\n" if ($dbg_values > 1);
1188 }
1189 if (defined $1) {
1190 $cur = substr($cur, length($1));
1191 $res .= $type x length($1);
1192 }
1193 }
1194
1195 return ($res, $var);
1196 }
1197
1198 sub possible {
1199 my ($possible, $line) = @_;
1200 my $notPermitted = qr{(?:
1201 ^(?:
1202 $Modifier|
1203 $Storage|
1204 $Type|
1205 DEFINE_\S+
1206 )$|
1207 ^(?:
1208 goto|
1209 return|
1210 case|
1211 else|
1212 asm|__asm__|
1213 do
1214 )(?:\s|$)|
1215 ^(?:typedef|struct|enum)\b
1216 )}x;
1217 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1218 if ($possible !~ $notPermitted) {
1219 # Check for modifiers.
1220 $possible =~ s/\s*$Storage\s*//g;
1221 $possible =~ s/\s*$Sparse\s*//g;
1222 if ($possible =~ /^\s*$/) {
1223
1224 } elsif ($possible =~ /\s/) {
1225 $possible =~ s/\s*$Type\s*//g;
1226 for my $modifier (split(' ', $possible)) {
1227 if ($modifier !~ $notPermitted) {
1228 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1229 push(@modifierList, $modifier);
1230 }
1231 }
1232
1233 } else {
1234 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1235 push(@typeList, $possible);
1236 }
1237 build_types();
1238 } else {
1239 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1240 }
1241 }
1242
1243 my $prefix = '';
1244
1245 sub show_type {
1246 return !defined $ignore_type{$_[0]};
1247 }
1248
1249 sub report {
1250 if (!show_type($_[1]) ||
1251 (defined $tst_only && $_[2] !~ /\Q$tst_only\E/)) {
1252 return 0;
1253 }
1254 my $line;
1255 if ($show_types) {
1256 $line = "$prefix$_[0]:$_[1]: $_[2]\n";
1257 } else {
1258 $line = "$prefix$_[0]: $_[2]\n";
1259 }
1260 $line = (split('\n', $line))[0] . "\n" if ($terse);
1261
1262 push(our @report, $line);
1263
1264 return 1;
1265 }
1266 sub report_dump {
1267 our @report;
1268 }
1269
1270 sub ERROR {
1271 if (report("ERROR", $_[0], $_[1])) {
1272 our $clean = 0;
1273 our $cnt_error++;
1274 }
1275 }
1276 sub WARN {
1277 if (report("WARNING", $_[0], $_[1])) {
1278 our $clean = 0;
1279 our $cnt_warn++;
1280 }
1281 }
1282 sub CHK {
1283 if ($check && report("CHECK", $_[0], $_[1])) {
1284 our $clean = 0;
1285 our $cnt_chk++;
1286 }
1287 }
1288
1289 sub check_absolute_file {
1290 my ($absolute, $herecurr) = @_;
1291 my $file = $absolute;
1292
1293 ##print "absolute<$absolute>\n";
1294
1295 # See if any suffix of this path is a path within the tree.
1296 while ($file =~ s@^[^/]*/@@) {
1297 if (-f "$root/$file") {
1298 ##print "file<$file>\n";
1299 last;
1300 }
1301 }
1302 if (! -f _) {
1303 return 0;
1304 }
1305
1306 # It is, so see if the prefix is acceptable.
1307 my $prefix = $absolute;
1308 substr($prefix, -length($file)) = '';
1309
1310 ##print "prefix<$prefix>\n";
1311 if ($prefix ne ".../") {
1312 WARN("USE_RELATIVE_PATH",
1313 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
1314 }
1315 }
1316
1317 sub process {
1318 my $filename = shift;
1319
1320 my $linenr=0;
1321 my $prevline="";
1322 my $prevrawline="";
1323 my $stashline="";
1324 my $stashrawline="";
1325
1326 my $length;
1327 my $indent;
1328 my $previndent=0;
1329 my $stashindent=0;
1330
1331 our $clean = 1;
1332 my $signoff = 0;
1333 my $is_patch = 0;
1334
1335 our @report = ();
1336 our $cnt_lines = 0;
1337 our $cnt_error = 0;
1338 our $cnt_warn = 0;
1339 our $cnt_chk = 0;
1340
1341 # Trace the real file/line as we go.
1342 my $realfile = '';
1343 my $realline = 0;
1344 my $realcnt = 0;
1345 my $here = '';
1346 my $in_comment = 0;
1347 my $comment_edge = 0;
1348 my $first_line = 0;
1349 my $p1_prefix = '';
1350
1351 my $prev_values = 'E';
1352
1353 # suppression flags
1354 my %suppress_ifbraces;
1355 my %suppress_whiletrailers;
1356 my %suppress_export;
1357
1358 # Pre-scan the patch sanitizing the lines.
1359 # Pre-scan the patch looking for any __setup documentation.
1360 #
1361 my @setup_docs = ();
1362 my $setup_docs = 0;
1363
1364 sanitise_line_reset();
1365 my $line;
1366 foreach my $rawline (@rawlines) {
1367 $linenr++;
1368 $line = $rawline;
1369
1370 if ($rawline=~/^\+\+\+\s+(\S+)/) {
1371 $setup_docs = 0;
1372 if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
1373 $setup_docs = 1;
1374 }
1375 #next;
1376 }
1377 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1378 $realline=$1-1;
1379 if (defined $2) {
1380 $realcnt=$3+1;
1381 } else {
1382 $realcnt=1+1;
1383 }
1384 $in_comment = 0;
1385
1386 # Guestimate if this is a continuing comment. Run
1387 # the context looking for a comment "edge". If this
1388 # edge is a close comment then we must be in a comment
1389 # at context start.
1390 my $edge;
1391 my $cnt = $realcnt;
1392 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
1393 next if (defined $rawlines[$ln - 1] &&
1394 $rawlines[$ln - 1] =~ /^-/);
1395 $cnt--;
1396 #print "RAW<$rawlines[$ln - 1]>\n";
1397 last if (!defined $rawlines[$ln - 1]);
1398 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
1399 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
1400 ($edge) = $1;
1401 last;
1402 }
1403 }
1404 if (defined $edge && $edge eq '*/') {
1405 $in_comment = 1;
1406 }
1407
1408 # Guestimate if this is a continuing comment. If this
1409 # is the start of a diff block and this line starts
1410 # ' *' then it is very likely a comment.
1411 if (!defined $edge &&
1412 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
1413 {
1414 $in_comment = 1;
1415 }
1416
1417 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1418 sanitise_line_reset($in_comment);
1419
1420 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
1421 # Standardise the strings and chars within the input to
1422 # simplify matching -- only bother with positive lines.
1423 $line = sanitise_line($rawline);
1424 }
1425 push(@lines, $line);
1426
1427 if ($realcnt > 1) {
1428 $realcnt-- if ($line =~ /^(?:\+| |$)/);
1429 } else {
1430 $realcnt = 0;
1431 }
1432
1433 #print "==>$rawline\n";
1434 #print "-->$line\n";
1435
1436 if ($setup_docs && $line =~ /^\+/) {
1437 push(@setup_docs, $line);
1438 }
1439 }
1440
1441 $prefix = '';
1442
1443 $realcnt = 0;
1444 $linenr = 0;
1445 foreach my $line (@lines) {
1446 $linenr++;
1447
1448 my $rawline = $rawlines[$linenr - 1];
1449
1450 #extract the line range in the file after the patch is applied
1451 if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1452 $is_patch = 1;
1453 $first_line = $linenr + 1;
1454 $realline=$1-1;
1455 if (defined $2) {
1456 $realcnt=$3+1;
1457 } else {
1458 $realcnt=1+1;
1459 }
1460 annotate_reset();
1461 $prev_values = 'E';
1462
1463 %suppress_ifbraces = ();
1464 %suppress_whiletrailers = ();
1465 %suppress_export = ();
1466 next;
1467
1468 # track the line number as we move through the hunk, note that
1469 # new versions of GNU diff omit the leading space on completely
1470 # blank context lines so we need to count that too.
1471 } elsif ($line =~ /^( |\+|$)/) {
1472 $realline++;
1473 $realcnt-- if ($realcnt != 0);
1474
1475 # Measure the line length and indent.
1476 ($length, $indent) = line_stats($rawline);
1477
1478 # Track the previous line.
1479 ($prevline, $stashline) = ($stashline, $line);
1480 ($previndent, $stashindent) = ($stashindent, $indent);
1481 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
1482
1483 #warn "line<$line>\n";
1484
1485 } elsif ($realcnt == 1) {
1486 $realcnt--;
1487 }
1488
1489 my $hunk_line = ($realcnt != 0);
1490
1491 #make up the handle for any error we report on this line
1492 $prefix = "$filename:$realline: " if ($emacs && $file);
1493 $prefix = "$filename:$linenr: " if ($emacs && !$file);
1494
1495 $here = "#$linenr: " if (!$file);
1496 $here = "#$realline: " if ($file);
1497
1498 # extract the filename as it passes
1499 if ($line =~ /^diff --git.*?(\S+)$/) {
1500 $realfile = $1;
1501 $realfile =~ s@^([^/]*)/@@;
1502
1503 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
1504 $realfile = $1;
1505 $realfile =~ s@^([^/]*)/@@;
1506
1507 $p1_prefix = $1;
1508 if (!$file && $tree && $p1_prefix ne '' &&
1509 -e "$root/$p1_prefix") {
1510 WARN("PATCH_PREFIX",
1511 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
1512 }
1513
1514 if ($realfile =~ m@^include/asm/@) {
1515 ERROR("MODIFIED_INCLUDE_ASM",
1516 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
1517 }
1518 next;
1519 }
1520
1521 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
1522
1523 my $hereline = "$here\n$rawline\n";
1524 my $herecurr = "$here\n$rawline\n";
1525 my $hereprev = "$here\n$prevrawline\n$rawline\n";
1526
1527 $cnt_lines++ if ($realcnt != 0);
1528
1529 # Check for incorrect file permissions
1530 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
1531 my $permhere = $here . "FILE: $realfile\n";
1532 if ($realfile =~ /(Makefile|Kconfig|\.c|\.h|\.S|\.tmpl)$/) {
1533 ERROR("EXECUTE_PERMISSIONS",
1534 "do not set execute permissions for source files\n" . $permhere);
1535 }
1536 }
1537
1538 # Check the patch for a signoff:
1539 if ($line =~ /^\s*signed-off-by:/i) {
1540 $signoff++;
1541 }
1542
1543 # Check signature styles
1544 if ($line =~ /^(\s*)($signature_tags)(\s*)(.*)/) {
1545 my $space_before = $1;
1546 my $sign_off = $2;
1547 my $space_after = $3;
1548 my $email = $4;
1549 my $ucfirst_sign_off = ucfirst(lc($sign_off));
1550
1551 if (defined $space_before && $space_before ne "") {
1552 WARN("BAD_SIGN_OFF",
1553 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr);
1554 }
1555 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
1556 WARN("BAD_SIGN_OFF",
1557 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr);
1558 }
1559 if (!defined $space_after || $space_after ne " ") {
1560 WARN("BAD_SIGN_OFF",
1561 "Use a single space after $ucfirst_sign_off\n" . $herecurr);
1562 }
1563
1564 my ($email_name, $email_address, $comment) = parse_email($email);
1565 my $suggested_email = format_email(($email_name, $email_address));
1566 if ($suggested_email eq "") {
1567 ERROR("BAD_SIGN_OFF",
1568 "Unrecognized email address: '$email'\n" . $herecurr);
1569 } else {
1570 my $dequoted = $suggested_email;
1571 $dequoted =~ s/^"//;
1572 $dequoted =~ s/" </ </;
1573 # Don't force email to have quotes
1574 # Allow just an angle bracketed address
1575 if ("$dequoted$comment" ne $email &&
1576 "<$email_address>$comment" ne $email &&
1577 "$suggested_email$comment" ne $email) {
1578 WARN("BAD_SIGN_OFF",
1579 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
1580 }
1581 }
1582 }
1583
1584 # Check for wrappage within a valid hunk of the file
1585 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
1586 ERROR("CORRUPTED_PATCH",
1587 "patch seems to be corrupt (line wrapped?)\n" .
1588 $herecurr) if (!$emitted_corrupt++);
1589 }
1590
1591 # Check for absolute kernel paths.
1592 if ($tree) {
1593 while ($line =~ m{(?:^|\s)(/\S*)}g) {
1594 my $file = $1;
1595
1596 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
1597 check_absolute_file($1, $herecurr)) {
1598 #
1599 } else {
1600 check_absolute_file($file, $herecurr);
1601 }
1602 }
1603 }
1604
1605 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
1606 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
1607 $rawline !~ m/^$UTF8*$/) {
1608 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
1609
1610 my $blank = copy_spacing($rawline);
1611 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
1612 my $hereptr = "$hereline$ptr\n";
1613
1614 CHK("INVALID_UTF8",
1615 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
1616 }
1617
1618 # ignore non-hunk lines and lines being removed
1619 next if (!$hunk_line || $line =~ /^-/);
1620
1621 #trailing whitespace
1622 if ($line =~ /^\+.*\015/) {
1623 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1624 ERROR("DOS_LINE_ENDINGS",
1625 "DOS line endings\n" . $herevet);
1626
1627 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
1628 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1629 ERROR("TRAILING_WHITESPACE",
1630 "trailing whitespace\n" . $herevet);
1631 $rpt_cleaners = 1;
1632 }
1633
1634 if ($rawline =~ /\bwrite to the Free/i ||
1635 $rawline =~ /\b59\s+Temple\s+Pl/i ||
1636 $rawline =~ /\b51\s+Franklin\s+St/i) {
1637 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1638 my $msg_type = \&ERROR;
1639 ERROR("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)
1640 }
1641
1642 # check for Kconfig help text having a real description
1643 # Only applies when adding the entry originally, after that we do not have
1644 # sufficient context to determine whether it is indeed long enough.
1645 if ($realfile =~ /Kconfig/ &&
1646 $line =~ /\+\s*(?:---)?help(?:---)?$/) {
1647 my $length = 0;
1648 my $cnt = $realcnt;
1649 my $ln = $linenr + 1;
1650 my $f;
1651 my $is_end = 0;
1652 while ($cnt > 0 && defined $lines[$ln - 1]) {
1653 $f = $lines[$ln - 1];
1654 $cnt-- if ($lines[$ln - 1] !~ /^-/);
1655 $is_end = $lines[$ln - 1] =~ /^\+/;
1656 $ln++;
1657
1658 next if ($f =~ /^-/);
1659 $f =~ s/^.//;
1660 $f =~ s/#.*//;
1661 $f =~ s/^\s+//;
1662 next if ($f =~ /^$/);
1663 if ($f =~ /^\s*config\s/) {
1664 $is_end = 1;
1665 last;
1666 }
1667 $length++;
1668 }
1669 WARN("CONFIG_DESCRIPTION",
1670 "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_end && $length < 4);
1671 #print "is_end<$is_end> length<$length>\n";
1672 }
1673
1674 # check we are in a valid source file if not then ignore this hunk
1675 next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
1676
1677 #120 column limit
1678 if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&
1679 $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&
1680 !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ ||
1681 $line =~ /^\+\s*"[^"]*"\s*(?:\s*|,|\)\s*;)\s*$/) &&
1682 $length > 120)
1683 {
1684 WARN("LONG_LINE",
1685 "line over 120 characters\n" . $herecurr);
1686 }
1687
1688 # check for spaces before a quoted newline
1689 if ($rawline =~ /^.*\".*\s\\n/) {
1690 WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
1691 "unnecessary whitespace before a quoted newline\n" . $herecurr);
1692 }
1693
1694 # check for adding lines without a newline.
1695 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
1696 WARN("MISSING_EOF_NEWLINE",
1697 "adding a line without newline at end of file\n" . $herecurr);
1698 }
1699
1700 # Blackfin: use hi/lo macros
1701 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
1702 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
1703 my $herevet = "$here\n" . cat_vet($line) . "\n";
1704 ERROR("LO_MACRO",
1705 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
1706 }
1707 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
1708 my $herevet = "$here\n" . cat_vet($line) . "\n";
1709 ERROR("HI_MACRO",
1710 "use the HI() macro, not (... >> 16)\n" . $herevet);
1711 }
1712 }
1713
1714 # check we are in a valid source file C or perl if not then ignore this hunk
1715 next if ($realfile !~ /\.(h|c|pl)$/);
1716
1717 # at the beginning of a line any tabs must come first and anything
1718 # more than 8 must use tabs.
1719 if ($rawline =~ /^\+\s* \t\s*\S/ ||
1720 $rawline =~ /^\+\s* \s*/) {
1721 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1722 ERROR("CODE_INDENT",
1723 "code indent should use tabs where possible\n" . $herevet);
1724 $rpt_cleaners = 1;
1725 }
1726
1727 # check for space before tabs.
1728 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
1729 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1730 WARN("SPACE_BEFORE_TAB",
1731 "please, no space before tabs\n" . $herevet);
1732 }
1733
1734 # check we are in a valid C source file if not then ignore this hunk
1735 next if ($realfile !~ /\.(h|c)$/);
1736
1737 # check for spaces at the beginning of a line.
1738 # Exceptions:
1739 # 1) within comments
1740 # 2) indented preprocessor commands
1741 # 3) hanging labels
1742 if ($rawline =~ /^\+ / && $line !~ /\+ *(?:$;|#|$Ident:)/) {
1743 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1744 WARN("LEADING_SPACE",
1745 "please, no spaces at the start of a line\n" . $herevet);
1746 }
1747
1748 # check for RCS/CVS revision markers
1749 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
1750 WARN("CVS_KEYWORD",
1751 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
1752 }
1753
1754 # Blackfin: don't use __builtin_bfin_[cs]sync
1755 if ($line =~ /__builtin_bfin_csync/) {
1756 my $herevet = "$here\n" . cat_vet($line) . "\n";
1757 ERROR("CSYNC",
1758 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
1759 }
1760 if ($line =~ /__builtin_bfin_ssync/) {
1761 my $herevet = "$here\n" . cat_vet($line) . "\n";
1762 ERROR("SSYNC",
1763 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
1764 }
1765
1766 # Check for potential 'bare' types
1767 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
1768 $realline_next);
1769 if ($realcnt && $line =~ /.\s*\S/) {
1770 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
1771 ctx_statement_block($linenr, $realcnt, 0);
1772 $stat =~ s/\n./\n /g;
1773 $cond =~ s/\n./\n /g;
1774
1775 # Find the real next line.
1776 $realline_next = $line_nr_next;
1777 if (defined $realline_next &&
1778 (!defined $lines[$realline_next - 1] ||
1779 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
1780 $realline_next++;
1781 }
1782
1783 my $s = $stat;
1784 $s =~ s/{.*$//s;
1785
1786 # Ignore goto labels.
1787 if ($s =~ /$Ident:\*$/s) {
1788
1789 # Ignore functions being called
1790 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
1791
1792 } elsif ($s =~ /^.\s*else\b/s) {
1793
1794 # declarations always start with types
1795 } 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) {
1796 my $type = $1;
1797 $type =~ s/\s+/ /g;
1798 possible($type, "A:" . $s);
1799
1800 # definitions in global scope can only start with types
1801 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
1802 possible($1, "B:" . $s);
1803 }
1804
1805 # any (foo ... *) is a pointer cast, and foo is a type
1806 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
1807 possible($1, "C:" . $s);
1808 }
1809
1810 # Check for any sort of function declaration.
1811 # int foo(something bar, other baz);
1812 # void (*store_gdt)(x86_descr_ptr *);
1813 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
1814 my ($name_len) = length($1);
1815
1816 my $ctx = $s;
1817 substr($ctx, 0, $name_len + 1, '');
1818 $ctx =~ s/\)[^\)]*$//;
1819
1820 for my $arg (split(/\s*,\s*/, $ctx)) {
1821 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
1822
1823 possible($1, "D:" . $s);
1824 }
1825 }
1826 }
1827
1828 }
1829
1830 #
1831 # Checks which may be anchored in the context.
1832 #
1833
1834 # Check for switch () and associated case and default
1835 # statements should be at the same indent.
1836 # if ($line=~/\bswitch\s*\(.*\)/) {
1837 # my $err = '';
1838 # my $sep = '';
1839 # my @ctx = ctx_block_outer($linenr, $realcnt);
1840 # shift(@ctx);
1841 # for my $ctx (@ctx) {
1842 # my ($clen, $cindent) = line_stats($ctx);
1843 # if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
1844 # $indent != $cindent) {
1845 # $err .= "$sep$ctx\n";
1846 # $sep = '';
1847 # } else {
1848 # $sep = "[...]\n";
1849 # }
1850 # }
1851 # if ($err ne '') {
1852 # ERROR("SWITCH_CASE_INDENT_LEVEL",
1853 # "switch and case should be at the same indent\n$hereline$err");
1854 # }
1855 # }
1856
1857 # if/while/etc brace do not go on next line, unless defining a do while loop,
1858 # or if that brace on the next line is for something else
1859 if ($line =~ /(.*)\b((?:if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
1860 my $pre_ctx = "$1$2";
1861
1862 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
1863 my $ctx_cnt = $realcnt - $#ctx - 1;
1864 my $ctx = join("\n", @ctx);
1865
1866 my $ctx_ln = $linenr;
1867 my $ctx_skip = $realcnt;
1868
1869 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
1870 defined $lines[$ctx_ln - 1] &&
1871 $lines[$ctx_ln - 1] =~ /^-/)) {
1872 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
1873 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
1874 $ctx_ln++;
1875 }
1876
1877 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
1878 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
1879
1880 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
1881 ERROR("OPEN_BRACE",
1882 "that open brace { should be on the previous line\n" .
1883 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
1884 }
1885 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
1886 $ctx =~ /\)\s*\;\s*$/ &&
1887 defined $lines[$ctx_ln - 1])
1888 {
1889 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
1890 if ($nindent > $indent) {
1891 WARN("TRAILING_SEMICOLON",
1892 "trailing semicolon indicates no statements, indent implies otherwise\n" .
1893 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
1894 }
1895 }
1896 }
1897
1898 # Check relative indent for conditionals and blocks.
1899 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
1900 my ($s, $c) = ($stat, $cond);
1901
1902 substr($s, 0, length($c), '');
1903
1904 # Make sure we remove the line prefixes as we have
1905 # none on the first line, and are going to readd them
1906 # where necessary.
1907 $s =~ s/\n./\n/gs;
1908
1909 # Find out how long the conditional actually is.
1910 my @newlines = ($c =~ /\n/gs);
1911 my $cond_lines = 1 + $#newlines;
1912
1913 # We want to check the first line inside the block
1914 # starting at the end of the conditional, so remove:
1915 # 1) any blank line termination
1916 # 2) any opening brace { on end of the line
1917 # 3) any do (...) {
1918 my $continuation = 0;
1919 my $check = 0;
1920 $s =~ s/^.*\bdo\b//;
1921 $s =~ s/^\s*{//;
1922 if ($s =~ s/^\s*\\//) {
1923 $continuation = 1;
1924 }
1925 if ($s =~ s/^\s*?\n//) {
1926 $check = 1;
1927 $cond_lines++;
1928 }
1929
1930 # Also ignore a loop construct at the end of a
1931 # preprocessor statement.
1932 if (($prevline =~ /^.\s*#\s*define\s/ ||
1933 $prevline =~ /\\\s*$/) && $continuation == 0) {
1934 $check = 0;
1935 }
1936
1937 my $cond_ptr = -1;
1938 $continuation = 0;
1939 while ($cond_ptr != $cond_lines) {
1940 $cond_ptr = $cond_lines;
1941
1942 # If we see an #else/#elif then the code
1943 # is not linear.
1944 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
1945 $check = 0;
1946 }
1947
1948 # Ignore:
1949 # 1) blank lines, they should be at 0,
1950 # 2) preprocessor lines, and
1951 # 3) labels.
1952 if ($continuation ||
1953 $s =~ /^\s*?\n/ ||
1954 $s =~ /^\s*#\s*?/ ||
1955 $s =~ /^\s*$Ident\s*:/) {
1956 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
1957 if ($s =~ s/^.*?\n//) {
1958 $cond_lines++;
1959 }
1960 }
1961 }
1962
1963 my (undef, $sindent) = line_stats("+" . $s);
1964 my $stat_real = raw_line($linenr, $cond_lines);
1965
1966 # Check if either of these lines are modified, else
1967 # this is not this patch's fault.
1968 if (!defined($stat_real) ||
1969 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
1970 $check = 0;
1971 }
1972 if (defined($stat_real) && $cond_lines > 1) {
1973 $stat_real = "[...]\n$stat_real";
1974 }
1975
1976 #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";
1977
1978 if ($check && (($sindent % 4) != 0 ||
1979 ($sindent <= $indent && $s ne ''))) {
1980 WARN("SUSPECT_CODE_INDENT",
1981 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
1982 }
1983 }
1984
1985 # Track the 'values' across context and added lines.
1986 my $opline = $line; $opline =~ s/^./ /;
1987 my ($curr_values, $curr_vars) =
1988 annotate_values($opline . "\n", $prev_values);
1989 $curr_values = $prev_values . $curr_values;
1990 if ($dbg_values) {
1991 my $outline = $opline; $outline =~ s/\t/ /g;
1992 print "$linenr > .$outline\n";
1993 print "$linenr > $curr_values\n";
1994 print "$linenr > $curr_vars\n";
1995 }
1996 $prev_values = substr($curr_values, -1);
1997
1998 #ignore lines not being added
1999 if ($line=~/^[^\+]/) {next;}
2000
2001 # TEST: allow direct testing of the type matcher.
2002 if ($dbg_type) {
2003 if ($line =~ /^.\s*$Declare\s*$/) {
2004 ERROR("TEST_TYPE",
2005 "TEST: is type\n" . $herecurr);
2006 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
2007 ERROR("TEST_NOT_TYPE",
2008 "TEST: is not type ($1 is)\n". $herecurr);
2009 }
2010 next;
2011 }
2012 # TEST: allow direct testing of the attribute matcher.
2013 if ($dbg_attr) {
2014 if ($line =~ /^.\s*$Modifier\s*$/) {
2015 ERROR("TEST_ATTR",
2016 "TEST: is attr\n" . $herecurr);
2017 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
2018 ERROR("TEST_NOT_ATTR",
2019 "TEST: is not attr ($1 is)\n". $herecurr);
2020 }
2021 next;
2022 }
2023
2024 # check for initialisation to aggregates open brace on the next line
2025 if ($line =~ /^.\s*{/ &&
2026 $prevline =~ /(?:^|[^=])=\s*$/) {
2027 ERROR("OPEN_BRACE",
2028 "that open brace { should be on the previous line\n" . $hereprev);
2029 }
2030
2031 #
2032 # Checks which are anchored on the added line.
2033 #
2034
2035 # check for malformed paths in #include statements (uses RAW line)
2036 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
2037 my $path = $1;
2038 if ($path =~ m{//}) {
2039 ERROR("MALFORMED_INCLUDE",
2040 "malformed #include filename\n" .
2041 $herecurr);
2042 }
2043 }
2044
2045 # no C99 // comments
2046 if ($line =~ m{//}) {
2047 ERROR("C99_COMMENTS",
2048 "do not use C99 // comments\n" . $herecurr);
2049 }
2050 # Remove C99 comments.
2051 $line =~ s@//.*@@;
2052 $opline =~ s@//.*@@;
2053
2054 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
2055 # the whole statement.
2056 #print "APW <$lines[$realline_next - 1]>\n";
2057 if (defined $realline_next &&
2058 exists $lines[$realline_next - 1] &&
2059 !defined $suppress_export{$realline_next} &&
2060 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2061 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2062 # Handle definitions which produce identifiers with
2063 # a prefix:
2064 # XXX(foo);
2065 # EXPORT_SYMBOL(something_foo);
2066 my $name = $1;
2067 if ($stat =~ /^.([A-Z_]+)\s*\(\s*($Ident)/ &&
2068 $name =~ /^${Ident}_$2/) {
2069 #print "FOO C name<$name>\n";
2070 $suppress_export{$realline_next} = 1;
2071
2072 } elsif ($stat !~ /(?:
2073 \n.}\s*$|
2074 ^.DEFINE_$Ident\(\Q$name\E\)|
2075 ^.DECLARE_$Ident\(\Q$name\E\)|
2076 ^.LIST_HEAD\(\Q$name\E\)|
2077 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
2078 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
2079 )/x) {
2080 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
2081 $suppress_export{$realline_next} = 2;
2082 } else {
2083 $suppress_export{$realline_next} = 1;
2084 }
2085 }
2086 if (!defined $suppress_export{$linenr} &&
2087 $prevline =~ /^.\s*$/ &&
2088 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2089 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2090 #print "FOO B <$lines[$linenr - 1]>\n";
2091 $suppress_export{$linenr} = 2;
2092 }
2093 if (defined $suppress_export{$linenr} &&
2094 $suppress_export{$linenr} == 2) {
2095 WARN("EXPORT_SYMBOL",
2096 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
2097 }
2098
2099 # check for global initialisers.
2100 if ($line =~ /^.$Type\s*$Ident\s*(?:\s+$Modifier)*\s*=\s*(0|NULL|false)\s*;/) {
2101 ERROR("GLOBAL_INITIALISERS",
2102 "do not initialise globals to 0 or NULL\n" .
2103 $herecurr);
2104 }
2105 # check for static initialisers.
2106 if ($line =~ /\bstatic\s.*=\s*(0|NULL|false)\s*;/) {
2107 ERROR("INITIALISED_STATIC",
2108 "do not initialise statics to 0 or NULL\n" .
2109 $herecurr);
2110 }
2111
2112 # check for static const char * arrays.
2113 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
2114 WARN("STATIC_CONST_CHAR_ARRAY",
2115 "static const char * array should probably be static const char * const\n" .
2116 $herecurr);
2117 }
2118
2119 # check for static char foo[] = "bar" declarations.
2120 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
2121 WARN("STATIC_CONST_CHAR_ARRAY",
2122 "static char array declaration should probably be static const char\n" .
2123 $herecurr);
2124 }
2125
2126 # check for declarations of struct pci_device_id
2127 if ($line =~ /\bstruct\s+pci_device_id\s+\w+\s*\[\s*\]\s*\=\s*\{/) {
2128 WARN("DEFINE_PCI_DEVICE_TABLE",
2129 "Use DEFINE_PCI_DEVICE_TABLE for struct pci_device_id\n" . $herecurr);
2130 }
2131
2132 # check for new typedefs, only function parameters and sparse annotations
2133 # make sense.
2134 # if ($line =~ /\btypedef\s/ &&
2135 # $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
2136 # $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
2137 # $line !~ /\b$typeTypedefs\b/ &&
2138 # $line !~ /\b__bitwise(?:__|)\b/) {
2139 # WARN("NEW_TYPEDEFS",
2140 # "do not add new typedefs\n" . $herecurr);
2141 # }
2142
2143 # * goes on variable not on type
2144 # (char*[ const])
2145 if ($line =~ m{\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\)}) {
2146 my ($from, $to) = ($1, $1);
2147
2148 # Should start with a space.
2149 $to =~ s/^(\S)/ $1/;
2150 # Should not end with a space.
2151 $to =~ s/\s+$//;
2152 # '*'s should not have spaces between.
2153 while ($to =~ s/\*\s+\*/\*\*/) {
2154 }
2155
2156 #print "from<$from> to<$to>\n";
2157 if ($from ne $to) {
2158 ERROR("POINTER_LOCATION",
2159 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr);
2160 }
2161 } elsif ($line =~ m{\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident)}) {
2162 my ($from, $to, $ident) = ($1, $1, $2);
2163
2164 # Should start with a space.
2165 $to =~ s/^(\S)/ $1/;
2166 # Should not end with a space.
2167 $to =~ s/\s+$//;
2168 # '*'s should not have spaces between.
2169 while ($to =~ s/\*\s+\*/\*\*/) {
2170 }
2171 # Modifiers should have spaces.
2172 $to =~ s/(\b$Modifier$)/$1 /;
2173
2174 #print "from<$from> to<$to> ident<$ident>\n";
2175 if ($from ne $to && $ident !~ /^$Modifier$/) {
2176 ERROR("POINTER_LOCATION",
2177 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr);
2178 }
2179 }
2180
2181 # # no BUG() or BUG_ON()
2182 # if ($line =~ /\b(BUG|BUG_ON)\b/) {
2183 # print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
2184 # print "$herecurr";
2185 # $clean = 0;
2186 # }
2187
2188 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
2189 WARN("LINUX_VERSION_CODE",
2190 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
2191 }
2192
2193 # check for uses of printk_ratelimit
2194 if ($line =~ /\bprintk_ratelimit\s*\(/) {
2195 WARN("PRINTK_RATELIMITED",
2196 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
2197 }
2198
2199 # printk should use KERN_* levels. Note that follow on printk's on the
2200 # same line do not need a level, so we use the current block context
2201 # to try and find and validate the current printk. In summary the current
2202 # printk includes all preceding printk's which have no newline on the end.
2203 # we assume the first bad printk is the one to report.
2204 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
2205 my $ok = 0;
2206 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
2207 #print "CHECK<$lines[$ln - 1]\n";
2208 # we have a preceding printk if it ends
2209 # with "\n" ignore it, else it is to blame
2210 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
2211 if ($rawlines[$ln - 1] !~ m{\\n"}) {
2212 $ok = 1;
2213 }
2214 last;
2215 }
2216 }
2217 if ($ok == 0) {
2218 WARN("PRINTK_WITHOUT_KERN_LEVEL",
2219 "printk() should include KERN_ facility level\n" . $herecurr);
2220 }
2221 }
2222
2223 # function brace can't be on same line, except for #defines of do while,
2224 # or if closed on same line
2225 if (($line=~/$Type\s*$Ident\(.*\).*\s{/) and
2226 !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {
2227 ERROR("OPEN_BRACE",
2228 "open brace '{' following function declarations go on the next line\n" . $herecurr);
2229 }
2230
2231 # open braces for enum, union and struct go on the same line.
2232 if ($line =~ /^.\s*{/ &&
2233 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
2234 ERROR("OPEN_BRACE",
2235 "open brace '{' following $1 go on the same line\n" . $hereprev);
2236 }
2237
2238 # missing space after union, struct or enum definition
2239 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?(?:\s+$Ident)?[=\{]/) {
2240 WARN("SPACING",
2241 "missing space after $1 definition\n" . $herecurr);
2242 }
2243
2244 # check for spacing round square brackets; allowed:
2245 # 1. with a type on the left -- int [] a;
2246 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
2247 # 3. inside a curly brace -- = { [0...10] = 5 }
2248 while ($line =~ /(.*?\s)\[/g) {
2249 my ($where, $prefix) = ($-[1], $1);
2250 if ($prefix !~ /$Type\s+$/ &&
2251 ($where != 0 || $prefix !~ /^.\s+$/) &&
2252 $prefix !~ /{\s+$/) {
2253 ERROR("BRACKET_SPACE",
2254 "space prohibited before open square bracket '['\n" . $herecurr);
2255 }
2256 }
2257
2258 # check for spaces between functions and their parentheses.
2259 while ($line =~ /($Ident)\s+\(/g) {
2260 my $name = $1;
2261 my $ctx_before = substr($line, 0, $-[1]);
2262 my $ctx = "$ctx_before$name";
2263
2264 # Ignore those directives where spaces _are_ permitted.
2265 if ($name =~ /^(?:
2266 if|for|while|switch|return|case|
2267 volatile|__volatile__|
2268 __attribute__|format|__extension__|
2269 asm|__asm__)$/x)
2270 {
2271
2272 # cpp #define statements have non-optional spaces, ie
2273 # if there is a space between the name and the open
2274 # parenthesis it is simply not a parameter group.
2275 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
2276
2277 # cpp #elif statement condition may start with a (
2278 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
2279
2280 # If this whole things ends with a type its most
2281 # likely a typedef for a function.
2282 } elsif ($ctx =~ /$Type$/) {
2283
2284 } else {
2285 WARN("SPACING",
2286 "space prohibited between function name and open parenthesis '('\n" . $herecurr);
2287 }
2288 }
2289 # Check operator spacing.
2290 if (!($line=~/\#\s*include/)) {
2291 my $ops = qr{
2292 <<=|>>=|<=|>=|==|!=|
2293 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
2294 =>|->|<<|>>|<|>|=|!|~|
2295 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
2296 \?|:
2297 }x;
2298 my @elements = split(/($ops|;)/, $opline);
2299 my $off = 0;
2300
2301 my $blank = copy_spacing($opline);
2302
2303 for (my $n = 0; $n < $#elements; $n += 2) {
2304 $off += length($elements[$n]);
2305
2306 # Pick up the preceding and succeeding characters.
2307 my $ca = substr($opline, 0, $off);
2308 my $cc = '';
2309 if (length($opline) >= ($off + length($elements[$n + 1]))) {
2310 $cc = substr($opline, $off + length($elements[$n + 1]));
2311 }
2312 my $cb = "$ca$;$cc";
2313
2314 my $a = '';
2315 $a = 'V' if ($elements[$n] ne '');
2316 $a = 'W' if ($elements[$n] =~ /\s$/);
2317 $a = 'C' if ($elements[$n] =~ /$;$/);
2318 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
2319 $a = 'O' if ($elements[$n] eq '');
2320 $a = 'E' if ($ca =~ /^\s*$/);
2321
2322 my $op = $elements[$n + 1];
2323
2324 my $c = '';
2325 if (defined $elements[$n + 2]) {
2326 $c = 'V' if ($elements[$n + 2] ne '');
2327 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
2328 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
2329 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
2330 $c = 'O' if ($elements[$n + 2] eq '');
2331 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
2332 } else {
2333 $c = 'E';
2334 }
2335
2336 my $ctx = "${a}x${c}";
2337
2338 my $at = "(ctx:$ctx)";
2339
2340 my $ptr = substr($blank, 0, $off) . "^";
2341 my $hereptr = "$hereline$ptr\n";
2342
2343 # Pull out the value of this operator.
2344 my $op_type = substr($curr_values, $off + 1, 1);
2345
2346 # Get the full operator variant.
2347 my $opv = $op . substr($curr_vars, $off, 1);
2348
2349 # Ignore operators passed as parameters.
2350 if ($op_type ne 'V' &&
2351 $ca =~ /\s$/ && $cc =~ /^\s*,/) {
2352
2353 # # Ignore comments
2354 # } elsif ($op =~ /^$;+$/) {
2355
2356 # ; should have either the end of line or a space or \ after it
2357 } elsif ($op eq ';') {
2358 if ($ctx !~ /.x[WEBC]/ &&
2359 $cc !~ /^\\/ && $cc !~ /^;/) {
2360 ERROR("SPACING",
2361 "space required after that '$op' $at\n" . $hereptr);
2362 }
2363
2364 # // is a comment
2365 } elsif ($op eq '//') {
2366
2367 # No spaces for:
2368 # ->
2369 # : when part of a bitfield
2370 } elsif ($op eq '->' || $opv eq ':B') {
2371 if ($ctx =~ /Wx.|.xW/) {
2372 ERROR("SPACING",
2373 "spaces prohibited around that '$op' $at\n" . $hereptr);
2374 }
2375
2376 # , must have a space on the right.
2377 } elsif ($op eq ',') {
2378 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
2379 ERROR("SPACING",
2380 "space required after that '$op' $at\n" . $hereptr);
2381 }
2382
2383 # '*' as part of a type definition -- reported already.
2384 } elsif ($opv eq '*_') {
2385 #warn "'*' is part of type\n";
2386
2387 # unary operators should have a space before and
2388 # none after. May be left adjacent to another
2389 # unary operator, or a cast
2390 } elsif ($op eq '!' || $op eq '~' ||
2391 $opv eq '*U' || $opv eq '-U' ||
2392 $opv eq '&U' || $opv eq '&&U') {
2393 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
2394 ERROR("SPACING",
2395 "space required before that '$op' $at\n" . $hereptr);
2396 }
2397 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
2398 # A unary '*' may be const
2399
2400 } elsif ($ctx =~ /.xW/) {
2401 ERROR("SPACING",
2402 "space prohibited after that '$op' $at\n" . $hereptr);
2403 }
2404
2405 # unary ++ and unary -- are allowed no space on one side.
2406 } elsif ($op eq '++' or $op eq '--') {
2407 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
2408 ERROR("SPACING",
2409 "space required one side of that '$op' $at\n" . $hereptr);
2410 }
2411 if ($ctx =~ /Wx[BE]/ ||
2412 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
2413 ERROR("SPACING",
2414 "space prohibited before that '$op' $at\n" . $hereptr);
2415 }
2416 if ($ctx =~ /ExW/) {
2417 ERROR("SPACING",
2418 "space prohibited after that '$op' $at\n" . $hereptr);
2419 }
2420
2421
2422 # << and >> may either have or not have spaces both sides
2423 } elsif ($op eq '<<' or $op eq '>>' or
2424 $op eq '&' or $op eq '^' or $op eq '|' or
2425 $op eq '+' or $op eq '-' or
2426 $op eq '*' or $op eq '/' or
2427 $op eq '%')
2428 {
2429 if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
2430 ERROR("SPACING",
2431 "need consistent spacing around '$op' $at\n" .
2432 $hereptr);
2433 }
2434
2435 # A colon needs no spaces before when it is
2436 # terminating a case value or a label.
2437 } elsif ($opv eq ':C' || $opv eq ':L') {
2438 if ($ctx =~ /Wx./) {
2439 ERROR("SPACING",
2440 "space prohibited before that '$op' $at\n" . $hereptr);
2441 }
2442
2443 # All the others need spaces both sides.
2444 } elsif ($ctx !~ /[EWC]x[CWE]/) {
2445 my $ok = 0;
2446
2447 # Ignore email addresses <foo@bar>
2448 if (($op eq '<' &&
2449 $cc =~ /^\S+\@\S+>/) ||
2450 ($op eq '>' &&
2451 $ca =~ /<\S+\@\S+$/))
2452 {
2453 $ok = 1;
2454 }
2455
2456 # Ignore ?:
2457 if (($opv eq ':O' && $ca =~ /\?$/) ||
2458 ($op eq '?' && $cc =~ /^:/)) {
2459 $ok = 1;
2460 }
2461
2462 if ($ok == 0) {
2463 ERROR("SPACING",
2464 "spaces required around that '$op' $at\n" . $hereptr);
2465 }
2466 }
2467 $off += length($elements[$n + 1]);
2468 }
2469 }
2470
2471 # check for multiple assignments
2472 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
2473 CHK("MULTIPLE_ASSIGNMENTS",
2474 "multiple assignments should be avoided\n" . $herecurr);
2475 }
2476
2477 ## # check for multiple declarations, allowing for a function declaration
2478 ## # continuation.
2479 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
2480 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
2481 ##
2482 ## # Remove any bracketed sections to ensure we do not
2483 ## # falsly report the parameters of functions.
2484 ## my $ln = $line;
2485 ## while ($ln =~ s/\([^\(\)]*\)//g) {
2486 ## }
2487 ## if ($ln =~ /,/) {
2488 ## WARN("MULTIPLE_DECLARATION",
2489 ## "declaring multiple variables together should be avoided\n" . $herecurr);
2490 ## }
2491 ## }
2492
2493 #need space before brace following if, while, etc
2494 if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
2495 $line =~ /do{/) {
2496 ERROR("SPACING",
2497 "space required before the open brace '{'\n" . $herecurr);
2498 }
2499
2500 # closing brace should have a space following it when it has anything
2501 # on the line
2502 if ($line =~ /}(?!(?:,|;|\)))\S/) {
2503 ERROR("SPACING",
2504 "space required after that close brace '}'\n" . $herecurr);
2505 }
2506
2507 # check spacing on square brackets
2508 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
2509 ERROR("SPACING",
2510 "space prohibited after that open square bracket '['\n" . $herecurr);
2511 }
2512 if ($line =~ /\s\]/) {
2513 ERROR("SPACING",
2514 "space prohibited before that close square bracket ']'\n" . $herecurr);
2515 }
2516
2517 # check spacing on parentheses
2518 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
2519 $line !~ /for\s*\(\s+;/) {
2520 ERROR("SPACING",
2521 "space prohibited after that open parenthesis '('\n" . $herecurr);
2522 }
2523 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
2524 $line !~ /for\s*\(.*;\s+\)/ &&
2525 $line !~ /:\s+\)/) {
2526 ERROR("SPACING",
2527 "space prohibited before that close parenthesis ')'\n" . $herecurr);
2528 }
2529
2530 #goto labels aren't indented, allow a single space however
2531 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
2532 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
2533 WARN("INDENTED_LABEL",
2534 "labels should not be indented\n" . $herecurr);
2535 }
2536
2537 # Return is not a function.
2538 if (defined($stat) && $stat =~ /^.\s*return(\s*)(\(.*);/s) {
2539 my $spacing = $1;
2540 my $value = $2;
2541
2542 # Flatten any parentheses
2543 $value =~ s/\(/ \(/g;
2544 $value =~ s/\)/\) /g;
2545 while ($value =~ s/\[[^\{\}]*\]/1/ ||
2546 $value !~ /(?:$Ident|-?$Constant)\s*
2547 $Compare\s*
2548 (?:$Ident|-?$Constant)/x &&
2549 $value =~ s/\([^\(\)]*\)/1/) {
2550 }
2551 #print "value<$value>\n";
2552 if ($value =~ /^\s*(?:$Ident|-?$Constant)\s*$/) {
2553 ERROR("RETURN_PARENTHESES",
2554 "return is not a function, parentheses are not required\n" . $herecurr);
2555
2556 } elsif ($spacing !~ /\s+/) {
2557 ERROR("SPACING",
2558 "space required before the open parenthesis '('\n" . $herecurr);
2559 }
2560 }
2561 # Return of what appears to be an errno should normally be -'ve
2562 if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {
2563 my $name = $1;
2564 if ($name ne 'EOF' && $name ne 'ERROR') {
2565 WARN("USE_NEGATIVE_ERRNO",
2566 "return of an errno should typically be -ve (return -$1)\n" . $herecurr);
2567 }
2568 }
2569
2570 # typecasts on min/max could be min_t/max_t
2571 if ($line =~ /^\+(?:.*?)\b(min|max)\s*\($Typecast{0,1}($LvalOrFunc)\s*,\s*$Typecast{0,1}($LvalOrFunc)\s*\)/) {
2572 if (defined $2 || defined $8) {
2573 my $call = $1;
2574 my $cast1 = deparenthesize($2);
2575 my $arg1 = $3;
2576 my $cast2 = deparenthesize($8);
2577 my $arg2 = $9;
2578 my $cast;
2579
2580 if ($cast1 ne "" && $cast2 ne "") {
2581 $cast = "$cast1 or $cast2";
2582 } elsif ($cast1 ne "") {
2583 $cast = $cast1;
2584 } else {
2585 $cast = $cast2;
2586 }
2587 WARN("MINMAX",
2588 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . $herecurr);
2589 }
2590 }
2591
2592 # Need a space before open parenthesis after if, while etc
2593 if ($line=~/\b(if|while|for|switch)\(/) {
2594 ERROR("SPACING", "space required before the open parenthesis '('\n" . $herecurr);
2595 }
2596
2597 # Check for illegal assignment in if conditional -- and check for trailing
2598 # statements after the conditional.
2599 if ($line =~ /do\s*(?!{)/) {
2600 my ($stat_next) = ctx_statement_block($line_nr_next,
2601 $remain_next, $off_next);
2602 $stat_next =~ s/\n./\n /g;
2603 ##print "stat<$stat> stat_next<$stat_next>\n";
2604
2605 if ($stat_next =~ /^\s*while\b/) {
2606 # If the statement carries leading newlines,
2607 # then count those as offsets.
2608 my ($whitespace) =
2609 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
2610 my $offset =
2611 statement_rawlines($whitespace) - 1;
2612
2613 $suppress_whiletrailers{$line_nr_next +
2614 $offset} = 1;
2615 }
2616 }
2617 if (!defined $suppress_whiletrailers{$linenr} &&
2618 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
2619 my ($s, $c) = ($stat, $cond);
2620
2621 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
2622 ERROR("ASSIGN_IN_IF",
2623 "do not use assignment in if condition\n" . $herecurr);
2624 }
2625
2626 # Find out what is on the end of the line after the
2627 # conditional.
2628 substr($s, 0, length($c), '');
2629 $s =~ s/\n.*//g;
2630 $s =~ s/$;//g; # Remove any comments
2631 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
2632 $c !~ /}\s*while\s*/)
2633 {
2634 # Find out how long the conditional actually is.
2635 my @newlines = ($c =~ /\n/gs);
2636 my $cond_lines = 1 + $#newlines;
2637 my $stat_real = '';
2638
2639 $stat_real = raw_line($linenr, $cond_lines)
2640 . "\n" if ($cond_lines);
2641 if (defined($stat_real) && $cond_lines > 1) {
2642 $stat_real = "[...]\n$stat_real";
2643 }
2644
2645 ERROR("TRAILING_STATEMENTS",
2646 "trailing statements should be on next line\n" . $herecurr . $stat_real);
2647 }
2648 }
2649
2650 # Check for bitwise tests written as boolean
2651 if ($line =~ /
2652 (?:
2653 (?:\[|\(|\&\&|\|\|)
2654 \s*0[xX][0-9]+\s*
2655 (?:\&\&|\|\|)
2656 |
2657 (?:\&\&|\|\|)
2658 \s*0[xX][0-9]+\s*
2659 (?:\&\&|\|\||\)|\])
2660 )/x)
2661 {
2662 WARN("HEXADECIMAL_BOOLEAN_TEST",
2663 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
2664 }
2665
2666 # if and else should not have general statements after it
2667 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
2668 my $s = $1;
2669 $s =~ s/$;//g; # Remove any comments
2670 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
2671 ERROR("TRAILING_STATEMENTS",
2672 "trailing statements should be on next line\n" . $herecurr);
2673 }
2674 }
2675 # if should not continue a brace
2676 if ($line =~ /}\s*if\b/) {
2677 ERROR("TRAILING_STATEMENTS",
2678 "trailing statements should be on next line\n" .
2679 $herecurr);
2680 }
2681 # case and default should not have general statements after them
2682 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
2683 $line !~ /\G(?:
2684 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
2685 \s*return\s+
2686 )/xg)
2687 {
2688 ERROR("TRAILING_STATEMENTS",
2689 "trailing statements should be on next line\n" . $herecurr);
2690 }
2691
2692 # Check for }<nl>else {, these must be at the same
2693 # indent level to be relevant to each other.
2694 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
2695 $previndent == $indent) {
2696 ERROR("ELSE_AFTER_BRACE",
2697 "else should follow close brace '}'\n" . $hereprev);
2698 }
2699
2700 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and
2701 $previndent == $indent) {
2702 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
2703
2704 # Find out what is on the end of the line after the
2705 # conditional.
2706 substr($s, 0, length($c), '');
2707 $s =~ s/\n.*//g;
2708
2709 if ($s =~ /^\s*;/) {
2710 ERROR("WHILE_AFTER_BRACE",
2711 "while should follow close brace '}'\n" . $hereprev);
2712 }
2713 }
2714
2715 #studly caps, commented out until figure out how to distinguish between use of existing and adding new
2716 # if (($line=~/[\w_][a-z\d]+[A-Z]/) and !($line=~/print/)) {
2717 # print "No studly caps, use _\n";
2718 # print "$herecurr";
2719 # $clean = 0;
2720 # }
2721
2722 #no spaces allowed after \ in define
2723 if ($line=~/\#\s*define.*\\\s$/) {
2724 WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
2725 "Whitepspace after \\ makes next lines useless\n" . $herecurr);
2726 }
2727
2728 #warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
2729 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
2730 my $file = "$1.h";
2731 my $checkfile = "include/linux/$file";
2732 if (-f "$root/$checkfile" &&
2733 $realfile ne $checkfile &&
2734 $1 !~ /$allowed_asm_includes/)
2735 {
2736 if ($realfile =~ m{^arch/}) {
2737 CHK("ARCH_INCLUDE_LINUX",
2738 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
2739 } else {
2740 WARN("INCLUDE_LINUX",
2741 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
2742 }
2743 }
2744 }
2745
2746 # multi-statement macros should be enclosed in a do while loop, grab the
2747 # first statement and ensure its the whole macro if its not enclosed
2748 # in a known good container
2749 if ($realfile !~ m@/vmlinux.lds.h$@ &&
2750 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
2751 my $ln = $linenr;
2752 my $cnt = $realcnt;
2753 my ($off, $dstat, $dcond, $rest);
2754 my $ctx = '';
2755
2756 my $args = defined($1);
2757
2758 # Find the end of the macro and limit our statement
2759 # search to that.
2760 while ($cnt > 0 && defined $lines[$ln - 1] &&
2761 $lines[$ln - 1] =~ /^(?:-|..*\\$)/)
2762 {
2763 $ctx .= $rawlines[$ln - 1] . "\n";
2764 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2765 $ln++;
2766 }
2767 $ctx .= $rawlines[$ln - 1];
2768
2769 ($dstat, $dcond, $ln, $cnt, $off) =
2770 ctx_statement_block($linenr, $ln - $linenr + 1, 0);
2771 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
2772 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
2773
2774 # Extract the remainder of the define (if any) and
2775 # rip off surrounding spaces, and trailing \'s.
2776 $rest = '';
2777 while ($off != 0 || ($cnt > 0 && $rest =~ /\\\s*$/)) {
2778 #print "ADDING cnt<$cnt> $off <" . substr($lines[$ln - 1], $off) . "> rest<$rest>\n";
2779 if ($off != 0 || $lines[$ln - 1] !~ /^-/) {
2780 $rest .= substr($lines[$ln - 1], $off) . "\n";
2781 $cnt--;
2782 }
2783 $ln++;
2784 $off = 0;
2785 }
2786 $rest =~ s/\\\n.//g;
2787 $rest =~ s/^\s*//s;
2788 $rest =~ s/\s*$//s;
2789
2790 # Clean up the original statement.
2791 if ($args) {
2792 substr($dstat, 0, length($dcond), '');
2793 } else {
2794 $dstat =~ s/^.\s*\#\s*define\s+$Ident\s*//;
2795 }
2796 $dstat =~ s/$;//g;
2797 $dstat =~ s/\\\n.//g;
2798 $dstat =~ s/^\s*//s;
2799 $dstat =~ s/\s*$//s;
2800
2801 # Flatten any parentheses and braces
2802 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
2803 $dstat =~ s/\{[^\{\}]*\}/1/ ||
2804 $dstat =~ s/\[[^\{\}]*\]/1/)
2805 {
2806 }
2807
2808 my $exceptions = qr{
2809 $Declare|
2810 module_param_named|
2811 MODULE_PARAM_DESC|
2812 DECLARE_PER_CPU|
2813 DEFINE_PER_CPU|
2814 __typeof__\(|
2815 union|
2816 struct|
2817 \.$Ident\s*=\s*|
2818 ^\"|\"$
2819 }x;
2820 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
2821 if ($rest ne '' && $rest ne ',') {
2822 if ($rest !~ /while\s*\(/ &&
2823 $dstat !~ /$exceptions/)
2824 {
2825 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
2826 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$here\n$ctx\n");
2827 }
2828
2829 } elsif ($ctx !~ /;/) {
2830 if ($dstat ne '' &&
2831 $dstat !~ /^(?:$Ident|-?$Constant)$/ &&
2832 $dstat !~ /$exceptions/ &&
2833 $dstat !~ /^\.$Ident\s*=/ &&
2834 $dstat =~ /$Operators/)
2835 {
2836 ERROR("COMPLEX_MACRO",
2837 "Macros with complex values should be enclosed in parenthesis\n" . "$here\n$ctx\n");
2838 }
2839 }
2840 }
2841
2842 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
2843 # all assignments may have only one of the following with an assignment:
2844 # .
2845 # ALIGN(...)
2846 # VMLINUX_SYMBOL(...)
2847 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
2848 WARN("MISSING_VMLINUX_SYMBOL",
2849 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
2850 }
2851
2852 # check for redundant bracing round if etc
2853 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
2854 my ($level, $endln, @chunks) =
2855 ctx_statement_full($linenr, $realcnt, 1);
2856 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
2857 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
2858 if ($#chunks > 0 && $level == 0) {
2859 my $allowed = 0;
2860 my $seen = 0;
2861 my $herectx = $here . "\n";
2862 my $ln = $linenr - 1;
2863 for my $chunk (@chunks) {
2864 my ($cond, $block) = @{$chunk};
2865
2866 # If the condition carries leading newlines, then count those as offsets.
2867 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
2868 my $offset = statement_rawlines($whitespace) - 1;
2869
2870 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
2871
2872 # We have looked at and allowed this specific line.
2873 $suppress_ifbraces{$ln + $offset} = 1;
2874
2875 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
2876 $ln += statement_rawlines($block) - 1;
2877
2878 substr($block, 0, length($cond), '');
2879
2880 $seen++ if ($block =~ /^\s*{/);
2881
2882 #print "cond<$cond> block<$block> allowed<$allowed>\n";
2883 if (statement_lines($cond) > 1) {
2884 #print "APW: ALLOWED: cond<$cond>\n";
2885 $allowed = 1;
2886 }
2887 if ($block =~/\b(?:if|for|while)\b/) {
2888 #print "APW: ALLOWED: block<$block>\n";
2889 $allowed = 1;
2890 }
2891 if (statement_block_size($block) > 1) {
2892 #print "APW: ALLOWED: lines block<$block>\n";
2893 $allowed = 1;
2894 }
2895 }
2896 if ($seen && !$allowed) {
2897 WARN("BRACES",
2898 "braces {} are not necessary for any arm of this statement\n" . $herectx);
2899 }
2900 }
2901 }
2902 if (!defined $suppress_ifbraces{$linenr - 1} &&
2903 $line =~ /\b(if|while|for|else)\b/) {
2904 my $allowed = 0;
2905
2906 # Check the pre-context.
2907 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
2908 #print "APW: ALLOWED: pre<$1>\n";
2909 $allowed = 1;
2910 }
2911
2912 my ($level, $endln, @chunks) =
2913 ctx_statement_full($linenr, $realcnt, $-[0]);
2914
2915 # Check the condition.
2916 my ($cond, $block) = @{$chunks[0]};
2917 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
2918 if (defined $cond) {
2919 substr($block, 0, length($cond), '');
2920 }
2921 if (statement_lines($cond) > 1) {
2922 #print "APW: ALLOWED: cond<$cond>\n";
2923 $allowed = 1;
2924 }
2925 if ($block =~/\b(?:if|for|while)\b/) {
2926 #print "APW: ALLOWED: block<$block>\n";
2927 $allowed = 1;
2928 }
2929 if (statement_block_size($block) > 1) {
2930 #print "APW: ALLOWED: lines block<$block>\n";
2931 $allowed = 1;
2932 }
2933 # Check the post-context.
2934 if (defined $chunks[1]) {
2935 my ($cond, $block) = @{$chunks[1]};
2936 if (defined $cond) {
2937 substr($block, 0, length($cond), '');
2938 }
2939 if ($block =~ /^\s*\{/) {
2940 #print "APW: ALLOWED: chunk-1 block<$block>\n";
2941 $allowed = 1;
2942 }
2943 }
2944 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
2945 my $herectx = $here . "\n";
2946 my $cnt = statement_rawlines($block);
2947
2948 for (my $n = 0; $n < $cnt; $n++) {
2949 $herectx .= raw_line($linenr, $n) . "\n";
2950 }
2951
2952 WARN("BRACES",
2953 "braces {} are not necessary for single statement blocks\n" . $herectx);
2954 }
2955 }
2956
2957 # don't include deprecated include files (uses RAW line)
2958 for my $inc (@dep_includes) {
2959 if ($rawline =~ m@^.\s*\#\s*include\s*\<$inc>@) {
2960 ERROR("DEPRECATED_INCLUDE",
2961 "Don't use <$inc>: see Documentation/feature-removal-schedule.txt\n" . $herecurr);
2962 }
2963 }
2964
2965 # don't use deprecated functions
2966 for my $func (@dep_functions) {
2967 if ($line =~ /\b$func\b/) {
2968 ERROR("DEPRECATED_FUNCTION",
2969 "Don't use $func(): see Documentation/feature-removal-schedule.txt\n" . $herecurr);
2970 }
2971 }
2972
2973 # no volatiles please
2974 # my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
2975 # if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
2976 # WARN("VOLATILE",
2977 # "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
2978 # }
2979
2980 # warn about #if 0
2981 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
2982 CHK("REDUNDANT_CODE",
2983 "if this code is redundant consider removing it\n" .
2984 $herecurr);
2985 }
2986
2987 # check for needless kfree() checks
2988 if ($prevline =~ /\bif\s*\(([^\)]*)\)/) {
2989 my $expr = $1;
2990 if ($line =~ /\bkfree\(\Q$expr\E\);/) {
2991 WARN("NEEDLESS_KFREE",
2992 "kfree(NULL) is safe this check is probably not required\n" . $hereprev);
2993 }
2994 }
2995 # check for needless usb_free_urb() checks
2996 if ($prevline =~ /\bif\s*\(([^\)]*)\)/) {
2997 my $expr = $1;
2998 if ($line =~ /\busb_free_urb\(\Q$expr\E\);/) {
2999 WARN("NEEDLESS_USB_FREE_URB",
3000 "usb_free_urb(NULL) is safe this check is probably not required\n" . $hereprev);
3001 }
3002 }
3003
3004 # prefer usleep_range over udelay
3005 if ($line =~ /\budelay\s*\(\s*(\w+)\s*\)/) {
3006 # ignore udelay's < 10, however
3007 if (! (($1 =~ /(\d+)/) && ($1 < 10)) ) {
3008 CHK("USLEEP_RANGE",
3009 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $line);
3010 }
3011 }
3012
3013 # warn about unexpectedly long msleep's
3014 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
3015 if ($1 < 20) {
3016 WARN("MSLEEP",
3017 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $line);
3018 }
3019 }
3020
3021 # warn about #ifdefs in C files
3022 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
3023 # print "#ifdef in C files should be avoided\n";
3024 # print "$herecurr";
3025 # $clean = 0;
3026 # }
3027
3028 # warn about spacing in #ifdefs
3029 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
3030 ERROR("SPACING",
3031 "exactly one space required after that #$1\n" . $herecurr);
3032 }
3033
3034 # check for spinlock_t definitions without a comment.
3035 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
3036 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
3037 my $which = $1;
3038 if (!ctx_has_comment($first_line, $linenr)) {
3039 CHK("UNCOMMENTED_DEFINITION",
3040 "$1 definition without comment\n" . $herecurr);
3041 }
3042 }
3043 # check for memory barriers without a comment.
3044 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
3045 if (!ctx_has_comment($first_line, $linenr)) {
3046 CHK("MEMORY_BARRIER",
3047 "memory barrier without comment\n" . $herecurr);
3048 }
3049 }
3050 # check of hardware specific defines
3051 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
3052 CHK("ARCH_DEFINES",
3053 "architecture specific defines should be avoided\n" . $herecurr);
3054 }
3055
3056 # Check that the storage class is at the beginning of a declaration
3057 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
3058 WARN("STORAGE_CLASS",
3059 "storage class should be at the beginning of the declaration\n" . $herecurr)
3060 }
3061
3062 # check the location of the inline attribute, that it is between
3063 # storage class and type.
3064 if ($line =~ /\b$Type\s+$Inline\b/ ||
3065 $line =~ /\b$Inline\s+$Storage\b/) {
3066 ERROR("INLINE_LOCATION",
3067 "inline keyword should sit between storage class and type\n" . $herecurr);
3068 }
3069
3070 # Check for __inline__ and __inline, prefer inline
3071 if ($line =~ /\b(__inline__|__inline)\b/) {
3072 WARN("INLINE",
3073 "plain inline is preferred over $1\n" . $herecurr);
3074 }
3075
3076 # Check for __attribute__ packed, prefer __packed
3077 # if ($line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
3078 # WARN("PREFER_PACKED",
3079 # "__packed is preferred over __attribute__((packed))\n" . $herecurr);
3080 # }
3081
3082 # Check for __attribute__ aligned, prefer __aligned
3083 # if ($line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
3084 # WARN("PREFER_ALIGNED",
3085 # "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
3086 # }
3087
3088 # check for sizeof(&)
3089 if ($line =~ /\bsizeof\s*\(\s*\&/) {
3090 WARN("SIZEOF_ADDRESS",
3091 "sizeof(& should be avoided\n" . $herecurr);
3092 }
3093
3094 # check for line continuations in quoted strings with odd counts of "
3095 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
3096 WARN("LINE_CONTINUATIONS",
3097 "Avoid line continuations in quoted strings\n" . $herecurr);
3098 }
3099
3100 # check for new externs in .c files.
3101 # if ($realfile =~ /\.c$/ && defined $stat &&
3102 # $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
3103 # {
3104 # my $function_name = $1;
3105 # my $paren_space = $2;
3106 #
3107 # my $s = $stat;
3108 # if (defined $cond) {
3109 # substr($s, 0, length($cond), '');
3110 # }
3111 # if ($s =~ /^\s*;/ &&
3112 # $function_name ne 'uninitialized_var')
3113 # {
3114 # WARN("AVOID_EXTERNS",
3115 # "externs should be avoided in .c files\n" . $herecurr);
3116 # }
3117 #
3118 # if ($paren_space =~ /\n/) {
3119 # WARN("FUNCTION_ARGUMENTS",
3120 # "arguments for function declarations should follow identifier\n" . $herecurr);
3121 # }
3122 #
3123 # } elsif ($realfile =~ /\.c$/ && defined $stat &&
3124 # $stat =~ /^.\s*extern\s+/)
3125 # {
3126 # WARN("AVOID_EXTERNS",
3127 # "externs should be avoided in .c files\n" . $herecurr);
3128 # }
3129
3130 # checks for new __setup's
3131 if ($rawline =~ /\b__setup\("([^"]*)"/) {
3132 my $name = $1;
3133
3134 if (!grep(/$name/, @setup_docs)) {
3135 CHK("UNDOCUMENTED_SETUP",
3136 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
3137 }
3138 }
3139
3140 # check for pointless casting of kmalloc return
3141 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
3142 WARN("UNNECESSARY_CASTS",
3143 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
3144 }
3145
3146 # check for multiple semicolons
3147 if ($line =~ /;\s*;\s*$/) {
3148 WARN("ONE_SEMICOLON",
3149 "Statements terminations use 1 semicolon\n" . $herecurr);
3150 }
3151
3152 # check for gcc specific __FUNCTION__
3153 if ($line =~ /__FUNCTION__/) {
3154 WARN("USE_FUNC",
3155 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr);
3156 }
3157
3158 # check for semaphores initialized locked
3159 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
3160 WARN("CONSIDER_COMPLETION",
3161 "consider using a completion\n" . $herecurr);
3162
3163 }
3164 # recommend kstrto* over simple_strto*
3165 if ($line =~ /\bsimple_(strto.*?)\s*\(/) {
3166 WARN("CONSIDER_KSTRTO",
3167 "consider using kstrto* in preference to simple_$1\n" . $herecurr);
3168 }
3169 # check for __initcall(), use device_initcall() explicitly please
3170 if ($line =~ /^.\s*__initcall\s*\(/) {
3171 WARN("USE_DEVICE_INITCALL",
3172 "please use device_initcall() instead of __initcall()\n" . $herecurr);
3173 }
3174 # check for various ops structs, ensure they are const.
3175 my $struct_ops = qr{acpi_dock_ops|
3176 address_space_operations|
3177 backlight_ops|
3178 block_device_operations|
3179 dentry_operations|
3180 dev_pm_ops|
3181 dma_map_ops|
3182 extent_io_ops|
3183 file_lock_operations|
3184 file_operations|
3185 hv_ops|
3186 ide_dma_ops|
3187 intel_dvo_dev_ops|
3188 item_operations|
3189 iwl_ops|
3190 kgdb_arch|
3191 kgdb_io|
3192 kset_uevent_ops|
3193 lock_manager_operations|
3194 microcode_ops|
3195 mtrr_ops|
3196 neigh_ops|
3197 nlmsvc_binding|
3198 pci_raw_ops|
3199 pipe_buf_operations|
3200 platform_hibernation_ops|
3201 platform_suspend_ops|
3202 proto_ops|
3203 rpc_pipe_ops|
3204 seq_operations|
3205 snd_ac97_build_ops|
3206 soc_pcmcia_socket_ops|
3207 stacktrace_ops|
3208 sysfs_ops|
3209 tty_operations|
3210 usb_mon_operations|
3211 wd_ops}x;
3212 if ($line !~ /\bconst\b/ &&
3213 $line =~ /\bstruct\s+($struct_ops)\b/) {
3214 WARN("CONST_STRUCT",
3215 "struct $1 should normally be const\n" .
3216 $herecurr);
3217 }
3218
3219 # use of NR_CPUS is usually wrong
3220 # ignore definitions of NR_CPUS and usage to define arrays as likely right
3221 if ($line =~ /\bNR_CPUS\b/ &&
3222 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
3223 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
3224 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
3225 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
3226 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
3227 {
3228 WARN("NR_CPUS",
3229 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
3230 }
3231
3232 # check for %L{u,d,i} in strings
3233 my $string;
3234 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
3235 $string = substr($rawline, $-[1], $+[1] - $-[1]);
3236 $string =~ s/%%/__/g;
3237 if ($string =~ /(?<!%)%L[udi]/) {
3238 WARN("PRINTF_L",
3239 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
3240 last;
3241 }
3242 }
3243
3244 # whine mightly about in_atomic
3245 if ($line =~ /\bin_atomic\s*\(/) {
3246 if ($realfile =~ m@^drivers/@) {
3247 ERROR("IN_ATOMIC",
3248 "do not use in_atomic in drivers\n" . $herecurr);
3249 } elsif ($realfile !~ m@^kernel/@) {
3250 WARN("IN_ATOMIC",
3251 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
3252 }
3253 }
3254
3255 # check for lockdep_set_novalidate_class
3256 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
3257 $line =~ /__lockdep_no_validate__\s*\)/ ) {
3258 if ($realfile !~ m@^kernel/lockdep@ &&
3259 $realfile !~ m@^include/linux/lockdep@ &&
3260 $realfile !~ m@^drivers/base/core@) {
3261 ERROR("LOCKDEP",
3262 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
3263 }
3264 }
3265
3266 if ($line =~ /debugfs_create_file.*S_IWUGO/ ||
3267 $line =~ /DEVICE_ATTR.*S_IWUGO/ ) {
3268 WARN("EXPORTED_WORLD_WRITABLE",
3269 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
3270 }
3271
3272 # Check for memset with swapped arguments
3273 if ($line =~ /memset.*\,(\ |)(0x|)0(\ |0|)\);/) {
3274 ERROR("MEMSET",
3275 "memset size is 3rd argument, not the second.\n" . $herecurr);
3276 }
3277 }
3278
3279 # If we have no input at all, then there is nothing to report on
3280 # so just keep quiet.
3281 if ($#rawlines == -1) {
3282 exit(0);
3283 }
3284
3285 # In mailback mode only produce a report in the negative, for
3286 # things that appear to be patches.
3287 if ($mailback && ($clean == 1 || !$is_patch)) {
3288 exit(0);
3289 }
3290
3291 # This is not a patch, and we are are in 'no-patch' mode so
3292 # just keep quiet.
3293 if (!$chk_patch && !$is_patch) {
3294 exit(0);
3295 }
3296
3297 if (!$is_patch) {
3298 ERROR("NOT_UNIFIED_DIFF",
3299 "Does not appear to be a unified-diff format patch\n");
3300 }
3301 if ($is_patch && $chk_signoff && $signoff == 0) {
3302 ERROR("MISSING_SIGN_OFF",
3303 "Missing Signed-off-by: line(s)\n");
3304 }
3305
3306 print report_dump();
3307 if ($summary && !($clean == 1 && $quiet == 1)) {
3308 print "$filename " if ($summary_file);
3309 print "total: $cnt_error errors, $cnt_warn warnings, " .
3310 (($check)? "$cnt_chk checks, " : "") .
3311 "$cnt_lines lines checked\n";
3312 print "\n" if ($quiet == 0);
3313 }
3314
3315 if ($quiet == 0) {
3316 # If there were whitespace errors which cleanpatch can fix
3317 # then suggest that.
3318 if ($rpt_cleaners) {
3319 print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
3320 print " scripts/cleanfile\n\n";
3321 $rpt_cleaners = 0;
3322 }
3323 }
3324
3325 if (keys %ignore_type) {
3326 print "NOTE: Ignored message types:";
3327 foreach my $ignore (sort keys %ignore_type) {
3328 print " $ignore";
3329 }
3330 print "\n";
3331 print "\n" if ($quiet == 0);
3332 }
3333
3334 if ($clean == 1 && $quiet == 0) {
3335 print "$vname has no obvious style problems and is ready for submission.\n"
3336 }
3337 if ($clean == 0 && $quiet == 0) {
3338 print << "EOM";
3339 $vname has style problems, please review.
3340
3341 If any of these errors are false positives, please report
3342 them to the openocd-devel mailing list or prepare a patch
3343 and send it to Gerrit for review.
3344 EOM
3345 }
3346
3347 return $clean;
3348 }
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)