SAFE public projects git trees. - safe/jmp/linux-2.6/blob - scripts/checkpatch.pl

   1 #!/usr/bin/perl -w
   2 # (c) 2001, Dave Jones. <davej@codemonkey.org.uk> (the file handling bit)
   3 # (c) 2005, Joel Scohpp <jschopp@austin.ibm.com> (the ugly bit)
   4 # (c) 2007, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite, etc)
   5 # Licensed under the terms of the GNU GPL License version 2
   6
   7 use strict;
   8
   9 my $P = $0;
  10
  11 my $V = '0.03';
  12
  13 use Getopt::Long qw(:config no_auto_abbrev);
  14
  15 my $quiet = 0;
  16 my $tree = 1;
  17 my $chk_signoff = 1;
  18 my $chk_patch = 1;
  19 GetOptions(
  20         'q|quiet'       => \$quiet,
  21         'tree!'         => \$tree,
  22         'signoff!'      => \$chk_signoff,
  23         'patch!'        => \$chk_patch,
  24 ) or exit;
  25
  26 my $exit = 0;
  27
  28 if ($#ARGV < 0) {
  29         print "usage: patchstylecheckemail.pl [options] patchfile\n";
  30         print "version: $V\n";
  31         print "options: -q           => quiet\n";
  32         print "         --no-tree    => run without a kernel tree\n";
  33         exit(1);
  34 }
  35
  36 if ($tree && !top_of_kernel_tree()) {
  37         print "Must be run from the top-level dir. of a kernel tree\n";
  38         exit(2);
  39 }
  40
  41 my @dep_includes = ();
  42 my @dep_functions = ();
  43 my $removal = 'Documentation/feature-removal-schedule.txt';
  44 if ($tree && -f $removal) {
  45         open(REMOVE, "<$removal") || die "$P: $removal: open failed - $!\n";
  46         while (<REMOVE>) {
  47                 if (/^Files:\s+(.*\S)/) {
  48                         for my $file (split(/[, ]+/, $1)) {
  49                                 if ($file =~ m@include/(.*)@) {
  50                                         push(@dep_includes, $1);
  51                                 }
  52                         }
  53
  54                 } elsif (/^Funcs:\s+(.*\S)/) {
  55                         for my $func (split(/[, ]+/, $1)) {
  56                                 push(@dep_functions, $func);
  57                         }
  58                 }
  59         }
  60 }
  61
  62 my @lines = ();
  63 while (<>) {
  64         chomp;
  65         push(@lines, $_);
  66         if (eof(ARGV)) {
  67                 if (!process($ARGV, @lines)) {
  68                         $exit = 1;
  69                 }
  70                 @lines = ();
  71         }
  72 }
  73
  74 exit($exit);
  75
  76 sub top_of_kernel_tree {
  77         if ((-f "COPYING") && (-f "CREDITS") && (-f "Kbuild") &&
  78             (-f "MAINTAINERS") && (-f "Makefile") && (-f "README") &&
  79             (-d "Documentation") && (-d "arch") && (-d "include") &&
  80             (-d "drivers") && (-d "fs") && (-d "init") && (-d "ipc") &&
  81             (-d "kernel") && (-d "lib") && (-d "scripts")) {
  82                 return 1;
  83         }
  84         return 0;
  85 }
  86
  87 sub expand_tabs {
  88         my ($str) = @_;
  89
  90         my $res = '';
  91         my $n = 0;
  92         for my $c (split(//, $str)) {
  93                 if ($c eq "\t") {
  94                         $res .= ' ';
  95                         $n++;
  96                         for (; ($n % 8) != 0; $n++) {
  97                                 $res .= ' ';
  98                         }
  99                         next;
 100                 }
 101                 $res .= $c;
 102                 $n++;
 103         }
 104
 105         return $res;
 106 }
 107
 108 sub line_stats {
 109         my ($line) = @_;
 110
 111         # Drop the diff line leader and expand tabs
 112         $line =~ s/^.//;
 113         $line = expand_tabs($line);
 114
 115         # Pick the indent from the front of the line.
 116         my ($white) = ($line =~ /^(\s*)/);
 117
 118         return (length($line), length($white));
 119 }
 120
 121 sub ctx_block_get {
 122         my ($linenr, $remain, $outer) = @_;
 123         my $line;
 124         my $start = $linenr - 1;
 125         my $end = $linenr - 1 + $remain;
 126         my $blk = '';
 127         my @o;
 128         my @c;
 129         my @res = ();
 130
 131         for ($line = $start; $line < $end; $line++) {
 132                 $blk .= $lines[$line];
 133
 134                 @o = ($blk =~ /\{/g);
 135                 @c = ($blk =~ /\}/g);
 136
 137                 if (!$outer || (scalar(@o) - scalar(@c)) == 1) {
 138                         push(@res, $lines[$line]);
 139                 }
 140
 141                 last if (scalar(@o) == scalar(@c));
 142         }
 143
 144         return @res;
 145 }
 146 sub ctx_block_outer {
 147         my ($linenr, $remain) = @_;
 148
 149         return ctx_block_get($linenr, $remain, 1);
 150 }
 151 sub ctx_block {
 152         my ($linenr, $remain) = @_;
 153
 154         return ctx_block_get($linenr, $remain, 0);
 155 }
 156
 157 sub ctx_locate_comment {
 158         my ($first_line, $end_line) = @_;
 159
 160         # Catch a comment on the end of the line itself.
 161         my ($current_comment) = ($lines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*$@);
 162         return $current_comment if (defined $current_comment);
 163
 164         # Look through the context and try and figure out if there is a
 165         # comment.
 166         my $in_comment = 0;
 167         $current_comment = '';
 168         for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
 169                 my $line = $lines[$linenr - 1];
 170                 ##warn "           $line\n";
 171                 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
 172                         $in_comment = 1;
 173                 }
 174                 if ($line =~ m@/\*@) {
 175                         $in_comment = 1;
 176                 }
 177                 if (!$in_comment && $current_comment ne '') {
 178                         $current_comment = '';
 179                 }
 180                 $current_comment .= $line . "\n" if ($in_comment);
 181                 if ($line =~ m@\*/@) {
 182                         $in_comment = 0;
 183                 }
 184         }
 185
 186         chomp($current_comment);
 187         return($current_comment);
 188 }
 189 sub ctx_has_comment {
 190         my ($first_line, $end_line) = @_;
 191         my $cmt = ctx_locate_comment($first_line, $end_line);
 192
 193         ##print "LINE: $lines[$end_line - 1 ]\n";
 194         ##print "CMMT: $cmt\n";
 195
 196         return ($cmt ne '');
 197 }
 198
 199 sub cat_vet {
 200         my ($vet) = @_;
 201
 202         $vet =~ s/\t/^I/;
 203         $vet =~ s/$/\$/;
 204
 205         return $vet;
 206 }
 207
 208 sub has_non_quoted {
 209         return ($_[0] =~ m{$_[1]} and $_[0] !~ m{\".*$_[1].*\"});
 210 }
 211
 212 sub process {
 213         my $filename = shift;
 214         my @lines = @_;
 215
 216         my $linenr=0;
 217         my $prevline="";
 218         my $stashline="";
 219
 220         my $length;
 221         my $indent;
 222         my $previndent=0;
 223         my $stashindent=0;
 224
 225         my $clean = 1;
 226         my $signoff = 0;
 227         my $is_patch = 0;
 228
 229         # Trace the real file/line as we go.
 230         my $realfile = '';
 231         my $realline = 0;
 232         my $realcnt = 0;
 233         my $here = '';
 234         my $in_comment = 0;
 235         my $first_line = 0;
 236
 237         foreach my $line (@lines) {
 238                 $linenr++;
 239
 240 #extract the filename as it passes
 241                 if ($line=~/^\+\+\+\s+(\S+)/) {
 242                         $realfile=$1;
 243                         $in_comment = 0;
 244                         next;
 245                 }
 246 #extract the line range in the file after the patch is applied
 247                 if ($line=~/^\@\@ -\d+,\d+ \+(\d+)(,(\d+))? \@\@/) {
 248                         $is_patch = 1;
 249                         $first_line = $linenr + 1;
 250                         $in_comment = 0;
 251                         $realline=$1-1;
 252                         if (defined $2) {
 253                                 $realcnt=$3+1;
 254                         } else {
 255                                 $realcnt=1+1;
 256                         }
 257                         next;
 258                 }
 259
 260 # track the line number as we move through the hunk, note that
 261 # new versions of GNU diff omit the leading space on completely
 262 # blank context lines so we need to count that too.
 263                 if ($line =~ /^( |\+|$)/) {
 264                         $realline++;
 265                         $realcnt-- if ($realcnt != 0);
 266
 267                         # track any sort of multi-line comment.  Obviously if
 268                         # the added text or context do not include the whole
 269                         # comment we will not see it. Such is life.
 270                         #
 271                         # Guestimate if this is a continuing comment.  If this
 272                         # is the start of a diff block and this line starts
 273                         # ' *' then it is very likely a comment.
 274                         if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
 275                                 $in_comment = 1;
 276                         }
 277                         if ($line =~ m@/\*@) {
 278                                 $in_comment = 1;
 279                         }
 280                         if ($line =~ m@\*/@) {
 281                                 $in_comment = 0;
 282                         }
 283
 284                         # Measure the line length and indent.
 285                         ($length, $indent) = line_stats($line);
 286
 287                         # Track the previous line.
 288                         ($prevline, $stashline) = ($stashline, $line);
 289                         ($previndent, $stashindent) = ($stashindent, $indent);
 290                 }
 291
 292 #make up the handle for any error we report on this line
 293                 $here = "PATCH: $ARGV:$linenr:";
 294                 $here .= "\nFILE: $realfile:$realline:" if ($realcnt != 0);
 295
 296                 my $herecurr = "$here\n$line\n\n";
 297                 my $hereprev = "$here\n$prevline\n$line\n\n";
 298
 299 #check the patch for a signoff:
 300                 if ($line =~ /^\s*Signed-off-by:\s/) {
 301                         $signoff++;
 302
 303                 } elsif ($line =~ /^\s*signed-off-by:/i) {
 304                         # This is a signoff, if ugly, so do not double report.
 305                         $signoff++;
 306                         if (!($line =~ /^\s*Signed-off-by:/)) {
 307                                 print "use Signed-off-by:\n";
 308                                 print "$herecurr";
 309                                 $clean = 0;
 310                         }
 311                         if ($line =~ /^\s*signed-off-by:\S/i) {
 312                                 print "need space after Signed-off-by:\n";
 313                                 print "$herecurr";
 314                                 $clean = 0;
 315                         }
 316                 }
 317
 318 #ignore lines not being added
 319                 if ($line=~/^[^\+]/) {next;}
 320
 321 # check we are in a valid source file *.[hcsS] if not then ignore this hunk
 322                 next if ($realfile !~ /\.[hcsS]$/);
 323
 324 #trailing whitespace
 325                 if ($line=~/\S\s+$/) {
 326                         my $herevet = "$here\n" . cat_vet($line) . "\n\n";
 327                         print "trailing whitespace\n";
 328                         print "$herevet";
 329                         $clean = 0;
 330                 }
 331 #80 column limit
 332                 if (!($prevline=~/\/\*\*/) && $length > 80) {
 333                         print "line over 80 characters\n";
 334                         print "$herecurr";
 335                         $clean = 0;
 336                 }
 337
 338 # check we are in a valid source file *.[hc] if not then ignore this hunk
 339                 next if ($realfile !~ /\.[hc]$/);
 340
 341 # at the beginning of a line any tabs must come first and anything
 342 # more than 8 must use tabs.
 343                 if ($line=~/^\+\s* \t\s*\S/ or $line=~/^\+\s*        \s*/) {
 344                         my $herevet = "$here\n" . cat_vet($line) . "\n\n";
 345                         print "use tabs not spaces\n";
 346                         print "$herevet";
 347                         $clean = 0;
 348                 }
 349
 350                 #
 351                 # The rest of our checks refer specifically to C style
 352                 # only apply those _outside_ comments.
 353                 #
 354                 next if ($in_comment);
 355
 356 # no C99 // comments
 357                 if (has_non_quoted($line, '//')) {
 358                         print "do not use C99 // comments\n";
 359                         print "$herecurr";
 360                         $clean = 0;
 361                 }
 362
 363                 # Remove comments from the line before processing.
 364                 $line =~ s@/\*.*\*/@@g;
 365                 $line =~ s@/\*.*@@;
 366                 $line =~ s@.*\*/@@;
 367                 $line =~ s@//.*@@;
 368
 369 #EXPORT_SYMBOL should immediately follow its function closing }.
 370                 if (($line =~ /EXPORT_SYMBOL.*\(.*\)/) ||
 371                     ($line =~ /EXPORT_UNUSED_SYMBOL.*\(.*\)/)) {
 372                         if (($prevline !~ /^}/) &&
 373                            ($prevline !~ /^\+}/) &&
 374                            ($prevline !~ /^ }/)) {
 375                                 print "EXPORT_SYMBOL(func); should immediately follow its function\n";
 376                                 print "$herecurr";
 377                                 $clean = 0;
 378                         }
 379                 }
 380
 381                 # check for static initialisers.
 382                 if ($line=~/\s*static\s.*=\s+(0|NULL);/) {
 383                         print "do not initialise statics to 0 or NULL\n";
 384                         print "$herecurr";
 385                         $clean = 0;
 386                 }
 387
 388                 # check for new typedefs.
 389                 if ($line=~/\s*typedef\s/) {
 390                         print "do not add new typedefs\n";
 391                         print "$herecurr";
 392                         $clean = 0;
 393                 }
 394
 395 # * goes on variable not on type
 396                 if ($line=~/[A-Za-z\d_]+\* [A-Za-z\d_]+/) {
 397                         print "\"foo* bar\" should be \"foo *bar\"\n";
 398                         print "$herecurr";
 399                         $clean = 0;
 400                 }
 401
 402 # # no BUG() or BUG_ON()
 403 #               if ($line =~ /\b(BUG|BUG_ON)\b/) {
 404 #                       print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
 405 #                       print "$herecurr";
 406 #                       $clean = 0;
 407 #               }
 408
 409 # printk should use KERN_* levels
 410                 if ($line =~ /\bprintk\((?!KERN_)/) {
 411                         print "printk() should include KERN_ facility level\n";
 412                         print "$herecurr";
 413                         $clean = 0;
 414                 }
 415
 416 #function brace can't be on same line, except for #defines of do while, or if closed on same line
 417                 if (($line=~/[A-Za-z\d_]+\**\s+\**[A-Za-z\d_]+\(.*\).* {/) and
 418                     !($line=~/\#define.*do\s{/) and !($line=~/}/)) {
 419                         print "braces following function declarations go on the next line\n";
 420                         print "$herecurr";
 421                         $clean = 0;
 422                 }
 423                 # Note we expand the line with the leading + as the real
 424                 # line will be displayed with the leading + and the tabs
 425                 # will therefore also expand that way.
 426                 my $opline = $line;
 427                 $opline = expand_tabs($opline);
 428                 $opline =~ s/^.//;
 429                 if (!($line=~/\#\s*include/)) {
 430                         # Check operator spacing.
 431                         my @elements = split(/(<<=|>>=|<=|>=|==|!=|\+=|-=|\*=|\/=|%=|\^=|\|=|&=|->|<<|>>|<|>|=|!|~|&&|\|\||,|\^|\+\+|--|;|&|\||\+|-|\*|\/\/|\/)/, $opline);
 432                         my $off = 1;
 433                         for (my $n = 0; $n < $#elements; $n += 2) {
 434                                 $off += length($elements[$n]);
 435
 436                                 my $a = '';
 437                                 $a = 'V' if ($elements[$n] ne '');
 438                                 $a = 'W' if ($elements[$n] =~ /\s$/);
 439                                 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
 440                                 $a = 'O' if ($elements[$n] eq '');
 441                                 $a = 'E' if ($elements[$n] eq '' && $n == 0);
 442
 443                                 my $op = $elements[$n + 1];
 444
 445                                 my $c = '';
 446                                 if (defined $elements[$n + 2]) {
 447                                         $c = 'V' if ($elements[$n + 2] ne '');
 448                                         $c = 'W' if ($elements[$n + 2] =~ /^\s/);
 449                                         $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
 450                                         $c = 'O' if ($elements[$n + 2] eq '');
 451                                 } else {
 452                                         $c = 'E';
 453                                 }
 454
 455                                 my $ctx = "${a}x${c}";
 456
 457                                 my $at = "(ctx:$ctx)";
 458
 459                                 my $ptr = (" " x $off) . "^";
 460                                 my $hereptr = "$here\n$line\n$ptr\n\n";
 461
 462                                 ##print "<$s1:$op:$s2> <$elements[$n]:$elements[$n + 1]:$elements[$n + 2]>\n";
 463                                 # Skip things apparently in quotes.
 464                                 next if ($line=~/\".*\Q$op\E.*\"/ or $line=~/\'\Q$op\E\'/);
 465
 466                                 # We need ; as an operator.  // is a comment.
 467                                 if ($op eq ';' or $op eq '//') {
 468
 469                                 # -> should have no spaces
 470                                 } elsif ($op eq '->') {
 471                                         if ($ctx =~ /Wx.|.xW/) {
 472                                                 print "no spaces around that '$op' $at\n";
 473                                                 print "$hereptr";
 474                                                 $clean = 0;
 475                                         }
 476
 477                                 # , must have a space on the right.
 478                                 } elsif ($op eq ',') {
 479                                         if ($ctx !~ /.xW|.xE/) {
 480                                                 print "need space after that '$op' $at\n";
 481                                                 print "$hereptr";
 482                                                 $clean = 0;
 483                                         }
 484
 485                                 # unary ! and unary ~ are allowed no space on the right
 486                                 } elsif ($op eq '!' or $op eq '~') {
 487                                         if ($ctx !~ /[WOEB]x./) {
 488                                                 print "need space before that '$op' $at\n";
 489                                                 print "$hereptr";
 490                                                 $clean = 0;
 491                                         }
 492                                         if ($ctx =~ /.xW/) {
 493                                                 print "no space after that '$op' $at\n";
 494                                                 print "$hereptr";
 495                                                 $clean = 0;
 496                                         }
 497
 498                                 # unary ++ and unary -- are allowed no space on one side.
 499                                 } elsif ($op eq '++' or $op eq '--') {
 500                                         if ($ctx !~ /[WOB]x[^W]|[^W]x[WOB]/) {
 501                                                 print "need space one side of that '$op' $at\n";
 502                                                 print "$hereptr";
 503                                                 $clean = 0;
 504                                         }
 505
 506                                 # & is both unary and binary
 507                                 # unary:
 508                                 #       a &b
 509                                 # binary (consistent spacing):
 510                                 #       a&b             OK
 511                                 #       a & b           OK
 512                                 #
 513                                 # boiling down to: if there is a space on the right then there
 514                                 # should be one on the left.
 515                                 #
 516                                 # - is the same
 517                                 #
 518                                 # * is the same only adding:
 519                                 # type:
 520                                 #       (foo *)
 521                                 #       (foo **)
 522                                 #
 523                                 } elsif ($op eq '&' or $op eq '-') {
 524                                         if ($ctx !~ /VxV|[EWB]x[WE]|[EWB]x[VO]/) {
 525                                                 print "need space before that '$op' $at\n";
 526                                                 print "$hereptr";
 527                                                 $clean = 0;
 528                                         }
 529
 530                                 } elsif ($op eq '*') {
 531                                         if ($ctx !~ /VxV|[EWB]x[WE]|[EWB]x[VO]|[EWO]x[OBV]/) {
 532                                                 print "need space before that '$op' $at\n";
 533                                                 print "$hereptr";
 534                                                 $clean = 0;
 535                                         }
 536
 537                                 # << and >> may either have or not have spaces both sides
 538                                 } elsif ($op eq '<<' or $op eq '>>' or $op eq '+' or $op eq '/' or
 539                                          $op eq '^' or $op eq '|')
 540                                 {
 541                                         if ($ctx !~ /VxV|WxW|VxE|WxE/) {
 542                                                 print "need consistent spacing around '$op' $at\n";
 543                                                 print "$hereptr";
 544                                                 $clean = 0;
 545                                         }
 546
 547                                 # All the others need spaces both sides.
 548                                 } elsif ($ctx !~ /[EW]x[WE]/) {
 549                                         print "need spaces around that '$op' $at\n";
 550                                         print "$hereptr";
 551                                         $clean = 0;
 552                                 }
 553                                 $off += length($elements[$n + 1]);
 554                         }
 555                 }
 556
 557 #need space before brace following if, while, etc
 558                 if ($line=~/\(.*\){/) {
 559                         print "need a space before the brace\n";
 560                         print "$herecurr";
 561                         $clean = 0;
 562                 }
 563
 564 #goto labels aren't indented, allow a single space however
 565                 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
 566                    !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
 567                         print "labels should not be indented\n";
 568                         print "$herecurr";
 569                         $clean = 0;
 570                 }
 571
 572 # Need a space before open parenthesis after if, while etc
 573                 if ($line=~/\b(if|while|for|switch)\(/) {
 574                         print "need a space before the open parenthesis\n";
 575                         print "$herecurr";
 576                         $clean = 0;
 577                 }
 578
 579 # Check for illegal assignment in if conditional.
 580                 if ($line=~/\b(if|while)\s*\(.*[^<>!=]=[^=].*\)/) {
 581                         print "do not use assignment in condition\n";
 582                         print "$herecurr";
 583                         $clean = 0;
 584                 }
 585
 586                 # Check for }<nl>else {, these must be at the same
 587                 # indent level to be relevant to each other.
 588                 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
 589                                                 $previndent == $indent) {
 590                         print "else should follow close brace\n";
 591                         print "$hereprev";
 592                         $clean = 0;
 593                 }
 594
 595                 # Check for switch () and associated case and default
 596                 # statements should be at the same indent.
 597                 if ($line=~/\bswitch\s*\(.*\)/) {
 598                         my $err = '';
 599                         my $sep = '';
 600                         my @ctx = ctx_block_outer($linenr, $realcnt);
 601                         shift(@ctx);
 602                         for my $ctx (@ctx) {
 603                                 my ($clen, $cindent) = line_stats($ctx);
 604                                 if ($ctx =~ /\s*(case\s+|default:)/ &&
 605                                                         $indent != $cindent) {
 606                                         $err .= "$sep$ctx\n";
 607                                         $sep = '';
 608                                 } else {
 609                                         $sep = "[...]\n";
 610                                 }
 611                         }
 612                         if ($err ne '') {
 613                                 print "switch and case should be at the same indent\n";
 614                                 print "$here\n$line\n$err\n";
 615                                 $clean = 0;
 616                         }
 617                 }
 618
 619 #studly caps, commented out until figure out how to distinguish between use of existing and adding new
 620 #               if (($line=~/[\w_][a-z\d]+[A-Z]/) and !($line=~/print/)) {
 621 #                   print "No studly caps, use _\n";
 622 #                   print "$herecurr";
 623 #                   $clean = 0;
 624 #               }
 625
 626 #no spaces allowed after \ in define
 627                 if ($line=~/\#define.*\\\s$/) {
 628                         print("Whitepspace after \\ makes next lines useless\n");
 629                         print "$herecurr";
 630                         $clean = 0;
 631                 }
 632
 633 #warn if <asm/foo.h> is #included and <linux/foo.h> is available.
 634                 if ($tree && $line =~ qr|\s*\#\s*include\s*\<asm\/(.*)\.h\>|) {
 635                         my $checkfile = "include/linux/$1.h";
 636                         if (-f $checkfile) {
 637                                 print "Use #include <linux/$1.h> instead of <asm/$1.h>\n";
 638                                 print $herecurr;
 639                                 $clean = 0;
 640                         }
 641                 }
 642
 643 #if/while/etc brace do not go on next line, unless #defining a do while loop, or if that brace on the next line is for something else
 644                 if ($prevline=~/\b(if|while|for|switch)\s*\(/) {
 645                         my @opened = $prevline=~/\(/g;
 646                         my @closed = $prevline=~/\)/g;
 647                         my $nr_line = $linenr;
 648                         my $remaining = $realcnt;
 649                         my $next_line = $line;
 650                         my $extra_lines = 0;
 651                         my $display_segment = $prevline;
 652
 653                         while ($remaining > 1 && scalar @opened > scalar @closed) {
 654                                 $prevline .= $next_line;
 655                                 $display_segment .= "\n" . $next_line;
 656                                 $next_line = $lines[$nr_line];
 657                                 $nr_line++;
 658                                 $remaining--;
 659
 660                                 @opened = $prevline=~/\(/g;
 661                                 @closed = $prevline=~/\)/g;
 662                         }
 663
 664                         if (($prevline=~/\b(if|while|for|switch)\s*\(.*\)\s*$/) and ($next_line=~/{/) and
 665                            !($next_line=~/\b(if|while|for)/) and !($next_line=~/\#define.*do.*while/)) {
 666                                 print "That { should be on the previous line\n";
 667                                 print "$here\n$display_segment\n$next_line\n\n";
 668                                 $clean = 0;
 669                         }
 670                 }
 671
 672 #multiline macros should be enclosed in a do while loop
 673                 if (($prevline=~/\#define.*\\/) and !($prevline=~/do\s+{/) and
 674                    !($prevline=~/\(\{/) and ($line=~/;\s*\\/) and
 675                    !($line=~/do.*{/) and !($line=~/\(\{/)) {
 676                         print "Macros with multiple statements should be enclosed in a do - while loop\n";
 677                         print "$hereprev";
 678                         $clean = 0;
 679                 }
 680
 681 # don't include deprecated include files
 682                 for my $inc (@dep_includes) {
 683                         if ($line =~ m@\#\s*include\s*\<$inc>@) {
 684                                 print "Don't use <$inc>: see Documentation/feature-removal-schedule.txt\n";
 685                                 print "$herecurr";
 686                                 $clean = 0;
 687                         }
 688                 }
 689
 690 # don't use deprecated functions
 691                 for my $func (@dep_functions) {
 692                         if (has_non_quoted($line, '\b' . $func . '\b')) {
 693                                 print "Don't use $func(): see Documentation/feature-removal-schedule.txt\n";
 694                                 print "$herecurr";
 695                                 $clean = 0;
 696                         }
 697                 }
 698
 699 # no volatiles please
 700                 if (has_non_quoted($line, '\bvolatile\b')) {
 701                         print "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n";
 702                         print "$herecurr";
 703                         $clean = 0;
 704                 }
 705
 706 # warn about #ifdefs in C files
 707                 if ($line =~ /^.#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
 708                         print "#ifdef in C files should be avoided\n";
 709                         print "$herecurr";
 710                         $clean = 0;
 711                 }
 712
 713 # check for spinlock_t definitions without a comment.
 714                 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/) {
 715                         my $which = $1;
 716                         if (!ctx_has_comment($first_line, $linenr)) {
 717                                 print "$1 definition without comment\n";
 718                                 print "$herecurr";
 719                                 $clean = 0;
 720                         }
 721                 }
 722 # check for memory barriers without a comment.
 723                 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
 724                         if (!ctx_has_comment($first_line, $linenr)) {
 725                                 print "memory barrier without comment\n";
 726                                 print "$herecurr";
 727                                 $clean = 0;
 728                         }
 729                 }
 730 # check of hardware specific defines
 731                 if ($line =~ m@^.#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@) {
 732                         print "architecture specific defines should be avoided\n";
 733                         print "$herecurr";
 734                         $clean = 0;
 735                 }
 736         }
 737
 738         if ($chk_patch && !$is_patch) {
 739                 $clean = 0;
 740                 print "Does not appear to be a unified-diff format patch\n";
 741         }
 742         if ($is_patch && $chk_signoff && $signoff == 0) {
 743                 $clean = 0;
 744                 print "Missing Signed-off-by: line(s)\n";
 745         }
 746
 747         if ($clean == 1 && $quiet == 0) {
 748                 print "Your patch has no obvious style problems and is ready for submission.\n"
 749         }
 750         if ($clean == 0 && $quiet == 0) {
 751                 print "Your patch has style problems, please review.  If any of these errors\n";
 752                 print "are false positives report them to the maintainer, see\n";
 753                 print "CHECKPATCH in MAINTAINERS.\n";
 754         }
 755         return $clean;
 756 }