/[debian]/bti/branches/upstream/current/scripts/checkpatch.pl
ViewVC logotype

Annotation of /bti/branches/upstream/current/scripts/checkpatch.pl

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1524 - (hide annotations)
Tue Jan 20 15:47:44 2009 UTC (12 years, 3 months ago) by gregoa
File MIME type: text/plain
File size: 58503 byte(s)
[svn-upgrade] Integrating new upstream version, bti (011)
1 gregoa 1524 #!/usr/bin/perl -w
2     # (c) 2001, Dave Jones. <davej@codemonkey.org.uk> (the file handling bit)
3     # (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
4     # (c) 2007, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite, etc)
5     # Licensed under the terms of the GNU GPL License version 2
6    
7     use strict;
8    
9     my $P = $0;
10     $P =~ s@.*/@@g;
11    
12     my $V = '0.19';
13    
14     use Getopt::Long qw(:config no_auto_abbrev);
15    
16     my $quiet = 0;
17     my $tree = 1;
18     my $chk_signoff = 1;
19     my $chk_patch = 1;
20     my $tst_type = 0;
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 $root;
30     my %debug;
31     GetOptions(
32     'q|quiet+' => \$quiet,
33     'tree!' => \$tree,
34     'signoff!' => \$chk_signoff,
35     'patch!' => \$chk_patch,
36     'emacs!' => \$emacs,
37     'terse!' => \$terse,
38     'file!' => \$file,
39     'subjective!' => \$check,
40     'strict!' => \$check,
41     'root=s' => \$root,
42     'summary!' => \$summary,
43     'mailback!' => \$mailback,
44     'summary-file!' => \$summary_file,
45    
46     'debug=s' => \%debug,
47     'test-type!' => \$tst_type,
48     'test-only=s' => \$tst_only,
49     ) or exit;
50    
51     my $exit = 0;
52    
53     if ($#ARGV < 0) {
54     print "usage: $P [options] patchfile\n";
55     print "version: $V\n";
56     print "options: -q => quiet\n";
57     print " --no-tree => run without a kernel tree\n";
58     print " --terse => one line per report\n";
59     print " --emacs => emacs compile window format\n";
60     print " --file => check a source file\n";
61     print " --strict => enable more subjective tests\n";
62     print " --root => path to the kernel tree root\n";
63     print " --no-summary => suppress the per-file summary\n";
64     print " --summary-file => include the filename in summary\n";
65     exit(1);
66     }
67    
68     my $dbg_values = 0;
69     my $dbg_possible = 0;
70     for my $key (keys %debug) {
71     eval "\${dbg_$key} = '$debug{$key}';"
72     }
73    
74     if ($terse) {
75     $emacs = 1;
76     $quiet++;
77     }
78    
79     if ($tree) {
80     if (defined $root) {
81     if (!top_of_kernel_tree($root)) {
82     die "$P: $root: --root does not point at a valid tree\n";
83     }
84     } else {
85     if (top_of_kernel_tree('.')) {
86     $root = '.';
87     } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
88     top_of_kernel_tree($1)) {
89     $root = $1;
90     }
91     }
92    
93     if (!defined $root) {
94     print "Must be run from the top-level dir. of a kernel tree\n";
95     exit(2);
96     }
97     }
98    
99     my $emitted_corrupt = 0;
100    
101     our $Ident = qr{[A-Za-z_][A-Za-z\d_]*};
102     our $Storage = qr{extern|static|asmlinkage};
103     our $Sparse = qr{
104     __user|
105     __kernel|
106     __force|
107     __iomem|
108     __must_check|
109     __init_refok|
110     __kprobes
111     }x;
112     our $Attribute = qr{
113     const|
114     __read_mostly|
115     __kprobes|
116     __(?:mem|cpu|dev|)(?:initdata|init)
117     }x;
118     our $Modifier;
119     our $Inline = qr{inline|__always_inline|noinline};
120     our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
121     our $Lval = qr{$Ident(?:$Member)*};
122    
123     our $Constant = qr{(?:[0-9]+|0x[0-9a-fA-F]+)[UL]*};
124     our $Assignment = qr{(?:\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=)};
125     our $Operators = qr{
126     <=|>=|==|!=|
127     =>|->|<<|>>|<|>|!|~|
128     &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%
129     }x;
130    
131     our $NonptrType;
132     our $Type;
133     our $Declare;
134    
135     our $UTF8 = qr {
136     [\x09\x0A\x0D\x20-\x7E] # ASCII
137     | [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
138     | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
139     | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
140     | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
141     | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
142     | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
143     | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
144     }x;
145    
146     our @typeList = (
147     qr{void},
148     qr{(?:unsigned\s+)?char},
149     qr{(?:unsigned\s+)?short},
150     qr{(?:unsigned\s+)?int},
151     qr{(?:unsigned\s+)?long},
152     qr{(?:unsigned\s+)?long\s+int},
153     qr{(?:unsigned\s+)?long\s+long},
154     qr{(?:unsigned\s+)?long\s+long\s+int},
155     qr{unsigned},
156     qr{float},
157     qr{double},
158     qr{bool},
159     qr{(?:__)?(?:u|s|be|le)(?:8|16|32|64)},
160     qr{struct\s+$Ident},
161     qr{union\s+$Ident},
162     qr{enum\s+$Ident},
163     qr{${Ident}_t},
164     qr{${Ident}_handler},
165     qr{${Ident}_handler_fn},
166     );
167     our @modifierList = (
168     qr{fastcall},
169     );
170    
171     sub build_types {
172     my $mods = "(?: \n" . join("|\n ", @modifierList) . "\n)";
173     my $all = "(?: \n" . join("|\n ", @typeList) . "\n)";
174     $NonptrType = qr{
175     (?:const\s+)?
176     (?:$mods\s+)?
177     (?:
178     (?:typeof|__typeof__)\s*\(\s*\**\s*$Ident\s*\)|
179     (?:${all}\b)
180     )
181     (?:\s+$Sparse|\s+const)*
182     }x;
183     $Type = qr{
184     $NonptrType
185     (?:\s*\*+\s*const|\s*\*+|(?:\s*\[\s*\])+)?
186     (?:\s+$Inline|\s+$Sparse|\s+$Attribute|\s+$mods)*
187     }x;
188     $Declare = qr{(?:$Storage\s+)?$Type};
189     $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
190     }
191     build_types();
192    
193     $chk_signoff = 0 if ($file);
194    
195     my @dep_includes = ();
196     my @dep_functions = ();
197     my $removal = "Documentation/feature-removal-schedule.txt";
198     if ($tree && -f "$root/$removal") {
199     open(REMOVE, "<$root/$removal") ||
200     die "$P: $removal: open failed - $!\n";
201     while (<REMOVE>) {
202     if (/^Check:\s+(.*\S)/) {
203     for my $entry (split(/[, ]+/, $1)) {
204     if ($entry =~ m@include/(.*)@) {
205     push(@dep_includes, $1);
206    
207     } elsif ($entry !~ m@/@) {
208     push(@dep_functions, $entry);
209     }
210     }
211     }
212     }
213     }
214    
215     my @rawlines = ();
216     my @lines = ();
217     my $vname;
218     for my $filename (@ARGV) {
219     if ($file) {
220     open(FILE, "diff -u /dev/null $filename|") ||
221     die "$P: $filename: diff failed - $!\n";
222     } else {
223     open(FILE, "<$filename") ||
224     die "$P: $filename: open failed - $!\n";
225     }
226     if ($filename eq '-') {
227     $vname = 'Your patch';
228     } else {
229     $vname = $filename;
230     }
231     while (<FILE>) {
232     chomp;
233     push(@rawlines, $_);
234     }
235     close(FILE);
236     if (!process($filename)) {
237     $exit = 1;
238     }
239     @rawlines = ();
240     @lines = ();
241     }
242    
243     exit($exit);
244    
245     sub top_of_kernel_tree {
246     my ($root) = @_;
247    
248     my @tree_check = (
249     "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
250     "README", "Documentation", "arch", "include", "drivers",
251     "fs", "init", "ipc", "kernel", "lib", "scripts",
252     );
253    
254     foreach my $check (@tree_check) {
255     if (! -e $root . '/' . $check) {
256     return 0;
257     }
258     }
259     return 1;
260     }
261    
262     sub expand_tabs {
263     my ($str) = @_;
264    
265     my $res = '';
266     my $n = 0;
267     for my $c (split(//, $str)) {
268     if ($c eq "\t") {
269     $res .= ' ';
270     $n++;
271     for (; ($n % 8) != 0; $n++) {
272     $res .= ' ';
273     }
274     next;
275     }
276     $res .= $c;
277     $n++;
278     }
279    
280     return $res;
281     }
282     sub copy_spacing {
283     (my $res = shift) =~ tr/\t/ /c;
284     return $res;
285     }
286    
287     sub line_stats {
288     my ($line) = @_;
289    
290     # Drop the diff line leader and expand tabs
291     $line =~ s/^.//;
292     $line = expand_tabs($line);
293    
294     # Pick the indent from the front of the line.
295     my ($white) = ($line =~ /^(\s*)/);
296    
297     return (length($line), length($white));
298     }
299    
300     my $sanitise_quote = '';
301    
302     sub sanitise_line_reset {
303     my ($in_comment) = @_;
304    
305     if ($in_comment) {
306     $sanitise_quote = '*/';
307     } else {
308     $sanitise_quote = '';
309     }
310     }
311     sub sanitise_line {
312     my ($line) = @_;
313    
314     my $res = '';
315     my $l = '';
316    
317     my $qlen = 0;
318     my $off = 0;
319     my $c;
320    
321     # Always copy over the diff marker.
322     $res = substr($line, 0, 1);
323    
324     for ($off = 1; $off < length($line); $off++) {
325     $c = substr($line, $off, 1);
326    
327     # Comments we are wacking completly including the begin
328     # and end, all to $;.
329     if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
330     $sanitise_quote = '*/';
331    
332     substr($res, $off, 2, "$;$;");
333     $off++;
334     next;
335     }
336     if (substr($line, $off, 2) eq '*/') {
337     $sanitise_quote = '';
338     substr($res, $off, 2, "$;$;");
339     $off++;
340     next;
341     }
342    
343     # A \ in a string means ignore the next character.
344     if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
345     $c eq "\\") {
346     substr($res, $off, 2, 'XX');
347     $off++;
348     next;
349     }
350     # Regular quotes.
351     if ($c eq "'" || $c eq '"') {
352     if ($sanitise_quote eq '') {
353     $sanitise_quote = $c;
354    
355     substr($res, $off, 1, $c);
356     next;
357     } elsif ($sanitise_quote eq $c) {
358     $sanitise_quote = '';
359     }
360     }
361    
362     #print "SQ:$sanitise_quote\n";
363     if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
364     substr($res, $off, 1, $;);
365     } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
366     substr($res, $off, 1, 'X');
367     } else {
368     substr($res, $off, 1, $c);
369     }
370     }
371    
372     # The pathname on a #include may be surrounded by '<' and '>'.
373     if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
374     my $clean = 'X' x length($1);
375     $res =~ s@\<.*\>@<$clean>@;
376    
377     # The whole of a #error is a string.
378     } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
379     my $clean = 'X' x length($1);
380     $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
381     }
382    
383     return $res;
384     }
385    
386     sub ctx_statement_block {
387     my ($linenr, $remain, $off) = @_;
388     my $line = $linenr - 1;
389     my $blk = '';
390     my $soff = $off;
391     my $coff = $off - 1;
392     my $coff_set = 0;
393    
394     my $loff = 0;
395    
396     my $type = '';
397     my $level = 0;
398     my $p;
399     my $c;
400     my $len = 0;
401    
402     my $remainder;
403     while (1) {
404     #warn "CSB: blk<$blk> remain<$remain>\n";
405     # If we are about to drop off the end, pull in more
406     # context.
407     if ($off >= $len) {
408     for (; $remain > 0; $line++) {
409     next if ($lines[$line] =~ /^-/);
410     $remain--;
411     $loff = $len;
412     $blk .= $lines[$line] . "\n";
413     $len = length($blk);
414     $line++;
415     last;
416     }
417     # Bail if there is no further context.
418     #warn "CSB: blk<$blk> off<$off> len<$len>\n";
419     if ($off >= $len) {
420     last;
421     }
422     }
423     $p = $c;
424     $c = substr($blk, $off, 1);
425     $remainder = substr($blk, $off);
426    
427     #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
428     # Statement ends at the ';' or a close '}' at the
429     # outermost level.
430     if ($level == 0 && $c eq ';') {
431     last;
432     }
433    
434     # An else is really a conditional as long as its not else if
435     if ($level == 0 && $coff_set == 0 &&
436     (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
437     $remainder =~ /^(else)(?:\s|{)/ &&
438     $remainder !~ /^else\s+if\b/) {
439     $coff = $off + length($1) - 1;
440     $coff_set = 1;
441     #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
442     #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
443     }
444    
445     if (($type eq '' || $type eq '(') && $c eq '(') {
446     $level++;
447     $type = '(';
448     }
449     if ($type eq '(' && $c eq ')') {
450     $level--;
451     $type = ($level != 0)? '(' : '';
452    
453     if ($level == 0 && $coff < $soff) {
454     $coff = $off;
455     $coff_set = 1;
456     #warn "CSB: mark coff<$coff>\n";
457     }
458     }
459     if (($type eq '' || $type eq '{') && $c eq '{') {
460     $level++;
461     $type = '{';
462     }
463     if ($type eq '{' && $c eq '}') {
464     $level--;
465     $type = ($level != 0)? '{' : '';
466    
467     if ($level == 0) {
468     last;
469     }
470     }
471     $off++;
472     }
473     if ($off == $len) {
474     $line++;
475     $remain--;
476     }
477    
478     my $statement = substr($blk, $soff, $off - $soff + 1);
479     my $condition = substr($blk, $soff, $coff - $soff + 1);
480    
481     #warn "STATEMENT<$statement>\n";
482     #warn "CONDITION<$condition>\n";
483    
484     #print "coff<$coff> soff<$off> loff<$loff>\n";
485    
486     return ($statement, $condition,
487     $line, $remain + 1, $off - $loff + 1, $level);
488     }
489    
490     sub statement_lines {
491     my ($stmt) = @_;
492    
493     # Strip the diff line prefixes and rip blank lines at start and end.
494     $stmt =~ s/(^|\n)./$1/g;
495     $stmt =~ s/^\s*//;
496     $stmt =~ s/\s*$//;
497    
498     my @stmt_lines = ($stmt =~ /\n/g);
499    
500     return $#stmt_lines + 2;
501     }
502    
503     sub statement_rawlines {
504     my ($stmt) = @_;
505    
506     my @stmt_lines = ($stmt =~ /\n/g);
507    
508     return $#stmt_lines + 2;
509     }
510    
511     sub statement_block_size {
512     my ($stmt) = @_;
513    
514     $stmt =~ s/(^|\n)./$1/g;
515     $stmt =~ s/^\s*{//;
516     $stmt =~ s/}\s*$//;
517     $stmt =~ s/^\s*//;
518     $stmt =~ s/\s*$//;
519    
520     my @stmt_lines = ($stmt =~ /\n/g);
521     my @stmt_statements = ($stmt =~ /;/g);
522    
523     my $stmt_lines = $#stmt_lines + 2;
524     my $stmt_statements = $#stmt_statements + 1;
525    
526     if ($stmt_lines > $stmt_statements) {
527     return $stmt_lines;
528     } else {
529     return $stmt_statements;
530     }
531     }
532    
533     sub ctx_statement_full {
534     my ($linenr, $remain, $off) = @_;
535     my ($statement, $condition, $level);
536    
537     my (@chunks);
538    
539     # Grab the first conditional/block pair.
540     ($statement, $condition, $linenr, $remain, $off, $level) =
541     ctx_statement_block($linenr, $remain, $off);
542     #print "F: c<$condition> s<$statement> remain<$remain>\n";
543     push(@chunks, [ $condition, $statement ]);
544     if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
545     return ($level, $linenr, @chunks);
546     }
547    
548     # Pull in the following conditional/block pairs and see if they
549     # could continue the statement.
550     for (;;) {
551     ($statement, $condition, $linenr, $remain, $off, $level) =
552     ctx_statement_block($linenr, $remain, $off);
553     #print "C: c<$condition> s<$statement> remain<$remain>\n";
554     last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
555     #print "C: push\n";
556     push(@chunks, [ $condition, $statement ]);
557     }
558    
559     return ($level, $linenr, @chunks);
560     }
561    
562     sub ctx_block_get {
563     my ($linenr, $remain, $outer, $open, $close, $off) = @_;
564     my $line;
565     my $start = $linenr - 1;
566     my $blk = '';
567     my @o;
568     my @c;
569     my @res = ();
570    
571     my $level = 0;
572     for ($line = $start; $remain > 0; $line++) {
573     next if ($rawlines[$line] =~ /^-/);
574     $remain--;
575    
576     $blk .= $rawlines[$line];
577     foreach my $c (split(//, $rawlines[$line])) {
578     ##print "C<$c>L<$level><$open$close>O<$off>\n";
579     if ($off > 0) {
580     $off--;
581     next;
582     }
583    
584     if ($c eq $close && $level > 0) {
585     $level--;
586     last if ($level == 0);
587     } elsif ($c eq $open) {
588     $level++;
589     }
590     }
591    
592     if (!$outer || $level <= 1) {
593     push(@res, $rawlines[$line]);
594     }
595    
596     last if ($level == 0);
597     }
598    
599     return ($level, @res);
600     }
601     sub ctx_block_outer {
602     my ($linenr, $remain) = @_;
603    
604     my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
605     return @r;
606     }
607     sub ctx_block {
608     my ($linenr, $remain) = @_;
609    
610     my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
611     return @r;
612     }
613     sub ctx_statement {
614     my ($linenr, $remain, $off) = @_;
615    
616     my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
617     return @r;
618     }
619     sub ctx_block_level {
620     my ($linenr, $remain) = @_;
621    
622     return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
623     }
624     sub ctx_statement_level {
625     my ($linenr, $remain, $off) = @_;
626    
627     return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
628     }
629    
630     sub ctx_locate_comment {
631     my ($first_line, $end_line) = @_;
632    
633     # Catch a comment on the end of the line itself.
634     my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*$@);
635     return $current_comment if (defined $current_comment);
636    
637     # Look through the context and try and figure out if there is a
638     # comment.
639     my $in_comment = 0;
640     $current_comment = '';
641     for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
642     my $line = $rawlines[$linenr - 1];
643     #warn " $line\n";
644     if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
645     $in_comment = 1;
646     }
647     if ($line =~ m@/\*@) {
648     $in_comment = 1;
649     }
650     if (!$in_comment && $current_comment ne '') {
651     $current_comment = '';
652     }
653     $current_comment .= $line . "\n" if ($in_comment);
654     if ($line =~ m@\*/@) {
655     $in_comment = 0;
656     }
657     }
658    
659     chomp($current_comment);
660     return($current_comment);
661     }
662     sub ctx_has_comment {
663     my ($first_line, $end_line) = @_;
664     my $cmt = ctx_locate_comment($first_line, $end_line);
665    
666     ##print "LINE: $rawlines[$end_line - 1 ]\n";
667     ##print "CMMT: $cmt\n";
668    
669     return ($cmt ne '');
670     }
671    
672     sub cat_vet {
673     my ($vet) = @_;
674     my ($res, $coded);
675    
676     $res = '';
677     while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
678     $res .= $1;
679     if ($2 ne '') {
680     $coded = sprintf("^%c", unpack('C', $2) + 64);
681     $res .= $coded;
682     }
683     }
684     $res =~ s/$/\$/;
685    
686     return $res;
687     }
688    
689     my $av_preprocessor = 0;
690     my $av_pending;
691     my @av_paren_type;
692    
693     sub annotate_reset {
694     $av_preprocessor = 0;
695     $av_pending = '_';
696     @av_paren_type = ('E');
697     }
698    
699     sub annotate_values {
700     my ($stream, $type) = @_;
701    
702     my $res;
703     my $cur = $stream;
704    
705     print "$stream\n" if ($dbg_values > 1);
706    
707     while (length($cur)) {
708     @av_paren_type = ('E') if ($#av_paren_type < 0);
709     print " <" . join('', @av_paren_type) .
710     "> <$type> <$av_pending>" if ($dbg_values > 1);
711     if ($cur =~ /^(\s+)/o) {
712     print "WS($1)\n" if ($dbg_values > 1);
713     if ($1 =~ /\n/ && $av_preprocessor) {
714     $type = pop(@av_paren_type);
715     $av_preprocessor = 0;
716     }
717    
718     } elsif ($cur =~ /^($Type)/) {
719     print "DECLARE($1)\n" if ($dbg_values > 1);
720     $type = 'T';
721    
722     } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
723     print "DEFINE($1,$2)\n" if ($dbg_values > 1);
724     $av_preprocessor = 1;
725     push(@av_paren_type, $type);
726     if ($2 ne '') {
727     $av_pending = 'N';
728     }
729     $type = 'E';
730    
731     } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
732     print "UNDEF($1)\n" if ($dbg_values > 1);
733     $av_preprocessor = 1;
734     push(@av_paren_type, $type);
735    
736     } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
737     print "PRE_START($1)\n" if ($dbg_values > 1);
738     $av_preprocessor = 1;
739    
740     push(@av_paren_type, $type);
741     push(@av_paren_type, $type);
742     $type = 'E';
743    
744     } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
745     print "PRE_RESTART($1)\n" if ($dbg_values > 1);
746     $av_preprocessor = 1;
747    
748     push(@av_paren_type, $av_paren_type[$#av_paren_type]);
749    
750     $type = 'E';
751    
752     } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
753     print "PRE_END($1)\n" if ($dbg_values > 1);
754    
755     $av_preprocessor = 1;
756    
757     # Assume all arms of the conditional end as this
758     # one does, and continue as if the #endif was not here.
759     pop(@av_paren_type);
760     push(@av_paren_type, $type);
761     $type = 'E';
762    
763     } elsif ($cur =~ /^(\\\n)/o) {
764     print "PRECONT($1)\n" if ($dbg_values > 1);
765    
766     } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
767     print "ATTR($1)\n" if ($dbg_values > 1);
768     $av_pending = $type;
769     $type = 'N';
770    
771     } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
772     print "SIZEOF($1)\n" if ($dbg_values > 1);
773     if (defined $2) {
774     $av_pending = 'V';
775     }
776     $type = 'N';
777    
778     } elsif ($cur =~ /^(if|while|typeof|__typeof__|for)\b/o) {
779     print "COND($1)\n" if ($dbg_values > 1);
780     $av_pending = 'N';
781     $type = 'N';
782    
783     } elsif ($cur =~/^(return|case|else)/o) {
784     print "KEYWORD($1)\n" if ($dbg_values > 1);
785     $type = 'N';
786    
787     } elsif ($cur =~ /^(\()/o) {
788     print "PAREN('$1')\n" if ($dbg_values > 1);
789     push(@av_paren_type, $av_pending);
790     $av_pending = '_';
791     $type = 'N';
792    
793     } elsif ($cur =~ /^(\))/o) {
794     my $new_type = pop(@av_paren_type);
795     if ($new_type ne '_') {
796     $type = $new_type;
797     print "PAREN('$1') -> $type\n"
798     if ($dbg_values > 1);
799     } else {
800     print "PAREN('$1')\n" if ($dbg_values > 1);
801     }
802    
803     } elsif ($cur =~ /^($Ident)\(/o) {
804     print "FUNC($1)\n" if ($dbg_values > 1);
805     $av_pending = 'V';
806    
807     } elsif ($cur =~ /^($Ident|$Constant)/o) {
808     print "IDENT($1)\n" if ($dbg_values > 1);
809     $type = 'V';
810    
811     } elsif ($cur =~ /^($Assignment)/o) {
812     print "ASSIGN($1)\n" if ($dbg_values > 1);
813     $type = 'N';
814    
815     } elsif ($cur =~/^(;|{|})/) {
816     print "END($1)\n" if ($dbg_values > 1);
817     $type = 'E';
818    
819     } elsif ($cur =~ /^(;|\?|:|\[)/o) {
820     print "CLOSE($1)\n" if ($dbg_values > 1);
821     $type = 'N';
822    
823     } elsif ($cur =~ /^($Operators)/o) {
824     print "OP($1)\n" if ($dbg_values > 1);
825     if ($1 ne '++' && $1 ne '--') {
826     $type = 'N';
827     }
828    
829     } elsif ($cur =~ /(^.)/o) {
830     print "C($1)\n" if ($dbg_values > 1);
831     }
832     if (defined $1) {
833     $cur = substr($cur, length($1));
834     $res .= $type x length($1);
835     }
836     }
837    
838     return $res;
839     }
840    
841     sub possible {
842     my ($possible, $line) = @_;
843    
844     print "CHECK<$possible> ($line)\n" if ($dbg_possible > 1);
845     if ($possible !~ /^(?:$Storage|$Type|DEFINE_\S+)$/ &&
846     $possible ne 'goto' && $possible ne 'return' &&
847     $possible ne 'case' && $possible ne 'else' &&
848     $possible ne 'asm' &&
849     $possible !~ /^(typedef|struct|enum)\b/) {
850     # Check for modifiers.
851     $possible =~ s/\s*$Storage\s*//g;
852     $possible =~ s/\s*$Sparse\s*//g;
853     if ($possible =~ /^\s*$/) {
854    
855     } elsif ($possible =~ /\s/) {
856     $possible =~ s/\s*$Type\s*//g;
857     warn "MODIFIER: $possible ($line)\n" if ($dbg_possible);
858     push(@modifierList, $possible);
859    
860     } else {
861     warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
862     push(@typeList, $possible);
863     }
864     build_types();
865     }
866     }
867    
868     my $prefix = '';
869    
870     sub report {
871     if (defined $tst_only && $_[0] !~ /\Q$tst_only\E/) {
872     return 0;
873     }
874     my $line = $prefix . $_[0];
875    
876     $line = (split('\n', $line))[0] . "\n" if ($terse);
877    
878     push(our @report, $line);
879    
880     return 1;
881     }
882     sub report_dump {
883     our @report;
884     }
885     sub ERROR {
886     if (report("ERROR: $_[0]\n")) {
887     our $clean = 0;
888     our $cnt_error++;
889     }
890     }
891     sub WARN {
892     if (report("WARNING: $_[0]\n")) {
893     our $clean = 0;
894     our $cnt_warn++;
895     }
896     }
897     sub CHK {
898     if ($check && report("CHECK: $_[0]\n")) {
899     our $clean = 0;
900     our $cnt_chk++;
901     }
902     }
903    
904     sub process {
905     my $filename = shift;
906    
907     my $linenr=0;
908     my $prevline="";
909     my $prevrawline="";
910     my $stashline="";
911     my $stashrawline="";
912    
913     my $length;
914     my $indent;
915     my $previndent=0;
916     my $stashindent=0;
917    
918     our $clean = 1;
919     my $signoff = 0;
920     my $is_patch = 0;
921    
922     our @report = ();
923     our $cnt_lines = 0;
924     our $cnt_error = 0;
925     our $cnt_warn = 0;
926     our $cnt_chk = 0;
927    
928     # Trace the real file/line as we go.
929     my $realfile = '';
930     my $realline = 0;
931     my $realcnt = 0;
932     my $here = '';
933     my $in_comment = 0;
934     my $comment_edge = 0;
935     my $first_line = 0;
936    
937     my $prev_values = 'E';
938    
939     # suppression flags
940     my %suppress_ifbraces;
941    
942     # Pre-scan the patch sanitizing the lines.
943     # Pre-scan the patch looking for any __setup documentation.
944     #
945     my @setup_docs = ();
946     my $setup_docs = 0;
947    
948     sanitise_line_reset();
949     my $line;
950     foreach my $rawline (@rawlines) {
951     $linenr++;
952     $line = $rawline;
953    
954     if ($rawline=~/^\+\+\+\s+(\S+)/) {
955     $setup_docs = 0;
956     if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
957     $setup_docs = 1;
958     }
959     #next;
960     }
961     if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
962     $realline=$1-1;
963     if (defined $2) {
964     $realcnt=$3+1;
965     } else {
966     $realcnt=1+1;
967     }
968     $in_comment = 0;
969    
970     # Guestimate if this is a continuing comment. Run
971     # the context looking for a comment "edge". If this
972     # edge is a close comment then we must be in a comment
973     # at context start.
974     my $edge;
975     for (my $ln = $linenr + 1; $ln < ($linenr + $realcnt); $ln++) {
976     next if ($line =~ /^-/);
977     ($edge) = ($rawlines[$ln - 1] =~ m@(/\*|\*/)@);
978     last if (defined $edge);
979     }
980     if (defined $edge && $edge eq '*/') {
981     $in_comment = 1;
982     }
983    
984     # Guestimate if this is a continuing comment. If this
985     # is the start of a diff block and this line starts
986     # ' *' then it is very likely a comment.
987     if (!defined $edge &&
988     $rawlines[$linenr] =~ m@^.\s* \*(?:\s|$)@)
989     {
990     $in_comment = 1;
991     }
992    
993     ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
994     sanitise_line_reset($in_comment);
995    
996     } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
997     # Standardise the strings and chars within the input to
998     # simplify matching -- only bother with positive lines.
999     $line = sanitise_line($rawline);
1000     }
1001     push(@lines, $line);
1002    
1003     if ($realcnt > 1) {
1004     $realcnt-- if ($line =~ /^(?:\+| |$)/);
1005     } else {
1006     $realcnt = 0;
1007     }
1008    
1009     #print "==>$rawline\n";
1010     #print "-->$line\n";
1011    
1012     if ($setup_docs && $line =~ /^\+/) {
1013     push(@setup_docs, $line);
1014     }
1015     }
1016    
1017     $prefix = '';
1018    
1019     $realcnt = 0;
1020     $linenr = 0;
1021     foreach my $line (@lines) {
1022     $linenr++;
1023    
1024     my $rawline = $rawlines[$linenr - 1];
1025    
1026     #extract the line range in the file after the patch is applied
1027     if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1028     $is_patch = 1;
1029     $first_line = $linenr + 1;
1030     $realline=$1-1;
1031     if (defined $2) {
1032     $realcnt=$3+1;
1033     } else {
1034     $realcnt=1+1;
1035     }
1036     annotate_reset();
1037     $prev_values = 'E';
1038    
1039     %suppress_ifbraces = ();
1040     next;
1041    
1042     # track the line number as we move through the hunk, note that
1043     # new versions of GNU diff omit the leading space on completely
1044     # blank context lines so we need to count that too.
1045     } elsif ($line =~ /^( |\+|$)/) {
1046     $realline++;
1047     $realcnt-- if ($realcnt != 0);
1048    
1049     # Measure the line length and indent.
1050     ($length, $indent) = line_stats($rawline);
1051    
1052     # Track the previous line.
1053     ($prevline, $stashline) = ($stashline, $line);
1054     ($previndent, $stashindent) = ($stashindent, $indent);
1055     ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
1056    
1057     #warn "line<$line>\n";
1058    
1059     } elsif ($realcnt == 1) {
1060     $realcnt--;
1061     }
1062    
1063     #make up the handle for any error we report on this line
1064     $prefix = "$filename:$realline: " if ($emacs && $file);
1065     $prefix = "$filename:$linenr: " if ($emacs && !$file);
1066    
1067     $here = "#$linenr: " if (!$file);
1068     $here = "#$realline: " if ($file);
1069    
1070     # extract the filename as it passes
1071     if ($line=~/^\+\+\+\s+(\S+)/) {
1072     $realfile = $1;
1073     $realfile =~ s@^[^/]*/@@;
1074    
1075     if ($realfile =~ m@include/asm/@) {
1076     ERROR("do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
1077     }
1078     next;
1079     }
1080    
1081     $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
1082    
1083     my $hereline = "$here\n$rawline\n";
1084     my $herecurr = "$here\n$rawline\n";
1085     my $hereprev = "$here\n$prevrawline\n$rawline\n";
1086    
1087     $cnt_lines++ if ($realcnt != 0);
1088    
1089     #check the patch for a signoff:
1090     if ($line =~ /^\s*signed-off-by:/i) {
1091     # This is a signoff, if ugly, so do not double report.
1092     $signoff++;
1093     if (!($line =~ /^\s*Signed-off-by:/)) {
1094     WARN("Signed-off-by: is the preferred form\n" .
1095     $herecurr);
1096     }
1097     if ($line =~ /^\s*signed-off-by:\S/i) {
1098     WARN("space required after Signed-off-by:\n" .
1099     $herecurr);
1100     }
1101     }
1102    
1103     # Check for wrappage within a valid hunk of the file
1104     if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
1105     ERROR("patch seems to be corrupt (line wrapped?)\n" .
1106     $herecurr) if (!$emitted_corrupt++);
1107     }
1108    
1109     # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
1110     if (($realfile =~ /^$/ || $line =~ /^\+/) &&
1111     $rawline !~ m/^$UTF8*$/) {
1112     my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
1113    
1114     my $blank = copy_spacing($rawline);
1115     my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
1116     my $hereptr = "$hereline$ptr\n";
1117    
1118     ERROR("Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
1119     }
1120    
1121     #ignore lines being removed
1122     if ($line=~/^-/) {next;}
1123    
1124     # check we are in a valid source file if not then ignore this hunk
1125     next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
1126    
1127     #trailing whitespace
1128     if ($line =~ /^\+.*\015/) {
1129     my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1130     ERROR("DOS line endings\n" . $herevet);
1131    
1132     } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
1133     my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1134     ERROR("trailing whitespace\n" . $herevet);
1135     }
1136     #80 column limit
1137     if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&
1138     $rawline !~ /^.\s*\*\s*\@$Ident\s/ && $length > 80)
1139     {
1140     WARN("line over 80 characters\n" . $herecurr);
1141     }
1142    
1143     # check for adding lines without a newline.
1144     if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
1145     WARN("adding a line without newline at end of file\n" . $herecurr);
1146     }
1147    
1148     # check we are in a valid source file *.[hc] if not then ignore this hunk
1149     next if ($realfile !~ /\.[hc]$/);
1150    
1151     # at the beginning of a line any tabs must come first and anything
1152     # more than 8 must use tabs.
1153     if ($rawline =~ /^\+\s* \t\s*\S/ ||
1154     $rawline =~ /^\+\s* \s*/) {
1155     my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1156     ERROR("code indent should use tabs where possible\n" . $herevet);
1157     }
1158    
1159     # check for RCS/CVS revision markers
1160     if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
1161     WARN("CVS style keyword markers, these will _not_ be updated\n". $herecurr);
1162     }
1163    
1164     # Check for potential 'bare' types
1165     my ($stat, $cond);
1166     if ($realcnt && $line =~ /.\s*\S/) {
1167     ($stat, $cond) = ctx_statement_block($linenr,
1168     $realcnt, 0);
1169     $stat =~ s/\n./\n /g;
1170     $cond =~ s/\n./\n /g;
1171    
1172     my $s = $stat;
1173     $s =~ s/{.*$//s;
1174    
1175     # Ignore goto labels.
1176     if ($s =~ /$Ident:\*$/s) {
1177    
1178     # Ignore functions being called
1179     } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
1180    
1181     # declarations always start with types
1182     } elsif ($prev_values eq 'E' && $s =~ /^.\s*(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?((?:\s*$Ident)+)\b(?:\s+$Sparse)?\s*\**\s*(?:$Ident|\(\*[^\)]*\))\s*(?:;|=|,|\()/s) {
1183     my $type = $1;
1184     $type =~ s/\s+/ /g;
1185     possible($type, "A:" . $s);
1186    
1187     # definitions in global scope can only start with types
1188     } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b/s) {
1189     possible($1, "B:" . $s);
1190     }
1191    
1192     # any (foo ... *) is a pointer cast, and foo is a type
1193     while ($s =~ /\(($Ident)(?:\s+$Sparse)*\s*\*+\s*\)/sg) {
1194     possible($1, "C:" . $s);
1195     }
1196    
1197     # Check for any sort of function declaration.
1198     # int foo(something bar, other baz);
1199     # void (*store_gdt)(x86_descr_ptr *);
1200     if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
1201     my ($name_len) = length($1);
1202    
1203     my $ctx = $s;
1204     substr($ctx, 0, $name_len + 1, '');
1205     $ctx =~ s/\)[^\)]*$//;
1206    
1207     for my $arg (split(/\s*,\s*/, $ctx)) {
1208     if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
1209    
1210     possible($1, "D:" . $s);
1211     }
1212     }
1213     }
1214    
1215     }
1216    
1217     #
1218     # Checks which may be anchored in the context.
1219     #
1220    
1221     # Check for switch () and associated case and default
1222     # statements should be at the same indent.
1223     if ($line=~/\bswitch\s*\(.*\)/) {
1224     my $err = '';
1225     my $sep = '';
1226     my @ctx = ctx_block_outer($linenr, $realcnt);
1227     shift(@ctx);
1228     for my $ctx (@ctx) {
1229     my ($clen, $cindent) = line_stats($ctx);
1230     if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
1231     $indent != $cindent) {
1232     $err .= "$sep$ctx\n";
1233     $sep = '';
1234     } else {
1235     $sep = "[...]\n";
1236     }
1237     }
1238     if ($err ne '') {
1239     ERROR("switch and case should be at the same indent\n$hereline$err");
1240     }
1241     }
1242    
1243     # if/while/etc brace do not go on next line, unless defining a do while loop,
1244     # or if that brace on the next line is for something else
1245     if ($line =~ /(.*)\b((?:if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
1246     my $pre_ctx = "$1$2";
1247    
1248     my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
1249     my $ctx_ln = $linenr + $#ctx + 1;
1250     my $ctx_cnt = $realcnt - $#ctx - 1;
1251     my $ctx = join("\n", @ctx);
1252    
1253     ##warn "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
1254    
1255     # Skip over any removed lines in the context following statement.
1256     while (defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^-/) {
1257     $ctx_ln++;
1258     }
1259     ##warn "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
1260    
1261     if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
1262     ERROR("that open brace { should be on the previous line\n" .
1263     "$here\n$ctx\n$lines[$ctx_ln - 1]\n");
1264     }
1265     if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
1266     $ctx =~ /\)\s*\;\s*$/ &&
1267     defined $lines[$ctx_ln - 1])
1268     {
1269     my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
1270     if ($nindent > $indent) {
1271     WARN("trailing semicolon indicates no statements, indent implies otherwise\n" .
1272     "$here\n$ctx\n$lines[$ctx_ln - 1]\n");
1273     }
1274     }
1275     }
1276    
1277     # Track the 'values' across context and added lines.
1278     my $opline = $line; $opline =~ s/^./ /;
1279     my $curr_values = annotate_values($opline . "\n", $prev_values);
1280     $curr_values = $prev_values . $curr_values;
1281     if ($dbg_values) {
1282     my $outline = $opline; $outline =~ s/\t/ /g;
1283     print "$linenr > .$outline\n";
1284     print "$linenr > $curr_values\n";
1285     }
1286     $prev_values = substr($curr_values, -1);
1287    
1288     #ignore lines not being added
1289     if ($line=~/^[^\+]/) {next;}
1290    
1291     # TEST: allow direct testing of the type matcher.
1292     if ($tst_type && $line =~ /^.$Declare$/) {
1293     ERROR("TEST: is type $Declare\n" . $herecurr);
1294     next;
1295     }
1296    
1297     # check for initialisation to aggregates open brace on the next line
1298     if ($prevline =~ /$Declare\s*$Ident\s*=\s*$/ &&
1299     $line =~ /^.\s*{/) {
1300     ERROR("that open brace { should be on the previous line\n" . $hereprev);
1301     }
1302    
1303     #
1304     # Checks which are anchored on the added line.
1305     #
1306    
1307     # check for malformed paths in #include statements (uses RAW line)
1308     if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
1309     my $path = $1;
1310     if ($path =~ m{//}) {
1311     ERROR("malformed #include filename\n" .
1312     $herecurr);
1313     }
1314     }
1315    
1316     # no C99 // comments
1317     if ($line =~ m{//}) {
1318     ERROR("do not use C99 // comments\n" . $herecurr);
1319     }
1320     # Remove C99 comments.
1321     $line =~ s@//.*@@;
1322     $opline =~ s@//.*@@;
1323    
1324     #EXPORT_SYMBOL should immediately follow its function closing }.
1325     if (($line =~ /EXPORT_SYMBOL.*\((.*)\)/) ||
1326     ($line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
1327     my $name = $1;
1328     if (($prevline !~ /^}/) &&
1329     ($prevline !~ /^\+}/) &&
1330     ($prevline !~ /^ }/) &&
1331     ($prevline !~ /^.DECLARE_$Ident\(\Q$name\E\)/) &&
1332     ($prevline !~ /^.LIST_HEAD\(\Q$name\E\)/) &&
1333     ($prevline !~ /^.$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(/) &&
1334     ($prevline !~ /\b\Q$name\E(?:\s+$Attribute)?\s*(?:;|=|\[)/)) {
1335     WARN("EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
1336     }
1337     }
1338    
1339     # check for external initialisers.
1340     if ($line =~ /^.$Type\s*$Ident\s*(?:\s+$Modifier)*\s*=\s*(0|NULL|false)\s*;/) {
1341     ERROR("do not initialise externals to 0 or NULL\n" .
1342     $herecurr);
1343     }
1344     # check for static initialisers.
1345     if ($line =~ /\s*static\s.*=\s*(0|NULL|false)\s*;/) {
1346     ERROR("do not initialise statics to 0 or NULL\n" .
1347     $herecurr);
1348     }
1349    
1350     # check for new typedefs, only function parameters and sparse annotations
1351     # make sense.
1352     if ($line =~ /\btypedef\s/ &&
1353     $line !~ /\btypedef\s+$Type\s+\(\s*\*?$Ident\s*\)\s*\(/ &&
1354     $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
1355     $line !~ /\b__bitwise(?:__|)\b/) {
1356     WARN("do not add new typedefs\n" . $herecurr);
1357     }
1358    
1359     # * goes on variable not on type
1360     if ($line =~ m{\($NonptrType(\*+)(?:\s+const)?\)}) {
1361     ERROR("\"(foo$1)\" should be \"(foo $1)\"\n" .
1362     $herecurr);
1363    
1364     } elsif ($line =~ m{\($NonptrType\s+(\*+)(?!\s+const)\s+\)}) {
1365     ERROR("\"(foo $1 )\" should be \"(foo $1)\"\n" .
1366     $herecurr);
1367    
1368     } elsif ($line =~ m{$NonptrType(\*+)(?:\s+(?:$Attribute|$Sparse))?\s+[A-Za-z\d_]+}) {
1369     ERROR("\"foo$1 bar\" should be \"foo $1bar\"\n" .
1370     $herecurr);
1371    
1372     } elsif ($line =~ m{$NonptrType\s+(\*+)(?!\s+(?:$Attribute|$Sparse))\s+[A-Za-z\d_]+}) {
1373     ERROR("\"foo $1 bar\" should be \"foo $1bar\"\n" .
1374     $herecurr);
1375     }
1376    
1377     # # no BUG() or BUG_ON()
1378     # if ($line =~ /\b(BUG|BUG_ON)\b/) {
1379     # print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
1380     # print "$herecurr";
1381     # $clean = 0;
1382     # }
1383    
1384     if ($line =~ /\bLINUX_VERSION_CODE\b/) {
1385     WARN("LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
1386     }
1387    
1388     # printk should use KERN_* levels. Note that follow on printk's on the
1389     # same line do not need a level, so we use the current block context
1390     # to try and find and validate the current printk. In summary the current
1391     # printk includes all preceeding printk's which have no newline on the end.
1392     # we assume the first bad printk is the one to report.
1393     if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
1394     my $ok = 0;
1395     for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
1396     #print "CHECK<$lines[$ln - 1]\n";
1397     # we have a preceeding printk if it ends
1398     # with "\n" ignore it, else it is to blame
1399     if ($lines[$ln - 1] =~ m{\bprintk\(}) {
1400     if ($rawlines[$ln - 1] !~ m{\\n"}) {
1401     $ok = 1;
1402     }
1403     last;
1404     }
1405     }
1406     if ($ok == 0) {
1407     WARN("printk() should include KERN_ facility level\n" . $herecurr);
1408     }
1409     }
1410    
1411     # function brace can't be on same line, except for #defines of do while,
1412     # or if closed on same line
1413     if (($line=~/$Type\s*$Ident\(.*\).*\s{/) and
1414     !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {
1415     ERROR("open brace '{' following function declarations go on the next line\n" . $herecurr);
1416     }
1417    
1418     # open braces for enum, union and struct go on the same line.
1419     if ($line =~ /^.\s*{/ &&
1420     $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
1421     ERROR("open brace '{' following $1 go on the same line\n" . $hereprev);
1422     }
1423    
1424     # check for spaces between functions and their parentheses.
1425     while ($line =~ /($Ident)\s+\(/g) {
1426     my $name = $1;
1427     my $ctx_before = substr($line, 0, $-[1]);
1428     my $ctx = "$ctx_before$name";
1429    
1430     # Ignore those directives where spaces _are_ permitted.
1431     if ($name =~ /^(?:
1432     if|for|while|switch|return|case|
1433     volatile|__volatile__|
1434     __attribute__|format|__extension__|
1435     asm|__asm__)$/x)
1436     {
1437    
1438     # cpp #define statements have non-optional spaces, ie
1439     # if there is a space between the name and the open
1440     # parenthesis it is simply not a parameter group.
1441     } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
1442    
1443     # cpp #elif statement condition may start with a (
1444     } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
1445    
1446     # If this whole things ends with a type its most
1447     # likely a typedef for a function.
1448     } elsif ($ctx =~ /$Type$/) {
1449    
1450     } else {
1451     WARN("space prohibited between function name and open parenthesis '('\n" . $herecurr);
1452     }
1453     }
1454     # Check operator spacing.
1455     if (!($line=~/\#\s*include/)) {
1456     my $ops = qr{
1457     <<=|>>=|<=|>=|==|!=|
1458     \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
1459     =>|->|<<|>>|<|>|=|!|~|
1460     &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%
1461     }x;
1462     my @elements = split(/($ops|;)/, $opline);
1463     my $off = 0;
1464    
1465     my $blank = copy_spacing($opline);
1466    
1467     for (my $n = 0; $n < $#elements; $n += 2) {
1468     $off += length($elements[$n]);
1469    
1470     # Pick up the preceeding and succeeding characters.
1471     my $ca = substr($opline, 0, $off);
1472     my $cc = '';
1473     if (length($opline) >= ($off + length($elements[$n + 1]))) {
1474     $cc = substr($opline, $off + length($elements[$n + 1]));
1475     }
1476     my $cb = "$ca$;$cc";
1477    
1478     my $a = '';
1479     $a = 'V' if ($elements[$n] ne '');
1480     $a = 'W' if ($elements[$n] =~ /\s$/);
1481     $a = 'C' if ($elements[$n] =~ /$;$/);
1482     $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
1483     $a = 'O' if ($elements[$n] eq '');
1484     $a = 'E' if ($ca =~ /^\s*$/);
1485    
1486     my $op = $elements[$n + 1];
1487    
1488     my $c = '';
1489     if (defined $elements[$n + 2]) {
1490     $c = 'V' if ($elements[$n + 2] ne '');
1491     $c = 'W' if ($elements[$n + 2] =~ /^\s/);
1492     $c = 'C' if ($elements[$n + 2] =~ /^$;/);
1493     $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
1494     $c = 'O' if ($elements[$n + 2] eq '');
1495     $c = 'E' if ($elements[$n + 2] =~ /\s*\\$/);
1496     } else {
1497     $c = 'E';
1498     }
1499    
1500     my $ctx = "${a}x${c}";
1501    
1502     my $at = "(ctx:$ctx)";
1503    
1504     my $ptr = substr($blank, 0, $off) . "^";
1505     my $hereptr = "$hereline$ptr\n";
1506    
1507     # Classify operators into binary, unary, or
1508     # definitions (* only) where they have more
1509     # than one mode.
1510     my $op_type = substr($curr_values, $off + 1, 1);
1511     my $op_left = substr($curr_values, $off, 1);
1512     my $is_unary;
1513     if ($op_type eq 'T') {
1514     $is_unary = 2;
1515     } elsif ($op_left eq 'V') {
1516     $is_unary = 0;
1517     } else {
1518     $is_unary = 1;
1519     }
1520     #if ($op eq '-' || $op eq '&' || $op eq '*') {
1521     # print "UNARY: <$op_left$op_type $is_unary $a:$op:$c> <$ca:$op:$cc> <$unary_ctx>\n";
1522     #}
1523    
1524     # Ignore operators passed as parameters.
1525     if ($op_type ne 'V' &&
1526     $ca =~ /\s$/ && $cc =~ /^\s*,/) {
1527    
1528     # # Ignore comments
1529     # } elsif ($op =~ /^$;+$/) {
1530    
1531     # ; should have either the end of line or a space or \ after it
1532     } elsif ($op eq ';') {
1533     if ($ctx !~ /.x[WEBC]/ &&
1534     $cc !~ /^\\/ && $cc !~ /^;/) {
1535     ERROR("space required after that '$op' $at\n" . $hereptr);
1536     }
1537    
1538     # // is a comment
1539     } elsif ($op eq '//') {
1540    
1541     # -> should have no spaces
1542     } elsif ($op eq '->') {
1543     if ($ctx =~ /Wx.|.xW/) {
1544     ERROR("spaces prohibited around that '$op' $at\n" . $hereptr);
1545     }
1546    
1547     # , must have a space on the right.
1548     } elsif ($op eq ',') {
1549     if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
1550     ERROR("space required after that '$op' $at\n" . $hereptr);
1551     }
1552    
1553     # '*' as part of a type definition -- reported already.
1554     } elsif ($op eq '*' && $is_unary == 2) {
1555     #warn "'*' is part of type\n";
1556    
1557     # unary operators should have a space before and
1558     # none after. May be left adjacent to another
1559     # unary operator, or a cast
1560     } elsif ($op eq '!' || $op eq '~' ||
1561     ($is_unary && ($op eq '*' || $op eq '-' || $op eq '&'))) {
1562     if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
1563     ERROR("space required before that '$op' $at\n" . $hereptr);
1564     }
1565     if ($op eq '*' && $cc =~/\s*const\b/) {
1566     # A unary '*' may be const
1567    
1568     } elsif ($ctx =~ /.xW/) {
1569     ERROR("space prohibited after that '$op' $at\n" . $hereptr);
1570     }
1571    
1572     # unary ++ and unary -- are allowed no space on one side.
1573     } elsif ($op eq '++' or $op eq '--') {
1574     if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
1575     ERROR("space required one side of that '$op' $at\n" . $hereptr);
1576     }
1577     if ($ctx =~ /Wx[BE]/ ||
1578     ($ctx =~ /Wx./ && $cc =~ /^;/)) {
1579     ERROR("space prohibited before that '$op' $at\n" . $hereptr);
1580     }
1581     if ($ctx =~ /ExW/) {
1582     ERROR("space prohibited after that '$op' $at\n" . $hereptr);
1583     }
1584    
1585    
1586     # << and >> may either have or not have spaces both sides
1587     } elsif ($op eq '<<' or $op eq '>>' or
1588     $op eq '&' or $op eq '^' or $op eq '|' or
1589     $op eq '+' or $op eq '-' or
1590     $op eq '*' or $op eq '/' or
1591     $op eq '%')
1592     {
1593     if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
1594     ERROR("need consistent spacing around '$op' $at\n" .
1595     $hereptr);
1596     }
1597    
1598     # All the others need spaces both sides.
1599     } elsif ($ctx !~ /[EWC]x[CWE]/) {
1600     # Ignore email addresses <foo@bar>
1601     if (!($op eq '<' && $cb =~ /$;\S+\@\S+>/) &&
1602     !($op eq '>' && $cb =~ /<\S+\@\S+$;/)) {
1603     ERROR("spaces required around that '$op' $at\n" . $hereptr);
1604     }
1605     }
1606     $off += length($elements[$n + 1]);
1607     }
1608     }
1609    
1610     # check for multiple assignments
1611     if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
1612     CHK("multiple assignments should be avoided\n" . $herecurr);
1613     }
1614    
1615     ## # check for multiple declarations, allowing for a function declaration
1616     ## # continuation.
1617     ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
1618     ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
1619     ##
1620     ## # Remove any bracketed sections to ensure we do not
1621     ## # falsly report the parameters of functions.
1622     ## my $ln = $line;
1623     ## while ($ln =~ s/\([^\(\)]*\)//g) {
1624     ## }
1625     ## if ($ln =~ /,/) {
1626     ## WARN("declaring multiple variables together should be avoided\n" . $herecurr);
1627     ## }
1628     ## }
1629    
1630     #need space before brace following if, while, etc
1631     if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
1632     $line =~ /do{/) {
1633     ERROR("space required before the open brace '{'\n" . $herecurr);
1634     }
1635    
1636     # closing brace should have a space following it when it has anything
1637     # on the line
1638     if ($line =~ /}(?!(?:,|;|\)))\S/) {
1639     ERROR("space required after that close brace '}'\n" . $herecurr);
1640     }
1641    
1642     # check spacing on square brackets
1643     if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
1644     ERROR("space prohibited after that open square bracket '['\n" . $herecurr);
1645     }
1646     if ($line =~ /\s\]/) {
1647     ERROR("space prohibited before that close square bracket ']'\n" . $herecurr);
1648     }
1649    
1650     # check spacing on parentheses
1651     if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
1652     $line !~ /for\s*\(\s+;/) {
1653     ERROR("space prohibited after that open parenthesis '('\n" . $herecurr);
1654     }
1655     if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
1656     $line !~ /for\s*\(.*;\s+\)/ &&
1657     $line !~ /:\s+\)/) {
1658     ERROR("space prohibited before that close parenthesis ')'\n" . $herecurr);
1659     }
1660    
1661     #goto labels aren't indented, allow a single space however
1662     if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
1663     !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
1664     WARN("labels should not be indented\n" . $herecurr);
1665     }
1666    
1667     # Return is not a function.
1668     if (defined($stat) && $stat =~ /^.\s*return(\s*)(\(.*);/s) {
1669     my $spacing = $1;
1670     my $value = $2;
1671    
1672     # Flatten any parentheses and braces
1673     while ($value =~ s/\([^\(\)]*\)/1/) {
1674     }
1675    
1676     if ($value =~ /^(?:$Ident|-?$Constant)$/) {
1677     ERROR("return is not a function, parentheses are not required\n" . $herecurr);
1678    
1679     } elsif ($spacing !~ /\s+/) {
1680     ERROR("space required before the open parenthesis '('\n" . $herecurr);
1681     }
1682     }
1683    
1684     # Need a space before open parenthesis after if, while etc
1685     if ($line=~/\b(if|while|for|switch)\(/) {
1686     ERROR("space required before the open parenthesis '('\n" . $herecurr);
1687     }
1688    
1689     # Check for illegal assignment in if conditional.
1690     if ($line =~ /\bif\s*\(/) {
1691     my ($s, $c) = ($stat, $cond);
1692    
1693     if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/) {
1694     ERROR("do not use assignment in if condition\n" . $herecurr);
1695     }
1696    
1697     # Find out what is on the end of the line after the
1698     # conditional.
1699     substr($s, 0, length($c), '');
1700     $s =~ s/\n.*//g;
1701     $s =~ s/$;//g; # Remove any comments
1702     if (length($c) && $s !~ /^\s*({|;|)\s*\\*\s*$/ &&
1703     $c !~ /^.\s*\#\s*if/)
1704     {
1705     ERROR("trailing statements should be on next line\n" . $herecurr);
1706     }
1707     }
1708    
1709     # Check for bitwise tests written as boolean
1710     if ($line =~ /
1711     (?:
1712     (?:\[|\(|\&\&|\|\|)
1713     \s*0[xX][0-9]+\s*
1714     (?:\&\&|\|\|)
1715     |
1716     (?:\&\&|\|\|)
1717     \s*0[xX][0-9]+\s*
1718     (?:\&\&|\|\||\)|\])
1719     )/x)
1720     {
1721     WARN("boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
1722     }
1723    
1724     # if and else should not have general statements after it
1725     if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
1726     my $s = $1;
1727     $s =~ s/$;//g; # Remove any comments
1728     if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
1729     ERROR("trailing statements should be on next line\n" . $herecurr);
1730     }
1731     }
1732    
1733     # Check for }<nl>else {, these must be at the same
1734     # indent level to be relevant to each other.
1735     if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
1736     $previndent == $indent) {
1737     ERROR("else should follow close brace '}'\n" . $hereprev);
1738     }
1739    
1740     if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and
1741     $previndent == $indent) {
1742     my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
1743    
1744     # Find out what is on the end of the line after the
1745     # conditional.
1746     substr($s, 0, length($c), '');
1747     $s =~ s/\n.*//g;
1748    
1749     if ($s =~ /^\s*;/) {
1750     ERROR("while should follow close brace '}'\n" . $hereprev);
1751     }
1752     }
1753    
1754     #studly caps, commented out until figure out how to distinguish between use of existing and adding new
1755     # if (($line=~/[\w_][a-z\d]+[A-Z]/) and !($line=~/print/)) {
1756     # print "No studly caps, use _\n";
1757     # print "$herecurr";
1758     # $clean = 0;
1759     # }
1760    
1761     #no spaces allowed after \ in define
1762     if ($line=~/\#\s*define.*\\\s$/) {
1763     WARN("Whitepspace after \\ makes next lines useless\n" . $herecurr);
1764     }
1765    
1766     #warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
1767     if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
1768     my $checkfile = "include/linux/$1.h";
1769     if (-f "$root/$checkfile" && $realfile ne $checkfile &&
1770     $1 ne 'irq')
1771     {
1772     WARN("Use #include <linux/$1.h> instead of <asm/$1.h>\n" .
1773     $herecurr);
1774     }
1775     }
1776    
1777     # multi-statement macros should be enclosed in a do while loop, grab the
1778     # first statement and ensure its the whole macro if its not enclosed
1779     # in a known good container
1780     if ($line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
1781     my $ln = $linenr;
1782     my $cnt = $realcnt;
1783     my ($off, $dstat, $dcond, $rest);
1784     my $ctx = '';
1785    
1786     my $args = defined($1);
1787    
1788     # Find the end of the macro and limit our statement
1789     # search to that.
1790     while ($cnt > 0 && defined $lines[$ln - 1] &&
1791     $lines[$ln - 1] =~ /^(?:-|..*\\$)/)
1792     {
1793     $ctx .= $rawlines[$ln - 1] . "\n";
1794     $ln++;
1795     $cnt--;
1796     }
1797     $ctx .= $rawlines[$ln - 1];
1798    
1799     ($dstat, $dcond, $ln, $cnt, $off) =
1800     ctx_statement_block($linenr, $ln - $linenr + 1, 0);
1801     #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
1802     #print "LINE<$lines[$ln]> len<" . length($lines[$ln]) . "\n";
1803    
1804     # Extract the remainder of the define (if any) and
1805     # rip off surrounding spaces, and trailing \'s.
1806     $rest = '';
1807     if (defined $lines[$ln - 1] &&
1808     $off > length($lines[$ln - 1]))
1809     {
1810     $ln++;
1811     $cnt--;
1812     $off = 0;
1813     }
1814     while ($cnt > 0) {
1815     $rest .= substr($lines[$ln - 1], $off) . "\n";
1816     $ln++;
1817     $cnt--;
1818     $off = 0;
1819     }
1820     $rest =~ s/\\\n.//g;
1821     $rest =~ s/^\s*//s;
1822     $rest =~ s/\s*$//s;
1823    
1824     # Clean up the original statement.
1825     if ($args) {
1826     substr($dstat, 0, length($dcond), '');
1827     } else {
1828     $dstat =~ s/^.\s*\#\s*define\s+$Ident\s*//;
1829     }
1830     $dstat =~ s/\\\n.//g;
1831     $dstat =~ s/^\s*//s;
1832     $dstat =~ s/\s*$//s;
1833    
1834     # Flatten any parentheses and braces
1835     while ($dstat =~ s/\([^\(\)]*\)/1/) {
1836     }
1837     while ($dstat =~ s/\{[^\{\}]*\}/1/) {
1838     }
1839    
1840     my $exceptions = qr{
1841     $Declare|
1842     module_param_named|
1843     MODULE_PARAM_DESC|
1844     DECLARE_PER_CPU|
1845     DEFINE_PER_CPU|
1846     __typeof__\(
1847     }x;
1848     if ($rest ne '') {
1849     if ($rest !~ /while\s*\(/ &&
1850     $dstat !~ /$exceptions/)
1851     {
1852     ERROR("Macros with multiple statements should be enclosed in a do - while loop\n" . "$here\n$ctx\n");
1853     }
1854    
1855     } elsif ($ctx !~ /;/) {
1856     if ($dstat ne '' &&
1857     $dstat !~ /^(?:$Ident|-?$Constant)$/ &&
1858     $dstat !~ /$exceptions/ &&
1859     $dstat =~ /$Operators/)
1860     {
1861     ERROR("Macros with complex values should be enclosed in parenthesis\n" . "$here\n$ctx\n");
1862     }
1863     }
1864     }
1865    
1866     # check for redundant bracing round if etc
1867     if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
1868     my ($level, $endln, @chunks) =
1869     ctx_statement_full($linenr, $realcnt, 1);
1870     #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
1871     #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
1872     if ($#chunks > 0 && $level == 0) {
1873     my $allowed = 0;
1874     my $seen = 0;
1875     my $herectx = $here . "\n";
1876     my $ln = $linenr - 1;
1877     for my $chunk (@chunks) {
1878     my ($cond, $block) = @{$chunk};
1879    
1880     # If the condition carries leading newlines, then count those as offsets.
1881     my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
1882     my $offset = statement_rawlines($whitespace) - 1;
1883    
1884     #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
1885    
1886     # We have looked at and allowed this specific line.
1887     $suppress_ifbraces{$ln + $offset} = 1;
1888    
1889     $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
1890     $ln += statement_rawlines($block) - 1;
1891    
1892     substr($block, 0, length($cond), '');
1893    
1894     $seen++ if ($block =~ /^\s*{/);
1895    
1896     #print "cond<$cond> block<$block> allowed<$allowed>\n";
1897     if (statement_lines($cond) > 1) {
1898     #print "APW: ALLOWED: cond<$cond>\n";
1899     $allowed = 1;
1900     }
1901     if ($block =~/\b(?:if|for|while)\b/) {
1902     #print "APW: ALLOWED: block<$block>\n";
1903     $allowed = 1;
1904     }
1905     if (statement_block_size($block) > 1) {
1906     #print "APW: ALLOWED: lines block<$block>\n";
1907     $allowed = 1;
1908     }
1909     }
1910     if ($seen && !$allowed) {
1911     WARN("braces {} are not necessary for any arm of this statement\n" . $herectx);
1912     }
1913     }
1914     }
1915     if (!defined $suppress_ifbraces{$linenr - 1} &&
1916     $line =~ /\b(if|while|for|else)\b/) {
1917     my $allowed = 0;
1918    
1919     # Check the pre-context.
1920     if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
1921     #print "APW: ALLOWED: pre<$1>\n";
1922     $allowed = 1;
1923     }
1924    
1925     my ($level, $endln, @chunks) =
1926     ctx_statement_full($linenr, $realcnt, $-[0]);
1927    
1928     # Check the condition.
1929     my ($cond, $block) = @{$chunks[0]};
1930     #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
1931     if (defined $cond) {
1932     substr($block, 0, length($cond), '');
1933     }
1934     if (statement_lines($cond) > 1) {
1935     #print "APW: ALLOWED: cond<$cond>\n";
1936     $allowed = 1;
1937     }
1938     if ($block =~/\b(?:if|for|while)\b/) {
1939     #print "APW: ALLOWED: block<$block>\n";
1940     $allowed = 1;
1941     }
1942     if (statement_block_size($block) > 1) {
1943     #print "APW: ALLOWED: lines block<$block>\n";
1944     $allowed = 1;
1945     }
1946     # Check the post-context.
1947     if (defined $chunks[1]) {
1948     my ($cond, $block) = @{$chunks[1]};
1949     if (defined $cond) {
1950     substr($block, 0, length($cond), '');
1951     }
1952     if ($block =~ /^\s*\{/) {
1953     #print "APW: ALLOWED: chunk-1 block<$block>\n";
1954     $allowed = 1;
1955     }
1956     }
1957     if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
1958     my $herectx = $here . "\n";;
1959     my $end = $linenr + statement_rawlines($block) - 1;
1960    
1961     for (my $ln = $linenr - 1; $ln < $end; $ln++) {
1962     $herectx .= $rawlines[$ln] . "\n";;
1963     }
1964    
1965     WARN("braces {} are not necessary for single statement blocks\n" . $herectx);
1966     }
1967     }
1968    
1969     # don't include deprecated include files (uses RAW line)
1970     for my $inc (@dep_includes) {
1971     if ($rawline =~ m@^.\s*\#\s*include\s*\<$inc>@) {
1972     ERROR("Don't use <$inc>: see Documentation/feature-removal-schedule.txt\n" . $herecurr);
1973     }
1974     }
1975    
1976     # don't use deprecated functions
1977     for my $func (@dep_functions) {
1978     if ($line =~ /\b$func\b/) {
1979     ERROR("Don't use $func(): see Documentation/feature-removal-schedule.txt\n" . $herecurr);
1980     }
1981     }
1982    
1983     # no volatiles please
1984     my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
1985     if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
1986     WARN("Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
1987     }
1988    
1989     # SPIN_LOCK_UNLOCKED & RW_LOCK_UNLOCKED are deprecated
1990     if ($line =~ /\b(SPIN_LOCK_UNLOCKED|RW_LOCK_UNLOCKED)/) {
1991     ERROR("Use of $1 is deprecated: see Documentation/spinlocks.txt\n" . $herecurr);
1992     }
1993    
1994     # warn about #if 0
1995     if ($line =~ /^.\s*\#\s*if\s+0\b/) {
1996     CHK("if this code is redundant consider removing it\n" .
1997     $herecurr);
1998     }
1999    
2000     # check for needless kfree() checks
2001     if ($prevline =~ /\bif\s*\(([^\)]*)\)/) {
2002     my $expr = $1;
2003     if ($line =~ /\bkfree\(\Q$expr\E\);/) {
2004     WARN("kfree(NULL) is safe this check is probabally not required\n" . $hereprev);
2005     }
2006     }
2007    
2008     # warn about #ifdefs in C files
2009     # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
2010     # print "#ifdef in C files should be avoided\n";
2011     # print "$herecurr";
2012     # $clean = 0;
2013     # }
2014    
2015     # warn about spacing in #ifdefs
2016     if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
2017     ERROR("exactly one space required after that #$1\n" . $herecurr);
2018     }
2019    
2020     # check for spinlock_t definitions without a comment.
2021     if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
2022     $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
2023     my $which = $1;
2024     if (!ctx_has_comment($first_line, $linenr)) {
2025     CHK("$1 definition without comment\n" . $herecurr);
2026     }
2027     }
2028     # check for memory barriers without a comment.
2029     if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
2030     if (!ctx_has_comment($first_line, $linenr)) {
2031     CHK("memory barrier without comment\n" . $herecurr);
2032     }
2033     }
2034     # check of hardware specific defines
2035     if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
2036     CHK("architecture specific defines should be avoided\n" . $herecurr);
2037     }
2038    
2039     # check the location of the inline attribute, that it is between
2040     # storage class and type.
2041     if ($line =~ /\b$Type\s+$Inline\b/ ||
2042     $line =~ /\b$Inline\s+$Storage\b/) {
2043     ERROR("inline keyword should sit between storage class and type\n" . $herecurr);
2044     }
2045    
2046     # Check for __inline__ and __inline, prefer inline
2047     if ($line =~ /\b(__inline__|__inline)\b/) {
2048     WARN("plain inline is preferred over $1\n" . $herecurr);
2049     }
2050    
2051     # check for new externs in .c files.
2052     if ($realfile =~ /\.c$/ && defined $stat &&
2053     $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
2054     {
2055     my $function_name = $1;
2056     my $paren_space = $2;
2057    
2058     my $s = $stat;
2059     if (defined $cond) {
2060     substr($s, 0, length($cond), '');
2061     }
2062     if ($s =~ /^\s*;/ &&
2063     $function_name ne 'uninitialized_var')
2064     {
2065     WARN("externs should be avoided in .c files\n" . $herecurr);
2066     }
2067    
2068     if ($paren_space =~ /\n/) {
2069     WARN("arguments for function declarations should follow identifier\n" . $herecurr);
2070     }
2071    
2072     } elsif ($realfile =~ /\.c$/ && defined $stat &&
2073     $stat =~ /^.\s*extern\s+/)
2074     {
2075     WARN("externs should be avoided in .c files\n" . $herecurr);
2076     }
2077    
2078     # checks for new __setup's
2079     if ($rawline =~ /\b__setup\("([^"]*)"/) {
2080     my $name = $1;
2081    
2082     if (!grep(/$name/, @setup_docs)) {
2083     CHK("__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
2084     }
2085     }
2086    
2087     # check for pointless casting of kmalloc return
2088     if ($line =~ /\*\s*\)\s*k[czm]alloc\b/) {
2089     WARN("unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
2090     }
2091    
2092     # check for gcc specific __FUNCTION__
2093     if ($line =~ /__FUNCTION__/) {
2094     WARN("__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr);
2095     }
2096    
2097     # check for semaphores used as mutexes
2098     if ($line =~ /^.\s*(DECLARE_MUTEX|init_MUTEX)\s*\(/) {
2099     WARN("mutexes are preferred for single holder semaphores\n" . $herecurr);
2100     }
2101     # check for semaphores used as mutexes
2102     if ($line =~ /^.\s*init_MUTEX_LOCKED\s*\(/) {
2103     WARN("consider using a completion\n" . $herecurr);
2104     }
2105     # recommend strict_strto* over simple_strto*
2106     if ($line =~ /\bsimple_(strto.*?)\s*\(/) {
2107     WARN("consider using strict_$1 in preference to simple_$1\n" . $herecurr);
2108     }
2109    
2110     # use of NR_CPUS is usually wrong
2111     # ignore definitions of NR_CPUS and usage to define arrays as likely right
2112     if ($line =~ /\bNR_CPUS\b/ &&
2113     $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
2114     $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
2115     $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
2116     $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
2117     $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
2118     {
2119     WARN("usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
2120     }
2121    
2122     # check for %L{u,d,i} in strings
2123     my $string;
2124     while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
2125     $string = substr($rawline, $-[1], $+[1] - $-[1]);
2126     if ($string =~ /(?<!%)%L[udi]/) {
2127     WARN("\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
2128     last;
2129     }
2130     }
2131     }
2132    
2133     # If we have no input at all, then there is nothing to report on
2134     # so just keep quiet.
2135     if ($#rawlines == -1) {
2136     exit(0);
2137     }
2138    
2139     # In mailback mode only produce a report in the negative, for
2140     # things that appear to be patches.
2141     if ($mailback && ($clean == 1 || !$is_patch)) {
2142     exit(0);
2143     }
2144    
2145     # This is not a patch, and we are are in 'no-patch' mode so
2146     # just keep quiet.
2147     if (!$chk_patch && !$is_patch) {
2148     exit(0);
2149     }
2150    
2151     if (!$is_patch) {
2152     ERROR("Does not appear to be a unified-diff format patch\n");
2153     }
2154     if ($is_patch && $chk_signoff && $signoff == 0) {
2155     ERROR("Missing Signed-off-by: line(s)\n");
2156     }
2157    
2158     print report_dump();
2159     if ($summary && !($clean == 1 && $quiet == 1)) {
2160     print "$filename " if ($summary_file);
2161     print "total: $cnt_error errors, $cnt_warn warnings, " .
2162     (($check)? "$cnt_chk checks, " : "") .
2163     "$cnt_lines lines checked\n";
2164     print "\n" if ($quiet == 0);
2165     }
2166    
2167     if ($clean == 1 && $quiet == 0) {
2168     print "$vname has no obvious style problems and is ready for submission.\n"
2169     }
2170     if ($clean == 0 && $quiet == 0) {
2171     print "$vname has style problems, please review. If any of these errors\n";
2172     print "are false positives report them to the maintainer, see\n";
2173     print "CHECKPATCH in MAINTAINERS.\n";
2174     }
2175    
2176     return $clean;
2177     }

Properties

Name Value
svn:executable *

  ViewVC Help
Powered by ViewVC 1.1.26