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