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